From de2a53c1cf74ff573de3e5b7eac640a02acd1f59 Mon Sep 17 00:00:00 2001
From: GabrielTofvesson <gabriel.tofvesson@gmail.com>
Date: Mon, 9 Apr 2018 10:08:06 +0200
Subject: [PATCH] Changes: * Removed SHA1 implementation from ECDH

---
 .../KeyExchange/EllipticDiffieHellman.cs      | 94 +------------------
 1 file changed, 1 insertion(+), 93 deletions(-)

diff --git a/Common/Cryptography/KeyExchange/EllipticDiffieHellman.cs b/Common/Cryptography/KeyExchange/EllipticDiffieHellman.cs
index 7a29724..285c6c8 100644
--- a/Common/Cryptography/KeyExchange/EllipticDiffieHellman.cs
+++ b/Common/Cryptography/KeyExchange/EllipticDiffieHellman.cs
@@ -76,99 +76,7 @@ namespace Common.Cryptography.KeyExchange
 
             Point remotePublic = new Point(new BigInteger(p1), new BigInteger(p2));
 
-            byte[] secret = curve.Multiply(remotePublic, priv).X.ToByteArray(); // Use the x-coordinate as the shared secret
-
-            // SHA-1 (Common shared secret generation method)
-
-            // Initialize buffers
-            uint h0 = 0x67452301;
-            uint h1 = 0xEFCDAB89;
-            uint h2 = 0x98BADCFE;
-            uint h3 = 0x10325476;
-            uint h4 = 0xC3D2E1F0;
-
-            // Pad message
-            int ml = secret.Length + 1;
-            byte[] msg = new byte[ml + ((960 - (ml * 8 % 512)) % 512) / 8 + 8];
-            Array.Copy(secret, msg, secret.Length);
-            msg[secret.Length] = 0x80;
-            long len = secret.Length * 8;
-            for (int i = 0; i < 8; ++i) msg[msg.Length - 1 - i] = (byte)((len >> (i * 8)) & 255);
-            //Support.WriteToArray(msg, message.Length * 8, msg.Length - 8);
-            //for (int i = 0; i <4; ++i) msg[msg.Length - 5 - i] = (byte)(((message.Length*8) >> (i * 8)) & 255);
-
-            int chunks = msg.Length / 64;
-
-            // Perform hashing for each 512-bit block
-            for (int i = 0; i < chunks; ++i)
-            {
-
-                // Split block into words
-                uint[] w = new uint[80];
-                for (int j = 0; j < 16; ++j)
-                    w[j] |= (uint)((msg[i * 64 + j * 4] << 24) | (msg[i * 64 + j * 4 + 1] << 16) | (msg[i * 64 + j * 4 + 2] << 8) | (msg[i * 64 + j * 4 + 3] << 0));
-
-                // Expand words
-                for (int j = 16; j < 80; ++j)
-                    w[j] = Rot(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
-
-                // Initialize chunk-hash
-                uint
-                    a = h0,
-                    b = h1,
-                    c = h2,
-                    d = h3,
-                    e = h4;
-
-                // Do hash rounds
-                for (int t = 0; t < 80; ++t)
-                {
-                    uint tmp = ((a << 5) | (a >> (27))) +
-                        ( // Round-function
-                        t < 20 ? (b & c) | ((~b) & d) :
-                        t < 40 ? b ^ c ^ d :
-                        t < 60 ? (b & c) | (b & d) | (c & d) :
-                        /*t<80*/ b ^ c ^ d
-                        ) +
-                        e +
-                        ( // K-function
-                        t < 20 ? 0x5A827999 :
-                        t < 40 ? 0x6ED9EBA1 :
-                        t < 60 ? 0x8F1BBCDC :
-                        /*t<80*/ 0xCA62C1D6
-                        ) +
-                        w[t];
-                    e = d;
-                    d = c;
-                    c = Rot(b, 30);
-                    b = a;
-                    a = tmp;
-                }
-                h0 += a;
-                h1 += b;
-                h2 += c;
-                h3 += d;
-                h4 += e;
-            }
-
-            return WriteContiguous(new byte[20], 0, SwapEndian(h0), SwapEndian(h1), SwapEndian(h2), SwapEndian(h3), SwapEndian(h4));
-        }
-        private static uint Rot(uint val, int by) => (val << by) | (val >> (32 - by));
-
-        // Swap endianness of a given integer
-        private static uint SwapEndian(uint value) => (uint)(((value >> 24) & (255 << 0)) | ((value >> 8) & (255 << 8)) | ((value << 8) & (255 << 16)) | ((value << 24) & (255 << 24)));
-
-        private static byte[] WriteToArray(byte[] target, uint data, int offset)
-        {
-            for (int i = 0; i < 4; ++i)
-                target[i + offset] = (byte)((data >> (i * 8)) & 255);
-            return target;
-        }
-
-        private static byte[] WriteContiguous(byte[] target, int offset, params uint[] data)
-        {
-            for (int i = 0; i < data.Length; ++i) WriteToArray(target, data[i], offset + i * 4);
-            return target;
+            return curve.Multiply(remotePublic, priv).X.ToByteArray(); // Use the x-coordinate as the shared secret
         }
 
         public static EllipticDiffieHellman Curve25519(BigInteger priv) => new EllipticDiffieHellman(c_25519, c_25519_gen, c_25519_order, priv.ToByteArray());