Inheritance: IAsymmetricCipherKeyPairGenerator
        public override void PerformTest()
        {
            // Test with given key from NaccacheSternPaper (totally insecure)

            // First the Parameters from the NaccacheStern Paper
            // (see http://www.gemplus.com/smart/rd/publications/pdf/NS98pkcs.pdf )

            smallPrimes.Add(u1);
            smallPrimes.Add(u2);
            smallPrimes.Add(u3);
            smallPrimes.Add(v1);
            smallPrimes.Add(v2);
            smallPrimes.Add(v3);

            NaccacheSternKeyParameters pubParameters = new NaccacheSternKeyParameters(false, g, n, sigma.BitLength);

            NaccacheSternPrivateKeyParameters privParameters = new NaccacheSternPrivateKeyParameters(g, n, sigma
                .BitLength, smallPrimes, phi_n);

            IAsymmetricCipherKeyPair pair = new AsymmetricCipherKeyPair(pubParameters, privParameters);

            // Initialize Engines with KeyPair

            if (debug)
            {
                Console.WriteLine("initializing encryption engine");
            }
            cryptEng.Init(true, pair.Public);

            if (debug)
            {
                Console.WriteLine("initializing decryption engine");
            }
            decryptEng.Init(false, pair.Private);

            byte[] data = paperTest.ToByteArray();

            if (!new BigInteger(data).Equals(new BigInteger(enDeCrypt(data))))
            {
                Fail("failed NaccacheStern paper test");
            }

            //
            // key generation test
            //

            //
            // 768 Bit test
            //

            if (debug)
            {
                Console.WriteLine();
                Console.WriteLine("768 Bit TEST");
            }

            // specify key generation parameters
            NaccacheSternKeyGenerationParameters genParam
                = new NaccacheSternKeyGenerationParameters(new SecureRandom(), 768, 8, 30, debug);

            // Initialize Key generator and generate key pair
            NaccacheSternKeyPairGenerator pGen = new NaccacheSternKeyPairGenerator();
            pGen.Init(genParam);

            pair = pGen.GenerateKeyPair();

            if (((NaccacheSternKeyParameters)pair.Public).Modulus.BitLength < 768)
            {
                Console.WriteLine("FAILED: key size is <786 bit, exactly "
                           + ((NaccacheSternKeyParameters)pair.Public).Modulus.BitLength + " bit");
                Fail("failed key generation (768) length test");
            }

            // Initialize Engines with KeyPair

            if (debug)
            {
                Console.WriteLine("initializing " + genParam.Strength + " bit encryption engine");
            }
            cryptEng.Init(true, pair.Public);

            if (debug)
            {
                Console.WriteLine("initializing " + genParam.Strength + " bit decryption engine");
            }
            decryptEng.Init(false, pair.Private);

            // Basic data input
            data = Hex.Decode(input);

            if (!new BigInteger(1, data).Equals(new BigInteger(1, enDeCrypt(data))))
            {
                Fail("failed encryption decryption (" + genParam.Strength + ") basic test");
            }

            // Data starting with FF byte (would be interpreted as negative
            // BigInteger)

            data = Hex.Decode(edgeInput);

            if (!new BigInteger(1, data).Equals(new BigInteger(1, enDeCrypt(data))))
            {
                Fail("failed encryption decryption (" + genParam.Strength + ") edgeInput test");
            }

            //
            // 1024 Bit Test
            //
            /*
                    if (debug)
                    {
                        Console.WriteLine();
                        Console.WriteLine("1024 Bit TEST");
                    }

                    // specify key generation parameters
                    genParam = new NaccacheSternKeyGenerationParameters(new SecureRandom(), 1024, 8, 40, debug);

                    pGen.Init(genParam);
                    pair = pGen.generateKeyPair();

                    if (((NaccacheSternKeyParameters)pair.Public).getModulus().bitLength() < 1024)
                    {
                        if (debug)
                        {
                            Console.WriteLine("FAILED: key size is <1024 bit, exactly "
                                            + ((NaccacheSternKeyParameters)pair.Public).getModulus().bitLength() + " bit");
                        }
                        Fail("failed key generation (1024) length test");
                    }

                    // Initialize Engines with KeyPair

                    if (debug)
                    {
                        Console.WriteLine("initializing " + genParam.getStrength() + " bit encryption engine");
                    }
                    cryptEng.Init(true, pair.Public);

                    if (debug)
                    {
                        Console.WriteLine("initializing " + genParam.getStrength() + " bit decryption engine");
                    }
                    decryptEng.Init(false, pair.Private);

                    if (debug)
                    {
                        Console.WriteLine("Data is           " + new BigInteger(1, data));
                    }

                    // Basic data input
                    data = Hex.Decode(input);

                    if (!new BigInteger(1, data).Equals(new BigInteger(1, enDeCrypt(data))))
                    {
                        Fail("failed encryption decryption (" + genParam.getStrength() + ") basic test");
                    }

                    // Data starting with FF byte (would be interpreted as negative
                    // BigInteger)

                    data = Hex.Decode(edgeInput);

                    if (!new BigInteger(1, data).Equals(new BigInteger(1, enDeCrypt(data))))
                    {
                        Fail("failed encryption decryption (" + genParam.getStrength() + ") edgeInput test");
                    }
            */
            // END OF TEST CASE

            try
            {
                new NaccacheSternEngine().ProcessBlock(new byte[]{ 1 }, 0, 1);
                Fail("failed initialisation check");
            }
            catch (InvalidOperationException)
            {
                // expected
            }

            if (debug)
            {
                Console.WriteLine("All tests successful");
            }
        }
Esempio n. 2
0
        public AsymmetricCipherKeyPair GenerateKeyPair()
        {
            int          strength  = this.param.Strength;
            SecureRandom random    = this.param.Random;
            int          certainty = this.param.Certainty;
            bool         isDebug   = this.param.IsDebug;

            if (isDebug)
            {
                Console.WriteLine("Fetching first " + this.param.CountSmallPrimes + " primes.");
            }
            IList list = NaccacheSternKeyPairGenerator.findFirstPrimes(this.param.CountSmallPrimes);

            list = NaccacheSternKeyPairGenerator.permuteList(list, random);
            BigInteger bigInteger  = BigInteger.One;
            BigInteger bigInteger2 = BigInteger.One;

            for (int i = 0; i < list.Count / 2; i++)
            {
                bigInteger = bigInteger.Multiply((BigInteger)list[i]);
            }
            for (int j = list.Count / 2; j < list.Count; j++)
            {
                bigInteger2 = bigInteger2.Multiply((BigInteger)list[j]);
            }
            BigInteger bigInteger3 = bigInteger.Multiply(bigInteger2);
            int        num         = strength - bigInteger3.BitLength - 48;
            BigInteger bigInteger4 = NaccacheSternKeyPairGenerator.generatePrime(num / 2 + 1, certainty, random);
            BigInteger bigInteger5 = NaccacheSternKeyPairGenerator.generatePrime(num / 2 + 1, certainty, random);
            long       num2        = 0L;

            if (isDebug)
            {
                Console.WriteLine("generating p and q");
            }
            BigInteger val  = bigInteger4.Multiply(bigInteger).ShiftLeft(1);
            BigInteger val2 = bigInteger5.Multiply(bigInteger2).ShiftLeft(1);
            BigInteger bigInteger6;
            BigInteger bigInteger7;
            BigInteger bigInteger8;
            BigInteger bigInteger9;

            while (true)
            {
                num2       += 1L;
                bigInteger6 = NaccacheSternKeyPairGenerator.generatePrime(24, certainty, random);
                bigInteger7 = bigInteger6.Multiply(val).Add(BigInteger.One);
                if (bigInteger7.IsProbablePrime(certainty))
                {
                    while (true)
                    {
                        bigInteger8 = NaccacheSternKeyPairGenerator.generatePrime(24, certainty, random);
                        if (!bigInteger6.Equals(bigInteger8))
                        {
                            bigInteger9 = bigInteger8.Multiply(val2).Add(BigInteger.One);
                            if (bigInteger9.IsProbablePrime(certainty))
                            {
                                break;
                            }
                        }
                    }
                    if (!bigInteger3.Gcd(bigInteger6.Multiply(bigInteger8)).Equals(BigInteger.One))
                    {
                        Console.WriteLine(string.Concat(new object[]
                        {
                            "sigma.gcd(_p.mult(_q)) != 1!\n _p: ",
                            bigInteger6,
                            "\n _q: ",
                            bigInteger8
                        }));
                    }
                    else
                    {
                        if (bigInteger7.Multiply(bigInteger9).BitLength >= strength)
                        {
                            break;
                        }
                        if (isDebug)
                        {
                            Console.WriteLine(string.Concat(new object[]
                            {
                                "key size too small. Should be ",
                                strength,
                                " but is actually ",
                                bigInteger7.Multiply(bigInteger9).BitLength
                            }));
                        }
                    }
                }
            }
            if (isDebug)
            {
                Console.WriteLine("needed " + num2 + " tries to generate p and q.");
            }
            BigInteger bigInteger10 = bigInteger7.Multiply(bigInteger9);
            BigInteger bigInteger11 = bigInteger7.Subtract(BigInteger.One).Multiply(bigInteger9.Subtract(BigInteger.One));

            num2 = 0L;
            if (isDebug)
            {
                Console.WriteLine("generating g");
            }
            BigInteger bigInteger12;

            while (true)
            {
                IList list2 = Platform.CreateArrayList();
                for (int num3 = 0; num3 != list.Count; num3++)
                {
                    BigInteger val3 = (BigInteger)list[num3];
                    BigInteger e    = bigInteger11.Divide(val3);
                    do
                    {
                        num2        += 1L;
                        bigInteger12 = NaccacheSternKeyPairGenerator.generatePrime(strength, certainty, random);
                    }while (bigInteger12.ModPow(e, bigInteger10).Equals(BigInteger.One));
                    list2.Add(bigInteger12);
                }
                bigInteger12 = BigInteger.One;
                for (int k = 0; k < list.Count; k++)
                {
                    BigInteger bigInteger13 = (BigInteger)list2[k];
                    BigInteger val4         = (BigInteger)list[k];
                    bigInteger12 = bigInteger12.Multiply(bigInteger13.ModPow(bigInteger3.Divide(val4), bigInteger10)).Mod(bigInteger10);
                }
                bool flag = false;
                for (int l = 0; l < list.Count; l++)
                {
                    if (bigInteger12.ModPow(bigInteger11.Divide((BigInteger)list[l]), bigInteger10).Equals(BigInteger.One))
                    {
                        if (isDebug)
                        {
                            Console.WriteLine(string.Concat(new object[]
                            {
                                "g has order phi(n)/",
                                list[l],
                                "\n g: ",
                                bigInteger12
                            }));
                        }
                        flag = true;
                        break;
                    }
                }
                if (!flag)
                {
                    if (bigInteger12.ModPow(bigInteger11.ShiftRight(2), bigInteger10).Equals(BigInteger.One))
                    {
                        if (isDebug)
                        {
                            Console.WriteLine("g has order phi(n)/4\n g:" + bigInteger12);
                        }
                    }
                    else if (bigInteger12.ModPow(bigInteger11.Divide(bigInteger6), bigInteger10).Equals(BigInteger.One))
                    {
                        if (isDebug)
                        {
                            Console.WriteLine("g has order phi(n)/p'\n g: " + bigInteger12);
                        }
                    }
                    else if (bigInteger12.ModPow(bigInteger11.Divide(bigInteger8), bigInteger10).Equals(BigInteger.One))
                    {
                        if (isDebug)
                        {
                            Console.WriteLine("g has order phi(n)/q'\n g: " + bigInteger12);
                        }
                    }
                    else if (bigInteger12.ModPow(bigInteger11.Divide(bigInteger4), bigInteger10).Equals(BigInteger.One))
                    {
                        if (isDebug)
                        {
                            Console.WriteLine("g has order phi(n)/a\n g: " + bigInteger12);
                        }
                    }
                    else
                    {
                        if (!bigInteger12.ModPow(bigInteger11.Divide(bigInteger5), bigInteger10).Equals(BigInteger.One))
                        {
                            break;
                        }
                        if (isDebug)
                        {
                            Console.WriteLine("g has order phi(n)/b\n g: " + bigInteger12);
                        }
                    }
                }
            }
            if (isDebug)
            {
                Console.WriteLine("needed " + num2 + " tries to generate g");
                Console.WriteLine();
                Console.WriteLine("found new NaccacheStern cipher variables:");
                Console.WriteLine("smallPrimes: " + CollectionUtilities.ToString(list));
                Console.WriteLine(string.Concat(new object[]
                {
                    "sigma:...... ",
                    bigInteger3,
                    " (",
                    bigInteger3.BitLength,
                    " bits)"
                }));
                Console.WriteLine("a:.......... " + bigInteger4);
                Console.WriteLine("b:.......... " + bigInteger5);
                Console.WriteLine("p':......... " + bigInteger6);
                Console.WriteLine("q':......... " + bigInteger8);
                Console.WriteLine("p:.......... " + bigInteger7);
                Console.WriteLine("q:.......... " + bigInteger9);
                Console.WriteLine("n:.......... " + bigInteger10);
                Console.WriteLine("phi(n):..... " + bigInteger11);
                Console.WriteLine("g:.......... " + bigInteger12);
                Console.WriteLine();
            }
            return(new AsymmetricCipherKeyPair(new NaccacheSternKeyParameters(false, bigInteger12, bigInteger10, bigInteger3.BitLength), new NaccacheSternPrivateKeyParameters(bigInteger12, bigInteger10, bigInteger3.BitLength, list, bigInteger11)));
        }