public void SrpHashComputesValidSrpIntegerHashes()
        {
            var parts  = new[] { "Hello", " ", "world!" };
            var sample = string.Concat(parts);
            var srpint = SrpInteger.FromHex("48 65 6C 6C 6F 20 77 6F 72 6c 64 21");

            H   md5     = new SrpHash <MD5>().ComputeHash;
            var hashmd5 = SrpInteger.FromHex("86FB269D190D2C85F6E0468CECA42A20");

            Assert.AreEqual(hashmd5, md5(srpint));
            Assert.AreEqual(hashmd5, md5(sample));
            Assert.AreEqual(hashmd5, md5(parts));
            Assert.AreEqual(16, new SrpHash <MD5>().HashSizeBytes);

            H   sha256  = new SrpHash <SHA256>().ComputeHash;
            var hash256 = SrpInteger.FromHex("C0535E4BE2B79FFD93291305436BF889314E4A3FAEC05ECFFCBB7DF31AD9E51A");

            Assert.AreEqual(hash256, sha256(srpint));
            Assert.AreEqual(hash256, sha256(sample));
            Assert.AreEqual(hash256, sha256(parts));
            Assert.AreEqual(256 / 8, new SrpHash <SHA256>().HashSizeBytes);

            H   sha512  = new SrpHash <SHA512>().ComputeHash;
            var hash512 = SrpInteger.FromHex("F6CDE2A0F819314CDDE55FC227D8D7DAE3D28CC556222A0A8AD66D91CCAD4AAD6094F517A2182360C9AACF6A3DC323162CB6FD8CDFFEDB0FE038F55E85FFB5B6");

            Assert.AreEqual(hash512, sha512(srpint));
            Assert.AreEqual(hash512, sha512(sample));
            Assert.AreEqual(hash512, sha512(parts));
            Assert.AreEqual(512 / 8, new SrpHash <SHA512>().HashSizeBytes);
        }
        public void SrpHashComputesValidStringHashes()
        {
            var parts  = new[] { "D4C7F8A2B32", "C11B8FBA9581EC4BA4F1B0421", "", "5642EF7355E37C0FC0443EF7", "56EA2C6B8EEB755A1C72302", "7663CAA265EF785B8FF6A9B35227A52D86633DBDFCA43" };
            var sample = string.Concat(parts);
            var srpint = SrpInteger.FromHex(sample);

            H   md5     = new SrpHash <MD5>().ComputeHash;
            var hashmd5 = SrpInteger.FromHex("34ada39bbabfa6e663f1aad3d7814121");

            Assert.AreEqual(hashmd5, md5(srpint.ToHex().ToUpper()));
            Assert.AreEqual(hashmd5, md5(sample));
            Assert.AreEqual(hashmd5, md5(parts));
            Assert.AreEqual(16, new SrpHash <MD5>().HashSizeBytes);

            H   sha256  = new SrpHash <SHA256>().ComputeHash;
            var hash256 = SrpInteger.FromHex("1767fe8c94508ad3514b8332493fab5396757fe347023fc9d1fef6d26c3a70d3");

            Assert.AreEqual(hash256, sha256(srpint.ToHex().ToUpper()));
            Assert.AreEqual(hash256, sha256(sample));
            Assert.AreEqual(hash256, sha256(parts));
            Assert.AreEqual(256 / 8, new SrpHash <SHA256>().HashSizeBytes);

            H   sha512  = new SrpHash <SHA512>().ComputeHash;
            var hash512 = SrpInteger.FromHex("f2406fd4b33b15a6b47ff78ccac7cd80eec7944092425b640d740e7dc695fdd42f583a9b4a4b98ffa5409680181999bfe319f2a3b50ddb111e8405019a8c552a");

            Assert.AreEqual(hash512, sha512(srpint.ToHex().ToUpper()));
            Assert.AreEqual(hash512, sha512(sample));
            Assert.AreEqual(hash512, sha512(parts));
            Assert.AreEqual(512 / 8, new SrpHash <SHA512>().HashSizeBytes);
        }
Beispiel #3
0
        public void SrpHashMiscTests()
        {
            var hash = new SrpHash(() => MD5.Create());

            Assert.IsNotEmpty(hash.AlgorithmName);

            var tmp = hash.ComputeHash(null, null, null);
        }
Beispiel #4
0
        public void CreateHasherByNameTests()
        {
            var sha1 = SrpHash.CreateHasher("sha1");

            Assert.NotNull(sha1);

            var sha256 = SrpHash.CreateHasher("sha256");

            Assert.NotNull(sha256);

            var sha384 = SrpHash.CreateHasher("sha384");

            Assert.NotNull(sha384);

            var sha512 = SrpHash.CreateHasher("sha512");

            Assert.NotNull(sha512);
        }
Beispiel #5
0
        public void CreateHasherTests()
        {
            var sha1 = SrpHash <SHA1> .CreateHasher();

            Assert.NotNull(sha1);

            var sha256 = SrpHash <SHA256> .CreateHasher();

            Assert.NotNull(sha256);

            var sha384 = SrpHash <SHA384> .CreateHasher();

            Assert.NotNull(sha384);

            var sha512 = SrpHash <SHA512> .CreateHasher();

            Assert.NotNull(sha512);
        }
        public void SrpClientDerivesThePrivateKeyAndVerifier()
        {
            // validate intermediate steps
            var userName = "******";
            var password = "******";
            H   H        = new SrpHash <SHA256>().ComputeHash;
            var step1    = H($"{userName}:{password}");

            Assert.AreEqual(SrpInteger.FromHex("ed3250071433e544b62b5dd0341564825a697357b5379f07aabca795a4e0a109"), step1);

            // step1.1
            var salt   = "34ada39bbabfa6e663f1aad3d7814121";
            var s      = SrpInteger.FromHex(salt);
            var step11 = H(s);

            Assert.AreEqual(SrpInteger.FromHex("a5acfc1292e1b8e171b7c9a0f7b5bcd9bbcd4a3485c18d9d4fcf4480e8573442"), step11);

            // step1.2
            var step12 = H(step1);

            Assert.AreEqual(SrpInteger.FromHex("446d597ddf0e65ca0395926665e70f10a2b0f8194f633243e71359028895be6f"), step12);

            // step2
            var step2 = H(s, step1);

            Assert.AreEqual(SrpInteger.FromHex("e2db59181003e48e326292b3b307a1173a5f1fd12c6ffde55f7289503065fd6c"), step2);

            // private key derivation is deterministic for the same s, I, p
            var privateKey = new SrpClient().DerivePrivateKey(salt, userName, password);

            Assert.AreEqual("e2db59181003e48e326292b3b307a1173a5f1fd12c6ffde55f7289503065fd6c", privateKey);

            // verifier
            var verifier = new SrpClient().DeriveVerifier(privateKey);

            Assert.AreEqual("622dad56d6c282a949f9d2702941a9866b7dd277af92a6e538b2d7cca42583275a2f4b64bd61369a24b23170223faf212e2f3bdddc529204c61055687c4162aa2cd0fd41ced0186406b8a6dda4802fa941c54f5115ca69953a8e265210349a4cb89dda3febc96c86df08a87823235ff6c87a170cc1618f38ec493e758e2cac4c04db3dcdac8656458296dbcc3599fc1f66cde1e62e477dd1696c65dbeb413d8ed832adc7304e68566b46a7849126eea62c95d5561306f76fe1f8a77a3bd85db85e6b0262064d665890ff46170f96ce403a9b485abe387e91ca85e3522d6276e2fff41754d57a71dee6da62aea614725da100631efd7442cf68a294001d8134e9", verifier);
        }
Beispiel #7
0
            /// <summary>
            /// Creates the hasher.
            /// </summary>
            private HashAlgorithm CreateHasher()
            {
                var hasher = SrpHash.CreateHasher(H);

                if (hasher == null)
                {
                    HashAlgorithm blake2s() =>
                    Blake2S.Create().AsHashAlgorithm();

                    HashAlgorithm blake2b(int bits) =>
                    new Blake2BHasher(new Blake2BConfig {
                        OutputSizeInBits = bits
                    })
                    .AsHashAlgorithm();

                    switch (H.ToLowerInvariant())
                    {
                    case "blake2s-256":
                        return(blake2s());

                    case "blake2b-224":
                        return(blake2b(224));

                    case "blake2b-256":
                        return(blake2b(256));

                    case "blake2b-384":
                        return(blake2b(384));

                    case "blake2b-512":
                        return(blake2b(512));
                    }
                }

                return(hasher);
            }