void _DecryptBlock(Block input, Block output) { if (input == null || output == null) { throw new ArgumentNullException(); } if ( _privateModulus[0]._digitN + _privateModulus[1]._digitN - _modDigitN > 1 ) { throw new ArgumentException(); } Digits[] dmsg = new Digits[] { new Digits(_modDigitN + 1) , new Digits(_modDigitN + 1) }; int longerDigitN = _privateModulus[0]._digitN > _privateModulus[1]._digitN ? _privateModulus[0]._digitN : _privateModulus[1]._digitN; Digits res = new Digits(longerDigitN); Digits.BytesToDigits( input._Bytes, input._ByteI, dmsg[1], input._BitN); Modular.ValidateData(dmsg[1], _modDigits, _modDigitN); for (int ip = 0; ip != 2; ip++) { _privateModulus[ip]._ToModular(dmsg[1], _modDigitN, res); _privateModulus[ip] ._Exp(res, _dDigits[ip], _privateModulus[ip]._digitN, res); _privateModulus[ip]._Mul(res, _chineseDigits[ip], res); Digits.Mul(res , _privateModulus[ip]._digitN , _privateModulus[1 - ip]._mod , _privateModulus[1 - ip]._digitN , dmsg[ip]); } Modular.Add(dmsg[0], dmsg[1], dmsg[0], _modDigits, _modDigitN); Digits.DigitsToBytes( dmsg[0], output._Bytes, output._ByteI, output._BitN); }
_Exp(Digits @base, Digits exp, int expDigitN, Digits answer) { int expBitNUsed = Digits.SigBitN(exp, expDigitN); ushort[] widthCutoffs = new ushort[] { 6, 24, 80, 240, 672 }; Digits basepower = answer; int bucketWidth = 1; while ( bucketWidth < 5 && widthCutoffs[bucketWidth - 1] < expBitNUsed ) { bucketWidth++; } Modular.ValidateData(@base, _mod, _digitN); UInt32 bucketMask = (1U << bucketWidth) - 1; UInt32 maxBucket = bucketMask; Digits bucketData = new Digits((int)(_digitN * maxBucket)); Temps2000 temps = new Temps2000(); temps._modulus = this; temps._bucket[0] = null; Modular.Add(_one, _one, bucketData, _mod, _digitN); bool base2 = Digits.Compare(@base, bucketData, _digitN) == 0; if (base2 && expBitNUsed != 0) { int shiftMax = Digit.BitN * _digitN > 1024 ? 1024 : Digit.BitN * _digitN; int highExponBitN = 0; bool bighBitNProcessed = false; Digits temp = bucketData; for (int i = expBitNUsed; i-- != 0;) { Digit expBit = Digits.GetBit(exp, i); if (bighBitNProcessed) { _Mul(temp, temp, temp); if (expBit != 0) { Modular.Add(temp, temp, temp, _mod, _digitN); } } else { highExponBitN = (int)(2 * highExponBitN + expBit); if (i == 0 || 2 * highExponBitN >= shiftMax) { bighBitNProcessed = true; _Shift(_one, highExponBitN, temp); } } } temps._bucket[1] = temp; Debug.Assert(bighBitNProcessed, "internal error"); } else { UInt32 ibucket; for (ibucket = 1; ibucket <= maxBucket; ibucket++) { Digits bloc = bucketData + (int)(_digitN * (ibucket - 1 + ((ibucket & 1) == 0 ? maxBucket : 0)) / 2); temps._bucket[ibucket] = bloc; temps._bucketBusy[ibucket] = false; bloc._Set(_one, _digitN); } basepower._Set(@base, _digitN); Digit carried = 0; int ndoubling = 0; for (int i = 0; i != expBitNUsed; i++) { Digit bitNow = Digits.GetBit(exp, i); Debug.Assert(carried >> bucketWidth + 2 == 0 , "internal error"); if (bitNow != 0) { while (ndoubling >= bucketWidth + 1) { if ((carried & 1) != 0) { ibucket = carried & bucketMask; carried -= ibucket; temps._modulus ._BucketMul(ibucket, basepower, temps); } temps._modulus._BasePowerSquaring(basepower); carried /= 2; ndoubling--; } carried |= 1U << ndoubling; } ndoubling++; } while (carried != 0) { bool squareNow = false; if (carried <= maxBucket) { ibucket = carried; } else if ((carried & 1) == 0) { squareNow = true; } else if (carried <= 3 * maxBucket) { ibucket = maxBucket; } else { Debug.Assert(false, "untested code"); ibucket = carried & bucketMask; } if (squareNow) { carried /= 2; temps._modulus._BasePowerSquaring(basepower); } else { carried -= ibucket; temps._modulus._BucketMul(ibucket, basepower, temps); } } for (ibucket = maxBucket; ibucket >= 2; ibucket--) { if (temps._bucketBusy[ibucket]) { bool found = false; UInt32 jbucket, jbucketMax, kbucket; Digits bloci; if ((ibucket & 1) == 0) { jbucketMax = ibucket / 2; } else { jbucketMax = 1; } for ( jbucket = ibucket >> 1; jbucket != ibucket && !found; jbucket++ ) { if (temps._bucketBusy[jbucket]) { jbucketMax = jbucket; found = temps._bucketBusy[ibucket - jbucket]; } } jbucket = jbucketMax; kbucket = ibucket - jbucket; bloci = temps._bucket[ibucket]; temps._modulus._BucketMul(jbucket, bloci, temps); temps._modulus._BucketMul(kbucket, bloci, temps); } } } answer._Set(temps._bucket[1], _digitN); }
internal static Digits NewPrime(int pBitN, Random generator) { if (pBitN < Digit.BitN) { throw new ArgumentException(); } int pDigitN = (pBitN + (Digit.BitN - 1)) / Digit.BitN; Digits p = new Digits(pDigitN); while (true) { for ( int iteration = 0; iteration < _IterationsAllowed; iteration++ ) { Digits.Random(p, pDigitN, generator); p[pDigitN - 1] >>= Digit.BitN * pDigitN - pBitN; p[0] |= 1; Digits.SetBit(p, pBitN - 1, 1); Digits.SetBit(p, pBitN - 2, 1); if (DivisibleBySomeLowPrime(p, pDigitN)) { continue; } Modulus modulus = new Modulus(p, pDigitN, true); Digits minus1 = new Digits(pDigitN); Modular .Neg(modulus._one, minus1, modulus._mod, modulus._digitN); Digits exp = new Digits(pDigitN); Digits.Shift(p, -1, exp, pDigitN); Digits @base = new Digits(pDigitN); for (int i = 1; i <= _RabinTestN; i++) { if (i == 1) { Modular.Add(modulus._one , modulus._one , @base , modulus._mod , modulus._digitN); } else { Modular.NonZeroRandom( p, @base, pDigitN, generator); } Digits result = new Digits(pDigitN); modulus._Exp(@base, exp, pDigitN, result); if (Digits.Compare(result, minus1, pDigitN) == 0) { return(p); } if ( Digits.Compare(result, modulus._one, pDigitN) != 0 ) { break; } } } Debug.Assert(false, "too many iterations"); } }