Inheritance: Org.BouncyCastle.Crypto.KeyGenerationParameters
		/*
		 * (non-Javadoc)
		 *
		 * @see org.bouncycastle.crypto.AsymmetricCipherKeyPairGenerator#init(org.bouncycastle.crypto.KeyGenerationParameters)
		 */
		public void Init(KeyGenerationParameters parameters)
		{
			this.param = (NaccacheSternKeyGenerationParameters)parameters;
		}
        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");
            }
        }