public string DecryptText(BinaryHexString data, BinaryHexString nonce, bool uncompress, BinaryHexString sharedKey)
{
var decrypted = DecryptData(data, nonce, uncompress, sharedKey);
var message = Encoding.UTF8.GetString(decrypted, 0, decrypted.Length);
return(message);
}
private static JObject BuildSignedTransaction(Transaction transaction, string referencedTransactionFullHash,
BinaryHexString signature, JToken attachment)
{
var resultJson = new JObject();
resultJson.Add(Parameters.Type, (int)TransactionTypeMapper.GetMainTypeByte(transaction.Type));
resultJson.Add(Parameters.SubType, (int)TransactionTypeMapper.GetSubTypeByte(transaction.SubType));
resultJson.Add(Parameters.Timestamp, new DateTimeConverter().GetNxtTimestamp(transaction.Timestamp));
resultJson.Add(Parameters.Deadline, transaction.Deadline);
resultJson.Add(Parameters.SenderPublicKey, transaction.SenderPublicKey.ToHexString());
resultJson.Add(Parameters.AmountNqt, transaction.Amount.Nqt.ToString());
resultJson.Add(Parameters.FeeNqt, transaction.Fee.Nqt.ToString());
if (!string.IsNullOrEmpty(referencedTransactionFullHash))
{
resultJson.Add(Parameters.ReferencedTransactionFullHash, referencedTransactionFullHash);
}
resultJson.Add(Parameters.Signature, signature.ToHexString());
resultJson.Add(Parameters.Version, transaction.Version);
if (attachment != null && attachment.Children().Any())
{
resultJson.Add(Parameters.Attachment, attachment);
}
resultJson.Add(Parameters.EcBlockHeight, transaction.EcBlockHeight);
resultJson.Add(Parameters.EcBlockId, transaction.EcBlockId.ToString());
if (transaction.Recipient.HasValue)
{
resultJson.Add(Parameters.Recipient, transaction.Recipient.ToString());
}
return(resultJson);
}
public string DecryptTextFrom(BinaryHexString senderPublicKey, BinaryHexString data, BinaryHexString nonce, bool uncompress, string secretPhrase)
{
var decrypted = DecryptDataFrom(senderPublicKey, data, nonce, uncompress, secretPhrase);
var message = Encoding.UTF8.GetString(decrypted, 0, decrypted.Length);
return(message);
}
internal ulong GetAccountIdFromPublicKey(BinaryHexString publicKey)
{
var publicKeyHash = ComputeHash(publicKey.ToBytes().ToArray());
var bigInteger = new BigInteger(publicKeyHash.Take(8).ToArray());
return((ulong)(long)bigInteger);
}
private static BinaryHexString HashPrunableMessage(params byte[][] messages)
{
byte[] hash;
#if (NET40 || NET45)
using (var sha256 = SHA256.Create())
{
for (int i = 0; i < messages.Length - 1; i++)
{
sha256.TransformBlock(messages[i], 0, messages[i].Length, messages[i], 0);
}
sha256.TransformFinalBlock(messages[messages.Length - 1], 0, messages[messages.Length - 1].Length);
hash = sha256.Hash;
}
#elif NETSTANDARD13
using (var incrementalHash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256))
{
foreach (var byteArray in messages)
{
incrementalHash.AppendData(byteArray);
}
hash = incrementalHash.GetHashAndReset();
}
#endif
var computed = new BinaryHexString(hash);
return(computed);
}
public BinaryHexString GetSharedKey(BinaryHexString accountPublicKey, BinaryHexString nonce, string secretPhrase)
{
var accountBytes = accountPublicKey.ToBytes().ToArray();
var nonceBytes = nonce.ToBytes().ToArray();
var sharedSecret = _crypto.GetSharedSecret(accountBytes, nonceBytes, secretPhrase);
return(sharedSecret);
}
public async Task <ShufflersReply> GetShufflers(Account account = null, BinaryHexString shufflingFullHash = null,
SecretPhraseOrAdminPassword sercretPhraseOrAdminPassword = null)
{
var queryParameters = sercretPhraseOrAdminPassword != null ? sercretPhraseOrAdminPassword.QueryParameters : new Dictionary <string, string>();
queryParameters.AddIfHasValue(Parameters.Account, account);
queryParameters.AddIfHasValue(Parameters.ShufflingFullHash, shufflingFullHash);
return(await Get <ShufflersReply>("getShufflers", queryParameters));
}
public async Task <TransactionCreatedReply> ShufflingRegister(BinaryHexString shufflingFullHash, CreateTransactionParameters parameters)
{
var queryParameters = new Dictionary <string, string>
{
{ Parameters.ShufflingFullHash, shufflingFullHash.ToString() }
};
parameters.AppendToQueryParameters(queryParameters);
return(await Post <TransactionCreatedReply>("shufflingRegister", queryParameters));
}
internal BinaryHexString GetPublicKey(string secretPhrase)
{
var publicKey = new byte[32];
var encodedSecretPhrase = Encoding.UTF8.GetBytes(secretPhrase);
var hashedSecretPhrase = ComputeHash(encodedSecretPhrase);
Curve25519.Keygen(publicKey, null, hashedSecretPhrase);
var binaryHexString = new BinaryHexString(publicKey);
return(binaryHexString);
}
public async Task <TransactionCreatedReply> ShufflingVerify(ulong shuffling, BinaryHexString shufflingStateHash, CreateTransactionParameters parameters)
{
var queryParameters = new Dictionary <string, string>
{
{ Parameters.Shuffling, shuffling.ToString() },
{ Parameters.ShufflingStateHash, shufflingStateHash.ToString() }
};
parameters.AppendToQueryParameters(queryParameters);
return(await Post <TransactionCreatedReply>("shufflingVerify", queryParameters));
}
public async Task <HashReply> Hash(HashAlgorithm hashAlgorithm, BinaryHexString secret, bool?secretIsText = null)
{
var queryParameters = new Dictionary <string, string>
{
{ Parameters.HashAlgorithm, ((int)hashAlgorithm).ToString() },
{ Parameters.Secret, secret.ToString() }
};
queryParameters.AddIfHasValue(Parameters.SecretIsText, secretIsText);
return(await Get <HashReply>("hash", queryParameters));
}
public async Task <StopShufflerReply> StopShuffler(Account account = null, BinaryHexString shufflingFullHash = null,
SecretPhraseOrAdminPassword secretPhraseOrAdminPassword = null)
{
var queryParameters = secretPhraseOrAdminPassword == null
? new Dictionary <string, string>()
: secretPhraseOrAdminPassword.QueryParameters;
queryParameters.AddIfHasValue(Parameters.Account, account);
queryParameters.AddIfHasValue(Parameters.ShufflingFullHash, shufflingFullHash);
return(await Post <StopShufflerReply>("stopShuffler", queryParameters));
}
public BinaryHexString EncryptDataTo(BinaryHexString recipientPublicKey, BinaryHexString data, BinaryHexString nonce, bool compress, string secretPhrase)
{
var recipientPublicKeyBytes = recipientPublicKey.ToBytes().ToArray();
var nonceBytes = nonce.ToBytes().ToArray();
var dataBytes = data.ToBytes().ToArray();
if (compress)
{
dataBytes = _gzipCompressor.GzipCompress(dataBytes);
}
return(_crypto.AesEncryptTo(recipientPublicKeyBytes, dataBytes, nonceBytes, secretPhrase));
}
public async Task <TransactionListReply> GetLinkedPhasedTransactions(BinaryHexString linkedFullHash,
ulong?requireBlock = null, ulong?requireLastBlock = null)
{
var queryParameters = new Dictionary <string, string>
{
{ Parameters.LinkedFullHash, linkedFullHash.ToString() }
};
queryParameters.AddIfHasValue(Parameters.RequireBlock, requireBlock);
queryParameters.AddIfHasValue(Parameters.RequireLastBlock, requireLastBlock);
return(await Get <TransactionListReply>("getLinkedPhasedTransactions", queryParameters));
}
internal async void UpdateRecipientInfo()
{
if (string.IsNullOrEmpty(Recipient) || Errors[nameof(Recipient)].Any())
{
Info = string.Empty;
return;
}
AccountReply account = null;
Contact contact = null;
var recipientAddress = Contact.GetAddressOrInput(Recipient);
await Task.Run(async() =>
{
try
{
_recipientPublicKey = null;
account = await _nxtServer.GetAccountAsync(recipientAddress);
}
catch (Exception)
{
// Ignore
}
contact = await _contactRepository.GetContactAsync(recipientAddress);
});
if (!_nxtServer.IsOnline)
{
Info = "Unable to get information about recipient in offline mode.";
IsMessageEncryptionEnabled = false;
EncryptMessage = false;
return;
}
if (account == null)
{
Info = "The recipient account is an unknown account, meaning it has never had an incoming or outgoing transaction.";
IsMessageEncryptionEnabled = false;
EncryptMessage = false;
return;
}
_recipientPublicKey = account.PublicKey;
IsMessageEncryptionEnabled = true;
var recipientInfo = "The recipient";
var name = (contact != null) ? contact.Name : (!string.IsNullOrEmpty(account.Name)) ? account.Name : string.Empty;
if (!string.IsNullOrEmpty(name))
{
recipientInfo += $", {name}";
}
recipientInfo += $" has a balance of {account.Balance.Nxt.ToFormattedString(2)} NXT";
Info = recipientInfo;
}
public byte[] DecryptData(BinaryHexString data, BinaryHexString nonce, bool uncompress, BinaryHexString sharedKey)
{
var sharedKeyBytes = sharedKey.ToBytes().ToArray();
var dataBytes = data.ToBytes().ToArray();
var nonceBytes = nonce.ToBytes().ToArray();
var decrypted = _crypto.AesDecrypt(dataBytes, nonceBytes, sharedKeyBytes);
if (uncompress)
{
decrypted = _gzipCompressor.GzipUncompress(decrypted);
}
return(decrypted);
}
public async Task <ShufflerReply> StartShuffler(string secretPhrase, BinaryHexString shufflingFullHash,
string recipientSecretPhrase, BinaryHexString recipientPublicKey = null)
{
var queryParameters = new Dictionary <string, string>
{
{ Parameters.SecretPhrase, secretPhrase },
{ Parameters.ShufflingFullHash, shufflingFullHash.ToHexString() },
{ Parameters.RecipientSecretPhrase, recipientSecretPhrase }
};
queryParameters.AddIfHasValue(Parameters.RecipientPublicKey, recipientPublicKey);
return(await Post <ShufflerReply>("startShuffler", queryParameters));
}
public JObject SignTransaction(TransactionCreatedReply transactionCreatedReply, string secretPhrase)
{
var transaction = transactionCreatedReply.Transaction;
var unsignedBytes = transactionCreatedReply.UnsignedTransactionBytes.ToBytes().ToArray();
var referencedTransactionFullHash = transaction.ReferencedTransactionFullHash != null
? transaction.ReferencedTransactionFullHash.ToHexString()
: "";
var attachment = JObject.Parse(transactionCreatedReply.RawJsonReply).SelectToken($"{Parameters.TransactionJson}['{Parameters.Attachment}']");
var signature = new BinaryHexString(_crypto.Sign(unsignedBytes, secretPhrase));
return(BuildSignedTransaction(transaction, referencedTransactionFullHash, signature, attachment));
}
public async Task <TransactionCreatedReply> ShufflingProcess(ulong shuffling, string recipientSecretPhrase,
BinaryHexString recipientPublicKey, CreateTransactionParameters parameters)
{
var queryParameters = new Dictionary <string, string>
{
{ Parameters.Shuffling, shuffling.ToString() },
{ Parameters.RecipientSecretPhrase, recipientSecretPhrase },
{ Parameters.RecipientPublicKey, recipientPublicKey.ToString() }
};
parameters.AppendToQueryParameters(queryParameters);
return(await Post <TransactionCreatedReply>("shufflingProcess", queryParameters));
}
public byte[] DecryptDataFrom(BinaryHexString senderPublicKey, BinaryHexString data, BinaryHexString nonce, bool uncompress, string secretPhrase)
{
var senderPublicKeyBytes = senderPublicKey.ToBytes().ToArray();
var dataBytes = data.ToBytes().ToArray();
var nonceBytes = nonce.ToBytes().ToArray();
var decrypted = _crypto.AesDecryptFrom(senderPublicKeyBytes, dataBytes, nonceBytes, secretPhrase);
if (uncompress)
{
decrypted = _gzipCompressor.GzipUncompress(decrypted);
}
return(decrypted);
}
public async Task <PurchaseReply> GetPurchase(ulong purchaseId, string secretPhrase = null,
BinaryHexString sharedKey = null, ulong?requireBlock = null, ulong?requireLastBlock = null)
{
var queryParameters = new Dictionary <string, string> {
{ Parameters.Purchase, purchaseId.ToString() }
};
queryParameters.AddIfHasValue(Parameters.SecretPhrase, secretPhrase);
queryParameters.AddIfHasValue(Parameters.SharedKey, sharedKey);
queryParameters.AddIfHasValue(Parameters.RequireBlock, requireBlock);
queryParameters.AddIfHasValue(Parameters.RequireLastBlock, requireLastBlock);
return(await Get <PurchaseReply>("getDGSPurchase", queryParameters));
}
public async Task <CalculateFullHashReply> CalculateFullHash(BinaryHexString signatureHash,
BinaryHexString unsignedTransactionBytes = null, string unsignedTransactionJson = null)
{
var queryParameters = new Dictionary <string, string> {
{ Parameters.SignatureHash, signatureHash.ToHexString() }
};
if (unsignedTransactionBytes != null)
{
queryParameters.Add(Parameters.UnsignedTransactionBytes, unsignedTransactionBytes.ToHexString());
}
queryParameters.AddIfHasValue(Parameters.UnsignedTransactionJson, unsignedTransactionJson);
return(await Get <CalculateFullHashReply>("calculateFullHash", queryParameters));
}
public async Task <DecryptedDataReply> DecryptDataFrom(Account account, BinaryHexString data, BinaryHexString nonce,
bool uncompressDecryptedMessage, string secretPhrase)
{
var queryParameters = new Dictionary <string, string>
{
{ Parameters.Account, account.AccountId.ToString() },
{ Parameters.Data, data.ToHexString() },
{ Parameters.Nonce, nonce.ToHexString() },
{ Parameters.SecretPhrase, secretPhrase },
{ Parameters.UncompressDecryptedMessage, uncompressDecryptedMessage.ToString() },
{ Parameters.DecryptedMessageIsText, false.ToString() }
};
return(await Get <DecryptedDataReply>("decryptFrom", queryParameters));
}
private static BinaryHexString HashPrunableMessage(bool isText, string message)
{
byte[] isTextByte;
byte[] messageBytes;
if (isText)
{
isTextByte = new byte[] { 1 };
messageBytes = Encoding.UTF8.GetBytes(message);
}
else
{
isTextByte = new byte[] { 0 };
messageBytes = new BinaryHexString(message).ToBytes().ToArray();
}
return(HashPrunableMessage(isTextByte, messageBytes));
}
private void SendEncryptedDataByPublicKey()
{
using (Logger = new TestsessionLogger(_logger))
{
byte[] bytes = { 4, 7, 1, 64, 23, 91, 1, 45, 23 };
var expected = new BinaryHexString(bytes);
var parameters = CreateTransaction.CreateTransactionByPublicKey(Amount.CreateAmountFromNxt(3));
parameters.EncryptedMessage = new CreateTransactionParameters.MessageToBeEncrypted(bytes, true);
var sendMesageResult = _messageService.SendMessage(parameters, TestSettings.Account2.AccountRs).Result;
var actual = sendMesageResult.Transaction.EncryptedMessage;
AssertIsFalse(actual.IsPrunable, nameof(actual.IsPrunable));
AssertIsTrue(actual.IsCompressed, nameof(actual.IsCompressed));
AssertIsFalse(actual.IsText, nameof(actual.IsText));
AssertEquals(expected.ToHexString(), actual.MessageToEncrypt, nameof(actual.MessageToEncrypt));
AssertIsNull(actual.Data, nameof(actual.Data));
AssertIsNull(actual.EncryptedMessageHash, nameof(actual.EncryptedMessageHash));
AssertIsNull(actual.Nonce, nameof(actual.Nonce));
}
}
public async Task <TransactionCreatedReply> Delivery(ulong purchaseId, CreateTransactionParameters parameters,
Amount discount = null, string goodsToEncrypt = null, bool?goodsIsText = null, string goodsData = null,
BinaryHexString goodsNonce = null)
{
var queryParameters = new Dictionary <string, string> {
{ Parameters.Purchase, purchaseId.ToString() }
};
parameters.AppendToQueryParameters(queryParameters);
if (discount != null)
{
queryParameters.AddIfHasValue(Parameters.DiscountNqt, discount.Nqt);
}
queryParameters.AddIfHasValue(Parameters.GoodsToEncrypt, goodsToEncrypt);
queryParameters.AddIfHasValue(Parameters.GoodsIsText, goodsIsText);
queryParameters.AddIfHasValue(Parameters.GoodsData, goodsData);
if (goodsNonce != null)
{
queryParameters.AddIfHasValue(Parameters.GoodsNonce, goodsNonce.ToHexString());
}
return(await Post <TransactionCreatedReply>("dgsDelivery", queryParameters));
}
public TransactionParameter(BinaryHexString transactionBytes)
{
TransactionBytes = transactionBytes;
}
public static AccountIdLocator ByPublicKey(BinaryHexString publicKey)
{
return(new AccountIdLocator(Parameters.PublicKey, publicKey.ToHexString()));
}
public static GetTransactionLocator ByFullHash(BinaryHexString fullHash)
{
return(new GetTransactionLocator(fullHash));
}
internal static void AddIfHasValue(this Dictionary <string, string> me, string key, BinaryHexString value)
{
if (value != null)
{
me.Add(key, value.ToHexString());
}
}
