private bool IsStarted()
{
var response = new UniversalTransport(log)
.SendAsync(Request.Get($"http://{host}:{port}/ping"), null, 5.Seconds(), CancellationToken.None)
.GetAwaiter()
.GetResult();
return(response.Code == ResponseCode.Ok);
}
public HerculesDownloader(string baseDirectory, ILog log)
{
this.baseDirectory = baseDirectory;
this.log = log;
transport = new UniversalTransport(new UniversalTransportSettings {
AllowAutoRedirect = true
}, log);
Directory.CreateDirectory(CacheDirectoryPath);
}
private async Task ProcessUniversalTransport(UniversalTransport universalTransport)
{
_logger.LogIfDebug(() => $"[{AccountId}]: {nameof(ProcessUniversalTransport)} with {nameof(universalTransport.KeyImage)}={universalTransport.KeyImage}");
TaskCompletionSource <UniversalProofs> universalProofsTask = _universalProofsPool.Extract(universalTransport.KeyImage);
try
{
UniversalProofs universalProofs = await universalProofsTask.Task.ConfigureAwait(false);
_logger.LogIfDebug(() => $"[{AccountId}]: {nameof(ProcessUniversalTransport)}, {nameof(UniversalProofs)} obtained with {nameof(universalProofs.KeyImage)}={universalProofs.KeyImage} and {nameof(universalProofs.SessionKey)}={universalProofs.SessionKey}");
var mainIssuer = universalProofs.RootIssuers.Find(i => i.Issuer.Equals(universalProofs.MainIssuer));
IKey commitmentKey = mainIssuer.IssuersAttributes.FirstOrDefault(a => a.Issuer.Equals(mainIssuer.Issuer))?.RootAttribute.Commitment;
SurjectionProof eligibilityProof = mainIssuer.IssuersAttributes.FirstOrDefault(a => a.Issuer.Equals(mainIssuer.Issuer))?.RootAttribute.BindingProof;
bool isEligibilityCorrect = await CheckEligibilityProofs(commitmentKey.Value, eligibilityProof, mainIssuer.Issuer.Value).ConfigureAwait(false);
if (!isEligibilityCorrect && !string.IsNullOrEmpty(universalProofs.SessionKey))
{
SetException(universalProofs.SessionKey, new ArgumentException("Eligibility proofs were wrong"));
return;
}
SurjectionProof registrationProof = mainIssuer.IssuersAttributes.FirstOrDefault(a => a.Issuer.Equals(mainIssuer.Issuer))?.RootAttribute.CommitmentProof.SurjectionProof;
_spValidationsService.HandleAccount(AccountId, commitmentKey.Value, registrationProof);
SetCompletion(
new InherenceData
{
Issuer = mainIssuer.Issuer.ArraySegment.Array,
AssetRootCommitment = commitmentKey.ArraySegment.Array,
RootRegistrationProof = registrationProof,
AssociatedRootCommitment = mainIssuer.IssuersAttributes?.FirstOrDefault(a => !a.Issuer.Equals(mainIssuer.Issuer))?.RootAttribute.Commitment.ArraySegment.Array,
AssociatedRegistrationProof = mainIssuer.IssuersAttributes?.FirstOrDefault(a => !a.Issuer.Equals(mainIssuer.Issuer))?.RootAttribute.CommitmentProof.SurjectionProof
}, universalProofs.SessionKey);
}
catch (TimeoutException)
{
_logger.Error($"[{AccountId}]: Timeout during obtaining {nameof(UniversalProofs)} for key image {universalTransport.KeyImage}");
}
catch (Exception ex)
{
if (ex is AggregateException aex)
{
_logger.Error($"[{AccountId}]: {nameof(ProcessUniversalTransport)}, unexpected aggregated exception", aex.InnerException);
}
else
{
_logger.Error($"[{AccountId}]: {nameof(ProcessUniversalTransport)}, unexpected exception", ex);
}
throw;
}
}
private async Task ProcessUniversalTransport(UniversalTransport universalTransport)
{
TaskCompletionSource <UniversalProofs> universalProofsTask = _universalProofsPool.Extract(universalTransport.KeyImage);
try
{
UniversalProofs universalProofs = await universalProofsTask.Task.ConfigureAwait(false);
IKey commitmentKey = universalProofs.IssuersAttributes.FirstOrDefault(a => a.Issuer.Equals(universalProofs.Issuer))?.RootAttribute.Commitment;
SurjectionProof eligibilityProof = universalProofs.IssuersAttributes.FirstOrDefault(a => a.Issuer.Equals(universalProofs.Issuer))?.RootAttribute.BindingProof;
bool isEligibilityCorrect = await CheckEligibilityProofs(commitmentKey.Value, eligibilityProof, universalProofs.Issuer.Value).ConfigureAwait(false);
if (!isEligibilityCorrect && !string.IsNullOrEmpty(universalProofs.SessionKey))
{
await _idenitiesHubContext.Clients.Group(universalProofs.SessionKey).SendAsync("EligibilityCheckFailed").ConfigureAwait(false);
return;
}
try
{
await VerifyProofToAssociatedAttributeKnowledge(universalProofs, AttributesSchemes.ATTR_SCHEME_NAME_PASSWORD).ConfigureAwait(false);
}
catch (Exception ex)
{
string msg = ex.Message;
if (ex is AggregateException aex)
{
if (aex.InnerException is FlurlHttpException fex)
{
_logger.Error($"[{_accountId}]: Failed request '{fex.Call.Request.RequestUri}' with body '{fex.Call.RequestBody}'");
}
msg = aex.InnerException.Message;
_logger.Error($"[{_accountId}]: Failure at {nameof(ProcessUniversalTransport)}", aex.InnerException);
}
else
{
_logger.Error($"[{_accountId}]: Failure at {nameof(ProcessUniversalTransport)}", ex);
}
await _idenitiesHubContext.Clients.Group(universalProofs.SessionKey).SendAsync("ProtectionCheckFailed", msg).ConfigureAwait(false);
return;
}
switch (universalProofs.Mission)
{
case UniversalProofsMission.Authentication:
await ProcessUniversalProofsAuthentication(universalProofs).ConfigureAwait(false);
break;
default:
break;
}
}
catch (TimeoutException)
{
_logger.Error($"[{_accountId}]: Timeout during obtaining {nameof(UniversalProofs)} for key image {universalTransport.KeyImage}");
}
}
public void TestSetup()
{
transport = new UniversalTransport(new SilentLog());
}
