public IActionResult PostUniversalProofs([FromBody] UniversalProofs universalProofs)
{
//UniversalProofs universalProofs = (UniversalProofs)JsonConvert.DeserializeObject(body, typeof(UniversalProofs));
_universalProofsPool.Store(universalProofs);
return(Ok());
}
private async Task VerifyProofToAssociatedAttributeKnowledge(UniversalProofs universalProofs, string schemeName)
{
AttributeProofs attr = universalProofs.IssuersAttributes?.FirstOrDefault(a => a.Issuer.Equals(universalProofs.Issuer))?.Attributes.FirstOrDefault(a => a.SchemeName == schemeName);
if (attr == null)
{
throw new AssociatedAttrProofsAreMissingException(schemeName);
}
if (attr.CommitmentProof.SurjectionProof.AssetCommitments.Length != attr.BindingProof.AssetCommitments.Length)
{
throw new AssociatedAttrProofsMalformedException(schemeName);
}
if (!ConfidentialAssetsHelper.VerifySurjectionProof(attr.CommitmentProof.SurjectionProof, attr.Commitment.ArraySegment.Array))
{
throw new AssociatedAttrProofToValueKnowledgeIncorrectException(schemeName);
}
IKey commitmentKey = universalProofs.IssuersAttributes.FirstOrDefault(a => a.Issuer.Equals(universalProofs.Issuer))?.RootAttribute.Commitment;
byte[] commitment = ConfidentialAssetsHelper.SumCommitments(commitmentKey.Value.Span, attr.Commitment.Value.Span);
if (!ConfidentialAssetsHelper.VerifySurjectionProof(attr.BindingProof, commitment))
{
throw new AssociatedAttrProofToBindingIncorrectException(schemeName);
}
(Memory <byte> issuanceCommitment, Memory <byte> commitmentToRoot)[] attrs = new (Memory <byte>, Memory <byte>)[attr.BindingProof.AssetCommitments.Length];
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;
}
}
public void Store(UniversalProofs universalProofs)
{
Contract.Requires(universalProofs != null && universalProofs.KeyImage != null);
_logger.LogIfDebug(() => $"Storing {nameof(universalProofs)} with {nameof(universalProofs.KeyImage)}={universalProofs.KeyImage} and {nameof(universalProofs.SessionKey)}={universalProofs.SessionKey}");
TaskCompletionSource <UniversalProofs> taskCompletionSource = new TaskCompletionSource <UniversalProofs>();
taskCompletionSource.SetResult(universalProofs);
_universalProofs.AddOrUpdate(universalProofs.KeyImage, taskCompletionSource, (k, v) =>
{
if (!v.Task.IsCompleted)
{
v.SetResult(universalProofs);
}
return(v);
});
}
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}");
}
}
