bool InvertibleRSAFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const
{
bool pass = RSAFunction::Validate(rng, level);
CRYPTOPP_ASSERT(pass);
pass = pass && m_p > Integer::One() && m_p.IsOdd() && m_p < m_n;
CRYPTOPP_ASSERT(pass);
pass = pass && m_q > Integer::One() && m_q.IsOdd() && m_q < m_n;
CRYPTOPP_ASSERT(pass);
pass = pass && m_d > Integer::One() && m_d.IsOdd() && m_d < m_n;
CRYPTOPP_ASSERT(pass);
pass = pass && m_dp > Integer::One() && m_dp.IsOdd() && m_dp < m_p;
CRYPTOPP_ASSERT(pass);
pass = pass && m_dq > Integer::One() && m_dq.IsOdd() && m_dq < m_q;
CRYPTOPP_ASSERT(pass);
pass = pass && m_u.IsPositive() && m_u < m_p;
CRYPTOPP_ASSERT(pass);
if (level >= 1)
{
pass = pass && m_p * m_q == m_n;
CRYPTOPP_ASSERT(pass);
pass = pass && m_e*m_d % LCM(m_p-1, m_q-1) == 1;
CRYPTOPP_ASSERT(pass);
pass = pass && m_dp == m_d%(m_p-1) && m_dq == m_d%(m_q-1);
CRYPTOPP_ASSERT(pass);
pass = pass && m_u * m_q % m_p == 1;
CRYPTOPP_ASSERT(pass);
}
if (level >= 2)
{
pass = pass && VerifyPrime(rng, m_p, level-2) && VerifyPrime(rng, m_q, level-2);
CRYPTOPP_ASSERT(pass);
}
return pass;
}
bool InvertibleRWFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const
{
bool pass = RWFunction::Validate(rng, level);
pass = pass && m_p > Integer::One() && m_p%8 == 3 && m_p < m_n;
pass = pass && m_q > Integer::One() && m_q%8 == 7 && m_q < m_n;
pass = pass && m_u.IsPositive() && m_u < m_p;
if (level >= 1)
{
pass = pass && m_p * m_q == m_n;
pass = pass && m_u * m_q % m_p == 1;
}
if (level >= 2)
pass = pass && VerifyPrime(rng, m_p, level-2) && VerifyPrime(rng, m_q, level-2);
return pass;
}
bool ECP::ValidateParameters(RandomNumberGenerator &rng) const
{
Integer p = FieldSize();
return p.IsOdd() && VerifyPrime(rng, p)
&& !m_a.IsNegative() && m_a<p && !m_b.IsNegative() && m_b<p
&& ((4*m_a*m_a*m_a+27*m_b*m_b)%p).IsPositive();
}
bool XTR_DH::Validate(RandomNumberGenerator &rng, unsigned int level) const
{
bool pass = true;
pass = pass && m_p > Integer::One() && m_p.IsOdd();
pass = pass && m_q > Integer::One() && m_q.IsOdd();
GFP2Element three = GFP2_ONB<ModularArithmetic>(m_p).ConvertIn(3);
pass = pass && !(m_g.c1.IsNegative() || m_g.c2.IsNegative() || m_g.c1 >= m_p || m_g.c2 >= m_p || m_g == three);
if (level >= 1)
pass = pass && ((m_p.Squared()-m_p+1)%m_q).IsZero();
if (level >= 2)
{
pass = pass && VerifyPrime(rng, m_p, level-2) && VerifyPrime(rng, m_q, level-2);
pass = pass && XTR_Exponentiate(m_g, (m_p.Squared()-m_p+1)/m_q, m_p) != three;
pass = pass && XTR_Exponentiate(m_g, m_q, m_p) == three;
}
return pass;
}
bool InvertibleLUCFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const
{
bool pass = LUCFunction::Validate(rng, level);
pass = pass && m_p > Integer::One() && m_p.IsOdd() && m_p < m_n;
pass = pass && m_q > Integer::One() && m_q.IsOdd() && m_q < m_n;
pass = pass && m_u.IsPositive() && m_u < m_p;
if (level >= 1)
{
pass = pass && m_p * m_q == m_n;
pass = pass && RelativelyPrime(m_e, m_p+1);
pass = pass && RelativelyPrime(m_e, m_p-1);
pass = pass && RelativelyPrime(m_e, m_q+1);
pass = pass && RelativelyPrime(m_e, m_q-1);
pass = pass && m_u * m_q % m_p == 1;
}
if (level >= 2)
pass = pass && VerifyPrime(rng, m_p, level-2) && VerifyPrime(rng, m_q, level-2);
return pass;
}
bool ECP::ValidateParameters(RandomNumberGenerator &rng, unsigned int level) const
{
Integer p = FieldSize();
bool pass = p.IsOdd();
pass = pass && !m_a.IsNegative() && m_a<p && !m_b.IsNegative() && m_b<p;
if (level >= 1)
pass = pass && ((4*m_a*m_a*m_a+27*m_b*m_b)%p).IsPositive();
if (level >= 2)
pass = pass && VerifyPrime(rng, p);
return pass;
}
bool DL_GroupParameters_EC<EC>::ValidateGroup(RandomNumberGenerator &rng, unsigned int level) const
{
bool pass = GetCurve().ValidateParameters(rng, level);
Integer q = GetCurve().FieldSize();
pass = pass && m_n!=q;
if (level >= 2)
{
Integer qSqrt = q.SquareRoot();
pass = pass && m_n>4*qSqrt;
pass = pass && VerifyPrime(rng, m_n, level-2);
pass = pass && (m_k.IsZero() || m_k == (q+2*qSqrt+1)/m_n);
pass = pass && CheckMOVCondition(q, m_n);
}
return pass;
}
bool DH::ValidateDomainParameters(RandomNumberGenerator &rng) const
{
return VerifyPrime(rng, p) && VerifyPrime(rng, (p-1)/2) && g > 1 && g < p && Jacobi(g, p) == 1;
}
int main()
{
const Ulong TESTMAX = 10000;
PrimesTable Tbl_;
Ulong Value_, nthprime_, prevprime_, nextprime_;
int i, x, y, Max_, Limit_;
Boolean Error_, Verified_, nthok_, ceilfloorok_;
char* msg_;
Max_ = TESTMAX;
Verified_ = TRUE;
x = 0; y = 2; i = 0;
nextprime_ = prevprime_ = 0;
Limit_ = Max_ * 2;
Error_ = FALSE;
#if PRIMESTABLE_DEBUG_OUTPUT
for (x = 2; x <= Limit_; ++x)
if (Tbl_.IsPrime(x))
cout <<"\t" <<x;
cout <<endl <<endl;
#endif
x = 0;
for (y = 2; y <= Limit_; Max_ *= 2)
{
for (i = y; i <= Max_; ++i)
{
if (Tbl_.IsPrime(i))
{
#if PRIMESTABLE_DEBUG_OUTPUT
cout <<"\t" <<i;
#endif
++x;
nthprime_ = Tbl_.NthPrime(x);
nthok_ = nthprime_ == i;
if (prevprime_)
ceilfloorok_ = Tbl_.Ceiling(prevprime_ + .5) == nthprime_ &&
Tbl_.Floor(nthprime_ - .5) == prevprime_;
else
ceilfloorok_ = Tbl_.Ceiling(nthprime_ - .5) == nthprime_;
if (nextprime_)
ceilfloorok_ = ceilfloorok_ && nextprime_ == nthprime_;
nextprime_ = Tbl_.Ceiling(nthprime_ + .5);
prevprime_ = nthprime_;
Verified_ = VerifyPrime(i) && nthok_ && ceilfloorok_;
msg_ = "prime";
}
else
{
Verified_ = !VerifyPrime(i);
msg_ = "not prime";
}
if (!Verified_)
{
Error_ = TRUE;
break;
}
}
if (Error_)
break;
y = Max_;
}
#if PRIMESTABLE_DEBUG_OUTPUT
cout <<endl <<endl;
#endif
Ulong pfarr_[10] = {3, 5, 7, 11};
Boolean primefactorsok_;
primefactorsok_ = VerifyPrimeFactors(Tbl_, pfarr_);
Verified_ = Verified_ && primefactorsok_;
if (!Verified_)
cout <<"Error: generating primes: " <<endl
<<"\t: " <<i <<" is " <<msg_ <<endl
<<"\t: nthok = " <<nthok_ <<endl
<<"\t: nthprime = " <<nthprime_ <<endl
<<"\t: ceilfloorok = " <<ceilfloorok_ <<endl
<<"\t: primefactorsok = " <<primefactorsok_ <<endl
<<endl;
else
cout <<"Prime number generation verified" <<endl;
return 0;
}
