From b8adc91ce888b94505f383101ed3a2b06e4a70a2 Mon Sep 17 00:00:00 2001
From: Jeffrey Walton <noloader@gmail.com>
Date: Sun, 29 Jan 2017 04:58:56 -0500
Subject: [PATCH] Add asserts to validation routines

---
 blake2.cpp   |  4 ++--
 esign.cpp    | 12 ++++++++++++
 luc.cpp      | 15 +++++++++++++++
 rabin.cpp    | 19 +++++++++++++++++++
 rsa.cpp      | 16 ++++++++++++++++
 rsa.h        |  2 +-
 rw.cpp       | 10 ++++++++++
 xtrcrypt.cpp | 10 ++++++++++
 8 files changed, 85 insertions(+), 3 deletions(-)

diff --git a/blake2.cpp b/blake2.cpp
index 23a8b0fb..ea5056ec 100644
--- a/blake2.cpp
+++ b/blake2.cpp
@@ -3705,13 +3705,13 @@ static void BLAKE2_NEON_Compress32(const byte* input, BLAKE2_State<word32, false
     t0 = vext_u32(vget_high_u32(m2), vget_high_u32(m3), 1); \
     t1 = vzip_u32(vget_low_u32(m3), vget_low_u32(m0)).val[0]; \
     buf = vcombine_u32(t0, t1); } while(0)
-                              
+
     #define vrorq_n_u32_16(x) vreinterpretq_u32_u16(vrev32q_u16(vreinterpretq_u16_u32(x)))
 
     #define vrorq_n_u32_8(x) vsriq_n_u32(vshlq_n_u32((x), 24), (x), 8)
 
     #define vrorq_n_u32(x, c) vsriq_n_u32(vshlq_n_u32((x), 32-(c)), (x), (c))
-     
+
     #define BLAKE2S_G1(row1,row2,row3,row4,buf) \
     do { \
       row1 = vaddq_u32(vaddq_u32(row1, buf), row2); row4 = veorq_u32(row4, row1); \
diff --git a/esign.cpp b/esign.cpp
index cf78729c..77137d66 100644
--- a/esign.cpp
+++ b/esign.cpp
@@ -61,7 +61,9 @@ bool ESIGNFunction::Validate(RandomNumberGenerator& rng, unsigned int level) con
 	CRYPTOPP_UNUSED(rng), CRYPTOPP_UNUSED(level);
 	bool pass = true;
 	pass = pass && m_n > Integer::One() && m_n.IsOdd();
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && m_e >= 8 && m_e < m_n;
+	CRYPTOPP_ASSERT(pass);
 	return pass;
 }
 
@@ -192,13 +194,23 @@ Integer InvertibleESIGNFunction::CalculateRandomizedInverse(RandomNumberGenerato
 bool InvertibleESIGNFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const
 {
 	bool pass = ESIGNFunction::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_p.BitCount() == m_q.BitCount();
+	CRYPTOPP_ASSERT(pass);
 	if (level >= 1)
+	{
 		pass = pass && m_p * m_p * m_q == m_n;
+		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;
 }
 
diff --git a/luc.cpp b/luc.cpp
index 6abe2e48..c9faca62 100644
--- a/luc.cpp
+++ b/luc.cpp
@@ -74,7 +74,9 @@ bool LUCFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const
 	CRYPTOPP_UNUSED(rng), CRYPTOPP_UNUSED(level);
 	bool pass = true;
 	pass = pass && m_n > Integer::One() && m_n.IsOdd();
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && m_e > Integer::One() && m_e.IsOdd() && m_e < m_n;
+	CRYPTOPP_ASSERT(pass);
 	return pass;
 }
 
@@ -177,20 +179,33 @@ Integer InvertibleLUCFunction::CalculateInverse(RandomNumberGenerator &rng, cons
 bool InvertibleLUCFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const
 {
 	bool pass = LUCFunction::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_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 && RelativelyPrime(m_e, m_p+1);
+		CRYPTOPP_ASSERT(pass);
 		pass = pass && RelativelyPrime(m_e, m_p-1);
+		CRYPTOPP_ASSERT(pass);
 		pass = pass && RelativelyPrime(m_e, m_q+1);
+		CRYPTOPP_ASSERT(pass);
 		pass = pass && RelativelyPrime(m_e, 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;
 }
 
diff --git a/rabin.cpp b/rabin.cpp
index 410202e9..e112d9b8 100644
--- a/rabin.cpp
+++ b/rabin.cpp
@@ -44,10 +44,16 @@ bool RabinFunction::Validate(RandomNumberGenerator& /*rng*/, unsigned int level)
 {
 	bool pass = true;
 	pass = pass && m_n > Integer::One() && m_n%4 == 1;
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && m_r > Integer::One() && m_r < m_n;
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && m_s > Integer::One() && m_s < m_n;
+	CRYPTOPP_ASSERT(pass);
 	if (level >= 1)
+	{
 		pass = pass && Jacobi(m_r, m_n) == -1 && Jacobi(m_s, m_n) == -1;
+		CRYPTOPP_ASSERT(pass);
+	}
 	return pass;
 }
 
@@ -184,20 +190,33 @@ Integer InvertibleRabinFunction::CalculateInverse(RandomNumberGenerator &rng, co
 bool InvertibleRabinFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const
 {
 	bool pass = RabinFunction::Validate(rng, level);
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && m_p > Integer::One() && m_p%4 == 3 && m_p < m_n;
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && m_q > Integer::One() && m_q%4 == 3 && m_q < m_n;
+	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_u * m_q % m_p == 1;
+		CRYPTOPP_ASSERT(pass);
 		pass = pass && Jacobi(m_r, m_p) == 1;
+		CRYPTOPP_ASSERT(pass);
 		pass = pass && Jacobi(m_r, m_q) == -1;
+		CRYPTOPP_ASSERT(pass);
 		pass = pass && Jacobi(m_s, m_p) == -1;
+		CRYPTOPP_ASSERT(pass);
 		pass = pass && Jacobi(m_s, m_q) == 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;
 }
 
diff --git a/rsa.cpp b/rsa.cpp
index 73d796e9..c730ac39 100644
--- a/rsa.cpp
+++ b/rsa.cpp
@@ -73,7 +73,9 @@ bool RSAFunction::Validate(RandomNumberGenerator& rng, unsigned int level) const
 
 	bool pass = true;
 	pass = pass && m_n > Integer::One() && m_n.IsOdd();
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && m_e > Integer::One() && m_e.IsOdd() && m_e < m_n;
+	CRYPTOPP_ASSERT(pass);
 	return pass;
 }
 
@@ -247,21 +249,35 @@ Integer InvertibleRSAFunction::CalculateInverse(RandomNumberGenerator &rng, cons
 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;
 }
 
diff --git a/rsa.h b/rsa.h
index 9a3d3a7b..6f195a64 100644
--- a/rsa.h
+++ b/rsa.h
@@ -115,7 +115,7 @@ public:
 
 	// GeneratableCryptoMaterial
 	bool Validate(RandomNumberGenerator &rng, unsigned int level) const;
-	/*! parameters: (ModulusSize, PublicExponent (default 17)) */
+	// parameters: (ModulusSize, PublicExponent (default 17))
 	void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &alg);
 	bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const;
 	void AssignFrom(const NameValuePairs &source);
diff --git a/rw.cpp b/rw.cpp
index d1b9731d..702090cc 100644
--- a/rw.cpp
+++ b/rw.cpp
@@ -75,6 +75,7 @@ bool RWFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const
 	CRYPTOPP_UNUSED(rng), CRYPTOPP_UNUSED(level);
 	bool pass = true;
 	pass = pass && m_n > Integer::One() && m_n%8 == 5;
+	CRYPTOPP_ASSERT(pass);
 	return pass;
 }
 
@@ -252,16 +253,25 @@ Integer InvertibleRWFunction::CalculateInverse(RandomNumberGenerator &rng, const
 bool InvertibleRWFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const
 {
 	bool pass = RWFunction::Validate(rng, level);
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && m_p > Integer::One() && m_p%8 == 3 && m_p < m_n;
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && m_q > Integer::One() && m_q%8 == 7 && m_q < m_n;
+	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_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;
 }
 
diff --git a/xtrcrypt.cpp b/xtrcrypt.cpp
index 7ffc5b41..aa106aa4 100644
--- a/xtrcrypt.cpp
+++ b/xtrcrypt.cpp
@@ -45,16 +45,26 @@ bool XTR_DH::Validate(RandomNumberGenerator &rng, unsigned int level) const
 {
 	bool pass = true;
 	pass = pass && m_p > Integer::One() && m_p.IsOdd();
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && m_q > Integer::One() && m_q.IsOdd();
+	CRYPTOPP_ASSERT(pass);
 	GFP2Element three = GFP2_ONB<ModularArithmetic>(m_p).ConvertIn(3);
+	CRYPTOPP_ASSERT(pass);
 	pass = pass && !(m_g.c1.IsNegative() || m_g.c2.IsNegative() || m_g.c1 >= m_p || m_g.c2 >= m_p || m_g == three);
+	CRYPTOPP_ASSERT(pass);
 	if (level >= 1)
+	{
 		pass = pass && ((m_p.Squared()-m_p+1)%m_q).IsZero();
+		CRYPTOPP_ASSERT(pass);
+	}
 	if (level >= 2)
 	{
 		pass = pass && VerifyPrime(rng, m_p, level-2) && VerifyPrime(rng, m_q, level-2);
+		CRYPTOPP_ASSERT(pass);
 		pass = pass && XTR_Exponentiate(m_g, (m_p.Squared()-m_p+1)/m_q, m_p) != three;
+		CRYPTOPP_ASSERT(pass);
 		pass = pass && XTR_Exponentiate(m_g, m_q, m_p) == three;
+		CRYPTOPP_ASSERT(pass);
 	}
 	return pass;
 }