C# IBigInteger.Subtract方法代码示例

        /**
        * Return a random IBigInteger not less than 'min' and not greater than 'max'
        *
        * @param min the least value that may be generated
        * @param max the greatest value that may be generated
        * @param random the source of randomness
        * @return a random IBigInteger value in the range [min,max]
        */
        public static IBigInteger CreateRandomInRange(
            IBigInteger min,
            IBigInteger max,
			// TODO Should have been just Random class
			ISecureRandom	random)
        {
            int cmp = min.CompareTo(max);
            if (cmp >= 0)
            {
                if (cmp > 0)
                    throw new ArgumentException("'min' may not be greater than 'max'");

                return min;
            }

            if (min.BitLength > max.BitLength / 2)
            {
                return CreateRandomInRange(BigInteger.Zero, max.Subtract(min), random).Add(min);
            }

            for (int i = 0; i < MaxIterations; ++i)
            {
                IBigInteger x = new BigInteger(max.BitLength, random);
                if (x.CompareTo(min) >= 0 && x.CompareTo(max) <= 0)
                {
                    return x;
                }
            }

            // fall back to a faster (restricted) method
            return new BigInteger(max.Subtract(min).BitLength - 1, random).Add(min);
        }

        private static IBigInteger CalculateGenerator_FIPS186_2(IBigInteger p, IBigInteger q, SecureRandom r)
        {
            IBigInteger e = p.Subtract(BigInteger.One).Divide(q);
            IBigInteger pSub2 = p.Subtract(BigInteger.Two);

            for (;;)
            {
                IBigInteger h = BigIntegers.CreateRandomInRange(BigInteger.Two, pSub2, r);
                IBigInteger g = h.ModPow(e, p);

                if (g.BitLength > 1)
                    return g;
            }
        }

        public static IBigInteger GeneratePrivateValue(IDigest digest, IBigInteger N, IBigInteger g, SecureRandom random)
        {
            int minBits = System.Math.Min(256, N.BitLength / 2);
            IBigInteger min = BigInteger.One.ShiftLeft(minBits - 1);
            IBigInteger max = N.Subtract(BigInteger.One);

            return BigIntegers.CreateRandomInRange(min, max, random);
        }

        private static IBigInteger GeneratePrivateKey(IBigInteger q, ISecureRandom random)
        {
            // TODO Prefer this method? (change test cases that used fixed random)
            // B.1.1 Key Pair Generation Using Extra Random Bits
            //	        IBigInteger c = new BigInteger(q.BitLength + 64, random);
            //	        return c.Mod(q.Subtract(BigInteger.One)).Add(BigInteger.One);

            // B.1.2 Key Pair Generation by Testing Candidates
            return BigIntegers.CreateRandomInRange(BigInteger.One, q.Subtract(BigInteger.One), random);
        }

        public DHParameters(
            IBigInteger p,
            IBigInteger g,
            IBigInteger q,
			int						m,
			int						l,
            IBigInteger j,
			DHValidationParameters	validation)
        {
            if (p == null)
                throw new ArgumentNullException("p");
            if (g == null)
                throw new ArgumentNullException("g");
            if (!p.TestBit(0))
                throw new ArgumentException(@"field must be an odd prime", "p");
            if (g.CompareTo(BigInteger.Two) < 0
                || g.CompareTo(p.Subtract(BigInteger.Two)) > 0)
                throw new ArgumentException(@"generator must in the range [2, p - 2]", "g");
            if (q != null && q.BitLength >= p.BitLength)
                throw new ArgumentException(@"q too big to be a factor of (p-1)", "q");
            if (m >= p.BitLength)
                throw new ArgumentException(@"m value must be < bitlength of p", "m");
            if (l != 0)
            {
                if (l >= p.BitLength)
                    throw new ArgumentException(@"when l value specified, it must be less than bitlength(p)", "l");
                if (l < m)
                    throw new ArgumentException(@"when l value specified, it may not be less than m value", "l");
            }
            if (j != null && j.CompareTo(BigInteger.Two) < 0)
                throw new ArgumentException(@"subgroup factor must be >= 2", "j");

            // TODO If q, j both provided, validate p = jq + 1 ?

            this.p = p;
            this.g = g;
            this.q = q;
            this.m = m;
            this.l = l;
            this.j = j;
            this.validation = validation;
        }

        public RsaSecretBcpgKey(IBigInteger d, IBigInteger p, IBigInteger q)
        {
            // PGP requires (p < q)
            var cmp = p.CompareTo(q);
            if (cmp >= 0)
            {
                if (cmp == 0)
                    throw new ArgumentException("p and q cannot be equal");

                var tmp = p;
                p = q;
                q = tmp;
            }

            _d = new MPInteger(d);
            _p = new MPInteger(p);
            _q = new MPInteger(q);
            _u = new MPInteger(p.ModInverse(q));

            _expP = d.Remainder(p.Subtract(BigInteger.One));
            _expQ = d.Remainder(q.Subtract(BigInteger.One));
            _crt = q.ModInverse(p);
        }

        private static IBigInteger CalculateGenerator_FIPS186_3_Verifiable(IDigest d, IBigInteger p, IBigInteger q,
			byte[] seed, int index)
        {
            // A.2.3 Verifiable Canonical Generation of the Generator g
            IBigInteger e = p.Subtract(BigInteger.One).Divide(q);
            byte[] ggen = Hex.Decode("6767656E");

            // 7. U = domain_parameter_seed || "ggen" || index || count.
            byte[] U = new byte[seed.Length + ggen.Length + 1 + 2];
            Array.Copy(seed, 0, U, 0, seed.Length);
            Array.Copy(ggen, 0, U, seed.Length, ggen.Length);
            U[U.Length - 3] = (byte)index;

            byte[] w = new byte[d.GetDigestSize()];
            for (int count = 1; count < (1 << 16); ++count)
            {
                Inc(U);
                Hash(d, U, w);
                IBigInteger W = new BigInteger(1, w);
                IBigInteger g = W.ModPow(e, p);

                if (g.CompareTo(BigInteger.Two) >= 0)
                    return g;
            }

            return null;
        }

        // Section 7.2.6 ECVP-NR, pg 35
        /**
         * return true if the value r and s represent a signature for the
         * message passed in. Generally, the order of the curve should be at
         * least as long as the hash of the message of interest, and with
         * ECNR, it *must* be at least as long.  But just in case the signer
         * applied mod(n) to the longer digest, this implementation will
         * apply mod(n) during verification.
         *
         * @param digest  the digest to be verified.
         * @param r       the r value of the signature.
         * @param s       the s value of the signature.
         * @exception DataLengthException if the digest is longer than the key allows
         */
        public bool VerifySignature(
			byte[]		message,
            IBigInteger r,
            IBigInteger s)
        {
            if (this._forSigning)
            {
                // not properly initilaized... deal with it
                throw new InvalidOperationException("not initialised for verifying");
            }

            ECPublicKeyParameters pubKey = (ECPublicKeyParameters)_key;
            IBigInteger n = pubKey.Parameters.N;
            int nBitLength = n.BitLength;

            IBigInteger e = new BigInteger(1, message);
            int eBitLength = e.BitLength;

            if (eBitLength > nBitLength)
            {
                throw new DataLengthException("input too large for ECNR key.");
            }

            // r in the range [1,n-1]
            if (r.CompareTo(BigInteger.One) < 0 || r.CompareTo(n) >= 0)
            {
                return false;
            }

            // TODO So why is this different from the spec?
            // s in the range [0,n-1]           NB: ECNR spec says 0
            if (s.CompareTo(BigInteger.Zero) < 0 || s.CompareTo(n) >= 0)
            {
                return false;
            }

            // compute P = sG + rW

            ECPoint G = pubKey.Parameters.G;
            ECPoint W = pubKey.Q;
            // calculate P using Bouncy math
            ECPoint P = ECAlgorithms.SumOfTwoMultiplies(G, s, W, r);

            IBigInteger x = P.X.ToBigInteger();
            IBigInteger t = r.Subtract(x).Mod(n);

            return t.Equals(e);
        }

        /**
        * Partial modular reduction modulo
        * <code>(&#964;<sup>m</sup> - 1)/(&#964; - 1)</code>.
        * @param k The integer to be reduced.
        * @param m The bitlength of the underlying finite field.
        * @param a The parameter <code>a</code> of the elliptic curve.
        * @param s The auxiliary values <code>s<sub>0</sub></code> and
        * <code>s<sub>1</sub></code>.
        * @param mu The parameter &#956; of the elliptic curve.
        * @param c The precision (number of bits of accuracy) of the partial
        * modular reduction.
        * @return <code>&#961; := k partmod (&#964;<sup>m</sup> - 1)/(&#964; - 1)</code>
        */
        public static ZTauElement PartModReduction(IBigInteger k, int m, sbyte a,
            IBigInteger[] s, sbyte mu, sbyte c)
        {
            // d0 = s[0] + mu*s[1]; mu is either 1 or -1
            IBigInteger d0;
            if (mu == 1)
            {
                d0 = s[0].Add(s[1]);
            }
            else
            {
                d0 = s[0].Subtract(s[1]);
            }

            IBigInteger[] v = GetLucas(mu, m, true);
            IBigInteger vm = v[1];

            SimpleBigDecimal lambda0 = ApproximateDivisionByN(
                k, s[0], vm, a, m, c);

            SimpleBigDecimal lambda1 = ApproximateDivisionByN(
                k, s[1], vm, a, m, c);

            ZTauElement q = Round(lambda0, lambda1, mu);

            // r0 = n - d0*q0 - 2*s1*q1
            IBigInteger r0 = k.Subtract(d0.Multiply(q.u)).Subtract(
                BigInteger.ValueOf(2).Multiply(s[1]).Multiply(q.v));

            // r1 = s1*q0 - s0*q1
            IBigInteger r1 = s[1].Multiply(q.u).Subtract(s[0].Multiply(q.v));

            return new ZTauElement(r0, r1);
        }

        /**
        * Computes the Window NAF (non-adjacent Form) of an integer.
        * @param width The width <code>w</code> of the Window NAF. The width is
        * defined as the minimal number <code>w</code>, such that for any
        * <code>w</code> consecutive digits in the resulting representation, at
        * most one is non-zero.
        * @param k The integer of which the Window NAF is computed.
        * @return The Window NAF of the given width, such that the following holds:
        * <code>k = &#8722;<sub>i=0</sub><sup>l-1</sup> k<sub>i</sub>2<sup>i</sup>
        * </code>, where the <code>k<sub>i</sub></code> denote the elements of the
        * returned <code>sbyte[]</code>.
        */
        public sbyte[] WindowNaf(sbyte width, IBigInteger k)
        {
            // The window NAF is at most 1 element longer than the binary
            // representation of the integer k. sbyte can be used instead of short or
            // int unless the window width is larger than 8. For larger width use
            // short or int. However, a width of more than 8 is not efficient for
            // m = log2(q) smaller than 2305 Bits. Note: Values for m larger than
            // 1000 Bits are currently not used in practice.
            sbyte[] wnaf = new sbyte[k.BitLength + 1];

            // 2^width as short and BigInteger
            short pow2wB = (short)(1 << width);
            IBigInteger pow2wBI = BigInteger.ValueOf(pow2wB);

            int i = 0;

            // The actual length of the WNAF
            int length = 0;

            // while k >= 1
            while (k.SignValue > 0)
            {
                // if k is odd
                if (k.TestBit(0))
                {
                    // k Mod 2^width
                    IBigInteger remainder = k.Mod(pow2wBI);

                    // if remainder > 2^(width - 1) - 1
                    if (remainder.TestBit(width - 1))
                    {
                        wnaf[i] = (sbyte)(remainder.IntValue - pow2wB);
                    }
                    else
                    {
                        wnaf[i] = (sbyte)remainder.IntValue;
                    }
                    // wnaf[i] is now in [-2^(width-1), 2^(width-1)-1]

                    k = k.Subtract(BigInteger.ValueOf(wnaf[i]));
                    length = i;
                }
                else
                {
                    wnaf[i] = 0;
                }

                // k = k/2
                k = k.ShiftRight(1);
                i++;
            }

            length++;

            // Reduce the WNAF array to its actual length
            sbyte[] wnafShort = new sbyte[length];
            Array.Copy(wnaf, 0, wnafShort, 0, length);
            return wnafShort;
        }

        public IBigInteger Add(
            IBigInteger value)
        {
            if (this.SignValue == 0)
                return value;

            if (this.SignValue != value.SignValue)
            {
                if (value.SignValue == 0)
                    return this;

                if (value.SignValue < 0)
                    return Subtract(value.Negate());

                return value.Subtract(Negate());
            }

            return AddToMagnitude(value.Magnitude);
        }

        /**
         * Procedure C
         * procedure generates the a value from the given p,q,
         * returning the a value.
         */
        private IBigInteger procedure_C(IBigInteger p, IBigInteger q)
        {
            IBigInteger pSub1 = p.Subtract(BigInteger.One);
            IBigInteger pSub1Divq = pSub1.Divide(q);

            for(;;)
            {
                IBigInteger d = new BigInteger(p.BitLength, init_random);

                // 1 < d < p-1
                if (d.CompareTo(BigInteger.One) > 0 && d.CompareTo(pSub1) < 0)
                {
                    IBigInteger a = d.ModPow(pSub1Divq, p);

                    if (a.CompareTo(BigInteger.One) != 0)
                    {
                        return a;
                    }
                }
            }
        }

        /// <summary>
        /// Select a high order element of the multiplicative group Z
        ///
        /// p and q must be s.t. p = 2*q + 1, where p and q are prime (see generateSafePrimes)
        /// </summary>
        /// <param name="p">The p.</param>
        /// <param name="q">The q.</param>
        /// <param name="random">The random.</param>
        /// <returns></returns>
        internal static IBigInteger SelectGenerator(IBigInteger p, IBigInteger q, SecureRandom random)
        {
            var pMinusTwo = p.Subtract(BigInteger.Two);
            IBigInteger g;

            /*
             * (see: Handbook of Applied Cryptography 4.80)
             */
            //			do
            //			{
            //				g = BigIntegers.CreateRandomInRange(BigInteger.Two, pMinusTwo, random);
            //			}
            //			while (g.ModPow(BigInteger.Two, p).Equals(BigInteger.One)
            //				|| g.ModPow(q, p).Equals(BigInteger.One));

            /*
             * RFC 2631 2.2.1.2 (and see: Handbook of Applied Cryptography 4.81)
             */
            do
            {
                var h = BigIntegers.CreateRandomInRange(BigInteger.Two, pMinusTwo, random);

                g = h.ModPow(BigInteger.Two, p);
            }
            while (g.Equals(BigInteger.One));

            return g;
        }