Beispiel #1
0
        public IActionResult RequestForIdentity([FromBody] RequestForIdentityDto requestForIdentity)
        {
            ulong   accountId = ulong.Parse(User.Identity.Name, CultureInfo.InvariantCulture);
            Account account   = _accountsService.GetById(accountId);

            string blindingFactorSeedString = $"{requestForIdentity.IdCardContent}{requestForIdentity.Password}";

            byte[] blindingFactorSeed = ConfidentialAssetsHelper.FastHash256(Encoding.ASCII.GetBytes(blindingFactorSeedString));
            byte[] blindingFactor     = ConfidentialAssetsHelper.ReduceScalar32(blindingFactorSeed);
            byte[] blindingPoint      = ConfidentialAssetsHelper.GetPublicKey(blindingFactor);

            IdentityRequestDto identityRequest = new IdentityRequestDto
            {
                RequesterPublicSpendKey = account.PublicSpendKey.ToHexString(),
                RequesterPublicViewKey  = account.PublicViewKey.ToHexString(),
                RootAttributeContent    = requestForIdentity.IdCardContent,
                BlindingPoint           = blindingPoint.ToHexString(),
                FaceImageContent        = requestForIdentity.ImageContent
            };

            byte[] b   = Convert.FromBase64String(requestForIdentity.Target);
            string uri = Encoding.UTF8.GetString(b);
            HttpResponseMessage httpResponse = uri.PostJsonAsync(identityRequest).Result;

            if (httpResponse.IsSuccessStatusCode)
            {
                //TODO: this step should be done if Identity Provider API returned OK
                _dataAccessService.UpdateUserAssociatedAttributes(accountId, new List <Tuple <AttributeType, string> > {
                    new Tuple <AttributeType, string>(AttributeType.PassportPhoto, requestForIdentity.ImageContent)
                });
                return(Ok());
            }

            return(BadRequest(httpResponse.Content.ReadAsAsync <string>().Result));
        }
Beispiel #2
0
        public IActionResult SendOnboardingWithValidationsRequest([FromBody] UserAttributeTransferWithValidationsDto userAttributeTransferWithValidations)
        {
            ulong accountId = ulong.Parse(User.Identity.Name, CultureInfo.InvariantCulture);
            bool  res       = false;

            UtxoPersistency utxoPersistency = _executionContextManager.ResolveUtxoExecutionServices(accountId);

            var rootAttribute = _dataAccessService.GetUserAttributes(accountId).FirstOrDefault(u => !u.IsOverriden && u.AttributeType == _identityAttributesService.GetRootAttributeType().Item1);

            string blindingFactorSeedString = $"{rootAttribute.Content}{userAttributeTransferWithValidations.Password}";

            byte[] blindingFactorSeed        = ConfidentialAssetsHelper.FastHash256(Encoding.ASCII.GetBytes(blindingFactorSeedString));
            byte[] blindingFactor            = ConfidentialAssetsHelper.ReduceScalar32(blindingFactorSeed);
            byte[] blindingPoint             = ConfidentialAssetsHelper.GetPublicKey(blindingFactor);
            byte[] rootNonBlindedCommitment  = ConfidentialAssetsHelper.GetNonblindedAssetCommitment(rootAttribute.AssetId);
            byte[] rootOriginatingCommitment = ConfidentialAssetsHelper.SumCommitments(rootNonBlindedCommitment, blindingPoint);

            byte[] target = userAttributeTransferWithValidations.UserAttributeTransfer.Target.HexStringToByteArray();
            _dataAccessService.GetAccountId(target, out ulong spAccountId);

            AssociatedProofPreparation[] associatedProofPreparations = null;

            IEnumerable <SpIdenitityValidation> spIdenitityValidations = _dataAccessService.GetSpIdenitityValidations(spAccountId);

            if (spIdenitityValidations != null && spIdenitityValidations.Count() > 0)
            {
                associatedProofPreparations = new AssociatedProofPreparation[spIdenitityValidations.Count()];

                var associatedAttributes = _dataAccessService.GetUserAssociatedAttributes(accountId);

                int index = 0;
                foreach (var validation in spIdenitityValidations)
                {
                    string attrContent = associatedAttributes.FirstOrDefault(a => a.Item1 == validation.AttributeType)?.Item2 ?? string.Empty;
                    byte[] groupId     = _identityAttributesService.GetGroupId(validation.AttributeType);
                    byte[] assetId     = validation.AttributeType != AttributeType.DateOfBirth ? _assetsService.GenerateAssetId(validation.AttributeType, attrContent) : rootAttribute.AssetId;
                    byte[] associatedBlindingFactor        = validation.AttributeType != AttributeType.DateOfBirth ? ConfidentialAssetsHelper.GetRandomSeed() : null;
                    byte[] associatedCommitment            = validation.AttributeType != AttributeType.DateOfBirth ? ConfidentialAssetsHelper.GetAssetCommitment(assetId, associatedBlindingFactor) : null;
                    byte[] associatedNonBlindedCommitment  = ConfidentialAssetsHelper.GetNonblindedAssetCommitment(assetId);
                    byte[] associatedOriginatingCommitment = ConfidentialAssetsHelper.SumCommitments(associatedNonBlindedCommitment, blindingPoint);

                    AssociatedProofPreparation associatedProofPreparation = new AssociatedProofPreparation {
                        GroupId = groupId, Commitment = associatedCommitment, CommitmentBlindingFactor = associatedBlindingFactor, OriginatingAssociatedCommitment = associatedOriginatingCommitment, OriginatingBlindingFactor = blindingFactor, OriginatingRootCommitment = rootOriginatingCommitment
                    };

                    associatedProofPreparations[index++] = associatedProofPreparation;
                }
            }

            SendOnboardingRequest(userAttributeTransferWithValidations.UserAttributeTransfer, utxoPersistency.TransactionsService, associatedProofPreparations);

            return(Ok(res));
        }