private BlockBase CreateTransferAssetToUtxoBlock(byte[][] assetIds, int index, ulong tagId, ConfidentialAccount receiver, byte[] sk = null)
{
byte[] assetId = assetIds[index];
byte[] secretKey = sk ?? ConfidentialAssetsHelper.GetRandomSeed();
byte[] transactionKey = ConfidentialAssetsHelper.GetTrancationKey(secretKey);
byte[] destinationKey = ConfidentialAssetsHelper.GetDestinationKey(secretKey, receiver.PublicViewKey, receiver.PublicSpendKey);
byte[] blindingFactor = ConfidentialAssetsHelper.GetRandomSeed();
byte[] assetCommitment = ConfidentialAssetsHelper.GetAssetCommitment(assetId, blindingFactor);
ulong[] assetAmounts = new ulong[assetIds.Length];
for (int i = 0; i < assetAmounts.Length; i++)
{
assetAmounts[i] = 1;
}
TransferAssetToUtxoBlock transferAssetToUtxoBlock = new TransferAssetToUtxoBlock
{
TagId = tagId,
AssetIds = assetIds,
AssetAmounts = assetAmounts,
TransactionPublicKey = transactionKey,
DestinationKey = destinationKey,
AssetId = assetId,
AssetCommitment = assetCommitment,
SurjectionProof = ConfidentialAssetsHelper.CreateNewIssuanceSurjectionProof(assetCommitment, assetIds, index, blindingFactor),
EcdhTuple = ConfidentialAssetsHelper.CreateEcdhTupleCA(blindingFactor, assetId, secretKey, receiver.PublicViewKey)
};
FillHeightInfo(transferAssetToUtxoBlock);
FillSyncData(transferAssetToUtxoBlock);
FillRawData(transferAssetToUtxoBlock);
return(transferAssetToUtxoBlock);
}
public async Task <IActionResult> AddAllowedSigner(long spId, long documentId, [FromBody] AllowedSignerDto allowedSigner)
{
byte[] groupAssetId = await _assetsService.GenerateAssetId(AttributesSchemes.ATTR_SCHEME_NAME_EMPLOYEEGROUP, allowedSigner.GroupOwner + allowedSigner.GroupName, allowedSigner.GroupOwner).ConfigureAwait(false);
byte[] blindingFactor = ConfidentialAssetsHelper.GetRandomSeed();
byte[] groupCommitment = ConfidentialAssetsHelper.GetAssetCommitment(blindingFactor, groupAssetId);
allowedSigner.AllowedSignerId = _dataAccessService.AddSpDocumentAllowedSigner(spId, documentId, allowedSigner.GroupOwner, allowedSigner.GroupName, groupCommitment.ToHexString(), blindingFactor.ToHexString());
SpDocument document = _dataAccessService.GetSpDocument(spId, documentId);
StatePersistency statePersistency = _executionContextManager.ResolveStateExecutionServices(spId);
statePersistency.TransactionsService.IssueDocumentRecord(document.Hash.HexStringToByteArray(), document.AllowedSigners.Select(s => s.GroupCommitment.HexStringToByteArray()).ToArray());
return(Ok(allowedSigner));
}
public IActionResult AddAllowedSigner(ulong documentId, [FromBody] AllowedSignerDto allowedSigner)
{
ulong accountId = ulong.Parse(User.Identity.Name, CultureInfo.InvariantCulture);
byte[] groupAssetId = _assetsService.GenerateAssetId(AttributeType.EmployeeGroup, allowedSigner.GroupOwner + allowedSigner.GroupName);
byte[] blindingFactor = ConfidentialAssetsHelper.GetRandomSeed();
byte[] groupCommitment = ConfidentialAssetsHelper.GetAssetCommitment(groupAssetId, blindingFactor);
allowedSigner.AllowedSignerId = _dataAccessService.AddSpDocumentAllowedSigner(accountId, documentId, allowedSigner.GroupOwner, allowedSigner.GroupName, groupCommitment.ToHexString(), blindingFactor.ToHexString());
SpDocument document = _dataAccessService.GetSpDocument(accountId, documentId);
StatePersistency statePersistency = _executionContextManager.ResolveStateExecutionServices(accountId);
statePersistency.TransactionsService.IssueDocumentRecord(document.Hash.HexStringToByteArray(), document.AllowedSigners.Select(s => s.GroupCommitment.HexStringToByteArray()).ToArray());
return(Ok(allowedSigner));
}
private void ProcessDocumentSignRequest(DocumentSignRequest packet)
{
_clientCryptoService.DecodeEcdhTuple(packet.EcdhTuple, packet.TransactionPublicKey, out byte[] groupNameBlindingFactor, out byte[] documentHash, out byte[] issuer, out byte[] payload);
string sessionKey = payload.ToHexString();
SpDocument spDocument = _dataAccessService.GetSpDocument(_accountId, documentHash.ToHexString());
if (spDocument == null)
{
_idenitiesHubContext.Clients.Group(sessionKey).SendAsync("PushDocumentNotFound");
}
bool isEligibilityCorrect = CheckEligibilityProofs(packet.AssetCommitment, packet.EligibilityProof, issuer);
if (!isEligibilityCorrect)
{
_idenitiesHubContext.Clients.Group(sessionKey).SendAsync("PushDocumentSignIncorrect", new { Code = 2, Message = "Eligibility proofs were wrong" }).Wait();
return;
}
if (!ConfidentialAssetsHelper.VerifySurjectionProof(packet.SignerGroupRelationProof, packet.AssetCommitment, documentHash, BitConverter.GetBytes(spDocument.LastChangeRecordHeight)))
{
_idenitiesHubContext.Clients.Group(sessionKey).SendAsync("PushDocumentSignIncorrect", new { Code = 2, Message = "Signer group relation proofs were wrong" }).Wait();
return;
}
SurjectionProof signatureGroupProof = null;
string groupIssuer = null;
foreach (var allowedSigner in spDocument.AllowedSigners)
{
byte[] groupAssetId = _assetsService.GenerateAssetId(AttributeType.EmployeeGroup, allowedSigner.GroupIssuer + allowedSigner.GroupName);
byte[] expectedGroupCommitment = ConfidentialAssetsHelper.GetAssetCommitment(groupAssetId, groupNameBlindingFactor);
if (packet.AllowedGroupCommitment.Equals32(expectedGroupCommitment))
{
byte[] groupCommitment = _gatewayService.GetEmployeeRecordGroup(allowedSigner.GroupIssuer.HexStringToByteArray(), packet.SignerGroupRelationProof.AssetCommitments[0]);
if (groupCommitment != null && ConfidentialAssetsHelper.VerifySurjectionProof(packet.AllowedGroupNameSurjectionProof, packet.AllowedGroupCommitment))
{
byte[] diffBF = ConfidentialAssetsHelper.GetDifferentialBlindingFactor(groupNameBlindingFactor, allowedSigner.BlindingFactor.HexStringToByteArray());
byte[][] commitments = spDocument.AllowedSigners.Select(s => s.GroupCommitment.HexStringToByteArray()).ToArray();
byte[] allowedGroupCommitment = allowedSigner.GroupCommitment.HexStringToByteArray();
int index = 0;
for (; index < commitments.Length; index++)
{
if (commitments[index].Equals32(allowedGroupCommitment))
{
break;
}
}
signatureGroupProof = ConfidentialAssetsHelper.CreateSurjectionProof(packet.AllowedGroupCommitment, commitments, index, diffBF);
groupIssuer = allowedSigner.GroupIssuer;
break;
}
}
}
if (signatureGroupProof == null)
{
_idenitiesHubContext.Clients.Group(sessionKey).SendAsync("PushDocumentSignIncorrect", new { Code = 2, Message = "Signer group relation proofs were wrong" }).Wait();
return;
}
_transactionsService.IssueDocumentSignRecord(documentHash, spDocument.LastChangeRecordHeight, packet.AssetCommitment, packet.SignerGroupRelationProof, packet.AllowedGroupCommitment, groupIssuer.HexStringToByteArray(), packet.AllowedGroupNameSurjectionProof, signatureGroupProof, out ulong signatureRecordHeight);
ulong signatureId = _dataAccessService.AddSpDocumentSignature(_accountId, spDocument.SpDocumentId, spDocument.LastChangeRecordHeight, signatureRecordHeight);
_idenitiesHubContext.Clients.Group(_accountId.ToString(CultureInfo.InvariantCulture))
.SendAsync("PushDocumentSignature",
new DocumentSignatureDto
{
DocumentId = spDocument.SpDocumentId,
DocumentHash = spDocument.Hash,
DocumentRecordHeight = spDocument.LastChangeRecordHeight,
SignatureRecordHeight = signatureRecordHeight
});
_idenitiesHubContext.Clients.Group(sessionKey)
.SendAsync("PushDocumentSignature",
new DocumentSignatureDto
{
DocumentId = spDocument.SpDocumentId,
DocumentHash = spDocument.Hash,
DocumentRecordHeight = spDocument.LastChangeRecordHeight,
SignatureRecordHeight = signatureRecordHeight
});
}
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));
}
private BlockBase CreateNonQuantitativeTransitionAssetTransferBlock(Account receiver, byte[] assetId, byte[] prevTransactionKey, byte[] prevCommitment, byte[] prevDestinationKey, int ringSize, ulong tagId, out byte[] otsk, out int pos)
{
if (!_clientState.IsConfidential())
{
otsk = null;
pos = -1;
return(null);
}
byte[] otskAsset = ConfidentialAssetsHelper.GetOTSK(prevTransactionKey, _clientState.GetSecretViewKey(), _clientState.GetSecretSpendKey());
otsk = otskAsset;
byte[] keyImage = ConfidentialAssetsHelper.GenerateKeyImage(otskAsset);
byte[] secretKey = ConfidentialAssetsHelper.GetRandomSeed();
byte[] transactionKey = ConfidentialAssetsHelper.GetTrancationKey(secretKey);
byte[] destinationKey = _hashCalculation.CalculateHash(receiver.PublicKey);
byte[] blindingFactor = ConfidentialAssetsHelper.GetRandomSeed();
byte[] assetCommitment = ConfidentialAssetsHelper.GetAssetCommitment(assetId, blindingFactor);
byte[] msg = ConfidentialAssetsHelper.FastHash256(BitConverter.GetBytes(tagId), keyImage, destinationKey, transactionKey, assetCommitment);
Random random = new Random(BitConverter.ToInt32(secretKey, 0));
GetCommitmentAndProofs(prevCommitment, prevDestinationKey, ringSize, tagId, random, out int actualAssetPos, out byte[][] assetCommitments, out byte[][] assetPubs);
pos = actualAssetPos;
UtxoUnspentBlock idCardBlock = _dataAccessService.GetUtxoUnspentBlocksByTagId(_idCardTagId).First();
byte[] otskAffiliation = ConfidentialAssetsHelper.GetOTSK(idCardBlock.TransactionKey, _clientState.GetSecretViewKey(), _clientState.GetSecretSpendKey());
byte[] affiliationBlindingFactor = ConfidentialAssetsHelper.GetRandomSeed();
byte[] affiliationAssetCommitment = ConfidentialAssetsHelper.GetAssetCommitment(idCardBlock.AssetId, affiliationBlindingFactor);
GetCommitmentAndProofs(idCardBlock.Output.Commitment, idCardBlock.Output.DestinationKey, ringSize, _idCardTagId, random, out int actualAffiliationPos, out byte[][] affiliationCommitments, out byte[][] affiliationPubs);
BorromeanRingSignature borromeanRingSignature = ConfidentialAssetsHelper.GenerateBorromeanRingSignature(msg, affiliationPubs, actualAffiliationPos, otskAffiliation);
SurjectionProof assetSurjectionProof = ConfidentialAssetsHelper.CreateAssetRangeProof(assetCommitment, assetCommitments, actualAssetPos, blindingFactor);
SurjectionProof affilaitionSurjectionProof = ConfidentialAssetsHelper.CreateAssetRangeProof(affiliationAssetCommitment, affiliationCommitments, actualAffiliationPos, affiliationBlindingFactor);
List <TransactionalIncomingBlock> incomingBlocks = _dataAccessService.GetIncomingBlocksByBlockType(BlockTypes.Transaction_IssueAssets);
List <IssueAssetsBlock> issueAssetsBlocks = incomingBlocks.Where(b => b.TagId == _idCardTagId).ToList().Select(b =>
{
return((IssueAssetsBlock)_blockParsersRepositoriesRepository.GetBlockParsersRepository(PacketType.Transactional).GetInstance(b.BlockType).Parse(b.Content));
}).ToList();
List <byte[]> rawIdCardAssetIds = issueAssetsBlocks.SelectMany(b => b.IssuedAssetIds).ToList();
SurjectionProof affiliationEvidenceSurjectionProof = ConfidentialAssetsHelper.CreateNewIssuanceSurjectionProof(affiliationAssetCommitment, rawIdCardAssetIds.ToArray(), rawIdCardAssetIds.FindIndex(b => b.Equals32(idCardBlock.AssetId)), affiliationBlindingFactor);
NonQuantitativeTransitionAssetTransferBlock block = new NonQuantitativeTransitionAssetTransferBlock
{
TagId = tagId,
KeyImage = _identityKeyProvider.GetKey(keyImage),
DestinationKey = destinationKey,
TransactionPublicKey = transactionKey,
AssetCommitment = assetCommitment,
SurjectionProof = assetSurjectionProof,
AffiliationCommitment = affiliationAssetCommitment,
AffiliationPseudoKeys = affiliationPubs,
AffiliationSurjectionProof = affilaitionSurjectionProof,
AffiliationBorromeanSignature = borromeanRingSignature,
AffiliationEvidenceSurjectionProof = affiliationEvidenceSurjectionProof,
EcdhTuple = ConfidentialAssetsHelper.CreateEcdhTupleCA(blindingFactor, assetId, secretKey, receiver.PublicKey),
PublicKeys = assetPubs.Select(p => _identityKeyProvider.GetKey(p)).ToArray(),
Signatures = ConfidentialAssetsHelper.GenerateRingSignature(msg, keyImage, assetPubs, otskAsset, actualAssetPos)
};
FillSyncData(block);
FillRawData(block);
return(block);
}
