Esempio n. 1
0
        private static void DoDiffieHellman <TScalar, TElement>(
            CryptoGroup <TScalar, TElement> group, RandomNumberGenerator randomNumberGenerator
            ) where TScalar : notnull where TElement : notnull
        {
            // Generating DH secret and public key for Alice
            (TScalar dhSecretAlice, CryptoGroupElement <TScalar, TElement> dhPublicAlice) =
                group.GenerateRandom(randomNumberGenerator);

            // Generating DH secret and public key for Bob
            (TScalar dhSecretBob, CryptoGroupElement <TScalar, TElement> dhPublicBob) =
                group.GenerateRandom(randomNumberGenerator);

            // Computing shared secret for Alice and Bob
            CryptoGroupElement <TScalar, TElement> sharedSecretBob   = dhPublicAlice * dhSecretBob;
            CryptoGroupElement <TScalar, TElement> sharedSecretAlice = dhPublicBob * dhSecretAlice;

            // Confirm that it's the same
            Debug.Assert(sharedSecretAlice.Equals(sharedSecretBob));

            Console.WriteLine($"Alice - Secret: {dhSecretAlice}, Public: {dhPublicAlice}");
            Console.WriteLine($"Bob   - Secret: {dhSecretBob}, Public: {dhPublicBob}");

            Console.WriteLine($"Alice - Result: {sharedSecretAlice}");
            Console.WriteLine($"Bob   - Result: {sharedSecretBob}");
        }
Esempio n. 2
0
        public void TestGenerateRandom()
        {
            var order = BigPrime.CreateWithoutChecks(1021);

            var expectedIndex = new BigInteger(19);
            int expectedRaw   = 7;

            var algebraMock = new Mock <ICryptoGroupAlgebra <BigInteger, int> >(MockBehavior.Strict);

            algebraMock.Setup(alg => alg.IsPotentialElement(It.IsAny <int>())).Returns(true);
            algebraMock.Setup(alg => alg.GenerateRandomElement(It.IsAny <RandomNumberGenerator>())).Returns((expectedIndex, expectedRaw));

            var expectedElement = new CryptoGroupElement <BigInteger, int>(expectedRaw, algebraMock.Object);

            var groupMock = new CryptoGroup <BigInteger, int>(algebraMock.Object);

            var rngMock = new Mock <RandomNumberGenerator>();

            var result        = groupMock.GenerateRandom(rngMock.Object);
            var resultIndex   = result.Item1;
            var resultElement = result.Item2;

            Assert.AreEqual(expectedIndex, resultIndex);
            Assert.AreEqual(expectedElement, resultElement);
        }
        public static void DoDiffieHellman <TScalar, TElement>(
            CryptoGroup <TScalar, TElement> group
            ) where TScalar : notnull where TElement : notnull
        {
            RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create();

            // Generating DH secret and public key for Alice
            (var dhSecretAlice, var dhPublicAlice) =
                group.GenerateRandom(randomNumberGenerator);

            // Generating DH secret and public key for Bob
            (var dhSecretBob, var dhPublicBob) =
                group.GenerateRandom(randomNumberGenerator);

            // Computing shared secret for Alice and Bob
            var sharedSecretBob   = dhPublicAlice * dhSecretBob;
            var sharedSecretAlice = dhPublicBob * dhSecretAlice;

            Assert.AreEqual(sharedSecretAlice, sharedSecretBob);
        }