109 files changed, 854 insertions, 624 deletions

diff --git a/Filelist.txt b/Filelist.txt
index beec818d..0dd3d2ce 100644
--- a/Filelist.txt
+++ b/Filelist.txt
@@ -263,6 +263,7 @@ strciphr.h
 tea.cpp

 tea.h

 test.cpp

+trap.h

 tftables.cpp

 tiger.cpp

 tiger.h

diff --git a/adler32.cpp b/adler32.cpp
index 54cf892b..f48e9b73 100644
--- a/adler32.cpp
+++ b/adler32.cpp
@@ -46,8 +46,8 @@ void Adler32::Update(const byte *input, size_t length)
 			s2 %= BASE;

 	}

 

-	assert(s1 < BASE);

-	assert(s2 < BASE);

+	CRYPTOPP_ASSERT(s1 < BASE);

+	CRYPTOPP_ASSERT(s2 < BASE);

 

 	m_s1 = (word16)s1;

 	m_s2 = (word16)s2;

diff --git a/algebra.cpp b/algebra.cpp
index d6c204bc..c40e900e 100644
--- a/algebra.cpp
+++ b/algebra.cpp
@@ -262,7 +262,7 @@ void AbstractGroup<T>::SimultaneousMultiply(T *results, const T &base, const Int
 

 	for (i=0; i<expCount; i++)

 	{

-		assert(expBegin->NotNegative());

+		CRYPTOPP_ASSERT(expBegin->NotNegative());

 		exponents.push_back(WindowSlider(*expBegin++, InversionIsFast(), 0));

 		exponents[i].FindNextWindow();

 		buckets[i].resize(((size_t) 1) << (exponents[i].windowSize-1), Identity());

diff --git a/algparam.cpp b/algparam.cpp
index 2e93c9db..5ef155fd 100644
--- a/algparam.cpp
+++ b/algparam.cpp
@@ -22,7 +22,7 @@ bool CombinedNameValuePairs::GetVoidValue(const char *name, const std::type_info
 void AlgorithmParametersBase::operator=(const AlgorithmParametersBase &rhs)

 {

 	CRYPTOPP_UNUSED(rhs);

-	assert(false);

+	CRYPTOPP_ASSERT(false);

 }

 

 bool AlgorithmParametersBase::GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const

diff --git a/algparam.h b/algparam.h
index 87355acc..92eb384d 100644
--- a/algparam.h
+++ b/algparam.h
@@ -74,7 +74,7 @@ public:
 	void Assign(const byte *data, size_t size, bool deepCopy)

 	{

 		// This fires, which means: no data with a size, or data with no size.

-		// assert((data && size) || !(data || size));

+		// CRYPTOPP_ASSERT((data && size) || !(data || size));

 		if (deepCopy)

 			m_block.Assign(data, size);

 		else

diff --git a/asn.cpp b/asn.cpp
index 13cd50c3..297ff010 100644
--- a/asn.cpp
+++ b/asn.cpp
@@ -244,7 +244,7 @@ size_t OID::DecodeValue(BufferedTransformation &bt, word32 &v)
 

 void OID::DEREncode(BufferedTransformation &bt) const

 {

-	assert(m_values.size() >= 2);

+	CRYPTOPP_ASSERT(m_values.size() >= 2);

 	ByteQueue temp;

 	temp.Put(byte(m_values[0] * 40 + m_values[1]));

 	for (size_t i=2; i<m_values.size(); i++)

@@ -412,7 +412,7 @@ BERGeneralDecoder::~BERGeneralDecoder()
 	}

 	catch (const Exception&)

 	{

-		// assert(0);

+		// CRYPTOPP_ASSERT(0);

 	}

 }

 

@@ -506,7 +506,7 @@ DERGeneralEncoder::~DERGeneralEncoder()
 	}

 	catch (const Exception&)

 	{

-		assert(0);

+		CRYPTOPP_ASSERT(0);

 	}

 }

 

diff --git a/asn.h b/asn.h
index 8c8ac321..52a184c9 100644
--- a/asn.h
+++ b/asn.h
@@ -239,7 +239,7 @@ public:
 	~BERGeneralDecoder();

 

 	bool IsDefiniteLength() const {return m_definiteLength;}

-	lword RemainingLength() const {assert(m_definiteLength); return m_length;}

+	lword RemainingLength() const {CRYPTOPP_ASSERT(m_definiteLength); return m_length;}

 	bool EndReached() const;

 	byte PeekByte() const;

 	void CheckByte(byte b);

@@ -258,7 +258,7 @@ protected:
 private:

 	void Init(byte asnTag);

 	void StoreInitialize(const NameValuePairs &parameters)

-		{CRYPTOPP_UNUSED(parameters); assert(false);}

+		{CRYPTOPP_UNUSED(parameters); CRYPTOPP_ASSERT(false);}

 	lword ReduceLength(lword delta);

 };

 

diff --git a/authenc.cpp b/authenc.cpp
index 0ca5da60..08d4c99c 100644
--- a/authenc.cpp
+++ b/authenc.cpp
@@ -97,7 +97,7 @@ void AuthenticatedSymmetricCipherBase::Update(const byte *input, size_t length)
 		m_totalFooterLength += length;

 		break;

 	default:

-		assert(false);

+		CRYPTOPP_ASSERT(false);

 	}

 }

 

@@ -129,7 +129,7 @@ reswitch:
 		AuthenticateData(outString, length);

 		break;

 	default:

-		assert(false);

+		CRYPTOPP_ASSERT(false);

 	}

 }

 

@@ -169,7 +169,7 @@ void AuthenticatedSymmetricCipherBase::TruncatedFinal(byte *mac, size_t macSize)
 		break;

 

 	default:

-		assert(false);

+		CRYPTOPP_ASSERT(false);

 	}

 

 	m_state = State_KeySet;

diff --git a/authenc.h b/authenc.h
index ff719872..5882c743 100644
--- a/authenc.h
+++ b/authenc.h
@@ -31,7 +31,7 @@ public:
 	//! \param params additional parameters passed as  NameValuePairs

 	//! \details key must be at least DEFAULT_KEYLENGTH in length.

 	void UncheckedSetKey(const byte * key, unsigned int length,const CryptoPP::NameValuePairs &params)

-		{CRYPTOPP_UNUSED(key), CRYPTOPP_UNUSED(length), CRYPTOPP_UNUSED(params); assert(false);}

+		{CRYPTOPP_UNUSED(key), CRYPTOPP_UNUSED(length), CRYPTOPP_UNUSED(params); CRYPTOPP_ASSERT(false);}

 

 	void SetKey(const byte *userKey, size_t keylength, const NameValuePairs &params);

 	void Restart() {if (m_state > State_KeySet) m_state = State_KeySet;}

diff --git a/basecode.cpp b/basecode.cpp
index e4806466..954d11cb 100644
--- a/basecode.cpp
+++ b/basecode.cpp
@@ -57,7 +57,7 @@ size_t BaseN_Encoder::Put2(const byte *begin, size_t length, int messageEnd, boo
 		unsigned int b = begin[m_inputPosition++], bitsLeftInSource = 8;

 		while (true)

 		{

-			assert(m_bitsPerChar-m_bitPos >= 0);

+			CRYPTOPP_ASSERT(m_bitsPerChar-m_bitPos >= 0);

 			unsigned int bitsLeftInTarget = (unsigned int)(m_bitsPerChar-m_bitPos);

 			m_outBuf[m_bytePos] |= b >> (8-bitsLeftInTarget);

 			if (bitsLeftInSource >= bitsLeftInTarget)

@@ -78,13 +78,13 @@ size_t BaseN_Encoder::Put2(const byte *begin, size_t length, int messageEnd, boo
 		}

 		}

 

-		assert(m_bytePos <= m_outputBlockSize);

+		CRYPTOPP_ASSERT(m_bytePos <= m_outputBlockSize);

 		if (m_bytePos == m_outputBlockSize)

 		{

 			int i;

 			for (i=0; i<m_bytePos; i++)

 			{

-				assert(m_outBuf[i] < (1 << m_bitsPerChar));

+				CRYPTOPP_ASSERT(m_outBuf[i] < (1 << m_bitsPerChar));

 				m_outBuf[i] = m_alphabet[m_outBuf[i]];

 			}

 			FILTER_OUTPUT(1, m_outBuf, m_outputBlockSize, 0);

@@ -183,14 +183,14 @@ void BaseN_Decoder::InitializeDecodingLookupArray(int *lookup, const byte *alpha
 	{

 		if (caseInsensitive && isalpha(alphabet[i]))

 		{

-			assert(lookup[toupper(alphabet[i])] == -1);

+			CRYPTOPP_ASSERT(lookup[toupper(alphabet[i])] == -1);

 			lookup[toupper(alphabet[i])] = i;

-			assert(lookup[tolower(alphabet[i])] == -1);

+			CRYPTOPP_ASSERT(lookup[tolower(alphabet[i])] == -1);

 			lookup[tolower(alphabet[i])] = i;

 		}

 		else

 		{

-			assert(lookup[alphabet[i]] == -1);

+			CRYPTOPP_ASSERT(lookup[alphabet[i]] == -1);

 			lookup[alphabet[i]] = i;

 		}

 	}

diff --git a/bench1.cpp b/bench1.cpp
index d352ed92..887f2f22 100644
--- a/bench1.cpp
+++ b/bench1.cpp
@@ -385,9 +385,9 @@ void BenchmarkAll(double t, double hertz)
 

 	const time_t endTime = time(NULL);

 	err = localtime_s(&localTime, &endTime);

-	assert(err == 0);

+	CRYPTOPP_ASSERT(err == 0);

 	err = asctime_s(timeBuf, sizeof(timeBuf), &localTime);

-	assert(err == 0);

+	CRYPTOPP_ASSERT(err == 0);

 

 	cout << "\nTest ended at " << timeBuf;

 #else

diff --git a/blake2.cpp b/blake2.cpp
index b47dabd7..a7ca8f27 100644
--- a/blake2.cpp
+++ b/blake2.cpp
@@ -352,7 +352,7 @@ BLAKE2_Base<W, T_64bit>::BLAKE2_Base() : m_state(1), m_block(1), m_digestSize(DI
 template <class W, bool T_64bit>

 BLAKE2_Base<W, T_64bit>::BLAKE2_Base(bool treeMode, unsigned int digestSize) : m_state(1), m_block(1), m_digestSize(digestSize), m_treeMode(treeMode)

 {

-	assert(digestSize <= DIGESTSIZE);

+	CRYPTOPP_ASSERT(digestSize <= DIGESTSIZE);

 

 	UncheckedSetKey(NULL, 0, g_nullNameValuePairs);

 	Restart();

@@ -363,10 +363,10 @@ BLAKE2_Base<W, T_64bit>::BLAKE2_Base(const byte *key, size_t keyLength, const by
 	const byte* personalization, size_t personalizationLength, bool treeMode, unsigned int digestSize)

 	: m_state(1), m_block(1), m_digestSize(digestSize), m_treeMode(treeMode)

 {

-	assert(keyLength <= MAX_KEYLENGTH);

-	assert(digestSize <= DIGESTSIZE);

-	assert(saltLength <= SALTSIZE);

-	assert(personalizationLength <= PERSONALIZATIONSIZE);

+	CRYPTOPP_ASSERT(keyLength <= MAX_KEYLENGTH);

+	CRYPTOPP_ASSERT(digestSize <= DIGESTSIZE);

+	CRYPTOPP_ASSERT(saltLength <= SALTSIZE);

+	CRYPTOPP_ASSERT(personalizationLength <= PERSONALIZATIONSIZE);

 

 	UncheckedSetKey(key, static_cast<unsigned int>(keyLength), MakeParameters(Name::DigestSize(),(int)digestSize)(Name::TreeMode(),treeMode, false)

 		(Name::Salt(), ConstByteArrayParameter(salt, saltLength))(Name::Personalization(), ConstByteArrayParameter(personalization, personalizationLength)));

@@ -439,7 +439,7 @@ void BLAKE2_Base<W, T_64bit>::Update(const byte *input, size_t length)
 	// Copy tail bytes

 	if (input && length)

 	{

-		assert(length <= BLOCKSIZE - state.length);

+		CRYPTOPP_ASSERT(length <= BLOCKSIZE - state.length);

 		memcpy_s(&state.buffer[state.length], length, input, length);

 		state.length += static_cast<unsigned int>(length);

 	}

@@ -3470,10 +3470,10 @@ static const int LANE_L64 = 0;
 

 static void BLAKE2_NEON_Compress32(const byte* input, BLAKE2_State<word32, false>& state)

 {

-  //assert(IsAlignedOn(input,GetAlignmentOf<uint8_t*>()));

-  assert(IsAlignedOn(&state.h[0],GetAlignmentOf<uint32x4_t>()));

-  assert(IsAlignedOn(&state.h[4],GetAlignmentOf<uint32x4_t>()));

-  assert(IsAlignedOn(&state.t[0],GetAlignmentOf<uint32x4_t>()));

+  //CRYPTOPP_ASSERT(IsAlignedOn(input,GetAlignmentOf<uint8_t*>()));

+  CRYPTOPP_ASSERT(IsAlignedOn(&state.h[0],GetAlignmentOf<uint32x4_t>()));

+  CRYPTOPP_ASSERT(IsAlignedOn(&state.h[4],GetAlignmentOf<uint32x4_t>()));

+  CRYPTOPP_ASSERT(IsAlignedOn(&state.t[0],GetAlignmentOf<uint32x4_t>()));

 

   CRYPTOPP_ALIGN_DATA(16) uint32_t m0[4], m1[4], m2[4], m3[4], m4[4], m5[4], m6[4], m7[4];

   CRYPTOPP_ALIGN_DATA(16) uint32_t m8[4], m9[4], m10[4], m11[4], m12[4], m13[4], m14[4], m15[4];

@@ -3976,10 +3976,10 @@ static void BLAKE2_NEON_Compress32(const byte* input, BLAKE2_State<word32, false
 

 static void BLAKE2_NEON_Compress64(const byte* input, BLAKE2_State<word64, true>& state)

 {

-  //assert(IsAlignedOn(input,GetAlignmentOf<uint8_t*>()));

-  assert(IsAlignedOn(&state.h[0],GetAlignmentOf<uint64x2_t>()));

-  assert(IsAlignedOn(&state.h[4],GetAlignmentOf<uint64x2_t>()));

-  assert(IsAlignedOn(&state.t[0],GetAlignmentOf<uint64x2_t>()));

+  //CRYPTOPP_ASSERT(IsAlignedOn(input,GetAlignmentOf<uint8_t*>()));

+  CRYPTOPP_ASSERT(IsAlignedOn(&state.h[0],GetAlignmentOf<uint64x2_t>()));

+  CRYPTOPP_ASSERT(IsAlignedOn(&state.h[4],GetAlignmentOf<uint64x2_t>()));

+  CRYPTOPP_ASSERT(IsAlignedOn(&state.t[0],GetAlignmentOf<uint64x2_t>()));

 

   uint64x2_t m0m1,m2m3,m4m5,m6m7,m8m9,m10m11,m12m13,m14m15;

 

diff --git a/blake2.h b/blake2.h
index 5c1655da..8743996f 100644
--- a/blake2.h
+++ b/blake2.h
@@ -72,7 +72,7 @@ struct CRYPTOPP_NO_VTABLE BLAKE2_ParameterBlock<true>
 

 	BLAKE2_ParameterBlock(size_t digestSize)

 	{

-		assert(digestSize <= DIGESTSIZE);

+		CRYPTOPP_ASSERT(digestSize <= DIGESTSIZE);

 		memset(this, 0x00, sizeof(*this));

 		digestLength = (byte)digestSize;

 		fanout = depth = 1;

@@ -107,7 +107,7 @@ struct CRYPTOPP_NO_VTABLE BLAKE2_ParameterBlock<false>
 

 	BLAKE2_ParameterBlock(size_t digestSize)

 	{

-		assert(digestSize <= DIGESTSIZE);

+		CRYPTOPP_ASSERT(digestSize <= DIGESTSIZE);

 		memset(this, 0x00, sizeof(*this));

 		digestLength = (byte)digestSize;

 		fanout = depth = 1;

diff --git a/camellia.cpp b/camellia.cpp
index 5afe8df5..13880393 100644
--- a/camellia.cpp
+++ b/camellia.cpp
@@ -91,13 +91,13 @@ void Camellia::Base::UncheckedSetKey(const byte *key, unsigned int keylen, const
 	kwl = (word64(k0) << 32) | k1;	\

 	kwr = (word64(k2) << 32) | k3

 #define KS_ROUND_0(i)							\

-	assert(IsAlignedOn(CALC_ADDR(ks32, i+EFI(0)),GetAlignmentOf<word64>()));	\

-	assert(IsAlignedOn(CALC_ADDR(ks32, i+EFI(1)),GetAlignmentOf<word64>()));	\

+	CRYPTOPP_ASSERT(IsAlignedOn(CALC_ADDR(ks32, i+EFI(0)),GetAlignmentOf<word64>()));	\

+	CRYPTOPP_ASSERT(IsAlignedOn(CALC_ADDR(ks32, i+EFI(1)),GetAlignmentOf<word64>()));	\

 	*(word64*)(void*)CALC_ADDR(ks32, i+EFI(0)) = kwl;	\

 	*(word64*)(void*)CALC_ADDR(ks32, i+EFI(1)) = kwr

 #define KS_ROUND(i, r, which)																						\

-	assert(IsAlignedOn(CALC_ADDR(ks32, i+EFI(r<64)),GetAlignmentOf<word64>()));	\

-	assert(IsAlignedOn(CALC_ADDR(ks32, i+EFI(r>64)),GetAlignmentOf<word64>()));	\

+	CRYPTOPP_ASSERT(IsAlignedOn(CALC_ADDR(ks32, i+EFI(r<64)),GetAlignmentOf<word64>()));	\

+	CRYPTOPP_ASSERT(IsAlignedOn(CALC_ADDR(ks32, i+EFI(r>64)),GetAlignmentOf<word64>()));	\

 	if (which & (1<<int(r<64))) *(word64*)(void*)CALC_ADDR(ks32, i+EFI(r<64)) = (kwr << (r%64)) | (kwl >> (64 - (r%64)));	\

 	if (which & (1<<int(r>64))) *(word64*)(void*)CALC_ADDR(ks32, i+EFI(r>64)) = (kwl << (r%64)) | (kwr >> (64 - (r%64)))

 #else

@@ -222,7 +222,7 @@ void Camellia::Base::ProcessAndXorBlock(const byte *inBlock, const byte *xorBloc
 	volatile word32 _u = 0;

 	word32 u = _u;

 

-	assert(IsAlignedOn(s1,GetAlignmentOf<word32>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(s1,GetAlignmentOf<word32>()));

 	for (i=0; i<256; i+=cacheLineSize)

 		u &= *(const word32 *)(void*)(s1+i);

 	u &= *(const word32 *)(void*)(s1+252);

diff --git a/cast.cpp b/cast.cpp
index cc62b915..88162c06 100644
--- a/cast.cpp
+++ b/cast.cpp
@@ -282,7 +282,7 @@ void CAST256::Base::UncheckedSetKey(const byte *userKey, unsigned int keylength,
 				int i1=8*j+i;

 				int i2=8*(11-j)+i;

 

-				assert(i1<i2);

+				CRYPTOPP_ASSERT(i1<i2);

 

 				std::swap(K[i1],K[i2]);

 				std::swap(K[i1+4],K[i2+4]);

diff --git a/ccm.cpp b/ccm.cpp
index fe125f5c..97d05614 100644
--- a/ccm.cpp
+++ b/ccm.cpp
@@ -30,7 +30,7 @@ void CCM_Base::Resync(const byte *iv, size_t len)
 	BlockCipher &cipher = AccessBlockCipher();

 

 	m_L = REQUIRED_BLOCKSIZE-1-(int)len;

-	assert(m_L >= 2);

+	CRYPTOPP_ASSERT(m_L >= 2);

 	if (m_L > 8)

 		m_L = 8;

 

@@ -66,7 +66,7 @@ void CCM_Base::UncheckedSpecifyDataLengths(lword headerLength, lword messageLeng
 

 	if (headerLength>0)

 	{

-		assert(m_bufferedDataLength == 0);

+		CRYPTOPP_ASSERT(m_bufferedDataLength == 0);

 

 		if (headerLength < ((1<<16) - (1<<8)))

 		{

diff --git a/chacha.cpp b/chacha.cpp
index 833a6acb..58fbda26 100644
--- a/chacha.cpp
+++ b/chacha.cpp
@@ -31,7 +31,7 @@ template <unsigned int R>
 void ChaCha_Policy<R>::CipherSetKey(const NameValuePairs &params, const byte *key, size_t length)

 {

 	CRYPTOPP_UNUSED(params);

-	assert(length == 16 || length == 32);

+	CRYPTOPP_ASSERT(length == 16 || length == 32);

 

 	// "expand 16-byte k" or "expand 32-byte k"

 	m_state[0] = 0x61707865;

@@ -50,7 +50,7 @@ template <unsigned int R>
 void ChaCha_Policy<R>::CipherResynchronize(byte *keystreamBuffer, const byte *IV, size_t length)

 {

 	CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(length);

-	assert(length==8);

+	CRYPTOPP_ASSERT(length==8);

 

 	GetBlock<word32, LittleEndian> get(IV);

 	m_state[12] = m_state[13] = 0;

diff --git a/cmac.cpp b/cmac.cpp
index 95d37ddd..ce8563cf 100644
--- a/cmac.cpp
+++ b/cmac.cpp
@@ -57,7 +57,7 @@ void CMAC_Base::UncheckedSetKey(const byte *key, unsigned int length, const Name
 

 void CMAC_Base::Update(const byte *input, size_t length)

 {

-	assert((input && length) || !(input || length));

+	CRYPTOPP_ASSERT((input && length) || !(input || length));

 	if (!length)

 		return;

 

@@ -84,7 +84,7 @@ void CMAC_Base::Update(const byte *input, size_t length)
 

 	if (length > blockSize)

 	{

-		assert(m_counter == 0);

+		CRYPTOPP_ASSERT(m_counter == 0);

 		size_t leftOver = 1 + cipher.AdvancedProcessBlocks(m_reg, input, m_reg, length-1, BlockTransformation::BT_DontIncrementInOutPointers|BlockTransformation::BT_XorInput);

 		input += (length - leftOver);

 		length = leftOver;

@@ -92,12 +92,12 @@ void CMAC_Base::Update(const byte *input, size_t length)
 

 	if (length > 0)

 	{

-		assert(m_counter + length <= blockSize);

+		CRYPTOPP_ASSERT(m_counter + length <= blockSize);

 		xorbuf(m_reg+m_counter, input, length);

 		m_counter += (unsigned int)length;

 	}

 

-	assert(m_counter > 0);

+	CRYPTOPP_ASSERT(m_counter > 0);

 }

 

 void CMAC_Base::TruncatedFinal(byte *mac, size_t size)

diff --git a/config.h b/config.h
index 138626de..b4796095 100644
--- a/config.h
+++ b/config.h
@@ -138,6 +138,16 @@
 # define CRYPTOPP_USER_PRIORITY 250

 #endif

 

+// CRYPTOPP_DEBUG enables the library's CRYPTOPP_ASSERT. CRYPTOPP_ASSERT

+//   raises a SIGTRAP (Unix) or calls DebugBreak() (Windows). CRYPTOPP_ASSERT

+//   is only in effect when CRYPTOPP_DEBUG, DEBUG or _DEBUG is defined. Unlike

+//   Posix assert, CRYPTOPP_ASSERT is not affected by NDEBUG (or failure to

+//   define it).

+//   Also see http://github.com/weidai11/cryptopp/issues/277, CVE-2010-4179

+#if (defined(DEBUG) || defined(_DEBUG)) && !defined(CRYPTOPP_DEBUG)

+# define CRYPTOPP_DEBUG 1

+#endif

+

 // ***************** Important Settings Again ********************

 // But the defaults should be ok.

 

diff --git a/config.recommend b/config.recommend
index 629fb96c..d1840d42 100644
--- a/config.recommend
+++ b/config.recommend
@@ -138,6 +138,16 @@
 # define CRYPTOPP_USER_PRIORITY 250

 #endif

 

+// CRYPTOPP_DEBUG enables the library's CRYPTOPP_ASSERT. CRYPTOPP_ASSERT

+//   raises a SIGTRAP (Unix) or calls DebugBreak() (Windows). CRYPTOPP_ASSERT

+//   is only in effect when CRYPTOPP_DEBUG, DEBUG or _DEBUG is defined. Unlike

+//   Posix assert, CRYPTOPP_ASSERT is not affected by NDEBUG (or failure to

+//   define it).

+//   Also see http://github.com/weidai11/cryptopp/issues/277, CVE-2010-4179

+#if (defined(DEBUG) || defined(_DEBUG)) && !defined(CRYPTOPP_DEBUG)

+# define CRYPTOPP_DEBUG 1

+#endif

+

 // ***************** Important Settings Again ********************

 // But the defaults should be ok.

 

diff --git a/cryptdll.vcxproj b/cryptdll.vcxproj
index e082d29a..579b2777 100644
--- a/cryptdll.vcxproj
+++ b/cryptdll.vcxproj
@@ -895,6 +895,7 @@ IF %ERRORLEVEL% EQU 0 (echo mac done &gt; "$(OutDir)"\cryptopp.mac.done)
     <ClInclude Include="smartptr.h" />

     <ClInclude Include="stdcpp.h" />

     <ClInclude Include="strciphr.h" />

+    <ClInclude Include="trap.h" />

     <ClInclude Include="trdlocal.h" />

     <ClInclude Include="words.h" />

   </ItemGroup>

diff --git a/cryptdll.vcxproj.filters b/cryptdll.vcxproj.filters
index 10b6050b..7161f5f0 100644
--- a/cryptdll.vcxproj.filters
+++ b/cryptdll.vcxproj.filters
@@ -370,6 +370,9 @@
     <ClInclude Include="strciphr.h">

       <Filter>Header Files</Filter>

     </ClInclude>

+    <ClInclude Include="trap.h">

+      <Filter>Header Files</Filter>

+    </ClInclude>

     <ClInclude Include="trdlocal.h">

       <Filter>Header Files</Filter>

     </ClInclude>

diff --git a/cryptlib.cpp b/cryptlib.cpp
index d2ecc01b..c1f6f63e 100644
--- a/cryptlib.cpp
+++ b/cryptlib.cpp
@@ -181,9 +181,9 @@ void SimpleKeyingInterface::GetNextIV(RandomNumberGenerator &rng, byte *IV)
 

 size_t BlockTransformation::AdvancedProcessBlocks(const byte *inBlocks, const byte *xorBlocks, byte *outBlocks, size_t length, word32 flags) const

 {

-	assert(inBlocks);

-	assert(outBlocks);

-	assert(length);

+	CRYPTOPP_ASSERT(inBlocks);

+	CRYPTOPP_ASSERT(outBlocks);

+	CRYPTOPP_ASSERT(length);

 

 	size_t blockSize = BlockSize();

 	size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize;

@@ -192,7 +192,7 @@ size_t BlockTransformation::AdvancedProcessBlocks(const byte *inBlocks, const by
 

 	if (flags & BT_ReverseDirection)

 	{

-		assert(length % blockSize == 0);

+		CRYPTOPP_ASSERT(length % blockSize == 0);

 		inBlocks += length - blockSize;

 		xorBlocks += length - blockSize;

 		outBlocks += length - blockSize;

@@ -206,7 +206,7 @@ size_t BlockTransformation::AdvancedProcessBlocks(const byte *inBlocks, const by
 		if (flags & BT_XorInput)

 		{

 			// Coverity finding. However, xorBlocks is never NULL if BT_XorInput.

-			assert(xorBlocks);

+			CRYPTOPP_ASSERT(xorBlocks);

 #if defined(__COVERITY__)

 			if (xorBlocks)

 #endif

@@ -247,7 +247,7 @@ unsigned int HashTransformation::OptimalDataAlignment() const
 

 void StreamTransformation::ProcessLastBlock(byte *outString, const byte *inString, size_t length)

 {

-	assert(MinLastBlockSize() == 0);	// this function should be overriden otherwise

+	CRYPTOPP_ASSERT(MinLastBlockSize() == 0);	// this function should be overriden otherwise

 

 	if (length == MandatoryBlockSize())

 		ProcessData(outString, inString, length);

@@ -320,7 +320,7 @@ word32 RandomNumberGenerator::GenerateWord32(word32 min, word32 max)
 // see https://github.com/weidai11/cryptopp/issues/38.

 //

 // According to Wei, RandomNumberGenerator is an interface, and it should not

-// be instantiable. Its now spilt milk, and we are going to assert it in Debug

+// be instantiable. Its now spilt milk, and we are going to CRYPTOPP_ASSERT it in Debug

 // builds to alert the programmer and throw in Release builds. Developers have

 // a reference implementation in case its needed. If a programmer

 // unintentionally lands here, then they should ensure use of a

@@ -353,7 +353,7 @@ void RandomNumberGenerator::GenerateIntoBufferedTransformation(BufferedTransform
 		size_t len = UnsignedMin(buffer.size(), length);

 		GenerateBlock(buffer, len);

 		size_t rem = target.ChannelPut(channel, buffer, len);

-		CRYPTOPP_UNUSED(rem); assert(rem == 0);

+		CRYPTOPP_UNUSED(rem); CRYPTOPP_ASSERT(rem == 0);

 		length -= len;

 	}

 }

@@ -439,21 +439,21 @@ void BufferedTransformation::GetWaitObjects(WaitObjectContainer &container, Call
 void BufferedTransformation::Initialize(const NameValuePairs &parameters, int propagation)

 {

 	CRYPTOPP_UNUSED(propagation);

-	assert(!AttachedTransformation());

+	CRYPTOPP_ASSERT(!AttachedTransformation());

 	IsolatedInitialize(parameters);

 }

 

 bool BufferedTransformation::Flush(bool hardFlush, int propagation, bool blocking)

 {

 	CRYPTOPP_UNUSED(propagation);

-	assert(!AttachedTransformation());

+	CRYPTOPP_ASSERT(!AttachedTransformation());

 	return IsolatedFlush(hardFlush, blocking);

 }

 

 bool BufferedTransformation::MessageSeriesEnd(int propagation, bool blocking)

 {

 	CRYPTOPP_UNUSED(propagation);

-	assert(!AttachedTransformation());

+	CRYPTOPP_ASSERT(!AttachedTransformation());

 	return IsolatedMessageSeriesEnd(blocking);

 }

 

@@ -592,7 +592,7 @@ bool BufferedTransformation::GetNextMessage()
 		return AttachedTransformation()->GetNextMessage();

 	else

 	{

-		assert(!AnyMessages());

+		CRYPTOPP_ASSERT(!AnyMessages());

 		return false;

 	}

 }

@@ -629,7 +629,7 @@ size_t BufferedTransformation::TransferMessagesTo2(BufferedTransformation &targe
 				return 1;

 

 			bool result = GetNextMessage();

-			CRYPTOPP_UNUSED(result); assert(result);

+			CRYPTOPP_UNUSED(result); CRYPTOPP_ASSERT(result);

 		}

 		return 0;

 	}

@@ -660,7 +660,7 @@ size_t BufferedTransformation::TransferAllTo2(BufferedTransformation &target, co
 		return AttachedTransformation()->TransferAllTo2(target, channel, blocking);

 	else

 	{

-		assert(!NumberOfMessageSeries());

+		CRYPTOPP_ASSERT(!NumberOfMessageSeries());

 

 		unsigned int messageCount;

 		do

@@ -692,7 +692,7 @@ void BufferedTransformation::CopyAllTo(BufferedTransformation &target, const std
 		AttachedTransformation()->CopyAllTo(target, channel);

 	else

 	{

-		assert(!NumberOfMessageSeries());

+		CRYPTOPP_ASSERT(!NumberOfMessageSeries());

 		while (CopyMessagesTo(target, UINT_MAX, channel)) {}

 	}

 }

diff --git a/cryptlib.h b/cryptlib.h
index 9e388e05..c1619e65 100644
--- a/cryptlib.h
+++ b/cryptlib.h
@@ -85,6 +85,11 @@ and getting us started on the manual.
 

 #include "config.h"

 #include "stdcpp.h"

+#include "trap.h"

+

+#if defined(CRYPTOPP_BSD_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE)

+# include <signal.h>

+#endif

 

 #if CRYPTOPP_MSC_VERSION

 # pragma warning(push)

@@ -715,7 +720,7 @@ protected:
 	//! \brief Validates the key length

 	//! \param length the size of the keying material, in bytes

 	inline void AssertValidKeyLength(size_t length) const

-		{CRYPTOPP_UNUSED(length); assert(IsValidKeyLength(length));}

+		{CRYPTOPP_UNUSED(length); CRYPTOPP_ASSERT(IsValidKeyLength(length));}

 };

 

 //! \brief Interface for the data processing part of block ciphers

@@ -895,11 +900,11 @@ public:
 	//! \param pos position to seek

 	//! \throws NotImplemented

 	//! \details The base class implementation throws NotImplemented. The function

-	//!   asserts  IsRandomAccess() in debug builds.

+	//!   \ref CRYPTOPP_ASSERT "asserts" IsRandomAccess() in debug builds.

 	virtual void Seek(lword pos)

 	{

 		CRYPTOPP_UNUSED(pos);

-		assert(!IsRandomAccess());

+		CRYPTOPP_ASSERT(!IsRandomAccess());

 		throw NotImplemented("StreamTransformation: this object doesn't support random access");

 	}

 

@@ -2001,7 +2006,7 @@ public:
 		//! \return the attached transformation

 		//! \details AttachedTransformation() returns NULL if there is no attachment. The non-const

 		//!   version of AttachedTransformation() always returns NULL.

-		virtual BufferedTransformation *AttachedTransformation() {assert(!Attachable()); return 0;}

+		virtual BufferedTransformation *AttachedTransformation() {CRYPTOPP_ASSERT(!Attachable()); return 0;}

 

 		//! \brief Returns the object immediately attached to this object

 		//! \return the attached transformation

@@ -2017,7 +2022,7 @@ public:
 		//! \details If a derived class does not override  Detach, then the base class throws

 		//!   NotImplemented.

 		virtual void Detach(BufferedTransformation *newAttachment = 0) {

-			CRYPTOPP_UNUSED(newAttachment); assert(!Attachable());

+			CRYPTOPP_UNUSED(newAttachment); CRYPTOPP_ASSERT(!Attachable());

 			throw NotImplemented("BufferedTransformation: this object is not attachable");

 		}

 

@@ -2128,7 +2133,7 @@ public:
 	//!   NotImplemented.

 	//! \sa SupportsPrecomputation(), LoadPrecomputation(), SavePrecomputation()

 	virtual void Precompute(unsigned int precomputationStorage) {

-		CRYPTOPP_UNUSED(precomputationStorage); assert(!SupportsPrecomputation());

+		CRYPTOPP_UNUSED(precomputationStorage); CRYPTOPP_ASSERT(!SupportsPrecomputation());

 		throw NotImplemented("CryptoMaterial: this object does not support precomputation");

 	}

 

@@ -2137,13 +2142,13 @@ public:
 	//! \throws NotImplemented

 	//! \sa SupportsPrecomputation(), Precompute()

 	virtual void LoadPrecomputation(BufferedTransformation &storedPrecomputation)

-		{CRYPTOPP_UNUSED(storedPrecomputation); assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}

+		{CRYPTOPP_UNUSED(storedPrecomputation); CRYPTOPP_ASSERT(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}

 	//! \brief Save precomputation for later use

 	//! \param storedPrecomputation BufferedTransformation to write the precomputation

 	//! \throws NotImplemented

 	//! \sa SupportsPrecomputation(), Precompute()

 	virtual void SavePrecomputation(BufferedTransformation &storedPrecomputation) const

-		{CRYPTOPP_UNUSED(storedPrecomputation); assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}

+		{CRYPTOPP_UNUSED(storedPrecomputation); CRYPTOPP_ASSERT(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}

 

 	//! \brief Perform a quick sanity check

 	//! \details DoQuickSanityCheck() is for internal library use, and it should not be called by library users.

diff --git a/cryptlib.vcxproj b/cryptlib.vcxproj
index 5fbf8d4e..ae355894 100644
--- a/cryptlib.vcxproj
+++ b/cryptlib.vcxproj
@@ -2391,6 +2391,7 @@ echo: &gt;&gt; adhoc.cpp.copied
     <ClInclude Include="strciphr.h" />

     <ClInclude Include="tea.h" />

     <ClInclude Include="tiger.h" />

+    <ClInclude Include="trap.h" />

     <ClInclude Include="trdlocal.h" />

     <ClInclude Include="trunhash.h" />

     <ClInclude Include="ttmac.h" />

diff --git a/cryptlib.vcxproj.filters b/cryptlib.vcxproj.filters
index 13e713e7..bbfb85ca 100644
--- a/cryptlib.vcxproj.filters
+++ b/cryptlib.vcxproj.filters
@@ -768,6 +768,9 @@
     <ClInclude Include="tiger.h">

       <Filter>Header Files</Filter>

     </ClInclude>

+    <ClInclude Include="trap.h">

+      <Filter>Header Files</Filter>

+    </ClInclude>

     <ClInclude Include="trdlocal.h">

       <Filter>Header Files</Filter>

     </ClInclude>

diff --git a/datatest.cpp b/datatest.cpp
index 315b93da..7a2e64c9 100644
--- a/datatest.cpp
+++ b/datatest.cpp
@@ -300,12 +300,12 @@ void TestSignatureScheme(TestData &v)
 	else if (test == "RandomSign")

 	{

 		SignalTestError();

-		assert(false);	// TODO: implement

+		CRYPTOPP_ASSERT(false);	// TODO: implement

 	}

 	else

 	{

 		SignalTestError();

-		assert(false);

+		CRYPTOPP_ASSERT(false);

 	}

 }

 

@@ -345,7 +345,7 @@ void TestAsymmetricCipher(TestData &v)
 	else

 	{

 		SignalTestError();

-		assert(false);

+		CRYPTOPP_ASSERT(false);

 	}

 }

 

@@ -443,7 +443,7 @@ void TestSymmetricCipher(TestData &v, const NameValuePairs &overrideParameters)
 			while (ss.Pump(64)) {}

 			ss.PumpAll();

 			for (int i=0; i<z.length(); i++)

-				assert(encrypted[i] == z[i]);

+				CRYPTOPP_ASSERT(encrypted[i] == z[i]);

 		}*/

 		if (test != "EncryptXorDigest")

 			ciphertext = GetDecodedDatum(v, "Ciphertext");

@@ -608,7 +608,7 @@ void TestDigestOrMAC(TestData &v, bool testDigest)
 	else

 	{

 		SignalTestError();

-		assert(false);

+		CRYPTOPP_ASSERT(false);

 	}

 }

 

@@ -618,7 +618,7 @@ void TestKeyDerivationFunction(TestData &v)
 	std::string test = GetRequiredDatum(v, "Test");

 

 	if(test == "Skip") return;

-	assert(test == "Verify");

+	CRYPTOPP_ASSERT(test == "Verify");

 

 	std::string key = GetDecodedDatum(v, "Key");

 	std::string salt = GetDecodedDatum(v, "Salt");

@@ -722,7 +722,7 @@ void OutputPair(const NameValuePairs &v, const char *name)
 {

 	Integer x;

 	bool b = v.GetValue(name, x);

-	CRYPTOPP_UNUSED(b); assert(b);

+	CRYPTOPP_UNUSED(b); CRYPTOPP_ASSERT(b);

 	cout << name << ": \\\n    ";

 	x.Encode(HexEncoder(new FileSink(cout), false, 64, "\\\n    ").Ref(), x.MinEncodedSize());

 	cout << endl;

@@ -768,7 +768,7 @@ void TestDataFile(std::string filename, const NameValuePairs &overrideParameters
 	while (file)

 	{

 		while (file.peek() == '#')

-			file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

+			file.ignore((std::numeric_limits<std::streamsize>::max)(), '\n');

 

 		if (file.peek() == '\n' || file.peek() == '\r')

 			v.clear();

diff --git a/dlltest.cpp b/dlltest.cpp
index 01906207..559084ba 100644
--- a/dlltest.cpp
+++ b/dlltest.cpp
@@ -133,7 +133,7 @@ void FIPS140_SampleApplication()
 	// sign and verify

 	byte signature[40];

 	DSA::Signer signer(dsaPrivateKey);

-	assert(signer.SignatureLength() == 40);

+	CRYPTOPP_ASSERT(signer.SignatureLength() == 40);

 	signer.SignMessage(rng, message, 3, signature);

 

 	DSA::Verifier verifier(dsaPublicKey);

diff --git a/eax.cpp b/eax.cpp
index cf836632..437b502f 100644
--- a/eax.cpp
+++ b/eax.cpp
@@ -34,7 +34,7 @@ size_t EAX_Base::AuthenticateBlocks(const byte *data, size_t len)
 

 void EAX_Base::AuthenticateLastHeaderBlock()

 {

-	assert(m_bufferedDataLength == 0);

+	CRYPTOPP_ASSERT(m_bufferedDataLength == 0);

 	MessageAuthenticationCode &mac = AccessMAC();

 	unsigned int blockSize = mac.TagSize();

 

@@ -48,7 +48,7 @@ void EAX_Base::AuthenticateLastHeaderBlock()
 

 void EAX_Base::AuthenticateLastFooterBlock(byte *tag, size_t macSize)

 {

-	assert(m_bufferedDataLength == 0);

+	CRYPTOPP_ASSERT(m_bufferedDataLength == 0);

 	MessageAuthenticationCode &mac = AccessMAC();

 	unsigned int blockSize = mac.TagSize();

 

diff --git a/ec2n.cpp b/ec2n.cpp
index e00b53e7..33a9d454 100644
--- a/ec2n.cpp
+++ b/ec2n.cpp
@@ -71,11 +71,11 @@ bool EC2N::DecodePoint(EC2N::Point &P, BufferedTransformation &bt, size_t encode
 		}

 

 		FieldElement z = m_field->Square(P.x);

-		assert(P.x == m_field->SquareRoot(z));

+		CRYPTOPP_ASSERT(P.x == m_field->SquareRoot(z));

 		P.y = m_field->Divide(m_field->Add(m_field->Multiply(z, m_field->Add(P.x, m_a)), m_b), z);

-		assert(P.x == m_field->Subtract(m_field->Divide(m_field->Subtract(m_field->Multiply(P.y, z), m_b), z), m_a));

+		CRYPTOPP_ASSERT(P.x == m_field->Subtract(m_field->Divide(m_field->Subtract(m_field->Multiply(P.y, z), m_b), z), m_a));

 		z = m_field->SolveQuadraticEquation(P.y);

-		assert(m_field->Add(m_field->Square(z), z) == P.y);

+		CRYPTOPP_ASSERT(m_field->Add(m_field->Square(z), z) == P.y);

 		z.SetCoefficient(0, type & 1);

 

 		P.y = m_field->Multiply(z, P.x);

@@ -119,7 +119,7 @@ void EC2N::EncodePoint(byte *encodedPoint, const Point &P, bool compressed) cons
 {

 	ArraySink sink(encodedPoint, EncodedPointSize(compressed));

 	EncodePoint(sink, P, compressed);

-	assert(sink.TotalPutLength() == EncodedPointSize(compressed));

+	CRYPTOPP_ASSERT(sink.TotalPutLength() == EncodedPointSize(compressed));

 }

 

 EC2N::Point EC2N::BERDecodePoint(BufferedTransformation &bt) const

diff --git a/eccrypto.cpp b/eccrypto.cpp
index 6112e272..dd58bf4d 100644
--- a/eccrypto.cpp
+++ b/eccrypto.cpp
@@ -457,7 +457,7 @@ template <class EC> void DL_GroupParameters_EC<EC>::Initialize(const OID &oid)
 	this->SetSubgroupGenerator(G);

 

 	// TODO: this fails in practice. Should it throw?

-	CRYPTOPP_UNUSED(result); assert(result);

+	CRYPTOPP_UNUSED(result); CRYPTOPP_ASSERT(result);

 

 	StringSource ssN(param.n, true, new HexDecoder);

 	m_n.Decode(ssN, (size_t)ssN.MaxRetrievable());

diff --git a/ecp.cpp b/ecp.cpp
index c718a527..eae99eb1 100644
--- a/ecp.cpp
+++ b/ecp.cpp
@@ -140,7 +140,7 @@ void ECP::EncodePoint(byte *encodedPoint, const Point &P, bool compressed) const
 {

 	ArraySink sink(encodedPoint, EncodedPointSize(compressed));

 	EncodePoint(sink, P, compressed);

-	assert(sink.TotalPutLength() == EncodedPointSize(compressed));

+	CRYPTOPP_ASSERT(sink.TotalPutLength() == EncodedPointSize(compressed));

 }

 

 ECP::Point ECP::BERDecodePoint(BufferedTransformation &bt) const

@@ -384,7 +384,7 @@ void ECP::SimultaneousMultiply(ECP::Point *results, const ECP::Point &P, const I
 

 	for (i=0; i<expCount; i++)

 	{

-		assert(expBegin->NotNegative());

+		CRYPTOPP_ASSERT(expBegin->NotNegative());

 		exponents.push_back(WindowSlider(*expBegin++, InversionIsFast(), 5));

 		exponents[i].FindNextWindow();

 	}

diff --git a/emsa2.cpp b/emsa2.cpp
index 7da90516..fb387d2f 100644
--- a/emsa2.cpp
+++ b/emsa2.cpp
@@ -13,7 +13,7 @@ void EMSA2Pad::ComputeMessageRepresentative(RandomNumberGenerator& /*rng*/,
 	byte *representative, size_t representativeBitLength) const

 {

 	CRYPTOPP_UNUSED(recoverableMessage), CRYPTOPP_UNUSED(recoverableMessageLength), CRYPTOPP_UNUSED(representativeBitLength);

-	assert(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));

+	CRYPTOPP_ASSERT(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));

 

 	if (representativeBitLength % 8 != 7)

 		throw PK_SignatureScheme::InvalidKeyLength("EMSA2: EMSA2 requires a key length that is a multiple of 8");

diff --git a/eprecomp.cpp b/eprecomp.cpp
index 78c8f4cf..3a021b66 100644
--- a/eprecomp.cpp
+++ b/eprecomp.cpp
@@ -27,8 +27,8 @@ template <class T> void DL_FixedBasePrecomputationImpl<T>::SetBase(const DL_Grou
 

 template <class T> void DL_FixedBasePrecomputationImpl<T>::Precompute(const DL_GroupPrecomputation<Element> &group, unsigned int maxExpBits, unsigned int storage)

 {

-	assert(m_bases.size() > 0);

-	assert(storage <= maxExpBits);

+	CRYPTOPP_ASSERT(m_bases.size() > 0);

+	CRYPTOPP_ASSERT(storage <= maxExpBits);

 

 	if (storage > 1)

 	{

diff --git a/esign.cpp b/esign.cpp
index 4d79ad59..7fef8082 100644
--- a/esign.cpp
+++ b/esign.cpp
@@ -125,7 +125,7 @@ void InvertibleESIGNFunction::GenerateRandom(RandomNumberGenerator &rng, const N
 

 	m_n = m_p * m_p * m_q;

 

-	assert(m_n.BitCount() == (unsigned int)modulusSize);

+	CRYPTOPP_ASSERT(m_n.BitCount() == (unsigned int)modulusSize);

 }

 

 void InvertibleESIGNFunction::BERDecode(BufferedTransformation &bt)

@@ -174,7 +174,7 @@ Integer InvertibleESIGNFunction::CalculateRandomizedInverse(RandomNumberGenerato
 	ModularArithmetic modp(m_p);

 	Integer t = modp.Divide(w0 * r % m_p, m_e * re % m_p);

 	Integer s = r + t*pq;

-	assert(s < m_n);

+	CRYPTOPP_ASSERT(s < m_n);

 #if 0

 	using namespace std;

 	cout << "f = " << x << endl;

diff --git a/fhmqv.h b/fhmqv.h
index 0e9a317b..b5eceb79 100644
--- a/fhmqv.h
+++ b/fhmqv.h
@@ -171,7 +171,7 @@ public:
       }

       else

       {

-        assert(0);

+        CRYPTOPP_ASSERT(0);

         return false;

       }

 

@@ -248,7 +248,7 @@ protected:
   {

     HASH hash;

     size_t idx = 0, req = dlen;

-    size_t blk = std::min(dlen, (size_t)HASH::DIGESTSIZE);

+    size_t blk = STDMIN(dlen, (size_t)HASH::DIGESTSIZE);

 

     if(sigma)

     {

@@ -272,7 +272,7 @@ protected:
       hash.Update(&digest[idx], (size_t)HASH::DIGESTSIZE);

 

       idx += (size_t)HASH::DIGESTSIZE;

-      blk = std::min(req, (size_t)HASH::DIGESTSIZE);

+      blk = STDMIN(req, (size_t)HASH::DIGESTSIZE);

       hash.TruncatedFinal(&digest[idx], blk);

 

       req -= blk;

diff --git a/files.cpp b/files.cpp
index 5ac45c6c..ff25dc7e 100644
--- a/files.cpp
+++ b/files.cpp
@@ -141,7 +141,7 @@ size_t FileStore::CopyRangeTo2(BufferedTransformation &target, lword &begin, lwo
 	m_stream->seekg(newPosition);

 	try

 	{

-		assert(!m_waiting);

+		CRYPTOPP_ASSERT(!m_waiting);

 		lword copyMax = end-begin;

 		size_t blockedBytes = const_cast<FileStore *>(this)->TransferTo2(target, copyMax, channel, blocking);

 		begin += copyMax;

diff --git a/filters.cpp b/filters.cpp
index 80cd523b..9366ca79 100644
--- a/filters.cpp
+++ b/filters.cpp
@@ -188,7 +188,7 @@ size_t MeterFilter::PutMaybeModifiable(byte *begin, size_t length, int messageEn
 		{

 			FILTER_OUTPUT_MAYBE_MODIFIABLE(1, m_begin, t = (size_t)SaturatingSubtract(m_rangesToSkip.front().position, m_currentMessageBytes), false, modifiable);

 

-			assert(t < m_length);

+			CRYPTOPP_ASSERT(t < m_length);

 			m_begin += t;

 			m_length -= t;

 			m_currentMessageBytes += t;

@@ -199,7 +199,7 @@ size_t MeterFilter::PutMaybeModifiable(byte *begin, size_t length, int messageEn
 			else

 			{

 				t = (size_t)SaturatingSubtract(m_rangesToSkip.front().position + m_rangesToSkip.front().size, m_currentMessageBytes);

-				assert(t <= m_length);

+				CRYPTOPP_ASSERT(t <= m_length);

 				m_rangesToSkip.pop_front();

 			}

 

@@ -303,7 +303,7 @@ void FilterWithBufferedInput::BlockQueue::Put(const byte *inString, size_t lengt
 	// Avoid passing NULL pointer to memcpy

 	if (!inString || !length) return;

 

-	assert(m_size + length <= m_buffer.size());

+	CRYPTOPP_ASSERT(m_size + length <= m_buffer.size());

 	byte *end = (m_size < size_t(m_buffer.end()-m_begin)) ? m_begin + m_size : m_begin + m_size - m_buffer.size();

 	size_t len = STDMIN(length, size_t(m_buffer.end()-end));

 	memcpy(end, inString, len);

@@ -368,7 +368,7 @@ size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length
 			size_t len = m_firstSize - m_queue.CurrentSize();

 			m_queue.Put(inString, len);

 			FirstPut(m_queue.GetContigousBlocks(m_firstSize));

-			assert(m_queue.CurrentSize() == 0);

+			CRYPTOPP_ASSERT(m_queue.CurrentSize() == 0);

 			m_queue.ResetQueue(m_blockSize, (2*m_blockSize+m_lastSize-2)/m_blockSize);

 

 			inString += len;

@@ -406,7 +406,7 @@ size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length
 

 				if (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() > 0)

 				{

-					assert(m_queue.CurrentSize() < m_blockSize);

+					CRYPTOPP_ASSERT(m_queue.CurrentSize() < m_blockSize);

 					size_t len = m_blockSize - m_queue.CurrentSize();

 					m_queue.Put(inString, len);

 					inString += len;

@@ -465,10 +465,10 @@ void FilterWithBufferedInput::ForceNextPut()
 

 void FilterWithBufferedInput::NextPutMultiple(const byte *inString, size_t length)

 {

-	assert(m_blockSize > 1);	// m_blockSize = 1 should always override this function

+	CRYPTOPP_ASSERT(m_blockSize > 1);	// m_blockSize = 1 should always override this function

 	while (length > 0)

 	{

-		assert(length >= m_blockSize);

+		CRYPTOPP_ASSERT(length >= m_blockSize);

 		NextPutSingle(inString);

 		inString += m_blockSize;

 		length -= m_blockSize;

@@ -590,7 +590,7 @@ StreamTransformationFilter::StreamTransformationFilter(StreamTransformation &c,
 	: FilterWithBufferedInput(attachment)

 	, m_cipher(c), m_padding(DEFAULT_PADDING), m_optimalBufferSize(0)

 {

-	assert(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());

+	CRYPTOPP_ASSERT(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());

 

 	if (!allowAuthenticatedSymmetricCipher && dynamic_cast<AuthenticatedSymmetricCipher *>(&c) != 0)

 		throw InvalidArgument("StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher");

@@ -710,15 +710,15 @@ void StreamTransformationFilter::LastPut(const byte *inString, size_t length)
 	case ONE_AND_ZEROS_PADDING:

 		unsigned int s;

 		s = m_cipher.MandatoryBlockSize();

-		assert(s > 1);

+		CRYPTOPP_ASSERT(s > 1);

 		space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, s, m_optimalBufferSize);

 		if (m_cipher.IsForwardTransformation())

 		{

-			assert(length < s);

+			CRYPTOPP_ASSERT(length < s);

 			if (inString) {memcpy(space, inString, length);}

 			if (m_padding == PKCS_PADDING)

 			{

-				assert(s < 256);

+				CRYPTOPP_ASSERT(s < 256);

 				byte pad = byte(s-length);

 				memset(space+length, pad, s-length);

 			}

@@ -754,7 +754,7 @@ void StreamTransformationFilter::LastPut(const byte *inString, size_t length)
 		break;

 

 	default:

-		assert(false);

+		CRYPTOPP_ASSERT(false);

 	}

 }

 

@@ -836,7 +836,7 @@ void HashVerificationFilter::LastPut(const byte *inString, size_t length)
 {

 	if (m_flags & HASH_AT_BEGIN)

 	{

-		assert(length == 0);

+		CRYPTOPP_ASSERT(length == 0);

 		m_verified = m_hashModule.TruncatedVerify(m_expectedHash, m_digestSize);

 	}

 	else

@@ -860,7 +860,7 @@ AuthenticatedEncryptionFilter::AuthenticatedEncryptionFilter(AuthenticatedSymmet
 	: StreamTransformationFilter(c, attachment, padding, true)

 	, m_hf(c, new OutputProxy(*this, false), putAAD, truncatedDigestSize, AAD_CHANNEL, macChannel)

 {

-	assert(c.IsForwardTransformation());

+	CRYPTOPP_ASSERT(c.IsForwardTransformation());

 }

 

 void AuthenticatedEncryptionFilter::IsolatedInitialize(const NameValuePairs &parameters)

@@ -904,7 +904,7 @@ AuthenticatedDecryptionFilter::AuthenticatedDecryptionFilter(AuthenticatedSymmet
 	, m_hashVerifier(c, new OutputProxy(*this, false))

 	, m_streamFilter(c, new OutputProxy(*this, false), padding, true)

 {

-	assert(!c.IsForwardTransformation() || c.IsSelfInverting());

+	CRYPTOPP_ASSERT(!c.IsForwardTransformation() || c.IsSelfInverting());

 	IsolatedInitialize(MakeParameters(Name::BlockPaddingScheme(), padding)(Name::AuthenticatedDecryptionFilterFlags(), flags)(Name::TruncatedDigestSize(), truncatedDigestSize));

 }

 

@@ -998,7 +998,7 @@ void SignatureVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameV
 	m_flags = parameters.GetValueWithDefault(Name::SignatureVerificationFilterFlags(), (word32)DEFAULT_FLAGS);

 	m_messageAccumulator.reset(m_verifier.NewVerificationAccumulator());

 	size_t size = m_verifier.SignatureLength();

-	assert(size != 0);	// TODO: handle recoverable signature scheme

+	CRYPTOPP_ASSERT(size != 0);	// TODO: handle recoverable signature scheme

 	m_verified = false;

 	firstSize = m_flags & SIGNATURE_AT_BEGIN ? size : 0;

 	blockSize = 1;

@@ -1022,7 +1022,7 @@ void SignatureVerificationFilter::FirstPut(const byte *inString)
 	}

 	else

 	{

-		assert(!m_verifier.SignatureUpfront());

+		CRYPTOPP_ASSERT(!m_verifier.SignatureUpfront());

 	}

 }

 

@@ -1037,7 +1037,7 @@ void SignatureVerificationFilter::LastPut(const byte *inString, size_t length)
 {

 	if (m_flags & SIGNATURE_AT_BEGIN)

 	{

-		assert(length == 0);

+		CRYPTOPP_ASSERT(length == 0);

 		m_verifier.InputSignature(*m_messageAccumulator, m_signature, m_signature.size());

 		m_verified = m_verifier.VerifyAndRestart(*m_messageAccumulator);

 	}

diff --git a/filters.h b/filters.h
index 1beba302..1336aad7 100644
--- a/filters.h
+++ b/filters.h
@@ -176,7 +176,7 @@ struct CRYPTOPP_DLL FilterPutSpaceHelper
 	//!   called \p m_tempSpace is resized and used for the caller.

 	byte *HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize, size_t desiredSize, size_t &bufferSize)

 	{

-		assert(desiredSize >= minSize && bufferSize >= minSize);

+		CRYPTOPP_ASSERT(desiredSize >= minSize && bufferSize >= minSize);

 		if (m_tempSpace.size() < minSize)

 		{

 			byte *result = target.ChannelCreatePutSpace(channel, desiredSize);

@@ -362,7 +362,7 @@ protected:
 	virtual void FirstPut(const byte *inString) =0;

 	// NextPut() is called if totalLength >= firstSize+blockSize+lastSize

 	virtual void NextPutSingle(const byte *inString)

-		{CRYPTOPP_UNUSED(inString); assert(false);}

+		{CRYPTOPP_UNUSED(inString); CRYPTOPP_ASSERT(false);}

 	// Same as NextPut() except length can be a multiple of blockSize

 	// Either NextPut() or NextPutMultiple() must be overriden

 	virtual void NextPutMultiple(const byte *inString, size_t length);

@@ -387,7 +387,7 @@ protected:
 	// This function should no longer be used, put this here to cause a compiler error

 	// if someone tries to override NextPut().

 	virtual int NextPut(const byte *inString, size_t length)

-		{CRYPTOPP_UNUSED(inString); CRYPTOPP_UNUSED(length); assert(false); return 0;}

+		{CRYPTOPP_UNUSED(inString); CRYPTOPP_UNUSED(length); CRYPTOPP_ASSERT(false); return 0;}

 

 	class BlockQueue

 	{

@@ -965,7 +965,7 @@ public:
 	//! \brief Construct a StringSinkTemplate

 	//! \param output std::basic_string<char> type

 	StringSinkTemplate(T &output)

-		: m_output(&output) {assert(sizeof(output[0])==1);}

+		: m_output(&output) {CRYPTOPP_ASSERT(sizeof(output[0])==1);}

 

 	void IsolatedInitialize(const NameValuePairs &parameters)

 		{if (!parameters.GetValue("OutputStringPointer", m_output)) throw InvalidArgument("StringSink: OutputStringPointer not specified");}

diff --git a/fips140.cpp b/fips140.cpp
index a7e396d7..1c442e89 100644
--- a/fips140.cpp
+++ b/fips140.cpp
@@ -54,7 +54,7 @@ bool PowerUpSelfTestInProgressOnThisThread()
 #if CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2

 	return AccessPowerUpSelfTestInProgress().GetValue() != NULL;

 #else

-	assert(false);	// should not be called

+	CRYPTOPP_ASSERT(false);	// should not be called

 	return false;

 #endif

 }

diff --git a/fipsalgt.cpp b/fipsalgt.cpp
index c0d0c628..d20a9b9e 100644
--- a/fipsalgt.cpp
+++ b/fipsalgt.cpp
@@ -262,7 +262,7 @@ protected:
 

 	static inline void Xor(SecByteBlock &z, const SecByteBlock &x, const SecByteBlock &y)

 	{

-		assert(x.size() == y.size());

+		CRYPTOPP_ASSERT(x.size() == y.size());

 		z.resize(x.size());

 		xorbuf(z, x, y, x.size());

 	}

@@ -637,7 +637,7 @@ protected:
 			}

 			else

 			{

-				assert(m_test == "Gen");

+				CRYPTOPP_ASSERT(m_test == "Gen");

 				int modLen = atol(m_bracketString.substr(6).c_str());

 				std::string &encodedKey = m_data["PrivKey"];

 				RSA::PrivateKey priv;

@@ -1034,7 +1034,7 @@ protected:
 		}

 		else

 		{

-			assert(m_test == "KAT");

+			CRYPTOPP_ASSERT(m_test == "KAT");

 

 			SecByteBlock &input = m_data2[INPUT];

 			SecByteBlock result(input.size());

@@ -1097,7 +1097,7 @@ protected:
 

 		if (m_line.substr(0, 2) == "H>")

 		{

-			assert(m_test == "sha");

+			CRYPTOPP_ASSERT(m_test == "sha");

 			m_bracketString = m_line.substr(2, m_line.size()-4);

 			m_line = m_line.substr(0, 13) + "Hashes<H";

 			copyLine = true;

diff --git a/fltrimpl.h b/fltrimpl.h
index 957c1bcc..1577ca7d 100644
--- a/fltrimpl.h
+++ b/fltrimpl.h
@@ -20,7 +20,7 @@
 #define FILTER_END_NO_MESSAGE_END_NO_RETURN	\

 		break;	\

 	default:	\

-		assert(false);	\

+		CRYPTOPP_ASSERT(false);	\

 	}

 

 #define FILTER_END_NO_MESSAGE_END	\

diff --git a/gcm.cpp b/gcm.cpp
index caf282a5..a057f563 100644
--- a/gcm.cpp
+++ b/gcm.cpp
@@ -95,9 +95,9 @@ __m128i _mm_clmulepi64_si128(const __m128i &a, const __m128i &b, int i)
 inline static void SSE2_Xor16(byte *a, const byte *b, const byte *c)

 {

 #if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE

-	assert(IsAlignedOn(a,GetAlignmentOf<__m128i>()));

-	assert(IsAlignedOn(b,GetAlignmentOf<__m128i>()));

-	assert(IsAlignedOn(c,GetAlignmentOf<__m128i>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(a,GetAlignmentOf<__m128i>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(b,GetAlignmentOf<__m128i>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(c,GetAlignmentOf<__m128i>()));

 	*(__m128i *)(void *)a = _mm_xor_si128(*(__m128i *)(void *)b, *(__m128i *)(void *)c);

 #else

 	asm ("movdqa %1, %%xmm0; pxor %2, %%xmm0; movdqa %%xmm0, %0;" : "=m" (a[0]) : "m"(b[0]), "m"(c[0]));

@@ -108,18 +108,18 @@ inline static void SSE2_Xor16(byte *a, const byte *b, const byte *c)
 #if CRYPTOPP_BOOL_NEON_INTRINSICS_AVAILABLE

 inline static void NEON_Xor16(byte *a, const byte *b, const byte *c)

 {

-	assert(IsAlignedOn(a,GetAlignmentOf<uint64x2_t>()));

-	assert(IsAlignedOn(b,GetAlignmentOf<uint64x2_t>()));

-	assert(IsAlignedOn(c,GetAlignmentOf<uint64x2_t>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(a,GetAlignmentOf<uint64x2_t>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(b,GetAlignmentOf<uint64x2_t>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(c,GetAlignmentOf<uint64x2_t>()));

 	*(uint64x2_t*)a = veorq_u64(*(uint64x2_t*)b, *(uint64x2_t*)c);

 }

 #endif

 

 inline static void Xor16(byte *a, const byte *b, const byte *c)

 {

-	assert(IsAlignedOn(a,GetAlignmentOf<word64>()));

-	assert(IsAlignedOn(b,GetAlignmentOf<word64>()));

-	assert(IsAlignedOn(c,GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(a,GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(b,GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(c,GetAlignmentOf<word64>()));

 	((word64 *)(void *)a)[0] = ((word64 *)(void *)b)[0] ^ ((word64 *)(void *)c)[0];

 	((word64 *)(void *)a)[1] = ((word64 *)(void *)b)[1] ^ ((word64 *)(void *)c)[1];

 }

@@ -641,7 +641,7 @@ size_t GCM_Base::AuthenticateBlocks(const byte *data, size_t len)
 

 	typedef BlockGetAndPut<word64, NativeByteOrder> Block;

 	word64 *hashBuffer = (word64 *)(void *)HashBuffer();

-	assert(IsAlignedOn(hashBuffer,GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(hashBuffer,GetAlignmentOf<word64>()));

 

 	switch (2*(m_buffer.size()>=64*1024)

 #if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE || defined(CRYPTOPP_X64_MASM_AVAILABLE)

diff --git a/gf2_32.cpp b/gf2_32.cpp
index 929dac0d..084a1da3 100644
--- a/gf2_32.cpp
+++ b/gf2_32.cpp
@@ -52,7 +52,7 @@ GF2_32::Element GF2_32::MultiplicativeInverse(Element a) const
 	word32 g0=m_modulus, g1=a, g2=a;

 	word32 v0=0, v1=1, v2=1;

 

-	assert(g1);

+	CRYPTOPP_ASSERT(g1);

 

 	while (!(g2 & 0x80000000))

 	{

@@ -70,25 +70,25 @@ GF2_32::Element GF2_32::MultiplicativeInverse(Element a) const
 	{

 		if (g1 < g0 || ((g0^g1) < g0 && (g0^g1) < g1))

 		{

-			assert(BitPrecision(g1) <= BitPrecision(g0));

+			CRYPTOPP_ASSERT(BitPrecision(g1) <= BitPrecision(g0));

 			g2 = g1;

 			v2 = v1;

 		}

 		else

 		{

-			assert(BitPrecision(g1) > BitPrecision(g0));

+			CRYPTOPP_ASSERT(BitPrecision(g1) > BitPrecision(g0));

 			g2 = g0; g0 = g1; g1 = g2;

 			v2 = v0; v0 = v1; v1 = v2;

 		}

 

 		while ((g0^g2) >= g2)

 		{

-			assert(BitPrecision(g0) > BitPrecision(g2));

+			CRYPTOPP_ASSERT(BitPrecision(g0) > BitPrecision(g2));

 			g2 <<= 1;

 			v2 <<= 1;

 		}

 

-		assert(BitPrecision(g0) == BitPrecision(g2));

+		CRYPTOPP_ASSERT(BitPrecision(g0) == BitPrecision(g2));

 		g0 ^= g2;

 		v0 ^= v2;

 	}

diff --git a/gf2n.cpp b/gf2n.cpp
index 7c78fafd..f27a5401 100644
--- a/gf2n.cpp
+++ b/gf2n.cpp
@@ -27,7 +27,7 @@ PolynomialMod2::PolynomialMod2()
 PolynomialMod2::PolynomialMod2(word value, size_t bitLength)

 	: reg(BitsToWords(bitLength))

 {

-	assert(value==0 || reg.size()>0);

+	CRYPTOPP_ASSERT(value==0 || reg.size()>0);

 

 	if (reg.size() > 0)

 	{

@@ -327,7 +327,7 @@ PolynomialMod2& PolynomialMod2::operator<<=(unsigned int n)
 {

 #if !defined(NDEBUG)

 	int x; CRYPTOPP_UNUSED(x);

-	assert(SafeConvert(n,x));

+	CRYPTOPP_ASSERT(SafeConvert(n,x));

 #endif

 

 	if (!reg.size())

@@ -561,7 +561,7 @@ GF2NP::Element GF2NP::SquareRoot(const Element &a) const
 

 GF2NP::Element GF2NP::HalfTrace(const Element &a) const

 {

-	assert(m%2 == 1);

+	CRYPTOPP_ASSERT(m%2 == 1);

 	Element h = a;

 	for (unsigned int i=1; i<=(m-1)/2; i++)

 		h = Add(Square(Square(h)), a);

@@ -600,7 +600,7 @@ GF2NT::GF2NT(unsigned int c0, unsigned int c1, unsigned int c2)
 	, t0(c0), t1(c1)

 	, result((word)0, m)

 {

-	assert(c0 > c1 && c1 > c2 && c2==0);

+	CRYPTOPP_ASSERT(c0 > c1 && c1 > c2 && c2==0);

 }

 

 const GF2NT::Element& GF2NT::MultiplicativeInverse(const Element &a) const

@@ -618,7 +618,7 @@ const GF2NT::Element& GF2NT::MultiplicativeInverse(const Element &a) const
 

 	SetWords(T, 0, 3*m_modulus.reg.size());

 	b[0]=1;

-	assert(a.reg.size() <= m_modulus.reg.size());

+	CRYPTOPP_ASSERT(a.reg.size() <= m_modulus.reg.size());

 	CopyWords(f, a.reg, a.reg.size());

 	CopyWords(g, m_modulus.reg, m_modulus.reg.size());

 

@@ -630,7 +630,7 @@ const GF2NT::Element& GF2NT::MultiplicativeInverse(const Element &a) const
 			ShiftWordsRightByWords(f, fgLen, 1);

 			if (c[bcLen-1])

 				bcLen++;

-			assert(bcLen <= m_modulus.reg.size());

+			CRYPTOPP_ASSERT(bcLen <= m_modulus.reg.size());

 			ShiftWordsLeftByWords(c, bcLen, 1);

 			k+=WORD_BITS;

 			t=f[0];

@@ -661,7 +661,7 @@ const GF2NT::Element& GF2NT::MultiplicativeInverse(const Element &a) const
 		{

 			c[bcLen] = t;

 			bcLen++;

-			assert(bcLen <= m_modulus.reg.size());

+			CRYPTOPP_ASSERT(bcLen <= m_modulus.reg.size());

 		}

 

 		if (f[fgLen-1]==0 && g[fgLen-1]==0)

@@ -717,7 +717,7 @@ const GF2NT::Element& GF2NT::MultiplicativeInverse(const Element &a) const
 			for (unsigned int j=0; j<WORD_BITS-t1; j++)

 			{

 				// Coverity finding on shift amount of 'word x << (t1+j)'.

-				assert(t1+j < WORD_BITS);

+				CRYPTOPP_ASSERT(t1+j < WORD_BITS);

 				temp ^= ((temp >> j) & 1) << (t1 + j);

 			}

 		}

@@ -811,7 +811,7 @@ const GF2NT::Element& GF2NT::Reduced(const Element &a) const
 			if ((t0-t1)%WORD_BITS > t0%WORD_BITS)

 				b[i-(t0-t1)/WORD_BITS-1] ^= temp << (WORD_BITS - (t0-t1)%WORD_BITS);

 			else

-				assert(temp << (WORD_BITS - (t0-t1)%WORD_BITS) == 0);

+				CRYPTOPP_ASSERT(temp << (WORD_BITS - (t0-t1)%WORD_BITS) == 0);

 		}

 		else

 			b[i-(t0-t1)/WORD_BITS] ^= temp;

diff --git a/gf2n.h b/gf2n.h
index 867b7590..bfd19027 100644
--- a/gf2n.h
+++ b/gf2n.h
@@ -286,16 +286,16 @@ public:
 

 	virtual GF2NP * Clone() const {return new GF2NP(*this);}

 	virtual void DEREncode(BufferedTransformation &bt) const

-		{CRYPTOPP_UNUSED(bt); assert(false);}	// no ASN.1 syntax yet for general polynomial basis

+		{CRYPTOPP_UNUSED(bt); CRYPTOPP_ASSERT(false);}	// no ASN.1 syntax yet for general polynomial basis

 

 	void DEREncodeElement(BufferedTransformation &out, const Element &a) const;

 	void BERDecodeElement(BufferedTransformation &in, Element &a) const;

 

 	bool Equal(const Element &a, const Element &b) const

-		{assert(a.Degree() < m_modulus.Degree() && b.Degree() < m_modulus.Degree()); return a.Equals(b);}

+		{CRYPTOPP_ASSERT(a.Degree() < m_modulus.Degree() && b.Degree() < m_modulus.Degree()); return a.Equals(b);}

 

 	bool IsUnit(const Element &a) const

-		{assert(a.Degree() < m_modulus.Degree()); return !!a;}

+		{CRYPTOPP_ASSERT(a.Degree() < m_modulus.Degree()); return !!a;}

 

 	unsigned int MaxElementBitLength() const

 		{return m;}

diff --git a/gfpcrypt.cpp b/gfpcrypt.cpp
index 2a3b6974..8edd8553 100644
--- a/gfpcrypt.cpp
+++ b/gfpcrypt.cpp
@@ -82,8 +82,8 @@ void DL_SignatureMessageEncodingMethod_DSA::ComputeMessageRepresentative(RandomN
 {

 	CRYPTOPP_UNUSED(rng), CRYPTOPP_UNUSED(recoverableMessage), CRYPTOPP_UNUSED(recoverableMessageLength);

 	CRYPTOPP_UNUSED(messageEmpty), CRYPTOPP_UNUSED(hashIdentifier);

-	assert(recoverableMessageLength == 0);

-	assert(hashIdentifier.second == 0);

+	CRYPTOPP_ASSERT(recoverableMessageLength == 0);

+	CRYPTOPP_ASSERT(hashIdentifier.second == 0);

 

 	const size_t representativeByteLength = BitsToBytes(representativeBitLength);

 	const size_t digestSize = hash.DigestSize();

@@ -109,8 +109,8 @@ void DL_SignatureMessageEncodingMethod_NR::ComputeMessageRepresentative(RandomNu
 	CRYPTOPP_UNUSED(hash); CRYPTOPP_UNUSED(hashIdentifier); CRYPTOPP_UNUSED(messageEmpty);

 	CRYPTOPP_UNUSED(representative); CRYPTOPP_UNUSED(representativeBitLength);

 

-	assert(recoverableMessageLength == 0);

-	assert(hashIdentifier.second == 0);

+	CRYPTOPP_ASSERT(recoverableMessageLength == 0);

+	CRYPTOPP_ASSERT(hashIdentifier.second == 0);

 	const size_t representativeByteLength = BitsToBytes(representativeBitLength);

 	const size_t digestSize = hash.DigestSize();

 	const size_t paddingLength = SaturatingSubtract(representativeByteLength, digestSize);

diff --git a/gfpcrypt.h b/gfpcrypt.h
index 7fb7ec27..4cdf3b06 100644
--- a/gfpcrypt.h
+++ b/gfpcrypt.h
@@ -193,7 +193,7 @@ public:
 		r %= q;

 		Integer kInv = k.InverseMod(q);

 		s = (kInv * (x*r + e)) % q;

-		assert(!!r && !!s);

+		CRYPTOPP_ASSERT(!!r && !!s);

 	}

 

 	bool Verify(const DL_GroupParameters<T> &params, const DL_PublicKey<T> &publicKey, const Integer &e, const Integer &r, const Integer &s) const

@@ -228,7 +228,7 @@ public:
 		const Integer &q = params.GetSubgroupOrder();

 		r = (r + e) % q;

 		s = (k - x*r) % q;

-		assert(!!r);

+		CRYPTOPP_ASSERT(!!r);

 	}

 

 	bool Verify(const DL_GroupParameters<T> &params, const DL_PublicKey<T> &publicKey, const Integer &e, const Integer &r, const Integer &s) const

diff --git a/hkdf.h b/hkdf.h
index 447d15dc..a7903f60 100644
--- a/hkdf.h
+++ b/hkdf.h
@@ -62,9 +62,9 @@ unsigned int HKDF<T>::DeriveKey(byte *derived, size_t derivedLen, const byte *se
 	static const size_t DIGEST_SIZE = static_cast<size_t>(T::DIGESTSIZE);

 	const unsigned int req = static_cast<unsigned int>(derivedLen);

 

-	assert(secret && secretLen);

-	assert(derived && derivedLen);

-	assert(derivedLen <= MaxDerivedKeyLength());

+	CRYPTOPP_ASSERT(secret && secretLen);

+	CRYPTOPP_ASSERT(derived && derivedLen);

+	CRYPTOPP_ASSERT(derivedLen <= MaxDerivedKeyLength());

 

 	if (derivedLen > MaxDerivedKeyLength())

 		throw InvalidArgument("HKDF: derivedLen must be less than or equal to MaxDerivedKeyLength");

diff --git a/hmac.cpp b/hmac.cpp
index a25eb749..bb0d9e52 100644
--- a/hmac.cpp
+++ b/hmac.cpp
@@ -30,7 +30,7 @@ void HMAC_Base::UncheckedSetKey(const byte *userKey, unsigned int keylength, con
 		keylength = hash.DigestSize();

 	}

 

-	assert(keylength <= blockSize);

+	CRYPTOPP_ASSERT(keylength <= blockSize);

 	memset(AccessIpad()+keylength, 0, blockSize-keylength);

 

 	for (unsigned int i=0; i<blockSize; i++)

@@ -42,7 +42,7 @@ void HMAC_Base::UncheckedSetKey(const byte *userKey, unsigned int keylength, con
 

 void HMAC_Base::KeyInnerHash()

 {

-	assert(!m_innerHashKeyed);

+	CRYPTOPP_ASSERT(!m_innerHashKeyed);

 	HashTransformation &hash = AccessHash();

 	hash.Update(AccessIpad(), hash.BlockSize());

 	m_innerHashKeyed = true;

diff --git a/hmqv.h b/hmqv.h
index 2aa4058b..7cbc1c5b 100644
--- a/hmqv.h
+++ b/hmqv.h
@@ -170,7 +170,7 @@ public:
       }

       else

       {

-        assert(0);

+        CRYPTOPP_ASSERT(0);

         return false;

       }

 

@@ -253,12 +253,12 @@ protected:
   {

     HASH hash;

     size_t idx = 0, req = dlen;

-    size_t blk = std::min(dlen, (size_t)HASH::DIGESTSIZE);

+    size_t blk = STDMIN(dlen, (size_t)HASH::DIGESTSIZE);

 

     if(sigma)

     {

       if (e1len != 0 || s1len != 0) {

-	assert(0);

+	CRYPTOPP_ASSERT(0);

       }

       Integer x = GetAbstractGroupParameters().ConvertElementToInteger(*sigma);

       SecByteBlock sbb(x.MinEncodedSize());

@@ -266,7 +266,7 @@ protected:
       hash.Update(sbb.BytePtr(), sbb.SizeInBytes());

     } else {

       if (e1len == 0 || s1len == 0) {

-	assert(0);

+	CRYPTOPP_ASSERT(0);

       }

       hash.Update(e1, e1len);

       hash.Update(s1, s1len);

@@ -281,7 +281,7 @@ protected:
       hash.Update(&digest[idx], (size_t)HASH::DIGESTSIZE);

 

       idx += (size_t)HASH::DIGESTSIZE;

-      blk = std::min(req, (size_t)HASH::DIGESTSIZE);

+      blk = STDMIN(req, (size_t)HASH::DIGESTSIZE);

       hash.TruncatedFinal(&digest[idx], blk);

 

       req -= blk;

diff --git a/hrtimer.cpp b/hrtimer.cpp
index bf75d183..61529357 100644
--- a/hrtimer.cpp
+++ b/hrtimer.cpp
@@ -26,7 +26,7 @@
 #include <unistd.h>

 #endif

 

-#include <assert.h>

+#include "trap.h"

 

 NAMESPACE_BEGIN(CryptoPP)

 

@@ -53,7 +53,7 @@ double TimerBase::ConvertTo(TimerWord t, Unit unit)
 	static unsigned long unitsPerSecondTable[] = {1, 1000, 1000*1000, 1000*1000*1000};

 

 	// When 'unit' is an enum 'Unit', a Clang warning is generated.

-	assert(static_cast<unsigned int>(unit) < COUNTOF(unitsPerSecondTable));

+	CRYPTOPP_ASSERT(static_cast<unsigned int>(unit) < COUNTOF(unitsPerSecondTable));

 	return (double)CRYPTOPP_VC6_INT64 t * unitsPerSecondTable[unit] / CRYPTOPP_VC6_INT64 TicksPerSecond();

 }

 

@@ -83,7 +83,7 @@ double TimerBase::ElapsedTimeAsDouble()
 unsigned long TimerBase::ElapsedTime()

 {

 	double elapsed = ElapsedTimeAsDouble();

-	assert(elapsed <= (double)ULONG_MAX);

+	CRYPTOPP_ASSERT(elapsed <= (double)ULONG_MAX);

 	return (unsigned long)elapsed;

 }

 

diff --git a/ida.cpp b/ida.cpp
index 3c04ce61..64bcf968 100644
--- a/ida.cpp
+++ b/ida.cpp
@@ -22,7 +22,7 @@ void RawIDA::IsolatedInitialize(const NameValuePairs &parameters)
 	if (!parameters.GetIntValue("RecoveryThreshold", m_threshold))

 		throw InvalidArgument("RawIDA: missing RecoveryThreshold argument");

 

-	assert(m_threshold > 0);

+	CRYPTOPP_ASSERT(m_threshold > 0);

 	if (m_threshold <= 0)

 		throw InvalidArgument("RawIDA: RecoveryThreshold must be greater than 0");

 

@@ -43,7 +43,7 @@ void RawIDA::IsolatedInitialize(const NameValuePairs &parameters)
 	else

 	{

 		int nShares = parameters.GetIntValueWithDefault("NumberOfShares", m_threshold);

-		assert(nShares > 0);

+		CRYPTOPP_ASSERT(nShares > 0);

 		if (nShares <= 0) {nShares = m_threshold;}

 		for (unsigned int i=0; i< (unsigned int)(nShares); i++)

 			AddOutputChannel(i);

@@ -152,7 +152,7 @@ void RawIDA::AddOutputChannel(word32 channelId)
 

 void RawIDA::PrepareInterpolation()

 {

-	assert(m_inputChannelIds.size() == size_t(m_threshold));

+	CRYPTOPP_ASSERT(m_inputChannelIds.size() == size_t(m_threshold));

 	PrepareBulkPolynomialInterpolation(field, m_w.begin(), &(m_inputChannelIds[0]), (unsigned int)(m_threshold));

 	for (unsigned int i=0; i<m_outputChannelIds.size(); i++)

 		ComputeV(i);

diff --git a/idea.cpp b/idea.cpp
index d0b8836f..f13390d8 100644
--- a/idea.cpp
+++ b/idea.cpp
@@ -17,7 +17,7 @@ CRYPTOPP_COMPILE_ASSERT(sizeof(IDEA::Word) >= 2);
 // should use an inline function but macros are still faster in MSVC 4.0

 #define DirectMUL(a,b)					\

 {										\

-	assert(b <= 0xffff);				\

+	CRYPTOPP_ASSERT(b <= 0xffff);				\

 										\

 	word32 p=(word32)low16(a)*b;		\

 										\

diff --git a/integer.cpp b/integer.cpp
index bb41088f..457f3976 100644
--- a/integer.cpp
+++ b/integer.cpp
@@ -90,7 +90,7 @@ inline static int Compare(const word *A, const word *B, size_t N)
 

 inline static int Increment(word *A, size_t N, word B=1)

 {

-	assert(N);

+	CRYPTOPP_ASSERT(N);

 	word t = A[0];

 	A[0] = t+B;

 	if (A[0] >= t)

@@ -103,7 +103,7 @@ inline static int Increment(word *A, size_t N, word B=1)
 

 inline static int Decrement(word *A, size_t N, word B=1)

 {

-	assert(N);

+	CRYPTOPP_ASSERT(N);

 	word t = A[0];

 	A[0] = t-B;

 	if (A[0] <= t)

@@ -123,14 +123,14 @@ static void TwosComplement(word *A, size_t N)
 

 static word AtomicInverseModPower2(word A)

 {

-	assert(A%2==1);

+	CRYPTOPP_ASSERT(A%2==1);

 

 	word R=A%8;

 

 	for (unsigned i=3; i<WORD_BITS; i*=2)

 		R = R*(2-R*A);

 

-	assert(R*A==1);

+	CRYPTOPP_ASSERT(R*A==1);

 	return R;

 }

 

@@ -240,7 +240,7 @@ public:
 		#elif defined(MultiplyWordsLoHi)

 			MultiplyWordsLoHi(r.m_halfs.low, r.m_halfs.high, a, b);

 		#else

-			assert(0);

+			CRYPTOPP_ASSERT(0);

 		#endif

 		return r;

 	}

@@ -403,8 +403,8 @@ S DivideThreeWordsByTwo(S *A, S B0, S B1, D *dummy=NULL)
 {

 	CRYPTOPP_UNUSED(dummy);

 

-	// assert {A[2],A[1]} < {B1,B0}, so quotient can fit in a S

-	assert(A[2] < B1 || (A[2]==B1 && A[1] < B0));

+	// CRYPTOPP_ASSERT {A[2],A[1]} < {B1,B0}, so quotient can fit in a S

+	CRYPTOPP_ASSERT(A[2] < B1 || (A[2]==B1 && A[1] < B0));

 

 	// estimate the quotient: do a 2 S by 1 S divide

 	S Q;

@@ -432,7 +432,7 @@ S DivideThreeWordsByTwo(S *A, S B0, S B1, D *dummy=NULL)
 		A[1] = u.GetLowHalf();

 		A[2] += u.GetHighHalf();

 		Q++;

-		assert(Q);	// shouldn't overflow

+		CRYPTOPP_ASSERT(Q);	// shouldn't overflow

 	}

 

 	return Q;

@@ -843,7 +843,7 @@ CRYPTOPP_NAKED int CRYPTOPP_FASTCALL SSE2_Sub(size_t N, word *C, const word *A,
 #else

 int CRYPTOPP_FASTCALL Baseline_Add(size_t N, word *C, const word *A, const word *B)

 {

-	assert (N%2 == 0);

+	CRYPTOPP_ASSERT (N%2 == 0);

 

 	Declare2Words(u);

 	AssignWord(u, 0);

@@ -859,7 +859,7 @@ int CRYPTOPP_FASTCALL Baseline_Add(size_t N, word *C, const word *A, const word
 

 int CRYPTOPP_FASTCALL Baseline_Sub(size_t N, word *C, const word *A, const word *B)

 {

-	assert (N%2 == 0);

+	CRYPTOPP_ASSERT (N%2 == 0);

 

 	Declare2Words(u);

 	AssignWord(u, 0);

@@ -2171,7 +2171,7 @@ inline int Subtract(word *C, const word *A, const word *B, size_t N)
 

 void RecursiveMultiply(word *R, word *T, const word *A, const word *B, size_t N)

 {

-	assert(N>=2 && N%2==0);

+	CRYPTOPP_ASSERT(N>=2 && N%2==0);

 

 	if (N <= s_recursionLimit)

 		s_pMul[N/4](R, A, B);

@@ -2202,7 +2202,7 @@ void RecursiveMultiply(word *R, word *T, const word *A, const word *B, size_t N)
 			c3 += Add(R1, R1, T0, N);

 

 		c3 += Increment(R2, N2, c2);

-		assert (c3 >= 0 && c3 <= 2);

+		CRYPTOPP_ASSERT (c3 >= 0 && c3 <= 2);

 		Increment(R3, N2, c3);

 	}

 }

@@ -2213,7 +2213,7 @@ void RecursiveMultiply(word *R, word *T, const word *A, const word *B, size_t N)
 

 void RecursiveSquare(word *R, word *T, const word *A, size_t N)

 {

-	assert(N && N%2==0);

+	CRYPTOPP_ASSERT(N && N%2==0);

 

 	if (N <= s_recursionLimit)

 		s_pSqu[N/4](R, A);

@@ -2238,7 +2238,7 @@ void RecursiveSquare(word *R, word *T, const word *A, size_t N)
 

 void RecursiveMultiplyBottom(word *R, word *T, const word *A, const word *B, size_t N)

 {

-	assert(N>=2 && N%2==0);

+	CRYPTOPP_ASSERT(N>=2 && N%2==0);

 

 	if (N <= s_recursionLimit)

 		s_pBot[N/4](R, A, B);

@@ -2262,7 +2262,7 @@ void RecursiveMultiplyBottom(word *R, word *T, const word *A, const word *B, siz
 

 void MultiplyTop(word *R, word *T, const word *L, const word *A, const word *B, size_t N)

 {

-	assert(N>=2 && N%2==0);

+	CRYPTOPP_ASSERT(N>=2 && N%2==0);

 

 	if (N <= s_recursionLimit)

 		s_pTop[N/4](R, A, B, L[N-1]);

@@ -2304,7 +2304,7 @@ void MultiplyTop(word *R, word *T, const word *L, const word *A, const word *B,
 			c3 -= Decrement(T2, N2, -c2);

 		c3 += Add(R0, T2, R1, N2);

 

-		assert (c3 >= 0 && c3 <= 2);

+		CRYPTOPP_ASSERT (c3 >= 0 && c3 <= 2);

 		Increment(R1, N2, c3);

 	}

 }

@@ -2347,7 +2347,7 @@ void AsymmetricMultiply(word *R, word *T, const word *A, size_t NA, const word *
 		std::swap(NA, NB);

 	}

 

-	assert(NB % NA == 0);

+	CRYPTOPP_ASSERT(NB % NA == 0);

 

 	if (NA==2 && !A[1])

 	{

@@ -2433,7 +2433,7 @@ void MontgomeryReduce(word *R, word *T, word *X, const word *M, const word *U, s
 	word borrow = Subtract(T, X+N, T, N);

 	// defend against timing attack by doing this Add even when not needed

 	word carry = Add(T+N, T, M, N);

-	assert(carry | !borrow);

+	CRYPTOPP_ASSERT(carry | !borrow);

 	CRYPTOPP_UNUSED(carry), CRYPTOPP_UNUSED(borrow);

 	CopyWords(R, T + ((0-borrow) & N), N);

 #elif 0

@@ -2501,7 +2501,7 @@ void MontgomeryReduce(word *R, word *T, word *X, const word *M, const word *U, s
 

 void HalfMontgomeryReduce(word *R, word *T, const word *X, const word *M, const word *U, const word *V, size_t N)

 {

-	assert(N%2==0 && N>=4);

+	CRYPTOPP_ASSERT(N%2==0 && N>=4);

 

 #define M0		M

 #define M1		(M+N2)

@@ -2530,7 +2530,7 @@ void HalfMontgomeryReduce(word *R, word *T, const word *X, const word *M, const
 	else if (c2<0)

 		c3 -= Decrement(R1, N2, -c2);

 

-	assert(c3>=-1 && c3<=1);

+	CRYPTOPP_ASSERT(c3>=-1 && c3<=1);

 	if (c3>0)

 		Subtract(R, R, M, N);

 	else if (c3<0)

@@ -2566,8 +2566,8 @@ void HalfMontgomeryReduce(word *R, word *T, const word *X, const word *M, const
 // do a 3 word by 2 word divide, returns quotient and leaves remainder in A

 static word SubatomicDivide(word *A, word B0, word B1)

 {

-	// assert {A[2],A[1]} < {B1,B0}, so quotient can fit in a word

-	assert(A[2] < B1 || (A[2]==B1 && A[1] < B0));

+	// CRYPTOPP_ASSERT {A[2],A[1]} < {B1,B0}, so quotient can fit in a word

+	CRYPTOPP_ASSERT(A[2] < B1 || (A[2]==B1 && A[1] < B0));

 

 	// estimate the quotient: do a 2 word by 1 word divide

 	word Q;

@@ -2593,7 +2593,7 @@ static word SubatomicDivide(word *A, word B0, word B1)
 		A[1] = u.GetLowHalf();

 		A[2] += u.GetHighHalf();

 		Q++;

-		assert(Q);	// shouldn't overflow

+		CRYPTOPP_ASSERT(Q);	// shouldn't overflow

 	}

 

 	return Q;

@@ -2616,11 +2616,11 @@ static inline void AtomicDivide(word *Q, const word *A, const word *B)
 

 #ifndef NDEBUG

 		// multiply quotient and divisor and add remainder, make sure it equals dividend

-		assert(!T[2] && !T[3] && (T[1] < B[1] || (T[1]==B[1] && T[0]<B[0])));

+		CRYPTOPP_ASSERT(!T[2] && !T[3] && (T[1] < B[1] || (T[1]==B[1] && T[0]<B[0])));

 		word P[4];

 		LowLevel::Multiply2(P, Q, B);

 		Add(P, P, T, 4);

-		assert(memcmp(P, A, 4*WORD_SIZE)==0);

+		CRYPTOPP_ASSERT(memcmp(P, A, 4*WORD_SIZE)==0);

 #endif

 	}

 }

@@ -2637,11 +2637,11 @@ static inline void AtomicDivide(word *Q, const word *A, const word *B)
 	if (B[0] || B[1])

 	{

 		// multiply quotient and divisor and add remainder, make sure it equals dividend

-		assert(!T[2] && !T[3] && (T[1] < B[1] || (T[1]==B[1] && T[0]<B[0])));

+		CRYPTOPP_ASSERT(!T[2] && !T[3] && (T[1] < B[1] || (T[1]==B[1] && T[0]<B[0])));

 		word P[4];

 		s_pMul[0](P, Q, B);

 		Add(P, P, T, 4);

-		assert(memcmp(P, A, 4*WORD_SIZE)==0);

+		CRYPTOPP_ASSERT(memcmp(P, A, 4*WORD_SIZE)==0);

 	}

 #endif

 }

@@ -2649,19 +2649,19 @@ static inline void AtomicDivide(word *Q, const word *A, const word *B)
 // for use by Divide(), corrects the underestimated quotient {Q1,Q0}

 static void CorrectQuotientEstimate(word *R, word *T, word *Q, const word *B, size_t N)

 {

-	assert(N && N%2==0);

+	CRYPTOPP_ASSERT(N && N%2==0);

 

 	AsymmetricMultiply(T, T+N+2, Q, 2, B, N);

 

 	word borrow = Subtract(R, R, T, N+2);

-	assert(!borrow && !R[N+1]);

+	CRYPTOPP_ASSERT(!borrow && !R[N+1]);

 	CRYPTOPP_UNUSED(borrow);

 

 	while (R[N] || Compare(R, B, N) >= 0)

 	{

 		R[N] -= Subtract(R, R, B, N);

 		Q[1] += (++Q[0]==0);

-		assert(Q[0] || Q[1]); // no overflow

+		CRYPTOPP_ASSERT(Q[0] || Q[1]); // no overflow

 	}

 }

 

@@ -2673,9 +2673,9 @@ static void CorrectQuotientEstimate(word *R, word *T, word *Q, const word *B, si
 

 void Divide(word *R, word *Q, word *T, const word *A, size_t NA, const word *B, size_t NB)

 {

-	assert(NA && NB && NA%2==0 && NB%2==0);

-	assert(B[NB-1] || B[NB-2]);

-	assert(NB <= NA);

+	CRYPTOPP_ASSERT(NA && NB && NA%2==0 && NB%2==0);

+	CRYPTOPP_ASSERT(B[NB-1] || B[NB-2]);

+	CRYPTOPP_ASSERT(NB <= NA);

 

 	// set up temporary work space

 	word *const TA=T;

@@ -2687,7 +2687,7 @@ void Divide(word *R, word *Q, word *T, const word *A, size_t NA, const word *B,
 	TB[0] = TB[NB-1] = 0;

 	CopyWords(TB+shiftWords, B, NB-shiftWords);

 	unsigned shiftBits = WORD_BITS - BitPrecision(TB[NB-1]);

-	assert(shiftBits < WORD_BITS);

+	CRYPTOPP_ASSERT(shiftBits < WORD_BITS);

 	ShiftWordsLeftByBits(TB, NB, shiftBits);

 

 	// copy A into TA and normalize it

@@ -2707,7 +2707,7 @@ void Divide(word *R, word *Q, word *T, const word *A, size_t NA, const word *B,
 	else

 	{

 		NA+=2;

-		assert(Compare(TA+NA-NB, TB, NB) < 0);

+		CRYPTOPP_ASSERT(Compare(TA+NA-NB, TB, NB) < 0);

 	}

 

 	word BT[2];

@@ -2741,7 +2741,7 @@ static inline size_t EvenWordCount(const word *X, size_t N)
 

 unsigned int AlmostInverse(word *R, word *T, const word *A, size_t NA, const word *M, size_t N)

 {

-	assert(NA<=N && N && N%2==0);

+	CRYPTOPP_ASSERT(NA<=N && N && N%2==0);

 

 	word *b = T;

 	word *c = T+N;

@@ -2769,7 +2769,7 @@ unsigned int AlmostInverse(word *R, word *T, const word *A, size_t NA, const wor
 

 			ShiftWordsRightByWords(f, fgLen, 1);

 			bcLen += 2 * (c[bcLen-1] != 0);

-			assert(bcLen <= N);

+			CRYPTOPP_ASSERT(bcLen <= N);

 			ShiftWordsLeftByWords(c, bcLen, 1);

 			k+=WORD_BITS;

 			t=f[0];

@@ -2793,7 +2793,7 @@ unsigned int AlmostInverse(word *R, word *T, const word *A, size_t NA, const wor
 		t = ShiftWordsLeftByBits(c, bcLen, i);

 		c[bcLen] += t;

 		bcLen += 2 * (t!=0);

-		assert(bcLen <= N);

+		CRYPTOPP_ASSERT(bcLen <= N);

 

 		bool swap = Compare(f, g, fgLen)==-1;

 		ConditionalSwapPointers(swap, f, g);

@@ -2806,7 +2806,7 @@ unsigned int AlmostInverse(word *R, word *T, const word *A, size_t NA, const wor
 		t = Add(b, b, c, bcLen);

 		b[bcLen] += t;

 		bcLen += 2*t;

-		assert(bcLen <= N);

+		CRYPTOPP_ASSERT(bcLen <= N);

 	}

 }

 

@@ -2926,7 +2926,7 @@ bool Integer::IsConvertableToLong() const
 

 signed long Integer::ConvertToLong() const

 {

-	assert(IsConvertableToLong());

+	CRYPTOPP_ASSERT(IsConvertableToLong());

 

 	unsigned long value = (unsigned long)reg[0];

 	value += SafeLeftShift<WORD_BITS, unsigned long>((unsigned long)reg[1]);

@@ -2935,7 +2935,7 @@ signed long Integer::ConvertToLong() const
 

 Integer::Integer(BufferedTransformation &encodedInteger, size_t byteCount, Signedness s, ByteOrder o)

 {

-	assert(o == BIG_ENDIAN_ORDER || o == LITTLE_ENDIAN_ORDER);

+	CRYPTOPP_ASSERT(o == BIG_ENDIAN_ORDER || o == LITTLE_ENDIAN_ORDER);

 

 	if(o == LITTLE_ENDIAN_ORDER)

 	{

@@ -2952,7 +2952,7 @@ Integer::Integer(BufferedTransformation &encodedInteger, size_t byteCount, Signe
 

 Integer::Integer(const byte *encodedInteger, size_t byteCount, Signedness s, ByteOrder o)

 {

-	assert(o == BIG_ENDIAN_ORDER || o == LITTLE_ENDIAN_ORDER);

+	CRYPTOPP_ASSERT(o == BIG_ENDIAN_ORDER || o == LITTLE_ENDIAN_ORDER);

 

 	if(o == LITTLE_ENDIAN_ORDER)

 	{

@@ -3074,7 +3074,7 @@ void Integer::SetByte(size_t n, byte value)
 lword Integer::GetBits(size_t i, size_t n) const

 {

 	lword v = 0;

-	assert(n <= sizeof(v)*8);

+	CRYPTOPP_ASSERT(n <= sizeof(v)*8);

 	for (unsigned int j=0; j<n; j++)

 		v |= lword(GetBit(i+j)) << j;

 	return v;

@@ -3110,7 +3110,7 @@ Integer::Integer(word value, size_t length)
 template <class T>

 static Integer StringToInteger(const T *str, ByteOrder order)

 {

-	assert( order == BIG_ENDIAN_ORDER || order == LITTLE_ENDIAN_ORDER );

+	CRYPTOPP_ASSERT( order == BIG_ENDIAN_ORDER || order == LITTLE_ENDIAN_ORDER );

 

 	int radix, sign = 1;

 	// GCC workaround

@@ -3285,7 +3285,7 @@ void Integer::Decode(const byte *input, size_t inputLen, Signedness s)
 

 void Integer::Decode(BufferedTransformation &bt, size_t inputLen, Signedness s)

 {

-	assert(bt.MaxRetrievable() >= inputLen);

+	CRYPTOPP_ASSERT(bt.MaxRetrievable() >= inputLen);

 

 	byte b;

 	bt.Peek(b);

@@ -3302,7 +3302,7 @@ void Integer::Decode(BufferedTransformation &bt, size_t inputLen, Signedness s)
 	const size_t size = RoundupSize(BytesToWords(inputLen));

 	reg.CleanNew(size);

 

-	assert(reg.SizeInBytes() >= inputLen);

+	CRYPTOPP_ASSERT(reg.SizeInBytes() >= inputLen);

 	for (size_t i=inputLen; i > 0; i--)

 	{

 		bt.Get(b);

@@ -3331,7 +3331,7 @@ size_t Integer::MinEncodedSize(Signedness signedness) const
 

 void Integer::Encode(byte *output, size_t outputLen, Signedness signedness) const

 {

-	assert(output && outputLen);

+	CRYPTOPP_ASSERT(output && outputLen);

 	ArraySink sink(output, outputLen);

 	Encode(sink, outputLen, signedness);

 }

@@ -3669,7 +3669,7 @@ Integer& Integer::operator++()
 	else

 	{

 		word borrow = Decrement(reg, reg.size());

-		assert(!borrow);

+		CRYPTOPP_ASSERT(!borrow);

 		CRYPTOPP_UNUSED(borrow);

 

 		if (WordCount()==0)

@@ -3747,7 +3747,7 @@ void PositiveSubtract(Integer &diff, const Integer &a, const Integer& b)
 		word borrow = Subtract(diff.reg, a.reg, b.reg, bSize);

 		CopyWords(diff.reg+bSize, a.reg+bSize, aSize-bSize);

 		borrow = Decrement(diff.reg+bSize, aSize-bSize, borrow);

-		assert(!borrow);

+		CRYPTOPP_ASSERT(!borrow);

 		diff.sign = Integer::POSITIVE;

 	}

 	else

@@ -3755,7 +3755,7 @@ void PositiveSubtract(Integer &diff, const Integer &a, const Integer& b)
 		word borrow = Subtract(diff.reg, b.reg, a.reg, aSize);

 		CopyWords(diff.reg+aSize, b.reg+aSize, bSize-aSize);

 		borrow = Decrement(diff.reg+aSize, bSize-aSize, borrow);

-		assert(!borrow);

+		CRYPTOPP_ASSERT(!borrow);

 		diff.sign = Integer::NEGATIVE;

 	}

 }

@@ -4027,7 +4027,7 @@ void Integer::Divide(word &remainder, Integer &quotient, const Integer &dividend
 	if (!divisor)

 		throw Integer::DivideByZero();

 

-	assert(divisor);

+	CRYPTOPP_ASSERT(divisor);

 

 	if ((divisor & (divisor-1)) == 0)	// divisor is a power of 2

 	{

@@ -4071,7 +4071,7 @@ word Integer::Modulo(word divisor) const
 	if (!divisor)

 		throw Integer::DivideByZero();

 

-	assert(divisor);

+	CRYPTOPP_ASSERT(divisor);

 

 	word remainder;

 

@@ -4143,7 +4143,7 @@ Integer Integer::SquareRoot() const
 

 	// overestimate square root

 	Integer x, y = Power2((BitCount()+1)/2);

-	assert(y*y >= *this);

+	CRYPTOPP_ASSERT(y*y >= *this);

 

 	do

 	{

@@ -4188,7 +4188,7 @@ Integer Integer::Gcd(const Integer &a, const Integer &b)
 

 Integer Integer::InverseMod(const Integer &m) const

 {

-	assert(m.NotNegative());

+	CRYPTOPP_ASSERT(m.NotNegative());

 

 	if (IsNegative())

 		return Modulo(m).InverseMod(m);

@@ -4404,7 +4404,7 @@ const Integer& MontgomeryRepresentation::Multiply(const Integer &a, const Intege
 	word *const T = m_workspace.begin();

 	word *const R = m_result.reg.begin();

 	const size_t N = m_modulus.reg.size();

-	assert(a.reg.size()<=N && b.reg.size()<=N);

+	CRYPTOPP_ASSERT(a.reg.size()<=N && b.reg.size()<=N);

 

 	AsymmetricMultiply(T, T+2*N, a.reg, a.reg.size(), b.reg, b.reg.size());

 	SetWords(T+a.reg.size()+b.reg.size(), 0, 2*N-a.reg.size()-b.reg.size());

@@ -4417,7 +4417,7 @@ const Integer& MontgomeryRepresentation::Square(const Integer &a) const
 	word *const T = m_workspace.begin();

 	word *const R = m_result.reg.begin();

 	const size_t N = m_modulus.reg.size();

-	assert(a.reg.size()<=N);

+	CRYPTOPP_ASSERT(a.reg.size()<=N);

 

 	CryptoPP::Square(T, T+2*N, a.reg, a.reg.size());

 	SetWords(T+2*a.reg.size(), 0, 2*N-2*a.reg.size());

@@ -4430,7 +4430,7 @@ Integer MontgomeryRepresentation::ConvertOut(const Integer &a) const
 	word *const T = m_workspace.begin();

 	word *const R = m_result.reg.begin();

 	const size_t N = m_modulus.reg.size();

-	assert(a.reg.size()<=N);

+	CRYPTOPP_ASSERT(a.reg.size()<=N);

 

 	CopyWords(T, a.reg, a.reg.size());

 	SetWords(T+a.reg.size(), 0, 2*N-a.reg.size());

@@ -4444,7 +4444,7 @@ const Integer& MontgomeryRepresentation::MultiplicativeInverse(const Integer &a)
 	word *const T = m_workspace.begin();

 	word *const R = m_result.reg.begin();

 	const size_t N = m_modulus.reg.size();

-	assert(a.reg.size()<=N);

+	CRYPTOPP_ASSERT(a.reg.size()<=N);

 

 	CopyWords(T, a.reg, a.reg.size());

 	SetWords(T+a.reg.size(), 0, 2*N-a.reg.size());

@@ -4474,7 +4474,7 @@ std::string IntToString<Integer>(Integer value, unsigned int base)
 

 	const char CH = UPPER ? 'A' : 'a';

 	base &= ~(BIT_32|BIT_31);

-	assert(base >= 2 && base <= 32);

+	CRYPTOPP_ASSERT(base >= 2 && base <= 32);

 

 	if (value == 0)

 		return "0";

@@ -4537,7 +4537,7 @@ std::string IntToString<word64>(word64 value, unsigned int base)
 	const char CH = !!(base & HIGH_BIT) ? 'A' : 'a';

 	base &= ~HIGH_BIT;

 

-	assert(base >= 2);

+	CRYPTOPP_ASSERT(base >= 2);

 	if (value == 0)

 		return "0";

 

diff --git a/iterhash.cpp b/iterhash.cpp
index e324c442..a757a3e6 100644
--- a/iterhash.cpp
+++ b/iterhash.cpp
@@ -23,7 +23,7 @@ template <class T, class BASE> void IteratedHashBase<T, BASE>::Update(const byte
 

 	T* dataBuf = this->DataBuf();

 	byte* data = (byte *)dataBuf;

-	assert(dataBuf && data);

+	CRYPTOPP_ASSERT(dataBuf && data);

 

 	if (num != 0)	// process left over data

 	{

@@ -48,7 +48,7 @@ template <class T, class BASE> void IteratedHashBase<T, BASE>::Update(const byte
 	{

 		if (input == data)

 		{

-			assert(len == blockSize);

+			CRYPTOPP_ASSERT(len == blockSize);

 			HashBlock(dataBuf);

 			return;

 		}

diff --git a/keccak.cpp b/keccak.cpp
index 452df6d6..14a08db8 100644
--- a/keccak.cpp
+++ b/keccak.cpp
@@ -251,7 +251,7 @@ static void KeccakF1600(word64 *state)
 

 void Keccak::Update(const byte *input, size_t length)

 {

-	assert((input && length) || !(input || length));

+	CRYPTOPP_ASSERT((input && length) || !(input || length));

 	if (!length)

 		return;

 

diff --git a/luc.h b/luc.h
index bac96f2b..45be09cf 100644
--- a/luc.h
+++ b/luc.h
@@ -134,7 +134,7 @@ typedef LUCSS<PKCS1v15, SHA>::Verifier LUCSSA_PKCS1v15_SHA_Verifier;
 class DL_GroupPrecomputation_LUC : public DL_GroupPrecomputation<Integer>

 {

 public:

-	const AbstractGroup<Element> & GetGroup() const {assert(false); throw 0;}

+	const AbstractGroup<Element> & GetGroup() const {CRYPTOPP_ASSERT(false); throw 0;}

 	Element BERDecodeElement(BufferedTransformation &bt) const {return Integer(bt);}

 	void DEREncodeElement(BufferedTransformation &bt, const Element &v) const {v.DEREncode(bt);}

 

diff --git a/mersenne.h b/mersenne.h
index ca2362b8..5bb78f80 100644
--- a/mersenne.h
+++ b/mersenne.h
@@ -84,7 +84,7 @@ public:
 			case 2: output[1] = CRYPTOPP_GET_BYTE_AS_BYTE(temp, 2); /* fall through */

 			case 1: output[0] = CRYPTOPP_GET_BYTE_AS_BYTE(temp, 3); break;

 

-			default: assert(0); ;;

+			default: CRYPTOPP_ASSERT(0); ;;

 		}

 

 		// Wipe temp

@@ -148,7 +148,7 @@ protected:
 		static const unsigned long magic[2]={0x0UL, K};

 		word32 kk, temp;

 

-		assert(N >= M);

+		CRYPTOPP_ASSERT(N >= M);

 		for (kk=0;kk<N-M;kk++)

 		{

 			temp = (m_state[kk] & 0x80000000)|(m_state[kk+1] & 0x7FFFFFFF);

diff --git a/misc.cpp b/misc.cpp
index f48f5dd9..dda21544 100644
--- a/misc.cpp
+++ b/misc.cpp
@@ -27,9 +27,9 @@ NAMESPACE_BEGIN(CryptoPP)
 

 void xorbuf(byte *buf, const byte *mask, size_t count)

 {

-	assert(buf != NULL);

-	assert(mask != NULL);

-	assert(count > 0);

+	CRYPTOPP_ASSERT(buf != NULL);

+	CRYPTOPP_ASSERT(mask != NULL);

+	CRYPTOPP_ASSERT(count > 0);

 

 	size_t i=0;

 	if (IsAligned<word32>(buf) && IsAligned<word32>(mask))

@@ -60,9 +60,9 @@ void xorbuf(byte *buf, const byte *mask, size_t count)
 

 void xorbuf(byte *output, const byte *input, const byte *mask, size_t count)

 {

-	assert(output != NULL);

-	assert(input != NULL);

-	assert(count > 0);

+	CRYPTOPP_ASSERT(output != NULL);

+	CRYPTOPP_ASSERT(input != NULL);

+	CRYPTOPP_ASSERT(count > 0);

 

 	size_t i=0;

 	if (IsAligned<word32>(output) && IsAligned<word32>(input) && IsAligned<word32>(mask))

@@ -95,9 +95,9 @@ void xorbuf(byte *output, const byte *input, const byte *mask, size_t count)
 

 bool VerifyBufsEqual(const byte *buf, const byte *mask, size_t count)

 {

-	assert(buf != NULL);

-	assert(mask != NULL);

-	assert(count > 0);

+	CRYPTOPP_ASSERT(buf != NULL);

+	CRYPTOPP_ASSERT(mask != NULL);

+	CRYPTOPP_ASSERT(count > 0);

 

 	size_t i=0;

 	byte acc8 = 0;

@@ -136,7 +136,7 @@ bool VerifyBufsEqual(const byte *buf, const byte *mask, size_t count)
 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562

 std::string StringNarrow(const wchar_t *str, bool throwOnError)

 {

-	assert(str);

+	CRYPTOPP_ASSERT(str);

 	std::string result;

 

 	// Safer functions on Windows for C&A, https://github.com/weidai11/cryptopp/issues/55

@@ -149,12 +149,12 @@ std::string StringNarrow(const wchar_t *str, bool throwOnError)
 	len = wcslen(str)+1;

 

 	err = wcstombs_s(&size, NULL, 0, str, len*sizeof(wchar_t));

-	assert(err == 0);

+	CRYPTOPP_ASSERT(err == 0);

 	if (err != 0) {goto CONVERSION_ERROR;}

 

 	result.resize(size);

 	err = wcstombs_s(&size, &result[0], size, str, len*sizeof(wchar_t));

-	assert(err == 0);

+	CRYPTOPP_ASSERT(err == 0);

 

 	if (err != 0)

 	{

@@ -170,12 +170,12 @@ CONVERSION_ERROR:
 		result.erase(size - 1);

 #else

 	size_t size = wcstombs(NULL, str, 0);

-	assert(size != (size_t)-1);

+	CRYPTOPP_ASSERT(size != (size_t)-1);

 	if (size == (size_t)-1) {goto CONVERSION_ERROR;}

 

 	result.resize(size);

 	size = wcstombs(&result[0], str, size);

-	assert(size != (size_t)-1);

+	CRYPTOPP_ASSERT(size != (size_t)-1);

 

 	if (size == (size_t)-1)

 	{

@@ -232,7 +232,7 @@ void * AlignedAllocate(size_t size)
 	p[-1] = (byte)adjustment;

 #endif

 

-	assert(IsAlignedOn(p, 16));

+	CRYPTOPP_ASSERT(IsAlignedOn(p, 16));

 	return p;

 }

 

diff --git a/misc.h b/misc.h
index 23ef0999..61833034 100644
--- a/misc.h
+++ b/misc.h
@@ -114,10 +114,10 @@ NAMESPACE_BEGIN(CryptoPP)
 // Forward declaration for IntToString specialization

 class Integer;

 

-// ************** compile-time assertion ***************

+// ************** compile-time CRYPTOPP_ASSERTion ***************

 

 #if CRYPTOPP_DOXYGEN_PROCESSING

-//! \brief Compile time assertion

+//! \brief Compile time CRYPTOPP_ASSERTion

 //! \param expr the expression to evaluate

 //! \details Asserts the expression expr though a dummy struct.

 #define CRYPTOPP_COMPILE_ASSERT(expr) ...

@@ -129,18 +129,18 @@ struct CompileAssert
 };

 //! \endif

 

-#define CRYPTOPP_COMPILE_ASSERT(assertion) CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, __LINE__)

+#define CRYPTOPP_COMPILE_ASSERT(CRYPTOPP_ASSERTion) CRYPTOPP_COMPILE_ASSERT_INSTANCE(CRYPTOPP_ASSERTion, __LINE__)

 #if defined(CRYPTOPP_EXPORTS) || defined(CRYPTOPP_IMPORTS)

-#define CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, instance)

+#define CRYPTOPP_COMPILE_ASSERT_INSTANCE(CRYPTOPP_ASSERTion, instance)

 #else

 # if defined(__GNUC__)

-#  define CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, instance) \

-		static CompileAssert<(assertion)> \

-		CRYPTOPP_ASSERT_JOIN(cryptopp_assert_, instance) __attribute__ ((unused))

+#  define CRYPTOPP_COMPILE_ASSERT_INSTANCE(CRYPTOPP_ASSERTion, instance) \

+		static CompileAssert<(CRYPTOPP_ASSERTion)> \

+		CRYPTOPP_ASSERT_JOIN(cryptopp_CRYPTOPP_ASSERT_, instance) __attribute__ ((unused))

 # else

-#  define CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, instance) \

-		static CompileAssert<(assertion)> \

-		CRYPTOPP_ASSERT_JOIN(cryptopp_assert_, instance)

+#  define CRYPTOPP_COMPILE_ASSERT_INSTANCE(CRYPTOPP_ASSERTion, instance) \

+		static CompileAssert<(CRYPTOPP_ASSERTion)> \

+		CRYPTOPP_ASSERT_JOIN(cryptopp_CRYPTOPP_ASSERT_, instance)

 # endif // __GNUC__

 #endif

 #define CRYPTOPP_ASSERT_JOIN(X, Y) CRYPTOPP_DO_ASSERT_JOIN(X, Y)

@@ -331,6 +331,88 @@ const T & Singleton<T, F, instance>::Ref(CRYPTOPP_NOINLINE_DOTDOTDOT) const
 }

 #endif

 

+#if defined(CRYPTOPP_BSD_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE) || defined(CRYPTOPP_DOXYGEN_PROCESSING)

+//! \brief Signal handler function pointer

+//! \sa SignalHandler

+extern "C" {

+	typedef void (*SignalHandlerFn) (int);

+};

+

+//! Signal handler for Linux and Unix compatibles

+//! \tparam S Signal number

+//! \tparam O Flag indicating exsting handler should be overwriiten

+//! \details SignalHandler() can be used to install a signal handler with the signature

+//!   <tt>void handler_fn(int)</tt>. If <tt>SignalHandlerFn</tt> is not <tt>NULL</tt>, then

+//!   the sigaction is set to the function and the sigaction flags is set to the flags.

+//!   If <tt>SignalHandlerFn</tt> is <tt>NULL</tt>, then a default handler is installed

+//!   using sigaction flags set to 0. The default handler only returns from the call.

+//! \details Upon destruction the previous signal handler is restored.

+//! \warning Do not use SignalHandler in a code block that uses <tt>setjmp</tt> or <tt>longjmp</tt>

+//!   because the destructor may not run.

+//! \since Crypto++ 5.6.5

+//! \sa SignalHandlerFn, \ref CRYPTOPP_ASSERT "CRYPTOPP_ASSERT", DebugTrapHandler

+template <int S, bool O=false>

+struct SignalHandler : private NotCopyable

+{

+	//! \brief Construct a signal handler

+	//! \param pfn Pointer to a signal handler function

+	//! \param flags Flags to use with the signal handler

+	//! \details SignalHandler() installs a signal handler with the signature

+	//!   <tt>void handler_fn(int)</tt>. If <tt>SignalHandlerFn</tt> is not <tt>NULL</tt>, then

+	//!   the sigaction is set to the function and the sigaction flags is set to the flags.

+	//!   If <tt>SignalHandlerFn</tt> is <tt>NULL</tt>, then a default handler is installed

+	//!   using sigaction flags set to 0. The default handler only returns from the call.

+	//! \details Upon destruction the previous signal handler is restored.

+	//! \warning Do not use SignalHandler in a code block that uses <tt>setjmp</tt> or <tt>longjmp</tt>

+	//!   because the destructor may not run.

+	//! \since Crypto++ 5.6.5

+    SignalHandler(SignalHandlerFn pfn = 0, int flags = 0) : m_installed(false)

+	{

+		// http://pubs.opengroup.org/onlinepubs/007908799/xsh/sigaction.html

+		struct sigaction new_handler;

+		// memset(&new_handler, 0x00, sizeof(new_handler));

+

+		do

+		{

+			int ret = 0;

+

+			ret = sigaction (S, 0, &m_old);

+			if (ret != 0) break; // Failed

+

+			// Don't step on another's handler if Overwrite=false

+			if (m_old.sa_handler != 0 && !O) break;

+

+			// Set up the structure to specify the action.

+			new_handler.sa_handler = (pfn ? pfn : &SignalHandler::NullHandler);

+			new_handler.sa_flags = (pfn ? flags : 0);

+

+            ret = sigemptyset (&new_handler.sa_mask);

+            if (ret != 0) break; // Failed

+

+            // Install it

+            ret = sigaction (S, &new_handler, 0);

+            if (ret != 0) break; // Failed

+

+			m_installed = true;

+

+        } while(0);

+    }

+

+	~SignalHandler()

+	{

+		if (m_installed)

+			sigaction (S, &m_old, 0);

+	}

+

+private:

+

+	struct sigaction m_old;

+	bool m_installed;

+

+	static void NullHandler(int /*unused*/) { }

+};

+#endif

+

 // ************** misc functions ***************

 

 #if (!__STDC_WANT_SECURE_LIB__ && !defined(_MEMORY_S_DEFINED)) || defined(CRYPTOPP_WANT_SECURE_LIB)

@@ -351,16 +433,16 @@ const T & Singleton<T, F, instance>::Ref(CRYPTOPP_NOINLINE_DOTDOTDOT) const
 //!   makes memcpy_s() and memmove_s() available. The library will also optionally

 //!   make the symbols available if <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is defined.

 //!   <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is in config.h, but it is disabled by default.

-//! \details memcpy_s() will assert the pointers src and dest are not NULL

+//! \details memcpy_s() will CRYPTOPP_ASSERT the pointers src and dest are not NULL

 //!   in debug builds. Passing NULL for either pointer is undefined behavior.

 inline void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t count)

 {

 	// Safer functions on Windows for C&A, http://github.com/weidai11/cryptopp/issues/55

 

 	// Pointers must be valid; otherwise undefined behavior

-	assert(dest != NULL); assert(src != NULL);

+	CRYPTOPP_ASSERT(dest != NULL); CRYPTOPP_ASSERT(src != NULL);

 	// Destination buffer must be large enough to satsify request

-	assert(sizeInBytes >= count);

+	CRYPTOPP_ASSERT(sizeInBytes >= count);

 	if (count > sizeInBytes)

 		throw InvalidArgument("memcpy_s: buffer overflow");

 

@@ -393,16 +475,16 @@ inline void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t cou
 //!   makes memcpy_s() and memmove_s() available. The library will also optionally

 //!   make the symbols available if <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is defined.

 //!   <tt>CRYPTOPP_WANT_SECURE_LIB</tt> is in config.h, but it is disabled by default.

-//! \details memmove_s() will assert the pointers src and dest are not NULL

+//! \details memmove_s() will CRYPTOPP_ASSERT the pointers src and dest are not NULL

 //!   in debug builds. Passing NULL for either pointer is undefined behavior.

 inline void memmove_s(void *dest, size_t sizeInBytes, const void *src, size_t count)

 {

 	// Safer functions on Windows for C&A, http://github.com/weidai11/cryptopp/issues/55

 

 	// Pointers must be valid; otherwise undefined behavior

-	assert(dest != NULL); assert(src != NULL);

+	CRYPTOPP_ASSERT(dest != NULL); CRYPTOPP_ASSERT(src != NULL);

 	// Destination buffer must be large enough to satsify request

-	assert(sizeInBytes >= count);

+	CRYPTOPP_ASSERT(sizeInBytes >= count);

 	if (count > sizeInBytes)

 		throw InvalidArgument("memmove_s: buffer overflow");

 

@@ -534,7 +616,7 @@ std::string IntToString(T value, unsigned int base = 10)
 	const char CH = !!(base & HIGH_BIT) ? 'A' : 'a';

 	base &= ~HIGH_BIT;

 

-	assert(base >= 2);

+	CRYPTOPP_ASSERT(base >= 2);

 	if (value == 0)

 		return "0";

 

@@ -672,7 +754,7 @@ inline unsigned int TrailingZeros(word32 v)
 	// GCC 4.7 and VS2012 provides tzcnt on AVX2/BMI enabled processors

 	// We don't enable for Microsoft because it requires a runtime check.

 	// http://msdn.microsoft.com/en-us/library/hh977023%28v=vs.110%29.aspx

-	assert(v != 0);

+	CRYPTOPP_ASSERT(v != 0);

 #if defined(__GNUC__) && defined(__BMI__)

 	return (unsigned int)_tzcnt_u32(v);

 #elif defined(__GNUC__) && (CRYPTOPP_GCC_VERSION >= 30400)

@@ -703,7 +785,7 @@ inline unsigned int TrailingZeros(word64 v)
 	// GCC 4.7 and VS2012 provides tzcnt on AVX2/BMI enabled processors

 	// We don't enable for Microsoft because it requires a runtime check.

 	// http://msdn.microsoft.com/en-us/library/hh977023%28v=vs.110%29.aspx

-	assert(v != 0);

+	CRYPTOPP_ASSERT(v != 0);

 #if defined(__GNUC__) && defined(__BMI__) && defined(__x86_64__)

 	return (unsigned int)_tzcnt_u64(v);

 #elif defined(__GNUC__) && (CRYPTOPP_GCC_VERSION >= 30400)

@@ -835,7 +917,7 @@ inline bool IsPowerOf2<word64>(const word64 &value)
 template <class T1, class T2>

 inline T2 ModPowerOf2(const T1 &a, const T2 &b)

 {

-	assert(IsPowerOf2(b));

+	CRYPTOPP_ASSERT(IsPowerOf2(b));

 	return T2(a) & (b-1);

 }

 

@@ -1020,7 +1102,7 @@ CRYPTOPP_DLL void CRYPTOPP_API CallNewHandler();
 //! \note The function is not constant time because it stops processing when the carry is 0.

 inline void IncrementCounterByOne(byte *inout, unsigned int size)

 {

-	assert(inout != NULL); assert(size < INT_MAX);

+	CRYPTOPP_ASSERT(inout != NULL); CRYPTOPP_ASSERT(size < INT_MAX);

 	for (int i=int(size-1), carry=1; i>=0 && carry; i--)

 		carry = !++inout[i];

 }

@@ -1034,7 +1116,7 @@ inline void IncrementCounterByOne(byte *inout, unsigned int size)
 //! \details The function is \a close to near-constant time because it operates on all the bytes in the blocks.

 inline void IncrementCounterByOne(byte *output, const byte *input, unsigned int size)

 {

-	assert(output != NULL); assert(input != NULL); assert(size < INT_MAX);

+	CRYPTOPP_ASSERT(output != NULL); CRYPTOPP_ASSERT(input != NULL); CRYPTOPP_ASSERT(size < INT_MAX);

 

 	int i, carry;

 	for (i=int(size-1), carry=1; i>=0 && carry; i--)

@@ -1210,7 +1292,7 @@ std::string StringNarrow(const wchar_t *str, bool throwOnError = true);
 #else

 static std::string StringNarrow(const wchar_t *str, bool throwOnError = true)

 {

-	assert(str);

+	CRYPTOPP_ASSERT(str);

 	std::string result;

 

 	// Safer functions on Windows for C&A, https://github.com/weidai11/cryptopp/issues/55

@@ -1223,12 +1305,12 @@ static std::string StringNarrow(const wchar_t *str, bool throwOnError = true)
 	len = wcslen(str)+1;

 

 	err = wcstombs_s(&size, NULL, 0, str, len*sizeof(wchar_t));

-	assert(err == 0);

+	CRYPTOPP_ASSERT(err == 0);

 	if (err != 0) {goto CONVERSION_ERROR;}

 

 	result.resize(size);

 	err = wcstombs_s(&size, &result[0], size, str, len*sizeof(wchar_t));

-	assert(err == 0);

+	CRYPTOPP_ASSERT(err == 0);

 

 	if (err != 0)

 	{

@@ -1244,12 +1326,12 @@ CONVERSION_ERROR:
 		result.erase(size - 1);

 #else

 	size_t size = wcstombs(NULL, str, 0);

-	assert(size != (size_t)-1);

+	CRYPTOPP_ASSERT(size != (size_t)-1);

 	if (size == (size_t)-1) {goto CONVERSION_ERROR;}

 

 	result.resize(size);

 	size = wcstombs(&result[0], str, size);

-	assert(size != (size_t)-1);

+	CRYPTOPP_ASSERT(size != (size_t)-1);

 

 	if (size == (size_t)-1)

 	{

@@ -1318,7 +1400,7 @@ template <class T> inline T rotlFixed(T x, unsigned int y)
 	// and https://llvm.org/bugs/show_bug.cgi?id=24226

 	static const unsigned int THIS_SIZE = sizeof(T)*8;

 	static const unsigned int MASK = THIS_SIZE-1;

-	assert(y < THIS_SIZE);

+	CRYPTOPP_ASSERT(y < THIS_SIZE);

 	return T((x<<y)|(x>>(-y&MASK)));

 }

 

@@ -1340,7 +1422,7 @@ template <class T> inline T rotrFixed(T x, unsigned int y)
 	// and https://llvm.org/bugs/show_bug.cgi?id=24226

 	static const unsigned int THIS_SIZE = sizeof(T)*8;

 	static const unsigned int MASK = THIS_SIZE-1;

-	assert(y < THIS_SIZE);

+	CRYPTOPP_ASSERT(y < THIS_SIZE);

 	return T((x >> y)|(x<<(-y&MASK)));

 }

 

@@ -1358,7 +1440,7 @@ template <class T> inline T rotlVariable(T x, unsigned int y)
 {

 	static const unsigned int THIS_SIZE = sizeof(T)*8;

 	static const unsigned int MASK = THIS_SIZE-1;

-	assert(y < THIS_SIZE);

+	CRYPTOPP_ASSERT(y < THIS_SIZE);

 	return T((x<<y)|(x>>(-y&MASK)));

 }

 

@@ -1376,7 +1458,7 @@ template <class T> inline T rotrVariable(T x, unsigned int y)
 {

 	static const unsigned int THIS_SIZE = sizeof(T)*8;

 	static const unsigned int MASK = THIS_SIZE-1;

-	assert(y < THIS_SIZE);

+	CRYPTOPP_ASSERT(y < THIS_SIZE);

 	return T((x>>y)|(x<<(-y&MASK)));

 }

 

@@ -1417,11 +1499,11 @@ template <class T> inline T rotrMod(T x, unsigned int y)
 //! \details This is a Microsoft specific implementation using <tt>_lrotl</tt> provided by

 //!   <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range

 //!   <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.

-//! \note rotlFixed will assert in Debug builds if is outside the allowed range.

+//! \note rotlFixed will CRYPTOPP_ASSERT in Debug builds if is outside the allowed range.

 template<> inline word32 rotlFixed<word32>(word32 x, unsigned int y)

 {

 	// Uses Microsoft <stdlib.h> call, bound to C/C++ language rules.

-	assert(y < 8*sizeof(x));

+	CRYPTOPP_ASSERT(y < 8*sizeof(x));

 	return y ? _lrotl(x, static_cast<byte>(y)) : x;

 }

 

@@ -1432,11 +1514,11 @@ template<> inline word32 rotlFixed<word32>(word32 x, unsigned int y)
 //! \details This is a Microsoft specific implementation using <tt>_lrotr</tt> provided by

 //!   <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range

 //!   <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.

-//! \note rotrFixed will assert in Debug builds if is outside the allowed range.

+//! \note rotrFixed will CRYPTOPP_ASSERT in Debug builds if is outside the allowed range.

 template<> inline word32 rotrFixed<word32>(word32 x, unsigned int y)

 {

 	// Uses Microsoft <stdlib.h> call, bound to C/C++ language rules.

-	assert(y < 8*sizeof(x));

+	CRYPTOPP_ASSERT(y < 8*sizeof(x));

 	return y ? _lrotr(x, static_cast<byte>(y)) : x;

 }

 

@@ -1447,10 +1529,10 @@ template<> inline word32 rotrFixed<word32>(word32 x, unsigned int y)
 //! \details This is a Microsoft specific implementation using <tt>_lrotl</tt> provided by

 //!   <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range

 //!   <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.

-//! \note rotlVariable will assert in Debug builds if is outside the allowed range.

+//! \note rotlVariable will CRYPTOPP_ASSERT in Debug builds if is outside the allowed range.

 template<> inline word32 rotlVariable<word32>(word32 x, unsigned int y)

 {

-	assert(y < 8*sizeof(x));

+	CRYPTOPP_ASSERT(y < 8*sizeof(x));

 	return _lrotl(x, static_cast<byte>(y));

 }

 

@@ -1461,10 +1543,10 @@ template<> inline word32 rotlVariable<word32>(word32 x, unsigned int y)
 //! \details This is a Microsoft specific implementation using <tt>_lrotr</tt> provided by

 //!   <stdlib.h>. The value x to be rotated is 32-bits. y must be in the range

 //!   <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.

-//! \note rotrVariable will assert in Debug builds if is outside the allowed range.

+//! \note rotrVariable will CRYPTOPP_ASSERT in Debug builds if is outside the allowed range.

 template<> inline word32 rotrVariable<word32>(word32 x, unsigned int y)

 {

-	assert(y < 8*sizeof(x));

+	CRYPTOPP_ASSERT(y < 8*sizeof(x));

 	return _lrotr(x, static_cast<byte>(y));

 }

 

@@ -1506,11 +1588,11 @@ template<> inline word32 rotrMod<word32>(word32 x, unsigned int y)
 //! \details This is a Microsoft specific implementation using <tt>_lrotl</tt> provided by

 //!   <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range

 //!   <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.

-//! \note rotrFixed will assert in Debug builds if is outside the allowed range.

+//! \note rotrFixed will CRYPTOPP_ASSERT in Debug builds if is outside the allowed range.

 template<> inline word64 rotlFixed<word64>(word64 x, unsigned int y)

 {

 	// Uses Microsoft <stdlib.h> call, bound to C/C++ language rules.

-	assert(y < 8*sizeof(x));

+	CRYPTOPP_ASSERT(y < 8*sizeof(x));

 	return y ? _rotl64(x, static_cast<byte>(y)) : x;

 }

 

@@ -1521,11 +1603,11 @@ template<> inline word64 rotlFixed<word64>(word64 x, unsigned int y)
 //! \details This is a Microsoft specific implementation using <tt>_lrotr</tt> provided by

 //!   <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range

 //!   <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.

-//! \note rotrFixed will assert in Debug builds if is outside the allowed range.

+//! \note rotrFixed will CRYPTOPP_ASSERT in Debug builds if is outside the allowed range.

 template<> inline word64 rotrFixed<word64>(word64 x, unsigned int y)

 {

 	// Uses Microsoft <stdlib.h> call, bound to C/C++ language rules.

-	assert(y < 8*sizeof(x));

+	CRYPTOPP_ASSERT(y < 8*sizeof(x));

 	return y ? _rotr64(x, static_cast<byte>(y)) : x;

 }

 

@@ -1536,10 +1618,10 @@ template<> inline word64 rotrFixed<word64>(word64 x, unsigned int y)
 //! \details This is a Microsoft specific implementation using <tt>_lrotl</tt> provided by

 //!   <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range

 //!   <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.

-//! \note rotlVariable will assert in Debug builds if is outside the allowed range.

+//! \note rotlVariable will CRYPTOPP_ASSERT in Debug builds if is outside the allowed range.

 template<> inline word64 rotlVariable<word64>(word64 x, unsigned int y)

 {

-	assert(y < 8*sizeof(x));

+	CRYPTOPP_ASSERT(y < 8*sizeof(x));

 	return _rotl64(x, static_cast<byte>(y));

 }

 

@@ -1550,10 +1632,10 @@ template<> inline word64 rotlVariable<word64>(word64 x, unsigned int y)
 //! \details This is a Microsoft specific implementation using <tt>_lrotr</tt> provided by

 //!   <stdlib.h>. The value x to be rotated is 64-bits. y must be in the range

 //!   <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.

-//! \note rotrVariable will assert in Debug builds if is outside the allowed range.

+//! \note rotrVariable will CRYPTOPP_ASSERT in Debug builds if is outside the allowed range.

 template<> inline word64 rotrVariable<word64>(word64 x, unsigned int y)

 {

-	assert(y < 8*sizeof(x));

+	CRYPTOPP_ASSERT(y < 8*sizeof(x));

 	return y ? _rotr64(x, static_cast<byte>(y)) : x;

 }

 

@@ -1566,7 +1648,7 @@ template<> inline word64 rotrVariable<word64>(word64 x, unsigned int y)
 //!   <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.

 template<> inline word64 rotlMod<word64>(word64 x, unsigned int y)

 {

-	assert(y < 8*sizeof(x));

+	CRYPTOPP_ASSERT(y < 8*sizeof(x));

 	return y ? _rotl64(x, static_cast<byte>(y)) : x;

 }

 

@@ -1579,7 +1661,7 @@ template<> inline word64 rotlMod<word64>(word64 x, unsigned int y)
 //!   <tt>[0, sizeof(T)*8 - 1]</tt> to avoid undefined behavior.

 template<> inline word64 rotrMod<word64>(word64 x, unsigned int y)

 {

-	assert(y < 8*sizeof(x));

+	CRYPTOPP_ASSERT(y < 8*sizeof(x));

 	return y ? _rotr64(x, static_cast<byte>(y)) : x;

 }

 

@@ -1658,25 +1740,25 @@ template<> inline byte rotrMod<byte>(byte x, unsigned int y)
 

 template<> inline word32 rotlFixed<word32>(word32 x, unsigned int y)

 {

-	assert(y < 32);

+	CRYPTOPP_ASSERT(y < 32);

 	return y ? __rlwinm(x,y,0,31) : x;

 }

 

 template<> inline word32 rotrFixed<word32>(word32 x, unsigned int y)

 {

-	assert(y < 32);

+	CRYPTOPP_ASSERT(y < 32);

 	return y ? __rlwinm(x,32-y,0,31) : x;

 }

 

 template<> inline word32 rotlVariable<word32>(word32 x, unsigned int y)

 {

-	assert(y < 32);

+	CRYPTOPP_ASSERT(y < 32);

 	return (__rlwnm(x,y,0,31));

 }

 

 template<> inline word32 rotrVariable<word32>(word32 x, unsigned int y)

 {

-	assert(y < 32);

+	CRYPTOPP_ASSERT(y < 32);

 	return (__rlwnm(x,32-y,0,31));

 }

 

@@ -1841,7 +1923,7 @@ inline T BitReverse(T value)
 		return (T)BitReverse((word32)value);

 	else

 	{

-		assert(sizeof(T) == 8);

+		CRYPTOPP_ASSERT(sizeof(T) == 8);

 		return (T)BitReverse((word64)value);

 	}

 }

@@ -1897,7 +1979,7 @@ inline T ConditionalByteReverse(ByteOrder order, T value)
 template <class T>

 void ByteReverse(T *out, const T *in, size_t byteCount)

 {

-	assert(byteCount % sizeof(T) == 0);

+	CRYPTOPP_ASSERT(byteCount % sizeof(T) == 0);

 	size_t count = byteCount/sizeof(T);

 	for (size_t i=0; i<count; i++)

 		out[i] = ByteReverse(in[i]);

@@ -1929,7 +2011,7 @@ template <class T>
 inline void GetUserKey(ByteOrder order, T *out, size_t outlen, const byte *in, size_t inlen)

 {

 	const size_t U = sizeof(T);

-	assert(inlen <= outlen*U);

+	CRYPTOPP_ASSERT(inlen <= outlen*U);

 	memcpy_s(out, outlen*U, in, inlen);

 	memset_z((byte *)out+inlen, 0, outlen*U-inlen);

 	ConditionalByteReverse(order, out, out, RoundUpToMultipleOf(inlen, U));

@@ -2114,7 +2196,7 @@ inline T GetWord(bool assumeAligned, ByteOrder order, const byte *block)
 //#ifndef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS

 //	if (!assumeAligned)

 //		return UnalignedGetWordNonTemplate(order, block, (T*)NULL);

-//	assert(IsAligned<T>(block));

+//	CRYPTOPP_ASSERT(IsAligned<T>(block));

 //#endif

 //	return ConditionalByteReverse(order, *reinterpret_cast<const T *>(block));

 	CRYPTOPP_UNUSED(assumeAligned);

@@ -2139,8 +2221,8 @@ inline void PutWord(bool assumeAligned, ByteOrder order, byte *block, T value, c
 //#ifndef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS

 //	if (!assumeAligned)

 //		return UnalignedbyteNonTemplate(order, block, value, xorBlock);

-//	assert(IsAligned<T>(block));

-//	assert(IsAligned<T>(xorBlock));

+//	CRYPTOPP_ASSERT(IsAligned<T>(block));

+//	CRYPTOPP_ASSERT(IsAligned<T>(xorBlock));

 //#endif

 //	*reinterpret_cast<T *>(block) = ConditionalByteReverse(order, value) ^ (xorBlock ? *reinterpret_cast<const T *>(xorBlock) : 0);

 	CRYPTOPP_UNUSED(assumeAligned);

diff --git a/modes.cpp b/modes.cpp
index ed2b3224..09d6fd13 100644
--- a/modes.cpp
+++ b/modes.cpp
@@ -35,10 +35,10 @@ void CipherModeBase::ResizeBuffers()
 

 void CFB_ModePolicy::Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount)

 {

-	assert(input);

-	assert(output);

-	assert(m_cipher->IsForwardTransformation());	// CFB mode needs the "encrypt" direction of the underlying block cipher, even to decrypt

-	assert(m_feedbackSize == BlockSize());

+	CRYPTOPP_ASSERT(input);

+	CRYPTOPP_ASSERT(output);

+	CRYPTOPP_ASSERT(m_cipher->IsForwardTransformation());	// CFB mode needs the "encrypt" direction of the underlying block cipher, even to decrypt

+	CRYPTOPP_ASSERT(m_feedbackSize == BlockSize());

 

 	const unsigned int s = BlockSize();

 	if (dir == ENCRYPTION)

@@ -60,7 +60,7 @@ void CFB_ModePolicy::Iterate(byte *output, const byte *input, CipherDir dir, siz
 

 void CFB_ModePolicy::TransformRegister()

 {

-	assert(m_cipher->IsForwardTransformation());	// CFB mode needs the "encrypt" direction of the underlying block cipher, even to decrypt

+	CRYPTOPP_ASSERT(m_cipher->IsForwardTransformation());	// CFB mode needs the "encrypt" direction of the underlying block cipher, even to decrypt

 	m_cipher->ProcessBlock(m_register, m_temp);

 	unsigned int updateSize = BlockSize()-m_feedbackSize;

 	memmove_s(m_register, m_register.size(), m_register+m_feedbackSize, updateSize);

@@ -69,7 +69,7 @@ void CFB_ModePolicy::TransformRegister()
 

 void CFB_ModePolicy::CipherResynchronize(const byte *iv, size_t length)

 {

-	assert(length == BlockSize());

+	CRYPTOPP_ASSERT(length == BlockSize());

 	CopyOrZero(m_register, iv, length);

 	TransformRegister();

 }

@@ -89,7 +89,7 @@ void CFB_ModePolicy::ResizeBuffers()
 

 void OFB_ModePolicy::WriteKeystream(byte *keystreamBuffer, size_t iterationCount)

 {

-	assert(m_cipher->IsForwardTransformation());	// OFB mode needs the "encrypt" direction of the underlying block cipher, even to decrypt

+	CRYPTOPP_ASSERT(m_cipher->IsForwardTransformation());	// OFB mode needs the "encrypt" direction of the underlying block cipher, even to decrypt

 	unsigned int s = BlockSize();

 	m_cipher->ProcessBlock(m_register, keystreamBuffer);

 	if (iterationCount > 1)

@@ -100,7 +100,7 @@ void OFB_ModePolicy::WriteKeystream(byte *keystreamBuffer, size_t iterationCount
 void OFB_ModePolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)

 {

 	CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(length);

-	assert(length == BlockSize());

+	CRYPTOPP_ASSERT(length == BlockSize());

 

 	CopyOrZero(m_register, iv, length);

 }

@@ -124,7 +124,7 @@ void CTR_ModePolicy::IncrementCounterBy256()
 

 void CTR_ModePolicy::OperateKeystream(KeystreamOperation /*operation*/, byte *output, const byte *input, size_t iterationCount)

 {

-	assert(m_cipher->IsForwardTransformation());	// CTR mode needs the "encrypt" direction of the underlying block cipher, even to decrypt

+	CRYPTOPP_ASSERT(m_cipher->IsForwardTransformation());	// CTR mode needs the "encrypt" direction of the underlying block cipher, even to decrypt

 	unsigned int s = BlockSize();

 	unsigned int inputIncrement = input ? s : 0;

 

@@ -145,7 +145,7 @@ void CTR_ModePolicy::OperateKeystream(KeystreamOperation /*operation*/, byte *ou
 void CTR_ModePolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)

 {

 	CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(length);

-	assert(length == BlockSize());

+	CRYPTOPP_ASSERT(length == BlockSize());

 

 	CopyOrZero(m_register, iv, length);

 	m_counterArray = m_register;

@@ -174,7 +174,7 @@ void BlockOrientedCipherModeBase::ResizeBuffers()
 

 void ECB_OneWay::ProcessData(byte *outString, const byte *inString, size_t length)

 {

-	assert(length%BlockSize()==0);

+	CRYPTOPP_ASSERT(length%BlockSize()==0);

 	m_cipher->AdvancedProcessBlocks(inString, NULL, outString, length, BlockTransformation::BT_AllowParallel);

 }

 

@@ -182,7 +182,7 @@ void CBC_Encryption::ProcessData(byte *outString, const byte *inString, size_t l
 {

 	if (!length)

 		return;

-	assert(length%BlockSize()==0);

+	CRYPTOPP_ASSERT(length%BlockSize()==0);

 

 	unsigned int blockSize = BlockSize();

 	m_cipher->AdvancedProcessBlocks(inString, m_register, outString, blockSize, BlockTransformation::BT_XorInput);

@@ -231,7 +231,7 @@ void CBC_Decryption::ProcessData(byte *outString, const byte *inString, size_t l
 {

 	if (!length)

 		return;

-	assert(length%BlockSize()==0);

+	CRYPTOPP_ASSERT(length%BlockSize()==0);

 

 	unsigned int blockSize = BlockSize();

 	memcpy(m_temp, inString+length-blockSize, blockSize);	// save copy now in case of in-place decryption

diff --git a/modes.h b/modes.h
index 01ea4bfe..ceac7ce2 100644
--- a/modes.h
+++ b/modes.h
@@ -66,7 +66,7 @@ public:
 

 protected:

 	CipherModeBase() : m_cipher(NULL) {}

-	inline unsigned int BlockSize() const {assert(m_register.size() > 0); return (unsigned int)m_register.size();}

+	inline unsigned int BlockSize() const {CRYPTOPP_ASSERT(m_register.size() > 0); return (unsigned int)m_register.size();}

 	virtual void SetFeedbackSize(unsigned int feedbackSize)

 	{

 		if (!(feedbackSize == 0 || feedbackSize == BlockSize()))

diff --git a/nbtheory.cpp b/nbtheory.cpp
index 6e2d33a3..d7a4a159 100644
--- a/nbtheory.cpp
+++ b/nbtheory.cpp
@@ -75,7 +75,7 @@ bool TrialDivision(const Integer &p, unsigned bound)
 	unsigned int primeTableSize;

 	const word16 * primeTable = GetPrimeTable(primeTableSize);

 

-	assert(primeTable[primeTableSize-1] >= bound);

+	CRYPTOPP_ASSERT(primeTable[primeTableSize-1] >= bound);

 

 	unsigned int i;

 	for (i = 0; primeTable[i]<bound; i++)

@@ -100,7 +100,7 @@ bool IsFermatProbablePrime(const Integer &n, const Integer &b)
 	if (n <= 3)

 		return n==2 || n==3;

 

-	assert(n>3 && b>1 && b<n-1);

+	CRYPTOPP_ASSERT(n>3 && b>1 && b<n-1);

 	return a_exp_b_mod_c(b, n-1, n)==1;

 }

 

@@ -109,7 +109,7 @@ bool IsStrongProbablePrime(const Integer &n, const Integer &b)
 	if (n <= 3)

 		return n==2 || n==3;

 

-	assert(n>3 && b>1 && b<n-1);

+	CRYPTOPP_ASSERT(n>3 && b>1 && b<n-1);

 

 	if ((n.IsEven() && n!=2) || GCD(b, n) != 1)

 		return false;

@@ -142,7 +142,7 @@ bool RabinMillerTest(RandomNumberGenerator &rng, const Integer &n, unsigned int
 	if (n <= 3)

 		return n==2 || n==3;

 

-	assert(n>3);

+	CRYPTOPP_ASSERT(n>3);

 

 	Integer b;

 	for (unsigned int i=0; i<rounds; i++)

@@ -162,7 +162,7 @@ bool IsLucasProbablePrime(const Integer &n)
 	if (n.IsEven())

 		return n==2;

 

-	assert(n>2);

+	CRYPTOPP_ASSERT(n>2);

 

 	Integer b=3;

 	unsigned int i=0;

@@ -189,7 +189,7 @@ bool IsStrongLucasProbablePrime(const Integer &n)
 	if (n.IsEven())

 		return n==2;

 

-	assert(n>2);

+	CRYPTOPP_ASSERT(n>2);

 

 	Integer b=3;

 	unsigned int i=0;

@@ -310,7 +310,7 @@ PrimeSieve::PrimeSieve(const Integer &first, const Integer &last, const Integer
 bool PrimeSieve::NextCandidate(Integer &c)

 {

 	bool safe = SafeConvert(std::find(m_sieve.begin()+m_next, m_sieve.end(), false) - m_sieve.begin(), m_next);

-	CRYPTOPP_UNUSED(safe); assert(safe);

+	CRYPTOPP_UNUSED(safe); CRYPTOPP_ASSERT(safe);

 	if (m_next == m_sieve.size())

 	{

 		m_first += long(m_sieve.size())*m_step;

@@ -363,7 +363,7 @@ void PrimeSieve::DoSieve()
 	}

 	else

 	{

-		assert(m_step%2==0);

+		CRYPTOPP_ASSERT(m_step%2==0);

 		Integer qFirst = (m_first-m_delta) >> 1;

 		Integer halfStep = m_step >> 1;

 		for (unsigned int i = 0; i < primeTableSize; ++i)

@@ -380,7 +380,7 @@ void PrimeSieve::DoSieve()
 

 bool FirstPrime(Integer &p, const Integer &max, const Integer &equiv, const Integer &mod, const PrimeSelector *pSelector)

 {

-	assert(!equiv.IsNegative() && equiv < mod);

+	CRYPTOPP_ASSERT(!equiv.IsNegative() && equiv < mod);

 

 	Integer gcd = GCD(equiv, mod);

 	if (gcd != Integer::One())

@@ -420,7 +420,7 @@ bool FirstPrime(Integer &p, const Integer &max, const Integer &equiv, const Inte
 		p = primeTable[primeTableSize-1]+1;

 	}

 

-	assert(p > primeTable[primeTableSize-1]);

+	CRYPTOPP_ASSERT(p > primeTable[primeTableSize-1]);

 

 	if (mod.IsOdd())

 		return FirstPrime(p, max, CRT(equiv, mod, 1, 2, 1), mod<<1, pSelector);

@@ -444,8 +444,8 @@ bool FirstPrime(Integer &p, const Integer &max, const Integer &equiv, const Inte
 // the following two functions are based on code and comments provided by Preda Mihailescu

 static bool ProvePrime(const Integer &p, const Integer &q)

 {

-	assert(p < q*q*q);

-	assert(p % q == 1);

+	CRYPTOPP_ASSERT(p < q*q*q);

+	CRYPTOPP_ASSERT(p % q == 1);

 

 // this is the Quisquater test. Numbers p having passed the Lucas - Lehmer test

 // for q and verifying p < q^3 can only be built up of two factors, both = 1 mod q,

@@ -459,7 +459,7 @@ static bool ProvePrime(const Integer &p, const Integer &q)
 	unsigned int primeTableSize;

 	const word16 * primeTable = GetPrimeTable(primeTableSize);

 

-	assert(primeTableSize >= 50);

+	CRYPTOPP_ASSERT(primeTableSize >= 50);

 	for (int i=0; i<50; i++)

 	{

 		Integer b = a_exp_b_mod_c(primeTable[i], r, p);

@@ -616,7 +616,7 @@ Integer ModularSquareRoot(const Integer &a, const Integer &p)
 		b = tempb*y%p;

 	}

 

-	assert(x.Squared()%p == a);

+	CRYPTOPP_ASSERT(x.Squared()%p == a);

 	return x;

 }

 

@@ -626,21 +626,21 @@ bool SolveModularQuadraticEquation(Integer &r1, Integer &r2, const Integer &a, c
 	switch (Jacobi(D, p))

 	{

 	default:

-		assert(false);	// not reached

+		CRYPTOPP_ASSERT(false);	// not reached

 		return false;

 	case -1:

 		return false;

 	case 0:

 		r1 = r2 = (-b*(a+a).InverseMod(p)) % p;

-		assert(((r1.Squared()*a + r1*b + c) % p).IsZero());

+		CRYPTOPP_ASSERT(((r1.Squared()*a + r1*b + c) % p).IsZero());

 		return true;

 	case 1:

 		Integer s = ModularSquareRoot(D, p);

 		Integer t = (a+a).InverseMod(p);

 		r1 = (s-b)*t % p;

 		r2 = (-s-b)*t % p;

-		assert(((r1.Squared()*a + r1*b + c) % p).IsZero());

-		assert(((r2.Squared()*a + r2*b + c) % p).IsZero());

+		CRYPTOPP_ASSERT(((r1.Squared()*a + r1*b + c) % p).IsZero());

+		CRYPTOPP_ASSERT(((r2.Squared()*a + r2*b + c) % p).IsZero());

 		return true;

 	}

 }

@@ -666,7 +666,7 @@ Integer ModularRoot(const Integer &a, const Integer &e,
 	Integer dp = EuclideanMultiplicativeInverse(e, p-1);

 	Integer dq = EuclideanMultiplicativeInverse(e, q-1);

 	Integer u = EuclideanMultiplicativeInverse(p, q);

-	assert(!!dp && !!dq && !!u);

+	CRYPTOPP_ASSERT(!!dp && !!dq && !!u);

 	return ModularRoot(a, dp, dq, p, q, u);

 }

 

@@ -676,7 +676,7 @@ Integer GCDI(const Integer &x, const Integer &y)
 	Integer a=x, b=y;

 	unsigned k=0;

 

-	assert(!!a && !!b);

+	CRYPTOPP_ASSERT(!!a && !!b);

 

 	while (a[0]==0 && b[0]==0)

 	{

@@ -711,14 +711,14 @@ Integer GCDI(const Integer &x, const Integer &y)
 				break;

 

 			default:

-				assert(false);

+				CRYPTOPP_ASSERT(false);

 		}

 	}

 }

 

 Integer EuclideanMultiplicativeInverse(const Integer &a, const Integer &b)

 {

-	assert(b.Positive());

+	CRYPTOPP_ASSERT(b.Positive());

 

 	if (a.Negative())

 		return EuclideanMultiplicativeInverse(a%b, b);

@@ -786,7 +786,7 @@ Integer EuclideanMultiplicativeInverse(const Integer &a, const Integer &b)
 

 int Jacobi(const Integer &aIn, const Integer &bIn)

 {

-	assert(bIn.IsOdd());

+	CRYPTOPP_ASSERT(bIn.IsOdd());

 

 	Integer b = bIn, a = aIn%bIn;

 	int result = 1;

@@ -979,7 +979,7 @@ Integer Lucas(const Integer &n, const Integer &P, const Integer &modulus)
 				continue;

 			}

 

-			assert(em2 == 0);

+			CRYPTOPP_ASSERT(em2 == 0);

 			// #9

 			e >>= 1;

 			C = f(C, B, A);

@@ -1038,8 +1038,8 @@ unsigned int DiscreteLogWorkFactor(unsigned int n)
 void PrimeAndGenerator::Generate(signed int delta, RandomNumberGenerator &rng, unsigned int pbits, unsigned int qbits)

 {

 	// no prime exists for delta = -1, qbits = 4, and pbits = 5

-	assert(qbits > 4);

-	assert(pbits > qbits);

+	CRYPTOPP_ASSERT(qbits > 4);

+	CRYPTOPP_ASSERT(pbits > qbits);

 

 	if (qbits+1 == pbits)

 	{

@@ -1054,9 +1054,9 @@ void PrimeAndGenerator::Generate(signed int delta, RandomNumberGenerator &rng, u
 

 			while (sieve.NextCandidate(p))

 			{

-				assert(IsSmallPrime(p) || SmallDivisorsTest(p));

+				CRYPTOPP_ASSERT(IsSmallPrime(p) || SmallDivisorsTest(p));

 				q = (p-delta) >> 1;

-				assert(IsSmallPrime(q) || SmallDivisorsTest(q));

+				CRYPTOPP_ASSERT(IsSmallPrime(q) || SmallDivisorsTest(q));

 				if (FastProbablePrimeTest(q) && FastProbablePrimeTest(p) && IsPrime(q) && IsPrime(p))

 				{

 					success = true;

@@ -1071,11 +1071,11 @@ void PrimeAndGenerator::Generate(signed int delta, RandomNumberGenerator &rng, u
 			// g=4 always works, but this way we get the smallest quadratic residue (other than 1)

 			for (g=2; Jacobi(g, p) != 1; ++g) {}

 			// contributed by Walt Tuvell: g should be the following according to the Law of Quadratic Reciprocity

-			assert((p%8==1 || p%8==7) ? g==2 : (p%12==1 || p%12==11) ? g==3 : g==4);

+			CRYPTOPP_ASSERT((p%8==1 || p%8==7) ? g==2 : (p%12==1 || p%12==11) ? g==3 : g==4);

 		}

 		else

 		{

-			assert(delta == -1);

+			CRYPTOPP_ASSERT(delta == -1);

 			// find g such that g*g-4 is a quadratic non-residue,

 			// and such that g has order q

 			for (g=3; ; ++g)

@@ -1103,11 +1103,11 @@ void PrimeAndGenerator::Generate(signed int delta, RandomNumberGenerator &rng, u
 				Integer h(rng, 2, p-2, Integer::ANY);

 				g = a_exp_b_mod_c(h, (p-1)/q, p);

 			} while (g <= 1);

-			assert(a_exp_b_mod_c(g, q, p)==1);

+			CRYPTOPP_ASSERT(a_exp_b_mod_c(g, q, p)==1);

 		}

 		else

 		{

-			assert(delta==-1);

+			CRYPTOPP_ASSERT(delta==-1);

 			do

 			{

 				Integer h(rng, 3, p-1, Integer::ANY);

@@ -1115,7 +1115,7 @@ void PrimeAndGenerator::Generate(signed int delta, RandomNumberGenerator &rng, u
 					continue;

 				g = Lucas((p+1)/q, h, p);

 			} while (g <= 2);

-			assert(Lucas(q, g, p) == 2);

+			CRYPTOPP_ASSERT(Lucas(q, g, p) == 2);

 		}

 	}

 }

diff --git a/network.cpp b/network.cpp
index f1233250..70d98339 100644
--- a/network.cpp
+++ b/network.cpp
@@ -435,7 +435,7 @@ size_t NetworkSink::Put2(const byte *inString, size_t length, int messageEnd, bo
 	{

 		if (m_skipBytes)

 		{

-			assert(length >= m_skipBytes);

+			CRYPTOPP_ASSERT(length >= m_skipBytes);

 			inString += m_skipBytes;

 			length -= m_skipBytes;

 		}

@@ -451,7 +451,7 @@ size_t NetworkSink::Put2(const byte *inString, size_t length, int messageEnd, bo
 

 		if (m_buffer.CurrentSize() > targetSize)

 		{

-			assert(!blocking);

+			CRYPTOPP_ASSERT(!blocking);

 			m_wasBlocked = true;

 			m_skipBytes += length;

 			size_t blockedBytes = UnsignedMin(length, m_buffer.CurrentSize() - targetSize);

diff --git a/oaep.cpp b/oaep.cpp
index 64984f87..d2be610e 100644
--- a/oaep.cpp
+++ b/oaep.cpp
@@ -19,7 +19,7 @@ size_t OAEP_Base::MaxUnpaddedLength(size_t paddedLength) const
 

 void OAEP_Base::Pad(RandomNumberGenerator &rng, const byte *input, size_t inputLength, byte *oaepBlock, size_t oaepBlockLen, const NameValuePairs &parameters) const

 {

-	assert (inputLength <= MaxUnpaddedLength(oaepBlockLen));

+	CRYPTOPP_ASSERT (inputLength <= MaxUnpaddedLength(oaepBlockLen));

 

 	// convert from bit length to byte length

 	if (oaepBlockLen % 8 != 0)

diff --git a/panama.cpp b/panama.cpp
index f10edbdc..32615c65 100644
--- a/panama.cpp
+++ b/panama.cpp
@@ -326,7 +326,7 @@ void CRYPTOPP_NOINLINE Panama_SSE2_Pull(size_t count, word32 *state, word32 *z,
 template <class B>

 void Panama<B>::Iterate(size_t count, const word32 *p, byte *output, const byte *input, KeystreamOperation operation)

 {

-	assert(IsAlignedOn(m_state,GetAlignmentOf<word32>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(m_state,GetAlignmentOf<word32>()));

 	word32 bstart = m_state[17];

 	word32 *const aPtr = m_state;

 	word32 cPtr[17];

@@ -452,7 +452,7 @@ template <class B>
 void PanamaCipherPolicy<B>::CipherSetKey(const NameValuePairs &params, const byte *key, size_t length)

 {

 	CRYPTOPP_UNUSED(params); CRYPTOPP_UNUSED(length);

-	assert(length==32);

+	CRYPTOPP_ASSERT(length==32);

 	memcpy(m_key, key, 32);

 }

 

@@ -460,8 +460,8 @@ template <class B>
 void PanamaCipherPolicy<B>::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)

 {

 	CRYPTOPP_UNUSED(keystreamBuffer); CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(length);

-	assert(IsAlignedOn(iv,GetAlignmentOf<word32>()));

-	assert(length==32);

+	CRYPTOPP_ASSERT(IsAlignedOn(iv,GetAlignmentOf<word32>()));

+	CRYPTOPP_ASSERT(length==32);

 

 	this->Reset();

 	this->Iterate(1, m_key);

@@ -500,7 +500,7 @@ template <class B>
 void PanamaCipherPolicy<B>::OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount)

 {

 #if (CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE || defined(CRYPTOPP_X64_MASM_AVAILABLE)) && !defined(CRYPTOPP_DISABLE_PANAMA_ASM)

-	// No need for alignment assert. Panama_SSE2_Pull is ASM, and its not bound by C alignment requirements.

+	// No need for alignment CRYPTOPP_ASSERT. Panama_SSE2_Pull is ASM, and its not bound by C alignment requirements.

 	if (B::ToEnum() == LITTLE_ENDIAN_ORDER && HasSSE2())

 		Panama_SSE2_Pull(iterationCount, this->m_state, (word32 *)(void *)output, (const word32 *)(void *)input);

 	else

diff --git a/pkcspad.cpp b/pkcspad.cpp
index 85eac6ae..7716256f 100644
--- a/pkcspad.cpp
+++ b/pkcspad.cpp
@@ -7,7 +7,7 @@
 

 #include "pkcspad.h"

 #include "misc.h"

-#include <assert.h>

+#include "trap.h"

 

 NAMESPACE_BEGIN(CryptoPP)

 

@@ -32,7 +32,7 @@ size_t PKCS_EncryptionPaddingScheme::MaxUnpaddedLength(size_t paddedLength) cons
 void PKCS_EncryptionPaddingScheme::Pad(RandomNumberGenerator& rng, const byte *input, size_t inputLen, byte *pkcsBlock, size_t pkcsBlockLen, const NameValuePairs& parameters) const

 {

 	CRYPTOPP_UNUSED(parameters);

-	assert (inputLen <= MaxUnpaddedLength(pkcsBlockLen));	// this should be checked by caller

+	CRYPTOPP_ASSERT (inputLen <= MaxUnpaddedLength(pkcsBlockLen));	// this should be checked by caller

 

 	// convert from bit length to byte length

 	if (pkcsBlockLen % 8 != 0)

@@ -73,7 +73,7 @@ DecodingResult PKCS_EncryptionPaddingScheme::Unpad(const byte *pkcsBlock, size_t
 	size_t i=1;

 	while (i<pkcsBlockLen && pkcsBlock[i++]) { // null body

 		}

-	assert(i==pkcsBlockLen || pkcsBlock[i-1]==0);

+	CRYPTOPP_ASSERT(i==pkcsBlockLen || pkcsBlock[i-1]==0);

 

 	size_t outputLen = pkcsBlockLen - i;

 	invalid = (outputLen > maxOutputLen) || invalid;

@@ -96,7 +96,7 @@ void PKCS1v15_SignatureMessageEncodingMethod::ComputeMessageRepresentative(Rando
 {

 	CRYPTOPP_UNUSED(rng), CRYPTOPP_UNUSED(recoverableMessage), CRYPTOPP_UNUSED(recoverableMessageLength);

 	CRYPTOPP_UNUSED(messageEmpty), CRYPTOPP_UNUSED(hashIdentifier);

-	assert(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));

+	CRYPTOPP_ASSERT(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));

 

 	size_t pkcsBlockLen = representativeBitLength;

 	// convert from bit length to byte length

diff --git a/polynomi.cpp b/polynomi.cpp
index bf8904c0..b88545bc 100644
--- a/polynomi.cpp
+++ b/polynomi.cpp
@@ -475,7 +475,7 @@ void RingOfPolynomialsOver<T>::CalculateAlpha(std::vector<CoefficientType> &alph
 template <class T>

 typename RingOfPolynomialsOver<T>::Element RingOfPolynomialsOver<T>::Interpolate(const CoefficientType x[], const CoefficientType y[], unsigned int n) const

 {

-	assert(n > 0);

+	CRYPTOPP_ASSERT(n > 0);

 

 	std::vector<CoefficientType> alpha(n);

 	CalculateAlpha(alpha, x, y, n);

@@ -497,7 +497,7 @@ typename RingOfPolynomialsOver<T>::Element RingOfPolynomialsOver<T>::Interpolate
 template <class T>

 typename RingOfPolynomialsOver<T>::CoefficientType RingOfPolynomialsOver<T>::InterpolateAt(const CoefficientType &position, const CoefficientType x[], const CoefficientType y[], unsigned int n) const

 {

-	assert(n > 0);

+	CRYPTOPP_ASSERT(n > 0);

 

 	std::vector<CoefficientType> alpha(n);

 	CalculateAlpha(alpha, x, y, n);

@@ -527,7 +527,7 @@ void PrepareBulkPolynomialInterpolation(const Ring &ring, Element *w, const Elem
 template <class Ring, class Element>

 void PrepareBulkPolynomialInterpolationAt(const Ring &ring, Element *v, const Element &position, const Element x[], const Element w[], unsigned int n)

 {

-	assert(n > 0);

+	CRYPTOPP_ASSERT(n > 0);

 

 	std::vector<Element> a(2*n-1);

 	unsigned int i;

diff --git a/pssr.cpp b/pssr.cpp
index 4f9339ff..559408da 100644
--- a/pssr.cpp
+++ b/pssr.cpp
@@ -51,7 +51,7 @@ void PSSR_MEM_Base::ComputeMessageRepresentative(RandomNumberGenerator &rng,
 {

 	CRYPTOPP_UNUSED(rng), CRYPTOPP_UNUSED(recoverableMessage), CRYPTOPP_UNUSED(recoverableMessageLength);

 	CRYPTOPP_UNUSED(messageEmpty), CRYPTOPP_UNUSED(hashIdentifier);

-	assert(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));

+	CRYPTOPP_ASSERT(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));

 

 	const size_t u = hashIdentifier.second + 1;

 	const size_t representativeByteLength = BitsToBytes(representativeBitLength);

@@ -99,7 +99,7 @@ DecodingResult PSSR_MEM_Base::RecoverMessageFromRepresentative(
 	byte *recoverableMessage) const

 {

 	CRYPTOPP_UNUSED(recoverableMessage), CRYPTOPP_UNUSED(messageEmpty), CRYPTOPP_UNUSED(hashIdentifier);

-	assert(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));

+	CRYPTOPP_ASSERT(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));

 

 	const size_t u = hashIdentifier.second + 1;

 	const size_t representativeByteLength = BitsToBytes(representativeBitLength);

diff --git a/pubkey.h b/pubkey.h
index 7f4cbb3c..a2032612 100644
--- a/pubkey.h
+++ b/pubkey.h
@@ -29,7 +29,7 @@
 //! </ul>

 //!

 //! \details The \p TF_ prefix means an implementation using trapdoor functions on integers.

-//! \details The \p DL_ prefix means an implementation using group operations (in groups where discrete log is hard).

+//! \details The \p DL_ prefix means an implementation using group operations in groups where discrete log is hard.

 

 #ifndef CRYPTOPP_PUBKEY_H

 #define CRYPTOPP_PUBKEY_H

@@ -56,9 +56,9 @@
 #undef INTERFACE

 

 #if defined(__SUNPRO_CC)

-# define MAYBE_RETURN_FOR_SOLARIS(x) return x

+# define MAYBE_RETURN(x) return x

 #else

-# define MAYBE_RETURN_FOR_SOLARIS(x) CRYPTOPP_UNUSED(x)

+# define MAYBE_RETURN(x) CRYPTOPP_UNUSED(x)

 #endif

 

 NAMESPACE_BEGIN(CryptoPP)

@@ -365,7 +365,7 @@ public:
 		CRYPTOPP_UNUSED(hash);CRYPTOPP_UNUSED(recoverableMessage); CRYPTOPP_UNUSED(recoverableMessageLength);

 		CRYPTOPP_UNUSED(presignature); CRYPTOPP_UNUSED(presignatureLength); CRYPTOPP_UNUSED(semisignature);

 		if (RecoverablePartFirst())

-			assert(!"ProcessRecoverableMessage() not implemented");

+			CRYPTOPP_ASSERT(!"ProcessRecoverableMessage() not implemented");

 	}

 

 	virtual void ComputeMessageRepresentative(RandomNumberGenerator &rng,

@@ -1314,7 +1314,7 @@ public:
 	{

 		CRYPTOPP_UNUSED(params); CRYPTOPP_UNUSED(publicKey); CRYPTOPP_UNUSED(r); CRYPTOPP_UNUSED(s);

 		throw NotImplemented("DL_ElgamalLikeSignatureAlgorithm: this signature scheme does not support message recovery");

-		MAYBE_RETURN_FOR_SOLARIS(Integer::Zero());

+		MAYBE_RETURN(Integer::Zero());

 	}

 	virtual size_t RLen(const DL_GroupParameters<T> &params) const

 		{return params.GetSubgroupOrder().ByteCount();}

@@ -1420,7 +1420,7 @@ public:
 	//! \returns maximum recoverable length based on signature length, in bytes

 	//! \details this function is not implemented and always returns 0.

 	size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const

-		{CRYPTOPP_UNUSED(signatureLength); assert(false); return 0;}	// TODO

+		{CRYPTOPP_UNUSED(signatureLength); CRYPTOPP_ASSERT(false); return 0;}	// TODO

 

 	//! \brief Determines if the scheme is probabilistic

 	//! \returns true if the scheme is probabilistic, false otherwise

@@ -2006,7 +2006,7 @@ public:
 			return params.ExponentiateElement(publicElement, privateExponent*params.GetCofactor());

 		else

 		{

-			assert(COFACTOR_OPTION::ToEnum() == NO_COFACTOR_MULTIPLICTION);

+			CRYPTOPP_ASSERT(COFACTOR_OPTION::ToEnum() == NO_COFACTOR_MULTIPLICTION);

 

 			if (!validateOtherPublicKey)

 				return params.ExponentiateElement(publicElement, privateExponent);

diff --git a/pwdbased.h b/pwdbased.h
index 539c9a7e..cc0bcedb 100644
--- a/pwdbased.h
+++ b/pwdbased.h
@@ -83,8 +83,8 @@ template <class T>
 unsigned int PKCS5_PBKDF1<T>::DeriveKey(byte *derived, size_t derivedLen, byte purpose, const byte *password, size_t passwordLen, const byte *salt, size_t saltLen, unsigned int iterations, double timeInSeconds) const

 {

 	CRYPTOPP_UNUSED(purpose);

-	assert(derivedLen <= MaxDerivedKeyLength());

-	assert(iterations > 0 || timeInSeconds > 0);

+	CRYPTOPP_ASSERT(derivedLen <= MaxDerivedKeyLength());

+	CRYPTOPP_ASSERT(iterations > 0 || timeInSeconds > 0);

 

 	if (!iterations)

 		iterations = 1;

@@ -113,8 +113,8 @@ template <class T>
 unsigned int PKCS5_PBKDF2_HMAC<T>::DeriveKey(byte *derived, size_t derivedLen, byte purpose, const byte *password, size_t passwordLen, const byte *salt, size_t saltLen, unsigned int iterations, double timeInSeconds) const

 {

 	CRYPTOPP_UNUSED(purpose);

-	assert(derivedLen <= MaxDerivedKeyLength());

-	assert(iterations > 0 || timeInSeconds > 0);

+	CRYPTOPP_ASSERT(derivedLen <= MaxDerivedKeyLength());

+	CRYPTOPP_ASSERT(iterations > 0 || timeInSeconds > 0);

 

 	if (!iterations)

 		iterations = 1;

@@ -183,8 +183,8 @@ public:
 template <class T>

 unsigned int PKCS12_PBKDF<T>::DeriveKey(byte *derived, size_t derivedLen, byte purpose, const byte *password, size_t passwordLen, const byte *salt, size_t saltLen, unsigned int iterations, double timeInSeconds) const

 {

-	assert(derivedLen <= MaxDerivedKeyLength());

-	assert(iterations > 0 || timeInSeconds > 0);

+	CRYPTOPP_ASSERT(derivedLen <= MaxDerivedKeyLength());

+	CRYPTOPP_ASSERT(iterations > 0 || timeInSeconds > 0);

 

 	if (!iterations)

 		iterations = 1;

diff --git a/queue.cpp b/queue.cpp
index 0569d18e..fd236381 100644
--- a/queue.cpp
+++ b/queue.cpp
@@ -464,7 +464,7 @@ byte ByteQueue::operator[](lword i) const
 		i -= current->CurrentSize();

 	}

 

-	assert(i < m_lazyLength);

+	CRYPTOPP_ASSERT(i < m_lazyLength);

 	return m_lazyString[i];

 }

 

diff --git a/queue.h b/queue.h
index 88a3b8d4..e1ed4da6 100644
--- a/queue.h
+++ b/queue.h
@@ -132,7 +132,7 @@ public:
 	LazyPutter(ByteQueue &bq, const byte *inString, size_t size)

 		: m_bq(bq) {bq.LazyPut(inString, size);}

 	~LazyPutter()

-		{try {m_bq.FinalizeLazyPut();} catch(const Exception&) {assert(0);}}

+		{try {m_bq.FinalizeLazyPut();} catch(const Exception&) {CRYPTOPP_ASSERT(0);}}

 protected:

 	LazyPutter(ByteQueue &bq) : m_bq(bq) {}

 private:

diff --git a/rdrand.cpp b/rdrand.cpp
index cc18cc43..36f0538c 100644
--- a/rdrand.cpp
+++ b/rdrand.cpp
@@ -163,7 +163,7 @@ NAMESPACE_BEGIN(CryptoPP)
 #if ALL_RDRAND_INTRIN_AVAILABLE

 static int ALL_RRI_GenerateBlock(byte *output, size_t size, unsigned int safety)

 {

-	assert((output && size) || !(output || size));

+	CRYPTOPP_ASSERT((output && size) || !(output || size));

 #if CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32

 	word32 val;

 #else

@@ -186,7 +186,7 @@ static int ALL_RRI_GenerateBlock(byte *output, size_t size, unsigned int safety)
 		{

 			if (!safety--)

 			{

-				assert(0);

+				CRYPTOPP_ASSERT(0);

 				return 0;

 			}

 		}

@@ -208,7 +208,7 @@ static int ALL_RRI_GenerateBlock(byte *output, size_t size, unsigned int safety)
 		{

 			if (!safety--)

 			{

-				assert(0);

+				CRYPTOPP_ASSERT(0);

 				return 0;

 			}

 		}

@@ -223,7 +223,7 @@ static int ALL_RRI_GenerateBlock(byte *output, size_t size, unsigned int safety)
 #if GCC_RDRAND_ASM_AVAILABLE

 static int GCC_RRA_GenerateBlock(byte *output, size_t size, unsigned int safety)

 {

-	assert((output && size) || !(output || size));

+	CRYPTOPP_ASSERT((output && size) || !(output || size));

 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32

 	word64 val;

 #else

@@ -268,7 +268,7 @@ static int GCC_RRA_GenerateBlock(byte *output, size_t size, unsigned int safety)
 		{

 			if (!safety--)

 			{

-				assert(0);

+				CRYPTOPP_ASSERT(0);

 				return 0;

 			}

 		}

@@ -285,7 +285,7 @@ static int GCC_RRA_GenerateBlock(byte *output, size_t size, unsigned int safety)
 void RDRAND::GenerateBlock(byte *output, size_t size)

 {

 	CRYPTOPP_UNUSED(output), CRYPTOPP_UNUSED(size);

-	assert((output && size) || !(output || size));

+	CRYPTOPP_ASSERT((output && size) || !(output || size));

 

 	if(!HasRDRAND())

 		throw NotImplemented("RDRAND: rdrand is not available on this platform");

@@ -313,7 +313,7 @@ void RDRAND::DiscardBytes(size_t n)
 {

 	// RoundUpToMultipleOf is used because a full word is read, and its cheaper

 	//   to discard full words. There's no sense in dealing with tail bytes.

-	assert(HasRDRAND());

+	CRYPTOPP_ASSERT(HasRDRAND());

 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32

 	FixedSizeSecBlock<word64, 16> discard;

 	n = RoundUpToMultipleOf(n, sizeof(word64));

@@ -338,7 +338,7 @@ void RDRAND::DiscardBytes(size_t n)
 #if ALL_RDSEED_INTRIN_AVAILABLE

 static int ALL_RSI_GenerateBlock(byte *output, size_t size, unsigned int safety)

 {

-	assert((output && size) || !(output || size));

+	CRYPTOPP_ASSERT((output && size) || !(output || size));

 #if CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32

 	word32 val;

 #else

@@ -361,7 +361,7 @@ static int ALL_RSI_GenerateBlock(byte *output, size_t size, unsigned int safety)
 		{

 			if (!safety--)

 			{

-				assert(0);

+				CRYPTOPP_ASSERT(0);

 				return 0;

 			}

 		}

@@ -383,7 +383,7 @@ static int ALL_RSI_GenerateBlock(byte *output, size_t size, unsigned int safety)
 		{

 			if (!safety--)

 			{

-				assert(0);

+				CRYPTOPP_ASSERT(0);

 				return 0;

 			}

 		}

@@ -398,7 +398,7 @@ static int ALL_RSI_GenerateBlock(byte *output, size_t size, unsigned int safety)
 #if GCC_RDSEED_ASM_AVAILABLE

 static int GCC_RSA_GenerateBlock(byte *output, size_t size, unsigned int safety)

 {

-	assert((output && size) || !(output || size));

+	CRYPTOPP_ASSERT((output && size) || !(output || size));

 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32

 	word64 val;

 #else

@@ -443,7 +443,7 @@ static int GCC_RSA_GenerateBlock(byte *output, size_t size, unsigned int safety)
 		{

 			if (!safety--)

 			{

-				assert(0);

+				CRYPTOPP_ASSERT(0);

 				return 0;

 			}

 		}

@@ -459,7 +459,7 @@ static int GCC_RSA_GenerateBlock(byte *output, size_t size, unsigned int safety)
 void RDSEED::GenerateBlock(byte *output, size_t size)

 {

 	CRYPTOPP_UNUSED(output), CRYPTOPP_UNUSED(size);

-	assert((output && size) || !(output || size));

+	CRYPTOPP_ASSERT((output && size) || !(output || size));

 

 	if(!HasRDSEED())

 		throw NotImplemented("RDSEED: rdseed is not available on this platform");

@@ -487,7 +487,7 @@ void RDSEED::DiscardBytes(size_t n)
 {

 	// RoundUpToMultipleOf is used because a full word is read, and its cheaper

 	//   to discard full words. There's no sense in dealing with tail bytes.

-	assert(HasRDSEED());

+	CRYPTOPP_ASSERT(HasRDSEED());

 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32

 	FixedSizeSecBlock<word64, 16> discard;

 	n = RoundUpToMultipleOf(n, sizeof(word64));

diff --git a/rdrand.h b/rdrand.h
index 58a71319..45c20f71 100644
--- a/rdrand.h
+++ b/rdrand.h
@@ -103,7 +103,7 @@ public:
 	{

 		// Override to avoid the base class' throw.

 		CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(length);

-		// assert(0); // warn in debug builds

+		// CRYPTOPP_ASSERT(0); // warn in debug builds

 	}

 

 private:

@@ -187,7 +187,7 @@ public:
 	{

 		// Override to avoid the base class' throw.

 		CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(length);

-		// assert(0); // warn in debug builds

+		// CRYPTOPP_ASSERT(0); // warn in debug builds

 	}

 

 private:

diff --git a/rijndael.cpp b/rijndael.cpp
index 0ba1a199..b4ca2d84 100644
--- a/rijndael.cpp
+++ b/rijndael.cpp
@@ -1128,7 +1128,7 @@ inline size_t AESNI_AdvancedProcessBlocks(F1 func1, F4 func4, MAYBE_CONST __m128
 

 	if (flags & BlockTransformation::BT_ReverseDirection)

 	{

-		assert(length % blockSize == 0);

+		CRYPTOPP_ASSERT(length % blockSize == 0);

 		inBlocks += length - blockSize;

 		xorBlocks += length - blockSize;

 		outBlocks += length - blockSize;

@@ -1267,7 +1267,7 @@ size_t Rijndael::Enc::AdvancedProcessBlocks(const byte *inBlocks, const byte *xo
 		size_t increment = BLOCKSIZE;

 		if (flags & BT_ReverseDirection)

 		{

-			assert(length % BLOCKSIZE == 0);

+			CRYPTOPP_ASSERT(length % BLOCKSIZE == 0);

 			inBlocks += length - BLOCKSIZE;

 			xorBlocks += length - BLOCKSIZE;

 			outBlocks += length - BLOCKSIZE;

diff --git a/rsa.cpp b/rsa.cpp
index 3587fe80..fd0a17d8 100644
--- a/rsa.cpp
+++ b/rsa.cpp
@@ -108,13 +108,13 @@ void InvertibleRSAFunction::GenerateRandom(RandomNumberGenerator &rng, const Nam
 	int modulusSize = 2048;

 	alg.GetIntValue(Name::ModulusSize(), modulusSize) || alg.GetIntValue(Name::KeySize(), modulusSize);

 

-	assert(modulusSize >= 16);

+	CRYPTOPP_ASSERT(modulusSize >= 16);

 	if (modulusSize < 16)

 		throw InvalidArgument("InvertibleRSAFunction: specified modulus size is too small");

 

 	m_e = alg.GetValueWithDefault(Name::PublicExponent(), Integer(17));

 

-	assert(m_e >= 3); assert(!m_e.IsEven());

+	CRYPTOPP_ASSERT(m_e >= 3); CRYPTOPP_ASSERT(!m_e.IsEven());

 	if (m_e < 3 || m_e.IsEven())

 		throw InvalidArgument("InvertibleRSAFunction: invalid public exponent");

 

@@ -125,7 +125,7 @@ void InvertibleRSAFunction::GenerateRandom(RandomNumberGenerator &rng, const Nam
 	m_q.GenerateRandom(rng, primeParam);

 

 	m_d = m_e.InverseMod(LCM(m_p-1, m_q-1));

-	assert(m_d.IsPositive());

+	CRYPTOPP_ASSERT(m_d.IsPositive());

 

 	m_dp = m_d % (m_p-1);

 	m_dq = m_d % (m_q-1);

diff --git a/rw.cpp b/rw.cpp
index 784a0368..56584d59 100644
--- a/rw.cpp
+++ b/rw.cpp
@@ -239,7 +239,7 @@ Integer InvertibleRWFunction::CalculateInverse(RandomNumberGenerator &rng, const
 

 	// Signature

 	Integer s = modn.Multiply(modn.Square(Y), rInv);

-	assert((e * f * s.Squared()) % m_n == x);

+	CRYPTOPP_ASSERT((e * f * s.Squared()) % m_n == x);

 

 	// IEEE P1363, Section 8.2.8 IFSP-RW, p.44

 	s = STDMIN(s, m_n - s);

diff --git a/salsa.cpp b/salsa.cpp
index ddf779ae..85c33545 100644
--- a/salsa.cpp
+++ b/salsa.cpp
@@ -63,7 +63,7 @@ void Salsa20_Policy::CipherSetKey(const NameValuePairs &params, const byte *key,
 void Salsa20_Policy::CipherResynchronize(byte *keystreamBuffer, const byte *IV, size_t length)

 {

 	CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(length);

-	assert(length==8);

+	CRYPTOPP_ASSERT(length==8);

 

 	GetBlock<word32, LittleEndian> get(IV);

 	get(m_state[14])(m_state[11]);

@@ -592,7 +592,7 @@ void XSalsa20_Policy::CipherSetKey(const NameValuePairs &params, const byte *key
 void XSalsa20_Policy::CipherResynchronize(byte *keystreamBuffer, const byte *IV, size_t length)

 {

 	CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(length);

-	assert(length==24);

+	CRYPTOPP_ASSERT(length==24);

 

 	word32 x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;

 

diff --git a/seal.cpp b/seal.cpp
index 9babbfa1..d827c1d6 100644
--- a/seal.cpp
+++ b/seal.cpp
@@ -73,7 +73,7 @@ template <class B>
 void SEAL_Policy<B>::CipherResynchronize(byte *keystreamBuffer, const byte *IV, size_t length)

 {

 	CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(IV), CRYPTOPP_UNUSED(length);

-	assert(length==4);

+	CRYPTOPP_ASSERT(length==4);

 

 	m_outsideCounter = IV ? GetWord<word32>(false, BIG_ENDIAN_ORDER, IV) : 0;

 	m_startCount = m_outsideCounter;

@@ -93,7 +93,7 @@ void SEAL_Policy<B>::OperateKeystream(KeystreamOperation operation, byte *output
 	word32 a, b, c, d, n1, n2, n3, n4;

 	unsigned int p, q;

 

-	assert(IsAlignedOn(m_T.begin(),GetAlignmentOf<word32>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(m_T.begin(),GetAlignmentOf<word32>()));

 	for (size_t iteration = 0; iteration < iterationCount; ++iteration)

 	{

 		#define Ttab(x) *(word32 *)(void*)((byte *)m_T.begin()+x)

diff --git a/secblock.h b/secblock.h
index 375f8209..4cf97068 100644
--- a/secblock.h
+++ b/secblock.h
@@ -118,7 +118,7 @@ typedef typename AllocatorBase<T>::const_reference const_reference;
 template <class T, class A>

 typename A::pointer StandardReallocate(A& alloc, T *oldPtr, typename A::size_type oldSize, typename A::size_type newSize, bool preserve)

 {

-	assert((oldPtr && oldSize) || !(oldPtr || oldSize));

+	CRYPTOPP_ASSERT((oldPtr && oldSize) || !(oldPtr || oldSize));

 	if (oldSize == newSize)

 		return oldPtr;

 

@@ -164,13 +164,13 @@ public:
 	//! \details AlignedAllocate() is used if T_Align16 is true.

 	//!   UnalignedAllocate() used if T_Align16 is false.

 	//! \details This is the C++ *Placement New* operator. ptr is not used, and the function

-	//!   asserts in Debug builds if ptr is non-NULL.

+	//!   CRYPTOPP_ASSERTs in Debug builds if ptr is non-NULL.

 	//! \sa CallNewHandler() for the methods used to recover from a failed

 	//!   allocation attempt.

 	//! \note size is the count of elements, and not the number of bytes

 	pointer allocate(size_type size, const void *ptr = NULL)

 	{

-		CRYPTOPP_UNUSED(ptr); assert(ptr == NULL);

+		CRYPTOPP_UNUSED(ptr); CRYPTOPP_ASSERT(ptr == NULL);

 		this->CheckSize(size);

 		if (size == 0)

 			return NULL;

@@ -194,7 +194,7 @@ public:
 	//!   UnalignedDeallocate() used if T_Align16 is false.

 	void deallocate(void *ptr, size_type size)

 	{

-		assert((ptr && size) || !(ptr || size));

+		CRYPTOPP_ASSERT((ptr && size) || !(ptr || size));

 		SecureWipeArray((pointer)ptr, size);

 

 #if CRYPTOPP_BOOL_ALIGN16

@@ -220,7 +220,7 @@ public:
 	//!   number of bytes.

 	pointer reallocate(T *oldPtr, size_type oldSize, size_type newSize, bool preserve)

 	{

-		assert((oldPtr && oldSize) || !(oldPtr || oldSize));

+		CRYPTOPP_ASSERT((oldPtr && oldSize) || !(oldPtr || oldSize));

 		return StandardReallocate(*this, oldPtr, oldSize, newSize, preserve);

 	}

 

@@ -272,13 +272,13 @@ public:
 	pointer allocate(size_type n, const void* unused = NULL)

 	{

 		CRYPTOPP_UNUSED(n); CRYPTOPP_UNUSED(unused);

-		assert(false); return NULL;

+		CRYPTOPP_ASSERT(false); return NULL;

 	}

 

 	void deallocate(void *p, size_type n)

 	{

 		CRYPTOPP_UNUSED(p); CRYPTOPP_UNUSED(n);

-		assert(false);

+		CRYPTOPP_ASSERT(false);

 	}

 

 	CRYPTOPP_CONSTEXPR size_type max_size() const {return 0;}

@@ -320,7 +320,7 @@ public:
 	//! \sa reallocate(), SecBlockWithHint

 	pointer allocate(size_type size)

 	{

-		assert(IsAlignedOn(m_array, 8));

+		CRYPTOPP_ASSERT(IsAlignedOn(m_array, 8));

 

 		if (size <= S && !m_allocated)

 		{

@@ -367,8 +367,8 @@ public:
 	{

 		if (ptr == GetAlignedArray())

 		{

-			assert(size <= S);

-			assert(m_allocated);

+			CRYPTOPP_ASSERT(size <= S);

+			CRYPTOPP_ASSERT(m_allocated);

 			m_allocated = false;

 			SecureWipeArray((pointer)ptr, size);

 		}

@@ -397,7 +397,7 @@ public:
 	{

 		if (oldPtr == GetAlignedArray() && newSize <= S)

 		{

-			assert(oldSize <= S);

+			CRYPTOPP_ASSERT(oldSize <= S);

 			if (oldSize > newSize)

 				SecureWipeArray(oldPtr+newSize, oldSize-newSize);

 			return oldPtr;

@@ -455,7 +455,7 @@ public:
 	//! \throws std::bad_alloc

 	SecBlock(const SecBlock<T, A> &t)

 		: m_size(t.m_size), m_ptr(m_alloc.allocate(t.m_size, NULL)) {

-			assert((!t.m_ptr && !m_size) || (t.m_ptr && m_size));

+			CRYPTOPP_ASSERT((!t.m_ptr && !m_size) || (t.m_ptr && m_size));

 			if (t.m_ptr) {memcpy_s(m_ptr, m_size*sizeof(T), t.m_ptr, t.m_size*sizeof(T));}

 		}

 

@@ -469,7 +469,7 @@ public:
 	//! \note size is the count of elements, and not the number of bytes

 	SecBlock(const T *ptr, size_type len)

 		: m_size(len), m_ptr(m_alloc.allocate(len, NULL)) {

-			assert((!m_ptr && !m_size) || (m_ptr && m_size));

+			CRYPTOPP_ASSERT((!m_ptr && !m_size) || (m_ptr && m_size));

 			if (ptr && m_ptr)

 				memcpy_s(m_ptr, m_size*sizeof(T), ptr, len*sizeof(T));

 			else if (m_size)

@@ -578,7 +578,7 @@ public:
 	//! \details Internally, this SecBlock calls Grow and then appends t.

 	SecBlock<T, A>& operator+=(const SecBlock<T, A> &t)

 	{

-		assert((!t.m_ptr && !t.m_size) || (t.m_ptr && t.m_size));

+		CRYPTOPP_ASSERT((!t.m_ptr && !t.m_size) || (t.m_ptr && t.m_size));

 

 		if(t.m_size)

 		{

@@ -603,8 +603,8 @@ public:
 	//! \details Internally, a new SecBlock is created from this and a concatenation of t.

 	SecBlock<T, A> operator+(const SecBlock<T, A> &t)

 	{

-		assert((!m_ptr && !m_size) || (m_ptr && m_size));

-		assert((!t.m_ptr && !t.m_size) || (t.m_ptr && t.m_size));

+		CRYPTOPP_ASSERT((!m_ptr && !m_size) || (m_ptr && m_size));

+		CRYPTOPP_ASSERT((!t.m_ptr && !t.m_size) || (t.m_ptr && t.m_size));

 		if(!t.m_size) return SecBlock(*this);

 

 		SecBlock<T, A> result(m_size+t.m_size);

diff --git a/sha.cpp b/sha.cpp
index 2b74b312..f02c0e19 100644
--- a/sha.cpp
+++ b/sha.cpp
@@ -886,8 +886,8 @@ CRYPTOPP_NAKED static void CRYPTOPP_FASTCALL SHA512_SSE2_Transform(word64 *state
 

 void SHA512::Transform(word64 *state, const word64 *data)

 {

-	assert(IsAlignedOn(state, GetAlignmentOf<word64>()));

-	assert(IsAlignedOn(data, GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(state, GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(data, GetAlignmentOf<word64>()));

 

 #if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE && (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32)

 	if (HasSSE2())

diff --git a/sha3.cpp b/sha3.cpp
index 4e383479..435cbd56 100644
--- a/sha3.cpp
+++ b/sha3.cpp
@@ -251,7 +251,7 @@ static void KeccakF1600(word64 *state)
 

 void SHA3::Update(const byte *input, size_t length)

 {

-	assert((input && length) || !(input || length));

+	CRYPTOPP_ASSERT((input && length) || !(input || length));

 	if (!length)

 		return;

 

diff --git a/shark.cpp b/shark.cpp
index 99d63d21..b9bd1307 100644
--- a/shark.cpp
+++ b/shark.cpp
@@ -96,7 +96,7 @@ template <const byte *sbox, const ArrayOf256Word64s *cbox>
 struct SharkProcessAndXorBlock{		// VC60 workaround: problem with template functions

 inline SharkProcessAndXorBlock(const word64 *roundKeys, unsigned int rounds, const byte *inBlock, const byte *xorBlock, byte *outBlock)

 {

-	assert(IsAlignedOn(inBlock,GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(inBlock,GetAlignmentOf<word64>()));

 	word64 tmp = *(word64 *)(void *)inBlock ^ roundKeys[0];

 

 	ByteOrder order = GetNativeByteOrder();

@@ -125,7 +125,7 @@ inline SharkProcessAndXorBlock(const word64 *roundKeys, unsigned int rounds, con
 		(sbox[GETBYTE(tmp, 1)])

 		(sbox[GETBYTE(tmp, 0)]);

 

-	assert(IsAlignedOn(outBlock,GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(outBlock,GetAlignmentOf<word64>()));

 	*(word64 *)(void *)outBlock ^= roundKeys[rounds];

 }};

 

diff --git a/simple.h b/simple.h
index 0c181124..afe06c75 100644
--- a/simple.h
+++ b/simple.h
@@ -97,7 +97,7 @@ public:
 	bool Flush(bool completeFlush, int propagation=-1, bool blocking=true)

 		{return ChannelFlush(DEFAULT_CHANNEL, completeFlush, propagation, blocking);}

 	bool IsolatedFlush(bool hardFlush, bool blocking)

-		{CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking); assert(false); return false;}

+		{CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking); CRYPTOPP_ASSERT(false); return false;}

 	bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true)

 	{

 		if (hardFlush && !InputBufferIsEmpty())

@@ -167,7 +167,7 @@ public:
 

 private:

 	bool IsolatedFlush(bool hardFlush, bool blocking)

-		{CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking); assert(false); return false;}

+		{CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking); CRYPTOPP_ASSERT(false); return false;}

 };

 

 //! \class CustomSignalPropagation

@@ -182,7 +182,7 @@ public:
 

 private:

 	void IsolatedInitialize(const NameValuePairs &parameters)

-		{CRYPTOPP_UNUSED(parameters); assert(false);}

+		{CRYPTOPP_UNUSED(parameters); CRYPTOPP_ASSERT(false);}

 };

 

 //! \class Multichannel

diff --git a/smartptr.h b/smartptr.h
index 1d08bf2d..38e1aeef 100644
--- a/smartptr.h
+++ b/smartptr.h
@@ -238,9 +238,9 @@ public:
 		{delete [] m_ptr;}

 

 	T& operator[](size_t index)

-		{assert(m_size && index<this->m_size); return this->m_ptr[index];}

+		{CRYPTOPP_ASSERT(m_size && index<this->m_size); return this->m_ptr[index];}

 	const T& operator[](size_t index) const

-		{assert(m_size && index<this->m_size); return this->m_ptr[index];}

+		{CRYPTOPP_ASSERT(m_size && index<this->m_size); return this->m_ptr[index];}

 

 	size_t size() const {return this->m_size;}

 	void resize(size_t newSize)

@@ -293,9 +293,9 @@ public:
 		{delete [] this->m_ptr;}

 

 	member_ptr<T>& operator[](size_t index)

-		{assert(index<this->m_size); return this->m_ptr[index];}

+		{CRYPTOPP_ASSERT(index<this->m_size); return this->m_ptr[index];}

 	const member_ptr<T>& operator[](size_t index) const

-		{assert(index<this->m_size); return this->m_ptr[index];}

+		{CRYPTOPP_ASSERT(index<this->m_size); return this->m_ptr[index];}

 

 	size_t size() const {return this->m_size;}

 	void resize(size_t newSize)

diff --git a/socketft.cpp b/socketft.cpp
index ff6e0d40..f9b5bd66 100644
--- a/socketft.cpp
+++ b/socketft.cpp
@@ -68,7 +68,7 @@ Socket::~Socket()
 		}

 		catch (const Exception&)

 		{

-			assert(0);

+			CRYPTOPP_ASSERT(0);

 		}

 	}

 }

@@ -93,7 +93,7 @@ socket_t Socket::DetachSocket()
 

 void Socket::Create(int nType)

 {

-	assert(m_s == INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s == INVALID_SOCKET);

 	m_s = socket(AF_INET, nType, 0);

 	CheckAndHandleError("socket", m_s);

 	m_own = true;

@@ -107,12 +107,12 @@ void Socket::CloseSocket()
 #ifdef USE_WINDOWS_STYLE_SOCKETS

 # if defined(USE_WINDOWS8_API)

 		BOOL result = CancelIoEx((HANDLE) m_s, NULL);

-		assert(result || (!result && GetLastError() == ERROR_NOT_FOUND));

+		CRYPTOPP_ASSERT(result || (!result && GetLastError() == ERROR_NOT_FOUND));

 		CheckAndHandleError_int("closesocket", closesocket(m_s));

-		CRYPTOPP_UNUSED(result);	// Used by assert in debug builds

+		CRYPTOPP_UNUSED(result);	// Used by CRYPTOPP_ASSERT in debug builds

 # else

 		BOOL result = CancelIo((HANDLE) m_s);

-		assert(result || (!result && GetLastError() == ERROR_NOT_FOUND));

+		CRYPTOPP_ASSERT(result || (!result && GetLastError() == ERROR_NOT_FOUND));

 		CheckAndHandleError_int("closesocket", closesocket(m_s));

 		CRYPTOPP_UNUSED(result);

 # endif

@@ -150,20 +150,20 @@ void Socket::Bind(unsigned int port, const char *addr)
 

 void Socket::Bind(const sockaddr *psa, socklen_t saLen)

 {

-	assert(m_s != INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s != INVALID_SOCKET);

 	// cygwin workaround: needs const_cast

 	CheckAndHandleError_int("bind", bind(m_s, const_cast<sockaddr *>(psa), saLen));

 }

 

 void Socket::Listen(int backlog)

 {

-	assert(m_s != INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s != INVALID_SOCKET);

 	CheckAndHandleError_int("listen", listen(m_s, backlog));

 }

 

 bool Socket::Connect(const char *addr, unsigned int port)

 {

-	assert(addr != NULL);

+	CRYPTOPP_ASSERT(addr != NULL);

 

 	sockaddr_in sa;

 	memset(&sa, 0, sizeof(sa));

@@ -180,7 +180,7 @@ bool Socket::Connect(const char *addr, unsigned int port)
 		}

 		else

 		{

-			assert(IsAlignedOn(lphost->h_addr,GetAlignmentOf<in_addr>()));

+			CRYPTOPP_ASSERT(IsAlignedOn(lphost->h_addr,GetAlignmentOf<in_addr>()));

 			sa.sin_addr.s_addr = ((in_addr *)(void *)lphost->h_addr)->s_addr;

 		}

 	}

@@ -192,7 +192,7 @@ bool Socket::Connect(const char *addr, unsigned int port)
 

 bool Socket::Connect(const sockaddr* psa, socklen_t saLen)

 {

-	assert(m_s != INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s != INVALID_SOCKET);

 	int result = connect(m_s, const_cast<sockaddr*>(psa), saLen);

 	if (result == SOCKET_ERROR && GetLastError() == SOCKET_EWOULDBLOCK)

 		return false;

@@ -202,7 +202,7 @@ bool Socket::Connect(const sockaddr* psa, socklen_t saLen)
 

 bool Socket::Accept(Socket& target, sockaddr *psa, socklen_t *psaLen)

 {

-	assert(m_s != INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s != INVALID_SOCKET);

 	socket_t s = accept(m_s, psa, psaLen);

 	if (s == INVALID_SOCKET && GetLastError() == SOCKET_EWOULDBLOCK)

 		return false;

@@ -213,19 +213,19 @@ bool Socket::Accept(Socket& target, sockaddr *psa, socklen_t *psaLen)
 

 void Socket::GetSockName(sockaddr *psa, socklen_t *psaLen)

 {

-	assert(m_s != INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s != INVALID_SOCKET);

 	CheckAndHandleError_int("getsockname", getsockname(m_s, psa, psaLen));

 }

 

 void Socket::GetPeerName(sockaddr *psa, socklen_t *psaLen)

 {

-	assert(m_s != INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s != INVALID_SOCKET);

 	CheckAndHandleError_int("getpeername", getpeername(m_s, psa, psaLen));

 }

 

 unsigned int Socket::Send(const byte* buf, size_t bufLen, int flags)

 {

-	assert(m_s != INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s != INVALID_SOCKET);

 	int result = send(m_s, (const char *)buf, UnsignedMin(INT_MAX, bufLen), flags);

 	CheckAndHandleError_int("send", result);

 	return result;

@@ -233,7 +233,7 @@ unsigned int Socket::Send(const byte* buf, size_t bufLen, int flags)
 

 unsigned int Socket::Receive(byte* buf, size_t bufLen, int flags)

 {

-	assert(m_s != INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s != INVALID_SOCKET);

 	int result = recv(m_s, (char *)buf, UnsignedMin(INT_MAX, bufLen), flags);

 	CheckAndHandleError_int("recv", result);

 	return result;

@@ -241,14 +241,14 @@ unsigned int Socket::Receive(byte* buf, size_t bufLen, int flags)
 

 void Socket::ShutDown(int how)

 {

-	assert(m_s != INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s != INVALID_SOCKET);

 	int result = shutdown(m_s, how);

 	CheckAndHandleError_int("shutdown", result);

 }

 

 void Socket::IOCtl(long cmd, unsigned long *argp)

 {

-	assert(m_s != INVALID_SOCKET);

+	CRYPTOPP_ASSERT(m_s != INVALID_SOCKET);

 #ifdef USE_WINDOWS_STYLE_SOCKETS

 	CheckAndHandleError_int("ioctlsocket", ioctlsocket(m_s, cmd, argp));

 #else

@@ -369,11 +369,11 @@ SocketReceiver::~SocketReceiver()
 #ifdef USE_WINDOWS_STYLE_SOCKETS

 # if defined(USE_WINDOWS8_API)

 	BOOL result = CancelIoEx((HANDLE) m_s.GetSocket(), NULL);

-	assert(result || (!result && GetLastError() == ERROR_NOT_FOUND));

-	CRYPTOPP_UNUSED(result);	// Used by assert in debug builds

+	CRYPTOPP_ASSERT(result || (!result && GetLastError() == ERROR_NOT_FOUND));

+	CRYPTOPP_UNUSED(result);	// Used by CRYPTOPP_ASSERT in debug builds

 # else

 	BOOL result = CancelIo((HANDLE) m_s.GetSocket());

-	assert(result || (!result && GetLastError() == ERROR_NOT_FOUND));

+	CRYPTOPP_ASSERT(result || (!result && GetLastError() == ERROR_NOT_FOUND));

 	CRYPTOPP_UNUSED(result);

 # endif

 #endif

@@ -381,7 +381,7 @@ SocketReceiver::~SocketReceiver()
 

 bool SocketReceiver::Receive(byte* buf, size_t bufLen)

 {

-	assert(!m_resultPending && !m_eofReceived);

+	CRYPTOPP_ASSERT(!m_resultPending && !m_eofReceived);

 

 	DWORD flags = 0;

 	// don't queue too much at once, or we might use up non-paged memory

@@ -459,11 +459,11 @@ SocketSender::~SocketSender()
 #ifdef USE_WINDOWS_STYLE_SOCKETS

 # if defined(USE_WINDOWS8_API)

 	BOOL result = CancelIoEx((HANDLE) m_s.GetSocket(), NULL);

-	assert(result || (!result && GetLastError() == ERROR_NOT_FOUND));

-	CRYPTOPP_UNUSED(result);	// Used by assert in debug builds

+	CRYPTOPP_ASSERT(result || (!result && GetLastError() == ERROR_NOT_FOUND));

+	CRYPTOPP_UNUSED(result);	// Used by CRYPTOPP_ASSERT in debug builds

 # else

 	BOOL result = CancelIo((HANDLE) m_s.GetSocket());

-	assert(result || (!result && GetLastError() == ERROR_NOT_FOUND));

+	CRYPTOPP_ASSERT(result || (!result && GetLastError() == ERROR_NOT_FOUND));

 	CRYPTOPP_UNUSED(result);

 # endif

 #endif

@@ -471,7 +471,7 @@ SocketSender::~SocketSender()
 

 void SocketSender::Send(const byte* buf, size_t bufLen)

 {

-	assert(!m_resultPending);

+	CRYPTOPP_ASSERT(!m_resultPending);

 	DWORD written = 0;

 	// don't queue too much at once, or we might use up non-paged memory

 	WSABUF wsabuf = {UnsignedMin((u_long)128*1024, bufLen), (char *)buf};

@@ -491,7 +491,7 @@ void SocketSender::Send(const byte* buf, size_t bufLen)
 

 void SocketSender::SendEof()

 {

-	assert(!m_resultPending);

+	CRYPTOPP_ASSERT(!m_resultPending);

 	m_s.ShutDown(SD_SEND);

 	m_s.CheckAndHandleError("ResetEvent", ResetEvent(m_event));

 	m_s.CheckAndHandleError_int("WSAEventSelect", WSAEventSelect(m_s, m_event, FD_CLOSE));

diff --git a/socketft.h b/socketft.h
index 61592834..2ebee4db 100644
--- a/socketft.h
+++ b/socketft.h
@@ -94,7 +94,7 @@ public:
 		{if (result == static_cast<socket_t>(SOCKET_ERROR)) HandleError(operation);}

 #ifdef USE_WINDOWS_STYLE_SOCKETS

 	void CheckAndHandleError(const char *operation, BOOL result) const

-		{assert(result==TRUE || result==FALSE); if (!result) HandleError(operation);}

+		{CRYPTOPP_ASSERT(result==TRUE || result==FALSE); if (!result) HandleError(operation);}

 	void CheckAndHandleError(const char *operation, bool result) const

 		{if (!result) HandleError(operation);}

 #endif

@@ -121,7 +121,7 @@ class SocketsInitializer
 {

 public:

 	SocketsInitializer() {Socket::StartSockets();}

-	~SocketsInitializer() {try {Socket::ShutdownSockets();} catch (const Exception&) {assert(0);}}

+	~SocketsInitializer() {try {Socket::ShutdownSockets();} catch (const Exception&) {CRYPTOPP_ASSERT(0);}}

 };

 

 class SocketReceiver : public NetworkReceiver

diff --git a/sosemanuk.cpp b/sosemanuk.cpp
index 2fba4371..366fe358 100644
--- a/sosemanuk.cpp
+++ b/sosemanuk.cpp
@@ -28,7 +28,7 @@ void SosemanukPolicy::CipherSetKey(const NameValuePairs &params, const byte *use
 void SosemanukPolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)

 {

 	CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(iv), CRYPTOPP_UNUSED(length);

-	assert(length==16);

+	CRYPTOPP_ASSERT(length==16);

 

 	word32 a, b, c, d, e;

 

diff --git a/stdcpp.h b/stdcpp.h
index f8f6c783..a176a597 100644
--- a/stdcpp.h
+++ b/stdcpp.h
@@ -44,7 +44,7 @@ namespace std {
 #include <cstddef>

 #include <cstring>

 #include <climits>

-#include <cassert>

+#include "trap.h"

 

 #ifdef CRYPTOPP_INCLUDE_VECTOR_CC

 // workaround needed on Sun Studio 12u1 Sun C++ 5.10 SunOS_i386 128229-02 2009/09/21

diff --git a/strciphr.cpp b/strciphr.cpp
index b8cd2530..a0197c94 100644
--- a/strciphr.cpp
+++ b/strciphr.cpp
@@ -39,7 +39,7 @@ void AdditiveCipherTemplate<S>::GenerateBlock(byte *outString, size_t length)
 		if (!length)

 			return;

 	}

-	assert(m_leftOver == 0);

+	CRYPTOPP_ASSERT(m_leftOver == 0);

 

 	PolicyInterface &policy = this->AccessPolicy();

 	unsigned int bytesPerIteration = policy.GetBytesPerIteration();

@@ -78,7 +78,7 @@ void AdditiveCipherTemplate<S>::ProcessData(byte *outString, const byte *inStrin
 		if (!length)

 			return;

 	}

-	assert(m_leftOver == 0);

+	CRYPTOPP_ASSERT(m_leftOver == 0);

 

 	PolicyInterface &policy = this->AccessPolicy();

 	unsigned int bytesPerIteration = policy.GetBytesPerIteration();

@@ -176,7 +176,7 @@ void CFB_CipherTemplate<BASE>::Resynchronize(const byte *iv, int length)
 template <class BASE>

 void CFB_CipherTemplate<BASE>::ProcessData(byte *outString, const byte *inString, size_t length)

 {

-	assert(length % this->MandatoryBlockSize() == 0);

+	CRYPTOPP_ASSERT(length % this->MandatoryBlockSize() == 0);

 

 	PolicyInterface &policy = this->AccessPolicy();

 	unsigned int bytesPerIteration = policy.GetBytesPerIteration();

@@ -196,7 +196,7 @@ void CFB_CipherTemplate<BASE>::ProcessData(byte *outString, const byte *inString
 	if (!length)

 		return;

 

-	assert(m_leftOver == 0);

+	CRYPTOPP_ASSERT(m_leftOver == 0);

 

 	if (policy.CanIterate() && length >= bytesPerIteration && IsAlignedOn(outString, alignment))

 	{

diff --git a/strciphr.h b/strciphr.h
index d0d1e8a7..9d1e093a 100644
--- a/strciphr.h
+++ b/strciphr.h
@@ -151,7 +151,7 @@ struct CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AdditiveCipherAbstractPolicy
 	//!   which will be derived from GetBytesPerIteration().

 	//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream(), KeystreamOperation()

 	virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount)

-		{CRYPTOPP_UNUSED(operation); CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(iterationCount); assert(false);}

+		{CRYPTOPP_UNUSED(operation); CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(iterationCount); CRYPTOPP_ASSERT(false);}

 

 	//! \brief Key the cipher

 	//! \param params set of NameValuePairs use to initialize this object

@@ -175,7 +175,7 @@ struct CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AdditiveCipherAbstractPolicy
 	//! \returns iterationCount

 	//! \sa CipherIsRandomAccess()

 	virtual void SeekToIteration(lword iterationCount)

-		{CRYPTOPP_UNUSED(iterationCount); assert(!CipherIsRandomAccess()); throw NotImplemented("StreamTransformation: this object doesn't support random access");}

+		{CRYPTOPP_UNUSED(iterationCount); CRYPTOPP_ASSERT(!CipherIsRandomAccess()); throw NotImplemented("StreamTransformation: this object doesn't support random access");}

 };

 

 //! \class AdditiveCipherConcretePolicy

@@ -382,7 +382,7 @@ public:
 	//! \sa IsSelfInverting() and IsForwardTransformation()

 	virtual void Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount)

 		{CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(dir); CRYPTOPP_UNUSED(iterationCount);

-		 assert(false); /*throw 0;*/ throw Exception(Exception::OTHER_ERROR, "SimpleKeyingInterface: unexpected error");}

+		 CRYPTOPP_ASSERT(false); /*throw 0;*/ throw Exception(Exception::OTHER_ERROR, "SimpleKeyingInterface: unexpected error");}

 

 	//! \brief Key the cipher

 	//! \param params set of NameValuePairs use to initialize this object

@@ -441,8 +441,8 @@ struct CRYPTOPP_NO_VTABLE CFB_CipherConcretePolicy : public BASE
 		//! \returns reference to the next feedback register word

 		inline RegisterOutput& operator()(WordType &registerWord)

 		{

-			assert(IsAligned<WordType>(m_output));

-			assert(IsAligned<WordType>(m_input));

+			CRYPTOPP_ASSERT(IsAligned<WordType>(m_output));

+			CRYPTOPP_ASSERT(IsAligned<WordType>(m_input));

 

 			if (!NativeByteOrderIs(B::ToEnum()))

 				registerWord = ByteReverse(registerWord);

@@ -450,7 +450,9 @@ struct CRYPTOPP_NO_VTABLE CFB_CipherConcretePolicy : public BASE
 			if (m_dir == ENCRYPTION)

 			{

 				if (m_input == NULL)

-					assert(m_output == NULL);

+				{

+					CRYPTOPP_ASSERT(m_output == NULL);

+				}

 				else

 				{

 					WordType ct = *(const WordType *)m_input ^ registerWord;

diff --git a/tea.cpp b/tea.cpp
index dba159f6..3c0daa4c 100644
--- a/tea.cpp
+++ b/tea.cpp
@@ -106,8 +106,8 @@ void XTEA::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, by
 void BTEA::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const

 {

 	CRYPTOPP_UNUSED(xorBlock);

-	assert(IsAlignedOn(inBlock,GetAlignmentOf<word32>()));

-	assert(IsAlignedOn(outBlock,GetAlignmentOf<word32>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(inBlock,GetAlignmentOf<word32>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(outBlock,GetAlignmentOf<word32>()));

 

 	unsigned int n = m_blockSize / 4;

 	word32 *v = (word32*)(void *)outBlock;

@@ -136,8 +136,8 @@ void BTEA::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, by
 void BTEA::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const

 {

 	CRYPTOPP_UNUSED(xorBlock);

-	assert(IsAlignedOn(inBlock,GetAlignmentOf<word32>()));

-	assert(IsAlignedOn(outBlock,GetAlignmentOf<word32>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(inBlock,GetAlignmentOf<word32>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(outBlock,GetAlignmentOf<word32>()));

 

 	unsigned int n = m_blockSize / 4;

 	word32 *v = (word32*)(void *)outBlock;

diff --git a/test.cpp b/test.cpp
index bf0ddc02..52dd740a 100644
--- a/test.cpp
+++ b/test.cpp
@@ -21,6 +21,7 @@
 #include "whrlpool.h"

 #include "tiger.h"

 #include "smartptr.h"

+#include "trap.h"

 

 #include "validate.h"

 #include "bench.h"

@@ -128,6 +129,11 @@ RandomNumberGenerator & GlobalRNG()
 	return dynamic_cast<RandomNumberGenerator&>(s_globalRNG);

 }

 

+// See misc.h and trap.h for comments and usage

+#if CRYPTOPP_DEBUG && (defined(CRYPTOPP_BSD_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE))

+static const SignalHandler<SIGTRAP, false> s_dummyHandler;

+#endif

+

 int CRYPTOPP_API main(int argc, char *argv[])

 {

 #ifdef _CRTDBG_LEAK_CHECK_DF

@@ -271,7 +277,7 @@ int CRYPTOPP_API main(int argc, char *argv[])
 

 			// compute MAC

 			member_ptr<MessageAuthenticationCode> pMac(NewIntegrityCheckingMAC());

-			assert(pMac->DigestSize() == sizeof(mac));

+			CRYPTOPP_ASSERT(pMac->DigestSize() == sizeof(mac));

 			MeterFilter f(new HashFilter(*pMac, new ArraySink(mac, sizeof(mac))));

 			f.AddRangeToSkip(0, checksumPos, 4);

 			f.AddRangeToSkip(0, certificateTableDirectoryPos, 8);

@@ -628,7 +634,7 @@ void DecryptFile(const char *in, const char *out, const char *passPhrase)
 

 void SecretShareFile(int threshold, int nShares, const char *filename, const char *seed)

 {

-	assert(nShares >= 1 && nShares<=1000);

+	CRYPTOPP_ASSERT(nShares >= 1 && nShares<=1000);

 	if (nShares < 1 || nShares > 1000)

 		throw InvalidArgument("SecretShareFile: " + IntToString(nShares) + " is not in range [1, 1000]");

 

@@ -658,7 +664,7 @@ void SecretShareFile(int threshold, int nShares, const char *filename, const cha
 

 void SecretRecoverFile(int threshold, const char *outFilename, char *const *inFilenames)

 {

-	assert(threshold >= 1 && threshold <=1000);

+	CRYPTOPP_ASSERT(threshold >= 1 && threshold <=1000);

 	if (threshold < 1 || threshold > 1000)

 		throw InvalidArgument("SecretRecoverFile: " + IntToString(threshold) + " is not in range [1, 1000]");

 

@@ -685,7 +691,7 @@ void SecretRecoverFile(int threshold, const char *outFilename, char *const *inFi
 

 void InformationDisperseFile(int threshold, int nShares, const char *filename)

 {

-	assert(threshold >= 1 && threshold <=1000);

+	CRYPTOPP_ASSERT(threshold >= 1 && threshold <=1000);

 	if (threshold < 1 || threshold > 1000)

 		throw InvalidArgument("InformationDisperseFile: " + IntToString(nShares) + " is not in range [1, 1000]");

 

@@ -712,7 +718,7 @@ void InformationDisperseFile(int threshold, int nShares, const char *filename)
 

 void InformationRecoverFile(int threshold, const char *outFilename, char *const *inFilenames)

 {

-	assert(threshold<=1000);

+	CRYPTOPP_ASSERT(threshold<=1000);

 	if (threshold < 1 || threshold > 1000)

 		throw InvalidArgument("InformationRecoverFile: " + IntToString(threshold) + " is not in range [1, 1000]");

 

@@ -811,7 +817,7 @@ void ForwardTcpPort(const char *sourcePortName, const char *destinationHost, con
 	sockListen.Bind(sourcePort);

 

 	int err = setsockopt(sockListen, IPPROTO_TCP, TCP_NODELAY, "\x01", 1);

-	assert(err == 0);

+	CRYPTOPP_ASSERT(err == 0);

 	if(err != 0)

 		throw Socket::Err(sockListen, "setsockopt", sockListen.GetLastError());

 

@@ -963,9 +969,9 @@ bool Validate(int alg, bool thorough, const char *seedInput)
 

 	const time_t endTime = time(NULL);

 	err = localtime_s(&localTime, &endTime);

-	assert(err == 0);

+	CRYPTOPP_ASSERT(err == 0);

 	err = asctime_s(timeBuf, sizeof(timeBuf), &localTime);

-	assert(err == 0);

+	CRYPTOPP_ASSERT(err == 0);

 

 	cout << "\nTest ended at " << timeBuf;

 #else

diff --git a/trap.h b/trap.h
index 63985840..7a5d4a39 100644
--- a/trap.h
+++ b/trap.h
@@ -1,28 +1,28 @@
 // trap.h - written and placed in public domain by Jeffrey Walton.

 //          Copyright assigned to Crypto++ project

 

+//! \file trap.h

+//! \brief Debugging and diagnostic assertions

+//! \details <tt>CRYPTOPP_ASSERT</tt> is the library's debugging and diagnostic assertion. <tt>CRYPTOPP_ASSERT</tt>

+//!   is enabled by <tt>CRYPTOPP_DEBUG</tt>, <tt>DEBUG</tt> or <tt>_DEBUG</tt>.

+//! \details <tt>CRYPTOPP_ASSERT</tt> raises a <tt>SIGTRAP</tt> (Unix) or calls <tt>DebugBreak()</tt> (Windows).

+//!   <tt>CRYPTOPP_ASSERT</tt> is only in effect when the user requests a debug configuration. Unlike Posix assert,

+//!   <tt>NDEBUG</tt> (or failure to define it) does not affect the library.

+//! The traditional Posix define <tt>NDEBUG</tt> has no effect on <tt>CRYPTOPP_DEBUG</tt> or DebugTrapHandler.

+//! \since Crypto++ 5.6.5

+//! \sa DebugTrapHandler, <A HREF="http://github.com/weidai11/cryptopp/issues/277">Issue 277</A>,

+//!   <A HREF="http://seclists.org/oss-sec/2016/q3/520">CVE-2016-7420</A>

+

 #ifndef CRYPTOPP_TRAP_H

 #define CRYPTOPP_TRAP_H

 

 #include "config.h"

 

-// CRYPTOPP_POSIX_ASSERT unconditionally disables the library assert and yields

-//   to Posix assert. CRYPTOPP_POSIX_ASSERT can be set in config.h. if you want

-//   to disable asserts, then define NDEBUG or _NDEBUG when building the library.

-

-// Needed for NDEBUG and CRYPTOPP_POSIX_ASSERT

-#include <cassert>

-

-#if defined(CRYPTOPP_DEBUG)

+#if CRYPTOPP_DEBUG

 #  include <iostream>

 #  include <sstream>

 #  if defined(CRYPTOPP_WIN32_AVAILABLE)

-#    pragma push_macro("WIN32_LEAN_AND_MEAN")

-#    pragma push_macro("_WIN32_WINNT")

-#    pragma push_macro("NOMINMAX")

 #    define WIN32_LEAN_AND_MEAN

-#    define _WIN32_WINNT 0x0400

-#    define NOMINMAX

 #    include <Windows.h>

 #  elif defined(CRYPTOPP_BSD_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE)

 #    include <signal.h>

@@ -31,11 +31,37 @@
 

 // ************** run-time assertion ***************

 

-// See test.cpp and DebugTrapHandler for code to install a null signal handler

-// for SIGTRAP on BSD, Linux and Unix. The handler installs itself during

-// initialization of the test program.

+#if defined(CRYPTOPP_DOXYGEN_PROCESSING)

+//! \brief Debugging and diagnostic assertion

+//! \details <tt>CRYPTOPP_ASSERT</tt> is the library's debugging and diagnostic assertion. <tt>CRYPTOPP_ASSERT</tt>

+//!   is enabled by the preprocessor macros <tt>CRYPTOPP_DEBUG</tt>, <tt>DEBUG</tt> or <tt>_DEBUG</tt>.

+//! \details <tt>CRYPTOPP_ASSERT</tt> raises a <tt>SIGTRAP</tt> (Unix) or calls <tt>DebugBreak()</tt> (Windows).

+//!   <tt>CRYPTOPP_ASSERT</tt> is only in effect when the user explictly requests a debug configuration.

+//! \details If you want to ensure <tt>CRYPTOPP_ASSERT</tt> is inert, then <em>do not</em> define

+//!   <tt>CRYPTOPP_DEBUG</tt>, <tt>DEBUG</tt> or <tt>_DEBUG</tt>. Avoiding the defines means <tt>CRYPTOPP_ASSERT</tt>

+//!   is processed into <tt>((void)(exp))</tt>.

+//! \details The traditional Posix define <tt>NDEBUG</tt> has no effect on <tt>CRYPTOPP_DEBUG</tt>, <tt>CRYPTOPP_ASSERT</tt>

+//!   or DebugTrapHandler.

+//! \details An example of using \ref CRYPTOPP_ASSERT "CRYPTOPP_ASSERT" and DebugTrapHandler is shown below. The library's

+//!   test program, <tt>cryptest.exe</tt> (from test.cpp), exercises the structure:

+//!  <pre>

+//!    #if CRYPTOPP_DEBUG && (defined(CRYPTOPP_BSD_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE))

+//!    static const DebugTrapHandler g_dummyHandler;

+//!    #endif

+//!

+//!    int main(int argc, char* argv[])

+//!    {

+//!       CRYPTOPP_ASSERT(argv != nullptr);

+//!       ...

+//!    }

+//!  </pre>

+//! \since Crypto++ 5.6.5

+//! \sa DebugTrapHandler, SignalHandler, <A HREF="http://github.com/weidai11/cryptopp/issues/277">Issue 277</A>,

+//!   <A HREF="http://seclists.org/oss-sec/2016/q3/520">CVE-2016-7420</A>

+#  define CRYPTOPP_ASSERT(exp) { ... }

+#endif

 

-#if defined(CRYPTOPP_DEBUG) && (defined(CRYPTOPP_BSD_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE))

+#if CRYPTOPP_DEBUG && (defined(CRYPTOPP_BSD_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE))

 #  define CRYPTOPP_ASSERT(exp) {                                  \

     if (!(exp)) {                                                 \

       std::ostringstream oss;                                     \

@@ -46,26 +72,106 @@
       raise(SIGTRAP);                                             \

     }                                                             \

   }

-#elif defined(CRYPTOPP_DEBUG) && defined(CRYPTOPP_WIN32_AVAILABLE)

+#elif CRYPTOPP_DEBUG && defined(CRYPTOPP_WIN32_AVAILABLE)

 #  define CRYPTOPP_ASSERT(exp) {                                  \

     if (!(exp)) {                                                 \

       std::ostringstream oss;                                     \

       oss << "Assertion failed: " << (char*)(__FILE__) << "("     \

           << (int)(__LINE__) << "): " << (char*)(__FUNCTION__)    \

           << std::endl;                                           \

-      DebugBreak();                                               \

       std::cerr << oss.str();                                     \

+      DebugBreak();                                               \

     }                                                             \

   }

-// Fallback to original behavior for NDEBUG (and non-Windows/non-Unix builds)

-#else

-#  define CRYPTOPP_ASSERT(exp) assert(exp)

 #endif // DEBUG and Unix or Windows

 

-#if defined(CRYPTOPP_DEBUG) && defined(CRYPTOPP_WIN32_AVAILABLE)

-#  pragma pop_macro("WIN32_LEAN_AND_MEAN")

-#  pragma pop_macro("_WIN32_WINNT")

-#  pragma pop_macro("NOMINMAX")

+// Remove CRYPTOPP_ASSERT in non-debug builds.

+//  Can't use CRYPTOPP_UNUSED due to circular dependency

+#ifndef CRYPTOPP_ASSERT

+#  define CRYPTOPP_ASSERT(exp) ((void)(exp))

 #endif

 

+NAMESPACE_BEGIN(CryptoPP)

+

+// ************** SIGTRAP handler ***************

+

+#if (CRYPTOPP_DEBUG && (defined(CRYPTOPP_BSD_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE))) || defined(CRYPTOPP_DOXYGEN_PROCESSING)

+//! \brief Default SIGTRAP handler

+//! \details DebugTrapHandler() can be used by a program to install an empty SIGTRAP handler. If present,

+//!   the handler ensures there is a signal handler in place for <tt>SIGTRAP</tt> raised by

+//!   <tt>CRYPTOPP_ASSERT</tt>. If <tt>CRYPTOPP_ASSERT</tt> raises <tt>SIGTRAP</tt> <em>without</em>

+//!   a handler, then one of two things can occur. First, the OS might allow the program

+//!   to continue. Second, the OS might terminate the program. OS X allows the program to continue, while

+//!   some Linuxes terminate the program.

+//! \details If DebugTrapHandler detects another handler in place, then it will not install a handler. This

+//!   ensures a debugger can gain control of the <tt>SIGTRAP</tt> signal without contention. It also allows multiple

+//!   DebugTrapHandler to be created without contentious or unusual behavior. Though muliple DebugTrapHandler can be

+//!   created, a program should only create one, if needed.

+//! \details A DebugTrapHandler is subject to C++ static initialization [dis]order. If you need to install a handler

+//!   and it must be installed early, then reference the code associated with <tt>CRYPTOPP_INIT_PRIORITY</tt> in

+//!   cryptlib.cpp and cpu.cpp.

+//! \details If you want to ensure <tt>CRYPTOPP_ASSERT</tt> is inert, then <em>do not</em> define

+//!   <tt>CRYPTOPP_DEBUG</tt>, <tt>DEBUG</tt> or <tt>_DEBUG</tt>. Avoiding the defines means <tt>CRYPTOPP_ASSERT</tt>

+//!   is processed into <tt>((void)(exp))</tt>.

+//! \details The traditional Posix define <tt>NDEBUG</tt> has no effect on <tt>CRYPTOPP_DEBUG</tt>, <tt>CRYPTOPP_ASSERT</tt>

+//!   or DebugTrapHandler.

+//! \details An example of using \ref CRYPTOPP_ASSERT "CRYPTOPP_ASSERT" and DebugTrapHandler is shown below. The library's

+//!   test program, <tt>cryptest.exe</tt> (from test.cpp), exercises the structure:

+//!  <pre>

+//!    #if CRYPTOPP_DEBUG && (defined(CRYPTOPP_BSD_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE))

+//!    static const DebugTrapHandler g_dummyHandler;

+//!    #endif

+//!

+//!    int main(int argc, char* argv[])

+//!    {

+//!       CRYPTOPP_ASSERT(argv != nullptr);

+//!       ...

+//!    }

+//!  </pre>

+//! \since Crypto++ 5.6.5

+//! \sa \ref CRYPTOPP_ASSERT "CRYPTOPP_ASSERT", SignalHandler, <A HREF="http://github.com/weidai11/cryptopp/issues/277">Issue 277</A>,

+//!   <A HREF="http://seclists.org/oss-sec/2016/q3/520">CVE-2016-7420</A>

+struct DebugTrapHandler

+{

+    DebugTrapHandler()

+    {

+        // http://pubs.opengroup.org/onlinepubs/007908799/xsh/sigaction.html

+        struct sigaction old_handler, new_handler;

+        memset(&old_handler, 0x00, sizeof(old_handler));

+		memset(&new_handler, 0x00, sizeof(new_handler));

+

+        do

+        {

+            int ret = 0;

+

+            ret = sigaction (SIGTRAP, 0, &old_handler);

+            if (ret != 0) break; // Failed

+

+            // Don't step on another's handler

+            if (old_handler.sa_handler != 0) break;

+

+            // Set up the structure to specify the NULL action.

+            new_handler.sa_handler = &DebugTrapHandler::NullHandler;

+            new_handler.sa_flags = 0;

+

+            ret = sigemptyset (&new_handler.sa_mask);

+            if (ret != 0) break; // Failed

+

+            // Install it

+            ret = sigaction (SIGTRAP, &new_handler, 0);

+            if (ret != 0) break; // Failed

+

+        } while(0);

+    }

+

+    static void NullHandler(int /*unused*/) { }

+

+private:

+    DebugTrapHandler(const DebugTrapHandler &);

+    void operator=(const DebugTrapHandler &);

+};

+#endif  // DebugTrapHandler

+

+NAMESPACE_END

+

 #endif // CRYPTOPP_TRAP_H

diff --git a/trdlocal.cpp b/trdlocal.cpp
index 12386abe..0d9d42f1 100644
--- a/trdlocal.cpp
+++ b/trdlocal.cpp
@@ -30,13 +30,13 @@ ThreadLocalStorage::ThreadLocalStorage()
 {

 #ifdef HAS_WINTHREADS

 	m_index = TlsAlloc();

-	assert(m_index != TLS_OUT_OF_INDEXES);

+	CRYPTOPP_ASSERT(m_index != TLS_OUT_OF_INDEXES);

 	if (m_index == TLS_OUT_OF_INDEXES)

 		throw Err("TlsAlloc", GetLastError());

 #else

 	m_index = 0;

 	int error = pthread_key_create(&m_index, NULL);

-	assert(!error);

+	CRYPTOPP_ASSERT(!error);

 	if (error)

 		throw Err("pthread_key_create", error);

 #endif

@@ -52,14 +52,14 @@ ThreadLocalStorage::~ThreadLocalStorage() CRYPTOPP_THROW
 #ifdef HAS_WINTHREADS

 	{

 		int rc = TlsFree(m_index);

-		assert(rc);

+		CRYPTOPP_ASSERT(rc);

 		if (!rc)

 			throw Err("TlsFree", GetLastError());

 	}

 #else

 	{

 		int error = pthread_key_delete(m_index);

-		assert(!error);

+		CRYPTOPP_ASSERT(!error);

 		if (error)

 			throw Err("pthread_key_delete", error);

 	}

@@ -89,7 +89,7 @@ void *ThreadLocalStorage::GetValue() const
 	void *result = TlsGetValue(m_index);

 	const DWORD dwRet = GetLastError();

 

-	assert(result || (!result && (dwRet == NO_ERROR)));

+	CRYPTOPP_ASSERT(result || (!result && (dwRet == NO_ERROR)));

 	if (!result && dwRet != NO_ERROR)

 		throw Err("TlsGetValue", dwRet);

 #else

diff --git a/validat1.cpp b/validat1.cpp
index 36c888dd..9f382e33 100644
--- a/validat1.cpp
+++ b/validat1.cpp
@@ -216,7 +216,7 @@ bool TestSettings()
 	}

 

 #ifdef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS

-	// Don't assert the alignment of testvals. That's what this test is for.

+	// Don't CRYPTOPP_ASSERT the alignment of testvals. That's what this test is for.

 	byte testvals[10] = {1,2,2,3,3,3,3,2,2,1};

 	if (*(word32 *)(void *)(testvals+3) == 0x03030303 && *(word64 *)(void *)(testvals+1) == W64LIT(0x0202030303030202))

 		cout << "passed:  Your machine allows unaligned data access.\n";

@@ -1580,7 +1580,7 @@ bool TestRDRAND()
 		RandomNumberSource rns(rdrand, SIZE, true, new Redirector(chsw));

 		deflator.Flush(true);

 

-		assert(0 == maurer.BytesNeeded());

+		CRYPTOPP_ASSERT(0 == maurer.BytesNeeded());

 		const double mv = maurer.GetTestValue();

 		if (mv < 0.98f)

 		{

@@ -1659,7 +1659,7 @@ bool TestRDSEED()
 		RandomNumberSource rns(rdseed, SIZE, true, new Redirector(chsw));

 		deflator.Flush(true);

 

-		assert(0 == maurer.BytesNeeded());

+		CRYPTOPP_ASSERT(0 == maurer.BytesNeeded());

 		const double mv = maurer.GetTestValue();

 		if (mv < 0.98f)

 		{

@@ -1803,7 +1803,7 @@ public:
 		{

 			std::cerr << "incorrect output " << counter << ", " << (word16)validOutput[counter] << ", " << (word16)inByte << "\n";

 			fail = true;

-			assert(false);

+			CRYPTOPP_ASSERT(false);

 		}

 		counter++;

 	}

@@ -1818,7 +1818,7 @@ public:
 			if (counter != outputLen)

 			{

 				fail = true;

-				assert(false);

+				CRYPTOPP_ASSERT(false);

 			}

 

 		return 0;

diff --git a/validat2.cpp b/validat2.cpp
index ccea46f1..307a19ad 100644
--- a/validat2.cpp
+++ b/validat2.cpp
@@ -711,7 +711,7 @@ bool ValidateDSA(bool thorough)
 	DSA::Verifier pub(priv);

 	FileSource fs2(CRYPTOPP_DATA_DIR "TestData/dsa1024b.dat", true, new HexDecoder());

 	DSA::Verifier pub1(fs2);

-	assert(pub.GetKey() == pub1.GetKey());

+	CRYPTOPP_ASSERT(pub.GetKey() == pub1.GetKey());

 	pass = SignatureValidate(priv, pub, thorough) && pass;

 	pass = RunTestDataFile(CRYPTOPP_DATA_DIR "TestVectors/dsa.txt", g_nullNameValuePairs, thorough) && pass;

 

diff --git a/vmac.cpp b/vmac.cpp
index 1fa58f1c..a6662f21 100644
--- a/vmac.cpp
+++ b/vmac.cpp
@@ -87,7 +87,7 @@ void VMAC_Base::UncheckedSetKey(const byte *userKey, unsigned int keylength, con
 	in[0] = 0xE0;

 	in[15] = 0;

 	word64 *l3Key = m_l3Key();

-	assert(IsAlignedOn(l3Key,GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(l3Key,GetAlignmentOf<word64>()));

 

 	for (i = 0; i <= (size_t)m_is128; i++)

 		do

@@ -147,7 +147,7 @@ void VMAC_Base::Resynchronize(const byte *nonce, int len)
 void VMAC_Base::HashEndianCorrectedBlock(const word64 *data)

 {

 	CRYPTOPP_UNUSED(data);

-	assert(false);

+	CRYPTOPP_ASSERT(false);

 	throw NotImplemented("VMAC: HashEndianCorrectedBlock is not implemented");

 }

 

@@ -170,8 +170,8 @@ __attribute__ ((noinline))		// Intel Compiler 9.1 workaround
 #endif

 VMAC_Base::VHASH_Update_SSE2(const word64 *data, size_t blocksRemainingInWord64, int tagPart)

 {

-	assert(IsAlignedOn(m_polyState(),GetAlignmentOf<word64>()));

-	assert(IsAlignedOn(m_nhKey(),GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(m_polyState(),GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(m_nhKey(),GetAlignmentOf<word64>()));

 

 	const word64 *nhK = m_nhKey();

 	word64 *polyS = (word64*)(void*)m_polyState();

@@ -538,8 +538,8 @@ template <bool T_128BitTag>
 #endif

 void VMAC_Base::VHASH_Update_Template(const word64 *data, size_t blocksRemainingInWord64)

 {

-	assert(IsAlignedOn(m_polyState(),GetAlignmentOf<word64>()));

-	assert(IsAlignedOn(m_nhKey(),GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(m_polyState(),GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(m_nhKey(),GetAlignmentOf<word64>()));

 

 	#define INNER_LOOP_ITERATION(j)	{\

 		word64 d0 = ConditionalByteReverse(LITTLE_ENDIAN_ORDER, data[i+2*j+0]);\

@@ -870,8 +870,8 @@ static word64 L3Hash(const word64 *input, const word64 *l3Key, size_t len)
 

 void VMAC_Base::TruncatedFinal(byte *mac, size_t size)

 {

-	assert(IsAlignedOn(DataBuf(),GetAlignmentOf<word64>()));

-	assert(IsAlignedOn(m_polyState(),GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(DataBuf(),GetAlignmentOf<word64>()));

+	CRYPTOPP_ASSERT(IsAlignedOn(m_polyState(),GetAlignmentOf<word64>()));

 	size_t len = ModPowerOf2(GetBitCountLo()/8, m_L1KeyLength);

 

 	if (len)

diff --git a/wait.cpp b/wait.cpp
index f559b9d4..3c3195c9 100644
--- a/wait.cpp
+++ b/wait.cpp
@@ -152,15 +152,15 @@ WaitObjectContainer::~WaitObjectContainer()
 			}

 

 			BOOL bResult = PulseEvent(m_startWaiting);

-			assert(bResult != 0); CRYPTOPP_UNUSED(bResult);

+			CRYPTOPP_ASSERT(bResult != 0); CRYPTOPP_UNUSED(bResult);

 

 			// Enterprise Analysis warning

 #if defined(USE_WINDOWS8_API)

 			DWORD dwResult = ::WaitForMultipleObjectsEx((DWORD)m_threads.size(), threadHandles, TRUE, INFINITE, FALSE);

-			assert((dwResult >= WAIT_OBJECT_0) && (dwResult < (DWORD)m_threads.size()));

+			CRYPTOPP_ASSERT((dwResult >= WAIT_OBJECT_0) && (dwResult < (DWORD)m_threads.size()));

 #else

 			DWORD dwResult = ::WaitForMultipleObjects((DWORD)m_threads.size(), threadHandles, TRUE, INFINITE);

-			assert((dwResult >= WAIT_OBJECT_0) && (dwResult < (DWORD)m_threads.size()));

+			CRYPTOPP_ASSERT((dwResult >= WAIT_OBJECT_0) && (dwResult < (DWORD)m_threads.size()));

 #endif

 

 			for (i=0; i<m_threads.size(); i++)

@@ -169,18 +169,18 @@ WaitObjectContainer::~WaitObjectContainer()
 				if (!threadHandles[i]) continue;

 

 				bResult = CloseHandle(threadHandles[i]);

-				assert(bResult != 0);

+				CRYPTOPP_ASSERT(bResult != 0);

 			}

 

 			bResult = CloseHandle(m_startWaiting);

-			assert(bResult != 0);

+			CRYPTOPP_ASSERT(bResult != 0);

 			bResult = CloseHandle(m_stopWaiting);

-			assert(bResult != 0);

+			CRYPTOPP_ASSERT(bResult != 0);

 		}

 	}

 	catch (const Exception&)

 	{

-		assert(0);

+		CRYPTOPP_ASSERT(0);

 	}

 }

 

@@ -201,10 +201,10 @@ DWORD WINAPI WaitingThread(LPVOID lParam)
 		thread.waitingToWait = true;

 #if defined(USE_WINDOWS8_API)

 		DWORD result = ::WaitForSingleObjectEx(thread.startWaiting, INFINITE, FALSE);

-		assert(result != WAIT_FAILED);

+		CRYPTOPP_ASSERT(result != WAIT_FAILED);

 #else

 		DWORD result = ::WaitForSingleObject(thread.startWaiting, INFINITE);

-		assert(result != WAIT_FAILED);

+		CRYPTOPP_ASSERT(result != WAIT_FAILED);

 #endif

 

 		thread.waitingToWait = false;

@@ -219,10 +219,10 @@ DWORD WINAPI WaitingThread(LPVOID lParam)
 

 #if defined(USE_WINDOWS8_API)

 		result = ::WaitForMultipleObjectsEx((DWORD)handles.size(), &handles[0], FALSE, INFINITE, FALSE);

-		assert(result != WAIT_FAILED);

+		CRYPTOPP_ASSERT(result != WAIT_FAILED);

 #else

 		result = ::WaitForMultipleObjects((DWORD)handles.size(), &handles[0], FALSE, INFINITE);

-		assert(result != WAIT_FAILED);

+		CRYPTOPP_ASSERT(result != WAIT_FAILED);

 #endif

 

 		if (result == WAIT_OBJECT_0)

@@ -230,7 +230,7 @@ DWORD WINAPI WaitingThread(LPVOID lParam)
 		SetEvent(thread.stopWaiting);

 		if (!(result > WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + handles.size()))

 		{

-			assert(!"error in WaitingThread");	// break here so we can see which thread has an error

+			CRYPTOPP_ASSERT(!"error in WaitingThread");	// break here so we can see which thread has an error

 			*thread.error = ::GetLastError();

 		}

 	}

@@ -328,10 +328,10 @@ bool WaitObjectContainer::Wait(unsigned long milliseconds)
 

 #if defined(USE_WINDOWS8_API)

 		DWORD result = ::WaitForSingleObjectEx(m_stopWaiting, milliseconds, FALSE);

-		assert(result != WAIT_FAILED);

+		CRYPTOPP_ASSERT(result != WAIT_FAILED);

 #else

 		DWORD result = ::WaitForSingleObject(m_stopWaiting, milliseconds);

-		assert(result != WAIT_FAILED);

+		CRYPTOPP_ASSERT(result != WAIT_FAILED);

 #endif

 

 		if (result == WAIT_OBJECT_0)

@@ -359,10 +359,10 @@ bool WaitObjectContainer::Wait(unsigned long milliseconds)
 #endif

 #if defined(USE_WINDOWS8_API)

 		DWORD result = ::WaitForMultipleObjectsEx((DWORD)m_handles.size(), &m_handles[0], FALSE, milliseconds, FALSE);

-		assert(result != WAIT_FAILED);

+		CRYPTOPP_ASSERT(result != WAIT_FAILED);

 #else

 		DWORD result = ::WaitForMultipleObjects((DWORD)m_handles.size(), &m_handles[0], FALSE, milliseconds);

-		assert(result != WAIT_FAILED);

+		CRYPTOPP_ASSERT(result != WAIT_FAILED);

 #endif

 #if TRACE_WAIT

 		if (milliseconds > 0)

diff --git a/winpipes.cpp b/winpipes.cpp
index 0b4846d0..ca0ed568 100644
--- a/winpipes.cpp
+++ b/winpipes.cpp
@@ -34,7 +34,7 @@ WindowsHandle::~WindowsHandle()
 		}

 		catch (const Exception&)

 		{

-			assert(0);

+			CRYPTOPP_ASSERT(0);

 		}

 	}

 }

@@ -99,7 +99,7 @@ WindowsPipeReceiver::WindowsPipeReceiver()
 

 bool WindowsPipeReceiver::Receive(byte* buf, size_t bufLen)

 {

-	assert(!m_resultPending && !m_eofReceived);

+	CRYPTOPP_ASSERT(!m_resultPending && !m_eofReceived);

 

 	const HANDLE h = GetHandle();

 	// don't queue too much at once, or we might use up non-paged memory

diff --git a/winpipes.h b/winpipes.h
index 246fb91b..f7335ffe 100644
--- a/winpipes.h
+++ b/winpipes.h
@@ -55,7 +55,7 @@ protected:
 	virtual HANDLE GetHandle() const =0;

 	virtual void HandleError(const char *operation) const;

 	void CheckAndHandleError(const char *operation, BOOL result) const

-		{assert(result==TRUE || result==FALSE); if (!result) HandleError(operation);}

+		{CRYPTOPP_ASSERT(result==TRUE || result==FALSE); if (!result) HandleError(operation);}

 };

 

 //! \brief Pipe-based implementation of NetworkReceiver

diff --git a/words.h b/words.h
index 5a5af2a2..c2be9793 100644
--- a/words.h
+++ b/words.h
@@ -55,7 +55,7 @@ inline void AndWords(word *r, const word *a, size_t n)
 

 inline word ShiftWordsLeftByBits(word *r, size_t n, unsigned int shiftBits)

 {

-	assert (shiftBits<WORD_BITS);

+	CRYPTOPP_ASSERT (shiftBits<WORD_BITS);

 	word u, carry=0;

 	if (shiftBits)

 		for (size_t i=0; i<n; i++)

@@ -69,7 +69,7 @@ inline word ShiftWordsLeftByBits(word *r, size_t n, unsigned int shiftBits)
 

 inline word ShiftWordsRightByBits(word *r, size_t n, unsigned int shiftBits)

 {

-	assert (shiftBits<WORD_BITS);

+	CRYPTOPP_ASSERT (shiftBits<WORD_BITS);

 	word u, carry=0;

 	if (shiftBits)

 		for (size_t i=n; i>0; i--)

diff --git a/xtr.cpp b/xtr.cpp
index 9819b81d..0de51f80 100644
--- a/xtr.cpp
+++ b/xtr.cpp
@@ -18,8 +18,8 @@ const GFP2Element & GFP2Element::Zero()
 

 void XTR_FindPrimesAndGenerator(RandomNumberGenerator &rng, Integer &p, Integer &q, GFP2Element &g, unsigned int pbits, unsigned int qbits)

 {

-	assert(qbits > 9);	// no primes exist for pbits = 10, qbits = 9

-	assert(pbits > qbits);

+	CRYPTOPP_ASSERT(qbits > 9);	// no primes exist for pbits = 10, qbits = 9

+	CRYPTOPP_ASSERT(pbits > qbits);

 

 	const Integer minQ = Integer::Power2(qbits - 1);

 	const Integer maxQ = Integer::Power2(qbits) - 1;

@@ -30,11 +30,11 @@ void XTR_FindPrimesAndGenerator(RandomNumberGenerator &rng, Integer &p, Integer
 	do

 	{

 		bool qFound = q.Randomize(rng, minQ, maxQ, Integer::PRIME, 7, 12);

-		CRYPTOPP_UNUSED(qFound); assert(qFound);

+		CRYPTOPP_UNUSED(qFound); CRYPTOPP_ASSERT(qFound);

 		bool solutionsExist = SolveModularQuadraticEquation(r1, r2, 1, -1, 1, q);

-		CRYPTOPP_UNUSED(solutionsExist); assert(solutionsExist);

+		CRYPTOPP_UNUSED(solutionsExist); CRYPTOPP_ASSERT(solutionsExist);

 	} while (!p.Randomize(rng, minP, maxP, Integer::PRIME, CRT(rng.GenerateBit()?r1:r2, q, 2, 3, EuclideanMultiplicativeInverse(p, 3)), 3*q));

-	assert(((p.Squared() - p + 1) % q).IsZero());

+	CRYPTOPP_ASSERT(((p.Squared() - p + 1) % q).IsZero());

 

 	GFP2_ONB<ModularArithmetic> gfp2(p);

 	GFP2Element three = gfp2.ConvertIn(3), t;

@@ -50,7 +50,7 @@ void XTR_FindPrimesAndGenerator(RandomNumberGenerator &rng, Integer &p, Integer
 		if (g != three)

 			break;

 	}

-	assert(XTR_Exponentiate(g, q, p) == three);

+	CRYPTOPP_ASSERT(XTR_Exponentiate(g, q, p) == three);

 }

 

 GFP2Element XTR_Exponentiate(const GFP2Element &b, const Integer &e, const Integer &p)

diff --git a/xtr.h b/xtr.h
index d38bae95..301d51cc 100644
--- a/xtr.h
+++ b/xtr.h
@@ -183,7 +183,7 @@ public:
 	// a^2 - 2a^p

 	const Element & SpecialOperation1(const Element &a) const

 	{

-		assert(&a != &result);

+		CRYPTOPP_ASSERT(&a != &result);

 		result = Square(a);

 		modp.Reduce(result.c1, a.c2);

 		modp.Reduce(result.c1, a.c2);

@@ -195,7 +195,7 @@ public:
 	// x * z - y * z^p

 	const Element & SpecialOperation2(const Element &x, const Element &y, const Element &z) const

 	{

-		assert(&x != &result && &y != &result && &z != &result);

+		CRYPTOPP_ASSERT(&x != &result && &y != &result && &z != &result);

 		t = modp.Add(x.c2, y.c2);

 		result.c1 = modp.Multiply(z.c1, modp.Subtract(y.c1, t));

 		modp.Accumulate(result.c1, modp.Multiply(z.c2, modp.Subtract(t, x.c1)));

diff --git a/zdeflate.cpp b/zdeflate.cpp
index a016b300..15ae2de7 100644
--- a/zdeflate.cpp
+++ b/zdeflate.cpp
@@ -20,14 +20,14 @@ LowFirstBitWriter::LowFirstBitWriter(BufferedTransformation *attachment)
 

 void LowFirstBitWriter::StartCounting()

 {

-	assert(!m_counting);

+	CRYPTOPP_ASSERT(!m_counting);

 	m_counting = true;

 	m_bitCount = 0;

 }

 

 unsigned long LowFirstBitWriter::FinishCounting()

 {

-	assert(m_counting);

+	CRYPTOPP_ASSERT(m_counting);

 	m_counting = false;

 	return m_bitCount;

 }

@@ -40,7 +40,7 @@ void LowFirstBitWriter::PutBits(unsigned long value, unsigned int length)
 	{

 		m_buffer |= value << m_bitsBuffered;

 		m_bitsBuffered += length;

-		assert(m_bitsBuffered <= sizeof(unsigned long)*8);

+		CRYPTOPP_ASSERT(m_bitsBuffered <= sizeof(unsigned long)*8);

 		while (m_bitsBuffered >= 8)

 		{

 			m_outputBuffer[m_bytesBuffered++] = (byte)m_buffer;

@@ -109,8 +109,8 @@ struct FreqLessThan
 

 void HuffmanEncoder::GenerateCodeLengths(unsigned int *codeBits, unsigned int maxCodeBits, const unsigned int *codeCounts, size_t nCodes)

 {

-	assert(nCodes > 0);

-	assert(nCodes <= ((size_t)1 << maxCodeBits));

+	CRYPTOPP_ASSERT(nCodes > 0);

+	CRYPTOPP_ASSERT(nCodes <= ((size_t)1 << maxCodeBits));

 

 	size_t i;

 	SecBlockWithHint<HuffmanNode, 2*286> tree(nCodes);

@@ -164,7 +164,7 @@ void HuffmanEncoder::GenerateCodeLengths(unsigned int *codeBits, unsigned int ma
 			bits--;

 		blCount[bits]--;

 		blCount[bits+1] += 2;

-		assert(blCount[maxCodeBits] > 0);

+		CRYPTOPP_ASSERT(blCount[maxCodeBits] > 0);

 		blCount[maxCodeBits]--;

 	}

 

@@ -178,12 +178,12 @@ void HuffmanEncoder::GenerateCodeLengths(unsigned int *codeBits, unsigned int ma
 		codeBits[tree[i].symbol] = bits;

 		blCount[bits]--;

 	}

-	assert(blCount[bits] == 0);

+	CRYPTOPP_ASSERT(blCount[bits] == 0);

 }

 

 void HuffmanEncoder::Initialize(const unsigned int *codeBits, unsigned int nCodes)

 {

-	assert(nCodes > 0);

+	CRYPTOPP_ASSERT(nCodes > 0);

 	unsigned int maxCodeBits = *std::max_element(codeBits, codeBits+nCodes);

 	if (maxCodeBits == 0)

 		return;		// assume this object won't be used

@@ -202,7 +202,7 @@ void HuffmanEncoder::Initialize(const unsigned int *codeBits, unsigned int nCode
 		code = (code + blCount[i-1]) << 1;

 		nextCode[i] = code;

 	}

-	assert(maxCodeBits == 1 || code == (1 << maxCodeBits) - blCount[maxCodeBits]);

+	CRYPTOPP_ASSERT(maxCodeBits == 1 || code == (1 << maxCodeBits) - blCount[maxCodeBits]);

 

 	m_valueToCode.resize(nCodes);

 	for (i=0; i<nCodes; i++)

@@ -215,7 +215,7 @@ void HuffmanEncoder::Initialize(const unsigned int *codeBits, unsigned int nCode
 

 inline void HuffmanEncoder::Encode(LowFirstBitWriter &writer, value_t value) const

 {

-	assert(m_valueToCode[value].len > 0);

+	CRYPTOPP_ASSERT(m_valueToCode[value].len > 0);

 	writer.PutBits(m_valueToCode[value].code, m_valueToCode[value].len);

 }

 

@@ -265,7 +265,7 @@ void Deflator::IsolatedInitialize(const NameValuePairs &parameters)
 	Reset(true);

 

 	const int deflateLevel = parameters.GetIntValueWithDefault("DeflateLevel", DEFAULT_DEFLATE_LEVEL);

-	assert(deflateLevel >= MIN_DEFLATE_LEVEL /*0*/ && deflateLevel <= MAX_DEFLATE_LEVEL /*9*/);

+	CRYPTOPP_ASSERT(deflateLevel >= MIN_DEFLATE_LEVEL /*0*/ && deflateLevel <= MAX_DEFLATE_LEVEL /*9*/);

 	SetDeflateLevel(deflateLevel);

 	bool detectUncompressible = parameters.GetValueWithDefault("DetectUncompressible", true);

 	m_compressibleDeflateLevel = detectUncompressible ? m_deflateLevel : 0;

@@ -276,7 +276,7 @@ void Deflator::Reset(bool forceReset)
 	if (forceReset)

 		ClearBitBuffer();

 	else

-		assert(m_bitsBuffered == 0);

+		CRYPTOPP_ASSERT(m_bitsBuffered == 0);

 

 	m_headerWritten = false;

 	m_matchAvailable = false;

@@ -340,16 +340,16 @@ unsigned int Deflator::FillWindow(const byte *str, size_t length)
 		memcpy(m_byteBuffer, m_byteBuffer + DSIZE, DSIZE);

 

 		m_dictionaryEnd = m_dictionaryEnd < DSIZE ? 0 : m_dictionaryEnd-DSIZE;

-		assert(m_stringStart >= DSIZE);

+		CRYPTOPP_ASSERT(m_stringStart >= DSIZE);

 		m_stringStart -= DSIZE;

-		assert(!m_matchAvailable || m_previousMatch >= DSIZE);

+		CRYPTOPP_ASSERT(!m_matchAvailable || m_previousMatch >= DSIZE);

 		m_previousMatch -= DSIZE;

-		assert(m_blockStart >= DSIZE);

+		CRYPTOPP_ASSERT(m_blockStart >= DSIZE);

 		m_blockStart -= DSIZE;

 

 		// These are set to the same value in IsolatedInitialize(). If they

 		//   are the same, then we can clear a Coverity false alarm.

-		assert(DSIZE == HSIZE);

+		CRYPTOPP_ASSERT(DSIZE == HSIZE);

 

 		unsigned int i;

 		for (i=0; i<HSIZE; i++)

@@ -359,9 +359,9 @@ unsigned int Deflator::FillWindow(const byte *str, size_t length)
 			m_prev[i] = SaturatingSubtract(m_prev[i], DSIZE);

 	}

 

-	assert(maxBlockSize > m_stringStart+m_lookahead);

+	CRYPTOPP_ASSERT(maxBlockSize > m_stringStart+m_lookahead);

 	unsigned int accepted = UnsignedMin(maxBlockSize-(m_stringStart+m_lookahead), length);

-	assert(accepted > 0);

+	CRYPTOPP_ASSERT(accepted > 0);

 	memcpy(m_byteBuffer + m_stringStart + m_lookahead, str, accepted);

 	m_lookahead += accepted;

 	return accepted;

@@ -369,13 +369,13 @@ unsigned int Deflator::FillWindow(const byte *str, size_t length)
 

 inline unsigned int Deflator::ComputeHash(const byte *str) const

 {

-	assert(str+3 <= m_byteBuffer + m_stringStart + m_lookahead);

+	CRYPTOPP_ASSERT(str+3 <= m_byteBuffer + m_stringStart + m_lookahead);

 	return ((str[0] << 10) ^ (str[1] << 5) ^ str[2]) & HMASK;

 }

 

 unsigned int Deflator::LongestMatch(unsigned int &bestMatch) const

 {

-	assert(m_previousLength < MAX_MATCH);

+	CRYPTOPP_ASSERT(m_previousLength < MAX_MATCH);

 

 	bestMatch = 0;

 	unsigned int bestLength = STDMAX(m_previousLength, (unsigned int)MIN_MATCH-1);

@@ -393,10 +393,10 @@ unsigned int Deflator::LongestMatch(unsigned int &bestMatch) const
 	while (current > limit && --chainLength > 0)

 	{

 		const byte *match = m_byteBuffer + current;

-		assert(scan + bestLength < m_byteBuffer + m_stringStart + m_lookahead);

+		CRYPTOPP_ASSERT(scan + bestLength < m_byteBuffer + m_stringStart + m_lookahead);

 		if (scan[bestLength-1] == match[bestLength-1] && scan[bestLength] == match[bestLength] && scan[0] == match[0] && scan[1] == match[1])

 		{

-			assert(scan[2] == match[2]);

+			CRYPTOPP_ASSERT(scan[2] == match[2]);

 			unsigned int len = (unsigned int)(

 #if defined(_STDEXT_BEGIN) && !(defined(_MSC_VER) && (_MSC_VER < 1400 || _MSC_VER >= 1600)) && !defined(_STLPORT_VERSION)

 				stdext::unchecked_mismatch

@@ -408,13 +408,13 @@ unsigned int Deflator::LongestMatch(unsigned int &bestMatch) const
 #else

 				(scan+3, scanEnd, match+3).first - scan);

 #endif

-			assert(len != bestLength);

+			CRYPTOPP_ASSERT(len != bestLength);

 			if (len > bestLength)

 			{

 				bestLength = len;

 				bestMatch = current;

 

-				assert(scanEnd >= scan);

+				CRYPTOPP_ASSERT(scanEnd >= scan);

 				if (len == (unsigned int)(scanEnd - scan))

 					break;

 			}

@@ -426,7 +426,7 @@ unsigned int Deflator::LongestMatch(unsigned int &bestMatch) const
 

 inline void Deflator::InsertString(unsigned int start)

 {

-	assert(start <= 0xffff);

+	CRYPTOPP_ASSERT(start <= 0xffff);

 	unsigned int hash = ComputeHash(m_byteBuffer + start);

 	m_prev[start & DMASK] = m_head[hash];

 	m_head[hash] = word16(start);

@@ -493,7 +493,7 @@ void Deflator::ProcessBuffer()
 			m_lookahead--;

 		}

 

-		assert(m_stringStart - (m_blockStart+m_blockLength) == (unsigned int)m_matchAvailable);

+		CRYPTOPP_ASSERT(m_stringStart - (m_blockStart+m_blockLength) == (unsigned int)m_matchAvailable);

 	}

 

 	if (m_minLookahead == 0 && m_matchAvailable)

@@ -517,7 +517,7 @@ size_t Deflator::Put2(const byte *str, size_t length, int messageEnd, bool block
 		ProcessUncompressedData(str+accepted, newAccepted);

 		accepted += newAccepted;

 	}

-	assert(accepted == length);

+	CRYPTOPP_ASSERT(accepted == length);

 

 	if (messageEnd)

 	{

@@ -586,9 +586,9 @@ void Deflator::MatchFound(unsigned int distance, unsigned int length)
 		{1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,

 		 4097,6145,8193,12289,16385,24577};

 

-	assert(m_matchBufferEnd < m_matchBuffer.size());

+	CRYPTOPP_ASSERT(m_matchBufferEnd < m_matchBuffer.size());

 	EncodedMatch &m = m_matchBuffer[m_matchBufferEnd++];

-	assert((length >= 3) && (length-3 < COUNTOF(lengthCodes)));

+	CRYPTOPP_ASSERT((length >= 3) && (length-3 < COUNTOF(lengthCodes)));

 	unsigned int lengthCode = lengthCodes[length-3];

 	m.literalCode = lengthCode;

 	m.literalExtra = length - lengthBases[lengthCode-257];

@@ -650,8 +650,8 @@ void Deflator::EncodeBlock(bool eof, unsigned int blockType)
 

 	if (blockType == STORED)

 	{

-		assert(m_blockStart + m_blockLength <= m_byteBuffer.size());

-		assert(m_blockLength <= 0xffff);

+		CRYPTOPP_ASSERT(m_blockStart + m_blockLength <= m_byteBuffer.size());

+		CRYPTOPP_ASSERT(m_blockLength <= 0xffff);

 		FlushBitBuffer();

 		AttachedTransformation()->PutWord16(word16(m_blockLength), LITTLE_ENDIAN_ORDER);

 		AttachedTransformation()->PutWord16(word16(~m_blockLength), LITTLE_ENDIAN_ORDER);

@@ -738,7 +738,7 @@ void Deflator::EncodeBlock(bool eof, unsigned int blockType)
 			literalEncoder.Encode(*this, literalCode);

 			if (literalCode >= 257)

 			{

-				assert(literalCode <= 285);

+				CRYPTOPP_ASSERT(literalCode <= 285);

 				PutBits(m_matchBuffer[i].literalExtra, lengthExtraBits[literalCode-257]);

 				unsigned int distanceCode = m_matchBuffer[i].distanceCode;

 				distanceEncoder.Encode(*this, distanceCode);

diff --git a/zinflate.cpp b/zinflate.cpp
index adffca01..da473f35 100644
--- a/zinflate.cpp
+++ b/zinflate.cpp
@@ -32,20 +32,20 @@ inline bool LowFirstBitReader::FillBuffer(unsigned int length)
 		m_buffer |= (unsigned long)b << m_bitsBuffered;

 		m_bitsBuffered += 8;

 	}

-	assert(m_bitsBuffered <= sizeof(unsigned long)*8);

+	CRYPTOPP_ASSERT(m_bitsBuffered <= sizeof(unsigned long)*8);

 	return true;

 }

 

 inline unsigned long LowFirstBitReader::PeekBits(unsigned int length)

 {

 	bool result = FillBuffer(length);

-	CRYPTOPP_UNUSED(result); assert(result);

+	CRYPTOPP_UNUSED(result); CRYPTOPP_ASSERT(result);

 	return m_buffer & (((unsigned long)1 << length) - 1);

 }

 

 inline void LowFirstBitReader::SkipBits(unsigned int length)

 {

-	assert(m_bitsBuffered >= length);

+	CRYPTOPP_ASSERT(m_bitsBuffered >= length);

 	m_buffer >>= length;

 	m_bitsBuffered -= length;

 }

@@ -141,10 +141,10 @@ void HuffmanDecoder::Initialize(const unsigned int *codeBits, unsigned int nCode
 	m_cacheBits = STDMIN(9U, m_maxCodeBits);

 	m_cacheMask = (1 << m_cacheBits) - 1;

 	m_normalizedCacheMask = NormalizeCode(m_cacheMask, m_cacheBits);

-	assert(m_normalizedCacheMask == BitReverse(m_cacheMask));

+	CRYPTOPP_ASSERT(m_normalizedCacheMask == BitReverse(m_cacheMask));

 

 	const word64 shiftedCache = ((word64)1 << m_cacheBits);

-	assert(shiftedCache <= SIZE_MAX);

+	CRYPTOPP_ASSERT(shiftedCache <= SIZE_MAX);

 	if (m_cache.size() != shiftedCache)

 		m_cache.resize((size_t)shiftedCache);

 

@@ -181,7 +181,7 @@ void HuffmanDecoder::FillCacheEntry(LookupEntry &entry, code_t normalizedCode) c
 

 inline unsigned int HuffmanDecoder::Decode(code_t code, /* out */ value_t &value) const

 {

-	assert(m_codeToValue.size() > 0);

+	CRYPTOPP_ASSERT(m_codeToValue.size() > 0);

 	LookupEntry &entry = m_cache[code & m_cacheMask];

 

 	code_t normalizedCode = 0;

@@ -209,7 +209,7 @@ inline unsigned int HuffmanDecoder::Decode(code_t code, /* out */ value_t &value
 bool HuffmanDecoder::Decode(LowFirstBitReader &reader, value_t &value) const

 {

 	bool result = reader.FillBuffer(m_maxCodeBits);

-	CRYPTOPP_UNUSED(result); // assert(result);

+	CRYPTOPP_UNUSED(result); // CRYPTOPP_ASSERT(result);

 

 	unsigned int codeBits = Decode(reader.PeekBuffer(), value);

 	if (codeBits > reader.BitsBuffered())

@@ -478,13 +478,13 @@ bool Inflator::DecodeBody()
 	switch (m_blockType)

 	{

 	case 0:	// stored

-		assert(m_reader.BitsBuffered() == 0);

+		CRYPTOPP_ASSERT(m_reader.BitsBuffered() == 0);

 		while (!m_inQueue.IsEmpty() && !blockEnd)

 		{

 			size_t size;

 			const byte *block = m_inQueue.Spy(size);

 			size = UnsignedMin(m_storedLen, size);

-			assert(size <= 0xffff);

+			CRYPTOPP_ASSERT(size <= 0xffff);

 

 			OutputString(block, size);

 			m_inQueue.Skip(size);

@@ -562,7 +562,7 @@ bool Inflator::DecodeBody()
 			}

 			break;

 		default:

-			assert(0);

+			CRYPTOPP_ASSERT(0);

 		}

 	}

 	if (blockEnd)

@@ -591,7 +591,7 @@ void Inflator::FlushOutput()
 {

 	if (m_state != PRE_STREAM)

 	{

-		assert(m_current >= m_lastFlush);

+		CRYPTOPP_ASSERT(m_current >= m_lastFlush);

 		ProcessDecompressedData(m_window + m_lastFlush, m_current - m_lastFlush);

 		m_lastFlush = m_current;

 	}

diff --git a/zlib.cpp b/zlib.cpp
index bba4dc8e..12b1f633 100644
--- a/zlib.cpp
+++ b/zlib.cpp
@@ -21,9 +21,9 @@ static const byte FDICT_FLAG = (1 << 5);
 void ZlibCompressor::WritePrestreamHeader()

 {

 	m_adler32.Restart();

-	assert(((GetLog2WindowSize()-8) << 4) <= 255);

+	CRYPTOPP_ASSERT(((GetLog2WindowSize()-8) << 4) <= 255);

 	byte cmf = byte(DEFLATE_METHOD | ((GetLog2WindowSize()-8) << 4));

-	assert((GetCompressionLevel() << 6) <= 255);

+	CRYPTOPP_ASSERT((GetCompressionLevel() << 6) <= 255);

 	byte flags = byte(GetCompressionLevel() << 6);

 	AttachedTransformation()->PutWord16(RoundUpToMultipleOf(word16(cmf*256+flags), word16(31)));

 }