public void Curve25519_GetPublicKey() { var ticks = new List <long>(); for (byte b = 0; b < 255; b++) { var stopwatch = Stopwatch.StartNew(); byte[] privateKey = Curve25519.ClampPrivateKey(TestHelpers.GetUniformBytes(b, 32)); for (int i = 0; i < 1000; i++) { byte[] publicKey = Curve25519.GetPublicKey(privateKey); // IDE0059 - Unnecessary assignment of a value } ticks.Add(stopwatch.ElapsedMilliseconds); } var min = long.MaxValue; var max = long.MinValue; foreach (var t in ticks) { if (min > t) { min = t; } if (max < t) { max = t; } } Assert.Null($"Min: {min}, Max: {max}"); // (.Inconclusive) - will Fail for now; waiting for Xunit.SkippableFact }
public void Test_15_X25519_ECDH() { byte[] A = Hashes.StringToBinary("77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a"); Curve25519 Alice = new Curve25519(A); Assert.AreEqual("8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a", Hashes.BinaryToString(Alice.PublicKey)); A = Hashes.StringToBinary("5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb"); Curve25519 Bob = new Curve25519(A); Assert.AreEqual("de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f", Hashes.BinaryToString(Bob.PublicKey)); byte[] Key1 = Alice.GetSharedKey(Bob.PublicKey, Hashes.ComputeSHA256Hash); byte[] Key2 = Bob.GetSharedKey(Alice.PublicKey, Hashes.ComputeSHA256Hash); string k1 = Hashes.BinaryToString(Key1); string k2 = Hashes.BinaryToString(Key2); Assert.AreEqual(k1, k2); A = Hashes.StringToBinary("4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742"); if (A.Length != 32) { Array.Resize <byte>(ref A, 32); } Array.Reverse(A); // Most significant byte first. A = Hashes.ComputeSHA256Hash(A); string k3 = Hashes.BinaryToString(A); Assert.AreEqual(k1, k3); }
public static byte[] calculateAgreement(ECPublicKey publicKey, ECPrivateKey privateKey) { if (publicKey == null) { throw new InvalidKeyException("public value is null"); } if (privateKey == null) { throw new InvalidKeyException("private value is null"); } if (publicKey.getType() != privateKey.getType()) { throw new InvalidKeyException("Public and private keys must be of the same type!"); } if (publicKey.getType() == DJB_TYPE) { return(Curve25519.getInstance(Curve25519ProviderType.BEST) .calculateAgreement(((DjbECPublicKey)publicKey).getPublicKey(), ((DjbECPrivateKey)privateKey).getPrivateKey())); } else { throw new InvalidKeyException("Unknown type: " + publicKey.getType()); } }
public void Test_11_X25519_TestVector_2() { byte[] A = Hashes.StringToBinary("4b66e9d4d1b4673c5ad22691957d6af5c11b6421e0ea01d42ca4169e7918ba0d"); A[0] &= 248; A[31] &= 127; A[31] |= 64; BigInteger N0 = new BigInteger(A); BigInteger N = BigInteger.Parse("35156891815674817266734212754503633747128614016119564763269015315466259359304"); Assert.AreEqual(N, N0); A = Hashes.StringToBinary("e5210f12786811d3f4b7959d0538ae2c31dbe7106fc03c3efc4cd549c715a493"); A[31] &= 127; BigInteger U0 = new BigInteger(A); BigInteger U = BigInteger.Parse("8883857351183929894090759386610649319417338800022198945255395922347792736741"); Assert.AreEqual(U, U0); A = Hashes.StringToBinary("95cbde9476e8907d7aade45cb4b873f88b595a68799fa152e6f8f7647aac7957"); BigInteger NU0 = new BigInteger(A); MontgomeryCurve C = new Curve25519(); BigInteger NU = C.ScalarMultiplication(N, U); Assert.AreEqual(NU0, NU); }
public static EcKeyPair GenerateKeyPair() { Curve25519KeyPair keyPair = Curve25519.GetInstance(Curve25519ProviderType.Best).GenerateKeyPair(); return(new EcKeyPair(new DjbEcPublicKey(keyPair.GetPublicKey()), new DjbEcPrivateKey(keyPair.GetPrivateKey()))); }
public void TestCurve25519() { var kvps = new Dictionary <string, string>() { { "oB2yte8v6Edhi3t3DeHX+LEfpRGi1jVb6FYTeheQ9XI=", "HfqqvO1mk4gx2bLDO6tPxTNHl6oi7Z42YLUaLj/Oe0Y=" }, { "YDYr+o/wLbovtba446v27X//NM4szFqXdij1dKLlPl8=", "oWX4rcyZHyQAwLRG7l4tZWgRamSPhXhfurx+y3bYAGY=" }, { "GOYViPkGsghgYGdUCVaCqvp4qTkKQ3tfPEUdCv/NT14=", "YWeFxQabAS+sKyxqJGHothzNZxdyhEPXYyBx/DtLb24=" }, { "oKNRZnxqn6uIpQDm58xsngQtuy8Ed0tzQbsfAUZYenQ=", "+UmPSdIVMLiIpe5WNngz5Gp85bAitD1aq0SW69D5WFU=" }, { "QFGPYiCQE/l92/1Kea1RASI+N/wKrlFypgBNahpE438=", "drKPmk5gSAGr77Nd7/oCsahsHFZmKfFisfmzMpvmzFs=" }, { "gFxQ2NGOJDjOww84Ye4x9Y5khSGTrTKfpJr7ODeOAEs=", "9y05bruujPguw4FFJ+JM5uHqn3IziMPTk8ag8Xpv/X8=" }, { "aCaXfvXjUpsb9MEClv6F59XoC4/9xPvp7lCUfz0n00Y=", "np0SHP6UIjvEBhNs2yJrMlqAb0w5vw64KK0sjj+AcWE=" }, { "yF+hep+SSWf3iVAD8AgFA7qV1KFOXprmFosh6h04Vlc=", "+T64sgnEGBsixpov0ovMNe11yThM2zkf09G8NTnbiAo=" }, { "sOdE3Tm4af1c5AUL624wdNtAR/jwV+Fdb6UqWzMSnmQ=", "Da29TizW/FfqUb4RfaJDOFkRo97W78GslypQbKL7tDQ=" }, { "OOzuuGFc6uug5gy/5GY5QDyqheWRYDAAJQz/LBcWZHI=", "nkqKSbuLFwYNY/2QA+C+gvRIOnc0aYowROwZmftD+Gc=" }, { "iAMBbzRD8ThURLaD4zI/XTbEN8eGE0Hg4KOh0nrZqnI=", "m/4VkymgSpp8k8bBNQmKnYY0Y6at8ttNlr+Wm4v7gzc=" }, { "YCfrE2SwOb4skiAFIFFpYA85WR1qR5nJmVySAHusilA=", "LATS8VywXK8813rVTdn1xfB/i3QFcY8/9BGloi++2ho=" }, { "+I05d4noKVZ1sAopMLn3NBysHEPdmfWyGSuoR1GKj2g=", "g8UNfQYTOwhQ73XQRSdlOlsiXIY7Q4nscrdyZeHFjhQ=" }, { "AAPEMoFI13vgwge4UhpTTnYQHAaHnYbgJHWoKjZ5Y28=", "+IU+ONtYsi4sVPNY4Xdcyoc9Q+YbTShMdZMt2+s9MRI=" }, { "4DVgmYHhWdjieJY20VvWPocR7IIv0/HuPl1DXRTd4mU=", "UtPY7Cq7G38SXdg1l1UTzsdg48taFYetMZXoa4rmZAg=" }, }; foreach (var kv in kvps) { var publicKey = Curve25519.GetPublicKey(kv.Key); Assert.AreEqual(publicKey, kv.Value); } }
private void NegotiateKey(ConnectedClient selectedClient) { var synMessage = new EncMessage() { Sender = new ConnectedClient() { Id = _userId, Username = _username }, Recipient = selectedClient, UsedForDHExchange = true, Payload = new byte[1] { 0x34 } }; _serverChannel.SendMessage(synMessage); byte[] rndBytes = new byte[32]; RNGCryptoServiceProvider.Create().GetBytes(rndBytes); privateKey = Curve25519.ClampPrivateKey(rndBytes); byte[] publicKey = Curve25519.GetPublicKey(privateKey); synMessage.Payload = publicKey; _serverChannel.SendMessage(synMessage); }
public void Curve25519_GetPublicKey() { List <long> ticks = new List <long>(); for (int i = 0; i < 255; i++) { Stopwatch stopwatch = Stopwatch.StartNew(); byte[] privateKey = Curve25519.ClampPrivateKey(TestHelpers.GetUniformBytes((byte)i, 32)); for (int j = 0; j < 1000; j++) { byte[] publicKey = Curve25519.GetPublicKey(privateKey); } ticks.Add(stopwatch.ElapsedMilliseconds); } long min = long.MaxValue; long max = long.MinValue; for (int i = 0; i < ticks.Count; i++) { if (ticks[i] < min) { min = ticks[i]; } if (ticks[i] > max) { max = ticks[i]; } } Assert.Inconclusive("Min: {0}, Max: {1}", min, max); }
public void Curve25519_GetPublicKey() { var ticks = new List <long>(); for (var i = 0; i < 255; i++) { var stopwatch = Stopwatch.StartNew(); var privateKey = Curve25519.ClampPrivateKey(TestHelpers.GetUniformBytes((byte)i, 32)); for (var j = 0; j < 1000; j++) { var publicKey = Curve25519.GetPublicKey(privateKey); } ticks.Add(stopwatch.ElapsedMilliseconds); } var min = long.MaxValue; var max = long.MinValue; foreach (var t in ticks) { if (t < min) { min = t; } if (t > max) { max = t; } } Assert.Inconclusive("Min: {0}, Max: {1}", min, max); }
private void button4_Click(object sender, EventArgs e) { if (loadedPartnerKey && loadedKeychain) { OpenFileDialog theDialog = new OpenFileDialog(); theDialog.Title = "Open file to decrypt"; theDialog.Filter = "CurveBox encrypted file |*.curvebox"; if (theDialog.ShowDialog() == DialogResult.OK) { string filename = theDialog.FileName; dataPath = filename; loadedFile = true; } if (!loadedFile) { MessageBox.Show("No file loaded!"); return; } byte[] sharedKey = Curve25519.GetSharedSecret(loadedPrivateKey, loadedPartnerPublicKey); byte[] hashedKey = sha256(System.Text.Encoding.UTF8.GetString(sharedKey)); AES_Decrypt(dataPath, Encoding.UTF8.GetString(sharedKey)); MessageBox.Show(String.Format("Wrote decrypted data to {0}", dataPath + ".decrypted")); } else { MessageBox.Show("Please load your keychain and your partners public key"); return; } }
public static void Square(int[] Outv, int Outvoffset, int[] A, int Aoffset) { int j; for (int i = 0; i < 32; ++i) { int u = 0; for (j = 0; j < i - j; ++j) { u += A[Aoffset + j] * A[Aoffset + i - j]; } for (j = i + 1; j < i + 32 - j; ++j) { u += 38 * A[Aoffset + j] * A[Aoffset + i + 32 - j]; } u *= 2; if ((i & 1) == 0) { u += A[Aoffset + i / 2] * A[Aoffset + i / 2]; u += 38 * A[Aoffset + i / 2 + 16] * A[Aoffset + i / 2 + 16]; } Outv[Outvoffset + i] = u; } Curve25519.Squeeze(Outv, Outvoffset); }
public static int CryptoScalarmult(byte[] Q, byte[] N, byte[] P) { int[] work = new int[96]; byte[] e = new byte[32]; for (int i = 0; i < 32; ++i) { e[i] = N[i]; } e[0] &= 248; e[31] &= 127; e[31] |= 64; for (int i = 0; i < 32; ++i) { work[i] = P[i] & 0xFF; } Curve25519.Mainloop(work, e); Curve25519.Recip(work, 32, work, 32); Curve25519.Mult(work, 64, work, 0, work, 32); Curve25519.Freeze(work, 64); for (int i = 0; i < 32; ++i) { Q[i] = (byte)work[64 + i]; } return(0); }
public static ECKeyPair generateKeyPair() { Curve25519KeyPair keyPair = Curve25519.getInstance(Curve25519ProviderType.BEST).generateKeyPair(); return(new ECKeyPair(new DjbECPublicKey(keyPair.getPublicKey()), new DjbECPrivateKey(keyPair.getPrivateKey()))); }
private void X25519_TestVector_3(int i, string HexResult) { MontgomeryCurve C = new Curve25519(); BigInteger N = 9; BigInteger U = 9; BigInteger NU; while (i-- > 0) { byte[] NBin = N.ToByteArray(); if (NBin.Length != 32) { Array.Resize <byte>(ref NBin, 32); } NBin[0] &= 0xf8; NBin[31] &= 0x3f; NBin[31] |= 0x40; NU = C.ScalarMultiplication(NBin, U); U = N; N = NU; } byte[] A = Hashes.StringToBinary(HexResult); BigInteger NU0 = new BigInteger(A); Assert.AreEqual(NU0, NU); }
public Response <ECKeyPair> GenerateECKeyPair(byte[] seed = null) { var response = new Response <ECKeyPair>(); try { var randomResponse = GetRandom(32, seed); if (!randomResponse.IsSuccess) { throw new Exception(response.Error); } var privateKeyToBeClamped = randomResponse.Result.X; Curve25519.ClampPrivateKeyInline(privateKeyToBeClamped); var publicKey = Curve25519.GetPublicKey(privateKeyToBeClamped); var keyPair = new ECKeyPair { PrivateKey = privateKeyToBeClamped, PublicKey = publicKey }; response.Result = keyPair; response.SetSuccess(); } catch (Exception e) { response.SetError(e); } return(response); }
public DNSCrypt(IOptionsMonitor <DNSCryptOptions> DNSCryptOptions) { Options = DNSCryptOptions; Random = new Random(); Client = new UdpClient { Client = { SendTimeout = Options.CurrentValue.Timeout, ReceiveTimeout = Options.CurrentValue.Timeout } }; Stamp = (DNSCryptStamp)Options.CurrentValue.Stamp.Value; IPEndPoint = IPEndPoint.Parse(Stamp.Address); var ClientCurve25519 = new Curve25519(); ClientPublicKey = ClientCurve25519.GetPublicKey(); ClientPrivateKey = ClientCurve25519.GetPrivateKey(); ChaCha20Poly1305 = new ChaCha20Poly1305(); IsInitialized = false; }
public byte[] CalculateAndHashSharedSecret(byte[] privateKey, byte[] publicKey) { Guard.NotNull(privateKey, publicKey); var sharedSecret = Curve25519.GetSharedSecret(privateKey, publicKey); var sharedSecretHash = this._platform.ComputeSHA256(sharedSecret); return(sharedSecretHash); }
static byte[] GenerateCurve25519PrivateKey() { RNGCryptoServiceProvider rngCsp = new RNGCryptoServiceProvider(); byte[] key = new byte[32]; rngCsp.GetBytes(key); return(Curve25519.ClampPrivateKey(key)); }
public ECDHCryptor() { //first we generate random bytes as starting sequence byte[] aliceRandomBytes = new byte[32]; //must be 32 bytes long RNGCryptoServiceProvider.Create().GetBytes(aliceRandomBytes); //generate random bytes _privateKey = Curve25519.ClampPrivateKey(aliceRandomBytes); PublicKey = Curve25519.GetPublicKey(_privateKey); }
private void loadKeychain(string location) { try { using (FileStream fsSource = new FileStream(location, FileMode.Open, FileAccess.Read)) { byte[] bytes = new byte[fsSource.Length]; int numBytesToRead = (int)fsSource.Length; int numBytesRead = 0; while (numBytesToRead > 0) { // Read may return anything from 0 to numBytesToRead. int n = fsSource.Read(bytes, numBytesRead, numBytesToRead); // Break when the end of the file is reached. if (n == 0) { break; } numBytesRead += n; numBytesToRead -= n; } numBytesToRead = bytes.Length; Byte[] hash = new Byte[64]; Buffer.BlockCopy(bytes, 0, hash, 0, hash.Length); string publicKeyhash = Encoding.UTF8.GetString(hash); byte[] hashBytes = Encoding.UTF8.GetBytes(publicKeyhash); Byte[] fileBytes = new Byte[bytes.Length - 64]; Buffer.BlockCopy(bytes, 64, fileBytes, 0, fileBytes.Length); string encodedKey = Encoding.UTF8.GetString(fileBytes); byte[] decodedBytes = Base64Decode(fileBytes); byte[] publicKey = Curve25519.GetPublicKey(decodedBytes); byte[] hashPublic = sha256(System.Text.Encoding.UTF8.GetString(publicKey)); if (String.ReferenceEquals(Encoding.UTF8.GetString(hashPublic), publicKeyhash)) { MessageBox.Show("Expected pubic key hash does not match calculated hash, loading failed."); return; } loadedPrivateKey = decodedBytes; loadedPublicKey = publicKey; label1.Text = String.Format("Keychain Loaded: YES"); label3.Text = String.Format("Loaded path: {0}", location); label2.Text = String.Format("Publickey hash: {0}", publicKeyhash); loadedKeychain = true; } } catch (FileNotFoundException ioEx) { Console.WriteLine(ioEx.Message); } }
public static void Main() { var curve = new Curve25519(); var privateKey = curve.CreateRandomPrivateKey(); var publicKey = curve.GetPublicKey(privateKey); Console.WriteLine(Convert.ToBase64String(privateKey)); Console.WriteLine(Convert.ToBase64String(publicKey)); }
public static bool VerifySignature(ECPublicKey signingKey, byte[] message, byte[] signature) { if (signingKey.GetKeyType() == DJB_TYPE) { return(Curve25519.GetInstance(Curve25519ProviderType.BEST).VerifySignature(((DjbECPublicKey)signingKey).GetPublicKey(), message, signature)); } else { throw new InvalidKeyException("Unknown type: " + signingKey.GetKeyType()); } }
public static byte[] CalculateSignature(ECPrivateKey signingKey, byte[] message) { if (signingKey.GetKeyType() == DJB_TYPE) { return(Curve25519.GetInstance(Curve25519ProviderType.BEST).CalculateSignature(((DjbECPrivateKey)signingKey).GetPrivateKey(), message)); } else { throw new InvalidKeyException("Unknown type: " + signingKey.GetKeyType()); } }
public void TestExternal() { for (int i = 0; i < 100; i++) { var privateKey = (i % 2 == 0) ? Utils.CreateProcess(wg, "genkey") : Curve25519.GetPrivateKey(); var publicKey1 = Utils.CreateProcess(wg, "pubkey", privateKey); var publicKey2 = Curve25519.GetPublicKey(privateKey); Assert.AreEqual(publicKey1, publicKey2); } }
/// <summary> /// 交换密钥 /// </summary> /// <param name="exchange">交换流程(输入值是我方公钥,返回值是对端公钥)</param> /// <returns>密钥</returns> public byte[] ExchangeSecret(Func <byte[], byte[]> exchange) { Guard.Requires <ArgumentNullException>(exchange != null); var randBytes = new byte[32]; RandomNumberGenerator.Create().GetBytes(randBytes); var privateKey = Curve25519.ClampPrivateKey(randBytes); var publicKey = Curve25519.GetPublicKey(privateKey); return(Curve25519.GetSharedSecret(privateKey, exchange.Invoke(publicKey))); }
public static byte[] VerifyVrfSignature(IEcPublicKey signingKey, byte[] message, byte[] signature) { if (signingKey.GetKeyType() == DjbType) { return(Curve25519.GetInstance(Curve25519ProviderType.Best) .VerifyVrfSignature(((DjbEcPublicKey)signingKey).GetPublicKey(), message, signature)); } else { throw new InvalidKeyException("Unknown type: " + signingKey.GetKeyType()); } }
/// <summary> /// Performs an Elliptic Curve Diffie-Hellman key agreement operation (scalar multiplication), /// with cofactor multiplication (ECDHC). /// </summary> /// <returns>The ECDHC shared secret.</returns> /// <param name="publicKey">Public key.</param> /// <param name="privateKey">Private key.</param> public static byte[] CalculateEcdhcSecret(ECKey publicKey, ECKey privateKey) { if (publicKey.CurveName.Equals(DjbCurve.Curve25519.ToString())) { return(Curve25519.CalculateSharedSecret(privateKey.EncodedKey, publicKey.EncodedKey)); } else if (publicKey.CurveName.Equals(DjbCurve.Ed25519.ToString())) { return(Ed25519.KeyExchange(publicKey.EncodedKey, privateKey.EncodedKey)); } return (CalculateEcdhcSecret(DecodeToPublicKey(publicKey), DecodeToPrivateKey(privateKey)).ToByteArrayUnsigned()); }
public void TestDonnaPublicKeyGeneration() { Curve25519 curve = Curve25519.getInstance(Curve25519.BEST); byte[] private_key = new byte[BYTES_SIZE]; byte[] public_key = new byte[BYTES_SIZE]; for (int i = 0; i < TEST_COUNT; i++) { private_key = curve.generatePrivateKey(); public_key = curve.generatePublicKey(private_key); } }
public RemoteAttestationKeys(Curve25519KeyPair keyPair, byte[] serverPublicEphemeral, byte[] serverPublicStatic) { byte[] ephemeralToEphemeral = Curve25519.getInstance(Curve25519.BEST).calculateAgreement(serverPublicEphemeral, keyPair.getPrivateKey()); byte[] ephemeralToStatic = Curve25519.getInstance(Curve25519.BEST).calculateAgreement(serverPublicStatic, keyPair.getPrivateKey()); byte[] masterSecret = ByteUtil.combine(ephemeralToEphemeral, ephemeralToStatic); byte[] publicKeys = ByteUtil.combine(keyPair.getPublicKey(), serverPublicEphemeral, serverPublicStatic); HkdfBytesGenerator generator = new HkdfBytesGenerator(new Sha256Digest()); generator.Init(new HkdfParameters(masterSecret, publicKeys, null)); generator.GenerateBytes(ClientKey, 0, ClientKey.Length); generator.GenerateBytes(ServerKey, 0, ServerKey.Length); }
private void button5_Click(object sender, EventArgs e) { byte[] aliceRandomBytes = new byte[32]; RNGCryptoServiceProvider.Create().GetBytes(aliceRandomBytes); byte[] alicePrivate = Curve25519.ClampPrivateKey(aliceRandomBytes); byte[] alicePublic = Curve25519.GetPublicKey(alicePrivate); string base64Key = Base64Encode(alicePrivate); byte[] encodedBytes = Encoding.UTF8.GetBytes(base64Key); byte[] hashPublic = sha256(System.Text.Encoding.UTF8.GetString(alicePublic)); SaveFileDialog saveFileDialog1 = new SaveFileDialog(); saveFileDialog1.Filter = "CurveBox keychain|*.curvechain"; saveFileDialog1.Title = "Save CurveBox keychain"; saveFileDialog1.ShowDialog(); // If the file name is not an empty string open it for saving. if (saveFileDialog1.FileName != "") { // Saves the Image via a FileStream created by the OpenFile method. System.IO.FileStream fs = (System.IO.FileStream)saveFileDialog1.OpenFile(); // Saves the Image in the appropriate ImageFormat based upon the // File type selected in the dialog box. // NOTE that the FilterIndex property is one-based. var fw = new BinaryWriter(fs); fw.Write(hashPublic); fw.Write(encodedBytes); fw.Flush(); fw.Close(); fs.Close(); } DialogResult dialogResult = MessageBox.Show("Would you like to try to load this new keychain now?", "Load keychain", MessageBoxButtons.YesNo); if (dialogResult == DialogResult.Yes) { loadKeychain(saveFileDialog1.FileName); } else if (dialogResult == DialogResult.No) { // do nothing n***a } }