internal void ModularPower( ChineseRemainder CRTResult,
Integer Exponent,
ChineseRemainder CRTModulus,
bool UsePresetBaseArray )
{
// The square and multiply method is in Wikipedia:
// https://en.wikipedia.org/wiki/Exponentiation_by_squaring
if( Worker.CancellationPending )
return;
if( CRTResult.IsZero())
return; // With CRTResult still zero.
if( CRTResult.IsEqual( CRTModulus ))
{
// It is congruent to zero % ModN.
CRTResult.SetToZero();
return;
}
// Result is not zero at this point.
if( Exponent.IsZero() )
{
CRTResult.SetToOne();
return;
}
Integer Result = new Integer();
CRTMath1.GetTraditionalInteger( Result, CRTResult );
Integer Modulus = new Integer();
CRTMath1.GetTraditionalInteger( Modulus, CRTModulus );
if( Modulus.ParamIsGreater( Result ))
{
// throw( new Exception( "This is not supposed to be input for RSA plain text." ));
IntMath.Divide( Result, Modulus, Quotient, Remainder );
Result.Copy( Remainder );
CRTResult.SetFromTraditionalInteger( Remainder );
}
if( Exponent.IsEqualToULong( 1 ))
{
// Result stays the same.
return;
}
if( !UsePresetBaseArray )
SetupBaseModArray( Modulus );
if( CRTBaseModArray == null )
throw( new Exception( "SetupBaseModArray() should have already been done here." ));
CRTXForModPower.Copy( CRTResult );
ExponentCopy.Copy( Exponent );
int TestIndex = 0;
CRTResult.SetToOne();
int LoopsTest = 0;
while( true )
{
LoopsTest++;
if( (ExponentCopy.GetD( 0 ) & 1) == 1 ) // If the bottom bit is 1.
{
CRTResult.Multiply( CRTXForModPower );
ModularReduction( CRTResult, CRTAccumulate );
CRTResult.Copy( CRTAccumulate );
}
ExponentCopy.ShiftRight( 1 ); // Divide by 2.
if( ExponentCopy.IsZero())
break;
// Square it.
CRTCopyForSquare.Copy( CRTXForModPower );
CRTXForModPower.Multiply( CRTCopyForSquare );
ModularReduction( CRTXForModPower, CRTAccumulate );
CRTXForModPower.Copy( CRTAccumulate );
}
ModularReduction( CRTResult, CRTAccumulate );
CRTResult.Copy( CRTAccumulate );
// Division is never used in the loop above.
// This is a very small Quotient.
// See SetupBaseMultiples() for a description of how to calculate
// the maximum size of this quotient.
CRTMath1.GetTraditionalInteger( Result, CRTResult );
IntMath.Divide( Result, Modulus, Quotient, Remainder );
// Is the Quotient bigger than a 32 bit integer?
if( Quotient.GetIndex() > 0 )
throw( new Exception( "I haven't ever seen this happen. Quotient.GetIndex() > 0. It is: " + Quotient.GetIndex().ToString() ));
QuotientForTest = Quotient.GetAsULong();
if( QuotientForTest > 2097867 )
throw( new Exception( "This can never happen unless I increase ChineseRemainder.DigitsArraySize." ));
Result.Copy( Remainder );
CRTResult.SetFromTraditionalInteger( Remainder );
}
// These bottom digits are 0 for each prime that gets
// multiplied by the base. So they keep getting one
// more zero at the bottom of each one.
// But the digits in BaseModArray only have the zeros
// at the bottom on the ones that are smaller than the
// modulus.
// At BaseArray[0] it's 1, 1, 1, 1, 1, .... for all of them.
// 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0
// 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 1, 0, 0
// 30, 30, 30, 30, 1, 7, 11, 13, 4, 8, 2, 0, 0, 0
private void SetupBaseArray()
{
// The first few numbers for the base:
// 2 2
// 3 6
// 5 30
// 7 210
// 11 2,310
// 13 30,030
// 17 510,510
// 19 9,699,690
// 23 223,092,870
try
{
if( NumbersArray == null )
throw( new Exception( "NumbersArray should have already been setup in SetupBaseArray()." ));
BaseStringsArray = new string[ChineseRemainder.DigitsArraySize];
BaseArray = new Integer[ChineseRemainder.DigitsArraySize];
CRTBaseArray = new ChineseRemainder[ChineseRemainder.DigitsArraySize];
Integer SetBase = new Integer();
ChineseRemainder CRTSetBase = new ChineseRemainder( IntMath );
Integer BigBase = new Integer();
ChineseRemainder CRTBigBase = new ChineseRemainder( IntMath );
BigBase.SetFromULong( 2 );
CRTBigBase.SetFromUInt( 2 );
string BaseS = "2";
SetBase.SetToOne();
CRTSetBase.SetToOne();
// The base at zero is 1.
BaseArray[0] = SetBase;
CRTBaseArray[0] = CRTSetBase;
BaseStringsArray[0] = "1";
ChineseRemainder CRTTemp = new ChineseRemainder( IntMath );
// The first time through the loop the base
// is set to 2.
// So BaseArray[0] = 1;
// So BaseArray[1] = 2;
// So BaseArray[2] = 6;
// So BaseArray[3] = 30;
// And so on...
// In BaseArray[3] digits at 2, 3 and 5 are set to zero.
// In BaseArray[4] digits at 2, 3, 5 and 7 are set to zero.
for( int Count = 1; Count < ChineseRemainder.DigitsArraySize; Count++ )
{
SetBase = new Integer();
CRTSetBase = new ChineseRemainder( IntMath );
SetBase.Copy( BigBase );
CRTSetBase.Copy( CRTBigBase );
BaseStringsArray[Count] = BaseS;
BaseArray[Count] = SetBase;
CRTBaseArray[Count] = CRTSetBase;
// if( Count < 50 )
// Worker.ReportProgress( 0, CRTBaseArray[Count].GetString() );
if( !IsEqualToInteger( CRTBaseArray[Count],
BaseArray[Count] ))
throw( new Exception( "Bug. The bases aren't equal." ));
// Multiply it for the next BigBase.
uint Prime = IntMath.GetPrimeAt( Count );
BaseS = BaseS + "*" + Prime.ToString();
IntMath.MultiplyUInt( BigBase, Prime );
CRTBigBase.Multiply( NumbersArray[IntMath.GetPrimeAt( Count )] );
}
}
catch( Exception Except )
{
throw( new Exception( "Exception in SetupBaseArray(): " + Except.Message ));
}
}
private void DoCRTTest( Integer StartingNumber )
{
CRTMath CRTMath1 = new CRTMath( Worker );
ECTime CRTTestTime = new ECTime();
ChineseRemainder CRTTest = new ChineseRemainder( IntMath );
ChineseRemainder CRTTest2 = new ChineseRemainder( IntMath );
ChineseRemainder CRTAccumulate = new ChineseRemainder( IntMath );
ChineseRemainder CRTToTest = new ChineseRemainder( IntMath );
ChineseRemainder CRTTempEqual = new ChineseRemainder( IntMath );
ChineseRemainder CRTTestEqual = new ChineseRemainder( IntMath );
Integer BigBase = new Integer();
Integer ToTest = new Integer();
Integer Accumulate = new Integer();
Integer Test1 = new Integer();
Integer Test2 = new Integer();
CRTTest.SetFromTraditionalInteger( StartingNumber );
// If the digit array size isn't set right in relation to
// Integer.DigitArraySize then it can cause an error here.
CRTMath1.GetTraditionalInteger( Accumulate, CRTTest );
if( !Accumulate.IsEqual( StartingNumber ))
throw( new Exception( " !Accumulate.IsEqual( Result )." ));
CRTTestEqual.SetFromTraditionalInteger( Accumulate );
if( !CRTMath1.IsEqualToInteger( CRTTestEqual, Accumulate ))
throw( new Exception( "IsEqualToInteger() didn't work." ));
// Make sure it works with even numbers too.
Test1.Copy( StartingNumber );
Test1.SetD( 0, Test1.GetD( 0 ) & 0xFE );
CRTTest.SetFromTraditionalInteger( Test1 );
CRTMath1.GetTraditionalInteger( Accumulate, CRTTest );
if( !Accumulate.IsEqual( Test1 ))
throw( new Exception( "For even numbers. !Accumulate.IsEqual( Test )." ));
////////////
// Make sure the size of this works with the Integer size because
// an overflow is hard to find.
CRTTestTime.SetToNow();
Test1.SetToMaxValueForCRT();
CRTTest.SetFromTraditionalInteger( Test1 );
CRTMath1.GetTraditionalInteger( Accumulate, CRTTest );
if( !Accumulate.IsEqual( Test1 ))
throw( new Exception( "For the max value. !Accumulate.IsEqual( Test1 )." ));
// Worker.ReportProgress( 0, "CRT Max test seconds: " + CRTTestTime.GetSecondsToNow().ToString( "N1" ));
// Worker.ReportProgress( 0, "MaxValue: " + IntMath.ToString10( Accumulate ));
// Worker.ReportProgress( 0, "MaxValue.Index: " + Accumulate.GetIndex().ToString());
// Multiplicative Inverse test:
Integer TestDivideBy = new Integer();
Integer TestProduct = new Integer();
ChineseRemainder CRTTestDivideBy = new ChineseRemainder( IntMath );
ChineseRemainder CRTTestProduct = new ChineseRemainder( IntMath );
TestDivideBy.Copy( StartingNumber );
TestProduct.Copy( StartingNumber );
IntMath.Multiply( TestProduct, TestDivideBy );
CRTTestDivideBy.SetFromTraditionalInteger( TestDivideBy );
CRTTestProduct.SetFromTraditionalInteger( TestDivideBy );
CRTTestProduct.Multiply( CRTTestDivideBy );
CRTMath1.GetTraditionalInteger( Accumulate, CRTTestProduct );
if( !Accumulate.IsEqual( TestProduct ))
throw( new Exception( "Multiply test was bad." ));
IntMath.Divide( TestProduct, TestDivideBy, Quotient, Remainder );
if( !Remainder.IsZero())
throw( new Exception( "This test won't work unless it divides it exactly." ));
ChineseRemainder CRTTestQuotient = new ChineseRemainder( IntMath );
CRTMath1.MultiplicativeInverse( CRTTestProduct, CRTTestDivideBy, CRTTestQuotient );
// Yes, multiplicative inverse is the same number
// as with regular division.
Integer TestQuotient = new Integer();
CRTMath1.GetTraditionalInteger( TestQuotient, CRTTestQuotient );
if( !TestQuotient.IsEqual( Quotient ))
throw( new Exception( "Modular Inverse in DoCRTTest didn't work." ));
// Subtract
Test1.Copy( StartingNumber );
IntMath.SetFromString( Test2, "12345678901234567890123456789012345" );
CRTTest.SetFromTraditionalInteger( Test1 );
CRTTest2.SetFromTraditionalInteger( Test2 );
CRTTest.Subtract( CRTTest2 );
IntMath.Subtract( Test1, Test2 );
CRTMath1.GetTraditionalInteger( Accumulate, CRTTest );
if( !Accumulate.IsEqual( Test1 ))
throw( new Exception( "Subtract test was bad." ));
// Add
Test1.Copy( StartingNumber );
IntMath.SetFromString( Test2, "12345678901234567890123456789012345" );
CRTTest.SetFromTraditionalInteger( Test1 );
CRTTest2.SetFromTraditionalInteger( Test2 );
CRTTest.Add( CRTTest2 );
IntMath.Add( Test1, Test2 );
CRTMath1.GetTraditionalInteger( Accumulate, CRTTest );
if( !Accumulate.IsEqual( Test1 ))
throw( new Exception( "Add test was bad." ));
/////////
CRTBaseMath CBaseMath = new CRTBaseMath( Worker, CRTMath1 );
ChineseRemainder CRTInput = new ChineseRemainder( IntMath );
CRTInput.SetFromTraditionalInteger( StartingNumber );
Test1.Copy( StartingNumber );
IntMath.SetFromString( Test2, "12345678901234567890123456789012345" );
IntMath.Add( Test1, Test2 );
Integer TestModulus = new Integer();
TestModulus.Copy( Test1 );
ChineseRemainder CRTTestModulus = new ChineseRemainder( IntMath );
CRTTestModulus.SetFromTraditionalInteger( TestModulus );
Integer Exponent = new Integer();
Exponent.SetFromULong( PubKeyExponentUint );
CBaseMath.ModularPower( CRTInput, Exponent, CRTTestModulus, false );
IntMath.IntMathNew.ModularPower( StartingNumber, Exponent, TestModulus, false );
if( !CRTMath1.IsEqualToInteger( CRTInput, StartingNumber ))
throw( new Exception( "CRTBase ModularPower() didn't work." ));
CRTBase ExpTest = new CRTBase( IntMath );
CBaseMath.SetFromCRTNumber( ExpTest, CRTInput );
CBaseMath.GetExponentForm( ExpTest, 37 );
// Worker.ReportProgress( 0, "CRT was good." );
}