/**
        * Generate a suitable blind factor for the public key the generator was initialised with.
        *
        * @return a random blind factor
        */
        public BigInteger GenerateBlindingFactor()
        {
            if (key == null)
                throw new InvalidOperationException("generator not initialised");

            BigInteger m = key.Modulus;
            int length = m.BitLength - 1; // must be less than m.BitLength
            BigInteger factor;
            BigInteger gcd;

            do
            {
                factor = new BigInteger(length, random);
                gcd = factor.Gcd(m);
            }
            while (factor.SignValue == 0 || factor.Equals(BigInteger.One) || !gcd.Equals(BigInteger.One));

            return factor;
        }
        /// <summary>Choose a random prime value for use with RSA</summary>
        /// <param name="bitlength">the bit-length of the returned prime</param>
        /// <param name="e">the RSA public exponent</param>
        /// <returns>a prime p, with (p-1) relatively prime to e</returns>
        protected virtual BigInteger ChooseRandomPrime(int bitlength, BigInteger e)
        {
            for (;;)
            {
                BigInteger p = new BigInteger(bitlength, 1, param.Random);

                if (p.Mod(e).Equals(BigInteger.One))
                    continue;

                if (!p.IsProbablePrime(param.Certainty))
                    continue;

                if (!e.Gcd(p.Subtract(BigInteger.One)).Equals(BigInteger.One))
                    continue;

                return p;
            }
        }