internal static string _Encode(byte[] privateKey, byte[] pubKey, string msg, byte[] iv, byte[] salt) { var shared = new byte[32]; Ed25519.key_derive( shared, salt, privateKey, pubKey); using (Aes aesAlg = Aes.Create()) { aesAlg.Key = shared; aesAlg.IV = iv; aesAlg.Mode = CipherMode.CBC; var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); using (var msEncrypt = new MemoryStream()) { using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (var swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(msg); } return(CryptoBytes.ToHexStringLower(salt) + CryptoBytes.ToHexStringLower(iv) + CryptoBytes.ToHexStringLower(msEncrypt.ToArray())); } } } }
public void RandomNonceTest() { var rnd = new Random(); var key = new byte[Snuffle.KEY_SIZE_IN_BYTES]; rnd.NextBytes(key); var aead = new ChaCha20Poly1305(key); var message = new byte[0]; var aad = new byte[0]; var ciphertexts = new HashSet <string>(); var samples = 1 << 17; for (var i = 0; i < samples; i++) { var ct = aead.Encrypt(message, aad); var ctHex = CryptoBytes.ToHexStringLower(ct); Assert.IsFalse(ciphertexts.Contains(ctHex)); ciphertexts.Add(ctHex); } Assert.AreEqual(samples, ciphertexts.Count); }
public static string PublicKeyToAddress(byte[] publicKey, int networkPrefix) { KeccakDigest shaDigest = new KeccakDigest(256); byte[] bytesFirst = new byte[32]; shaDigest.BlockUpdate(publicKey, 0, 32); shaDigest.DoFinal(bytesFirst, 0); RipeMD160Digest digestRipeMd160 = new RipeMD160Digest(); byte[] bytesSecond = new byte[20]; digestRipeMd160.BlockUpdate(bytesFirst, 0, 32); digestRipeMd160.DoFinal(bytesSecond, 0); byte[] bytesThird = CryptoBytes.FromHexString( string.Concat(networkPrefix, CryptoBytes.ToHexStringLower(bytesSecond)) ); byte[] bytesFourth = new byte[32]; shaDigest.BlockUpdate(bytesThird, 0, 21); shaDigest.DoFinal(bytesFourth, 0); byte[] bytesFifth = new byte[4]; Array.Copy(bytesFourth, 0, bytesFifth, 0, 4); byte[] bytesSixth = new byte[25]; Array.Copy(bytesThird, 0, bytesSixth, 0, 21); Array.Copy(bytesFifth, 0, bytesSixth, 21, 4); return(Base32.Encode(bytesSixth).ToUpper()); }
public static KeyPairViewModel GenerateFromPrivateKey(byte[] privateKey, int networkPrefix) { Array.Reverse(privateKey); byte[] publicKey = Ed25519.PublicKeyFromSeed(privateKey); Array.Reverse(privateKey); string address = PublicKeyToAddress(publicKey, networkPrefix); return(new KeyPairViewModel(CryptoBytes.ToHexStringLower(privateKey), CryptoBytes.ToHexStringLower(publicKey), address)); }
/// <summary> /// Produces a <see cref="PrivateKeyAccountClient"/> from a given <see cref="SecureString"/> of any size. /// </summary> /// <remarks> /// Takes a SecureString, hashes with Sha3 and converts the produced bytes to a 64 char hex string. The <see cref="StringUtils"/> class contains methods to convert to or from <see cref="SecureString"/>. /// </remarks> /// <param name="data">The data to convert to a private key.</param> /// <returns>A <see cref="PrivateKeyAccountClient"/> that can be used to initiate transactions.</returns> public PrivateKeyAccountClient FromNewDataPrivateKey(SecureString data) { var digestSha3 = new KeccakDigest(256); var dataBytes = Encoding.Default.GetBytes(StringUtils.ConvertToUnsecureString(data)); var pkBytes = new byte[32]; digestSha3.BlockUpdate(dataBytes, 0, 32); digestSha3.DoFinal(pkBytes, 0); var sk = StringUtils.ToSecureString(CryptoBytes.ToHexStringLower(pkBytes)); return(FromPrivateKey(new PrivateKey(sk))); }
/// <summary> /// Produces a public key from a given private key. /// </summary> /// <param name="privateKey">The private key to derive a public key from.</param> /// <remarks> /// As well as 64 char private keys, 66 char negative private keys are supported also supported. This does not affect the public key produced. /// </remarks> /// <returns>The derived public key string</returns> /// <exception cref="ArgumentException">invalid private key. Exacption bounds: Must be only hex string. Must be equal to 64 or 66 chars in length.</exception> /// <example> /// This sample shows how to use the <see cref="ToPublicKey"/> method. /// <code> /// class TestClass /// { /// static void Main() /// { /// string publicKey = PublicKeyConversion.ToPublicKey(new PrivateKey("0705c2634de7e58325dabc58c4a794559be4d55d102d3aafcb189acb2e596add")); /// } /// } /// </code> /// </example> public static string ToPublicKey(PrivateKey privateKey) { if (!StringUtils.OnlyHexInString(privateKey.Raw) || privateKey.Raw.Length == 64 && privateKey.Raw.Length == 66) { throw new ArgumentException("invalid private key"); } var privateKeyArray = CryptoBytes.FromHexString(StringUtils.ConvertToUnsecureString(privateKey.Raw)); Array.Reverse(privateKeyArray); return(CryptoBytes.ToHexStringLower(Ed25519.PublicKeyFromSeed(privateKeyArray))); }
private static FilterLog ConvertEthFilterLogToFilterLog(EthFilterLog log) { return(new FilterLog { Address = Address.FromBytes(log.Address.ToByteArray()).LocalAddress, Data = CryptoUtils.BytesToHexString(log.Data.ToByteArray()), Removed = log.Removed, Topics = log.Topics.Select(t => (object)t.ToStringUtf8()).ToArray(), Type = "", BlockHash = CryptoBytes.ToHexStringLower(log.BlockHash.ToByteArray()), BlockNumber = new HexBigInteger(log.BlockNumber), LogIndex = new HexBigInteger(log.LogIndex), TransactionHash = CryptoBytes.ToHexStringLower(log.TransactionHash.ToByteArray()), TransactionIndex = new HexBigInteger(log.TransactionIndex) }); }
/// <summary> /// Converts a public key to a main net or test net address. Network byte determines which network version to convert to. /// </summary> /// <param name="network">The network byte.</param> /// <param name="publicKey">The public key.</param> /// <returns>The unhyphenated address string.</returns> /// <exception cref="ArgumentException">invalid public key. Thrown when a public key is not a 64 char hex string.</exception> /// <example> /// This sample shows how to use the <see cref="ToEncoded"/> method. /// <code> /// class TestClass /// { /// static void Main() /// { /// Connection connection = new Connection(); /// /// string address = AddressEncoding.ToEncoded(connection.GetNetworkVersion(), new PublicKey("0705c2634de7e58325dabc58c4a794559be4d55d102d3aafcb189acb2e596add")); /// } /// } /// </code> /// </example> public static string ToEncoded(byte network, PublicKey publicKey) { if (!StringUtils.OnlyHexInString(publicKey.Raw) || publicKey.Raw.Length != 64) { throw new ArgumentException("invalid public key"); } // step 1) sha-3(256) public key var digestSha3 = new KeccakDigest(256); var stepOne = new byte[32]; digestSha3.BlockUpdate(CryptoBytes.FromHexString(publicKey.Raw), 0, 32); digestSha3.DoFinal(stepOne, 0); // step 2) perform ripemd160 on previous step var digestRipeMd160 = new RipeMD160Digest(); var stepTwo = new byte[20]; digestRipeMd160.BlockUpdate(stepOne, 0, 32); digestRipeMd160.DoFinal(stepTwo, 0); // step3) prepend network byte var stepThree = CryptoBytes.FromHexString(string.Concat(network == 0x68 ? 68 : 98, CryptoBytes.ToHexStringLower(stepTwo))); // step 4) perform sha3 on previous step var stepFour = new byte[32]; digestSha3.BlockUpdate(stepThree, 0, 21); digestSha3.DoFinal(stepFour, 0); // step 5) retrieve checksum var stepFive = new byte[4]; Array.Copy(stepFour, 0, stepFive, 0, 4); // step 6) append stepFive to resulst of stepThree var stepSix = new byte[25]; Array.Copy(stepThree, 0, stepSix, 0, 21); Array.Copy(stepFive, 0, stepSix, 21, 4); // step 7) return base 32 encode address byte array return(new Utils.Base32Encoder().Encode(stepSix).ToUpper()); }
public static PrivateKey Create() { var ng = RandomNumberGenerator.Create(); var bytes = new byte[2048]; ng.GetNonZeroBytes(bytes); var digestSha3 = new KeccakDigest(256); var stepOne = new byte[32]; digestSha3.BlockUpdate(bytes, 0, 32); digestSha3.DoFinal(stepOne, 0); var pk = new PrivateKey(StringUtils.ToSecureString(CryptoBytes.ToHexStringLower(stepOne))); bytes = null; stepOne = null; return(pk); }
protected void btnGerarChave_Click(object sender, EventArgs e) { RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider(); var byteArray = new byte[32]; provider.GetBytes(byteArray); var oi = CryptoBytes.ToHexStringLower(byteArray); byte[] chavePri, chavePu; Ed25519.KeyPairFromSeed(out chavePu, out chavePri, byteArray); var pri = CryptoBytes.ToHexStringLower(chavePri); var pu = CryptoBytes.ToHexStringLower(chavePu); chaveSementeGerada.Text = oi; chavePublicaGerada.Text = pu; }
public void WycheproofTestVectors() { var json = GetWycheproofTestVector(); var vector = JsonConvert.DeserializeObject <WycheproofVector>(json); //Utf8Json.JsonSerializer.Deserialize<WycheproofVector>(json); var errors = 0; foreach (var group in vector.TestGroups) { foreach (var test in group.Tests) { var id = $"TestCase {test.TcId}"; if (!string.IsNullOrEmpty(test.Comment)) { id += $" ({test.Comment})"; } var iv = CryptoBytes.FromHexString(test.Iv); var key = CryptoBytes.FromHexString(test.Key); var msg = CryptoBytes.FromHexString(test.Msg); var aad = CryptoBytes.FromHexString(test.Aad); var ct = CryptoBytes.FromHexString(test.Ct); var tag = CryptoBytes.FromHexString(test.Tag); var ciphertext = iv.Concat(ct).Concat(tag).ToArray(); // Result is one of "valid", "invalid", "acceptable". // "valid" are test vectors with matching plaintext, ciphertext and tag. // "invalid" are test vectors with invalid parameters or invalid ciphertext and tag. // "acceptable" are test vectors with weak parameters or legacy formats. var result = test.Result; try { var aead = new ChaCha20Poly1305(key); var decrypted = aead.Decrypt(ciphertext, aad); if (test.Result == "invalid") { TestContext.WriteLine($"FAIL {id}: accepting invalid ciphertext, cleartext: {test.Msg}, decrypted: {CryptoBytes.ToHexStringLower(decrypted)}"); errors++; continue; } if (!CryptoBytes.ConstantTimeEquals(msg, decrypted)) { TestContext.WriteLine($"FAIL {id}: incorrect decryption, result: {CryptoBytes.ToHexStringLower(decrypted)}, expected: {test.Msg}"); errors++; } } catch (Exception ex) { if (test.Result == "valid") { TestContext.WriteLine($"FAIL {id}: cannot decrypt, exception: {ex}"); errors++; } } } } Assert.AreEqual(0, errors); }
public void ToHexStringLowerNull() { Assert.AreEqual(null, CryptoBytes.ToHexStringLower(null)); }
public void ToHexStringLower() { Assert.AreEqual(HexStringLower, CryptoBytes.ToHexStringLower(_bytes)); }
public void ToHexStringLowerNull() { CryptoBytes.ToHexStringLower(null).Should().BeNull(); }
public void ToHexStringLower() { CryptoBytes.ToHexStringLower(_bytes).Should().Be(HexStringLower); }