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()); } }