From b7de164d6251dc066123b59bc15d30c74e920756 Mon Sep 17 00:00:00 2001 From: Jeffrey Walton Date: Sun, 26 Jul 2015 16:03:14 -0400 Subject: [PATCH] Cut-in CRYPTOPP_ASSERT in all remaining header and source files --- adler32.cpp | 4 +- algebra.cpp | 2 +- asn.cpp | 2 +- asn.h | 4 +- authenc.cpp | 6 +-- authenc.h | 2 +- basecode.cpp | 12 +++--- cast.cpp | 2 +- ccm.cpp | 4 +- cmac.cpp | 6 +-- cryptlib.cpp | 18 ++++----- cryptlib.h | 14 +++---- datatest.cpp | 14 +++---- dlltest.cpp | 2 +- eax.cpp | 4 +- ec2n.cpp | 8 ++-- eccrypto.cpp | 2 +- ecp.cpp | 4 +- emsa2.cpp | 2 +- eprecomp.cpp | 4 +- esign.cpp | 4 +- files.cpp | 2 +- filters.cpp | 76 +++++++++++++++++++------------------- filters.h | 8 ++-- fips140.cpp | 2 +- fipsalgt.cpp | 8 ++-- fltrimpl.h | 2 +- gf2_32.cpp | 10 ++--- gf2n.cpp | 14 +++---- gfpcrypt.cpp | 8 ++-- gfpcrypt.h | 4 +- hkdf.h | 6 +-- hmac.cpp | 4 +- hrtimer.cpp | 4 +- ida.cpp | 2 +- idea.cpp | 2 +- integer.cpp | 100 +++++++++++++++++++++++++------------------------- iterhash.cpp | 2 +- luc.h | 2 +- misc.cpp | 16 ++++---- modes.cpp | 22 +++++------ modes.h | 2 +- nbtheory.cpp | 66 ++++++++++++++++----------------- network.cpp | 4 +- oaep.cpp | 2 +- panama.cpp | 4 +- pkcspad.cpp | 6 +-- polynomi.cpp | 6 +-- pssr.cpp | 4 +- pubkey.h | 6 +-- pwdbased.h | 12 +++--- queue.cpp | 2 +- rijndael.cpp | 4 +- rsa.cpp | 2 +- rw.cpp | 2 +- salsa.cpp | 4 +- seal.cpp | 2 +- simple.h | 6 +-- smartptr.h | 4 +- socketft.cpp | 30 +++++++-------- socketft.h | 2 +- sosemanuk.cpp | 2 +- strciphr.cpp | 8 ++-- strciphr.h | 12 +++--- validat1.cpp | 4 +- validat2.cpp | 2 +- vmac.cpp | 2 +- wait.cpp | 2 +- winpipes.cpp | 2 +- winpipes.h | 2 +- words.h | 4 +- xtr.cpp | 12 +++--- xtr.h | 4 +- zdeflate.cpp | 56 ++++++++++++++-------------- zinflate.cpp | 14 +++---- 75 files changed, 355 insertions(+), 355 deletions(-) diff --git a/adler32.cpp b/adler32.cpp index 916fc704..27e318b1 100644 --- a/adler32.cpp +++ b/adler32.cpp @@ -47,8 +47,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 9e5222d9..a26627f5 100644 --- a/algebra.cpp +++ b/algebra.cpp @@ -263,7 +263,7 @@ void AbstractGroup::SimultaneousMultiply(T *results, const T &base, const Int for (i=0; iNotNegative()); + CRYPTOPP_ASSERT(expBegin->NotNegative()); exponents.push_back(WindowSlider(*expBegin++, InversionIsFast(), 0)); exponents[i].FindNextWindow(); buckets[i].resize(1<<(exponents[i].m_windowSize-1), Identity()); diff --git a/asn.cpp b/asn.cpp index 7f650dc2..b45569d8 100644 --- a/asn.cpp +++ b/asn.cpp @@ -246,7 +246,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 State_KeySet) m_state = State_KeySet;} diff --git a/basecode.cpp b/basecode.cpp index 864b5f9f..3cac35f6 100644 --- a/basecode.cpp +++ b/basecode.cpp @@ -54,7 +54,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_bitPos < m_bitsPerChar); + CRYPTOPP_ASSERT(m_bitPos < m_bitsPerChar); unsigned int bitsLeftInTarget = m_bitsPerChar-m_bitPos; m_outBuf[m_bytePos] |= b >> (8-bitsLeftInTarget); if (bitsLeftInSource >= bitsLeftInTarget) @@ -75,13 +75,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= 2); + CRYPTOPP_ASSERT(m_L >= 2); if (m_L > 8) m_L = 8; @@ -67,7 +67,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/cmac.cpp b/cmac.cpp index 5de39ca2..3e3a0631 100644 --- a/cmac.cpp +++ b/cmac.cpp @@ -81,7 +81,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; @@ -89,12 +89,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/cryptlib.cpp b/cryptlib.cpp index e7dfd6e4..3508fb37 100644 --- a/cryptlib.cpp +++ b/cryptlib.cpp @@ -153,7 +153,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; @@ -199,7 +199,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); @@ -333,19 +333,19 @@ void BufferedTransformation::GetWaitObjects(WaitObjectContainer &container, Call void BufferedTransformation::Initialize(const NameValuePairs ¶meters, int propagation) { - assert(!AttachedTransformation()); + CRYPTOPP_ASSERT(!AttachedTransformation()); IsolatedInitialize(parameters); } bool BufferedTransformation::Flush(bool hardFlush, int propagation, bool blocking) { - assert(!AttachedTransformation()); + CRYPTOPP_ASSERT(!AttachedTransformation()); return IsolatedFlush(hardFlush, blocking); } bool BufferedTransformation::MessageSeriesEnd(int propagation, bool blocking) { - assert(!AttachedTransformation()); + CRYPTOPP_ASSERT(!AttachedTransformation()); return IsolatedMessageSeriesEnd(blocking); } @@ -484,7 +484,7 @@ bool BufferedTransformation::GetNextMessage() return AttachedTransformation()->GetNextMessage(); else { - assert(!AnyMessages()); + CRYPTOPP_ASSERT(!AnyMessages()); return false; } } @@ -521,7 +521,7 @@ size_t BufferedTransformation::TransferMessagesTo2(BufferedTransformation &targe return 1; bool result = GetNextMessage(); - assert(result); + CRYPTOPP_ASSERT(result); } return 0; } @@ -552,7 +552,7 @@ size_t BufferedTransformation::TransferAllTo2(BufferedTransformation &target, co return AttachedTransformation()->TransferAllTo2(target, channel, blocking); else { - assert(!NumberOfMessageSeries()); + CRYPTOPP_ASSERT(!NumberOfMessageSeries()); unsigned int messageCount; do @@ -584,7 +584,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 a53d6841..2729008c 100644 --- a/cryptlib.h +++ b/cryptlib.h @@ -448,7 +448,7 @@ protected: size_t ThrowIfInvalidIVLength(int size); const byte * GetIVAndThrowIfInvalid(const NameValuePairs ¶ms, size_t &size); inline void AssertValidKeyLength(size_t length) const - {assert(IsValidKeyLength(length));} + {CRYPTOPP_ASSERT(IsValidKeyLength(length));} }; //! interface for the data processing part of block ciphers @@ -542,7 +542,7 @@ public: //! for random access ciphers, seek to an absolute position virtual void Seek(lword n) { - assert(!IsRandomAccess()); + CRYPTOPP_ASSERT(!IsRandomAccess()); throw NotImplemented("StreamTransformation: this object doesn't support random access"); } @@ -1040,13 +1040,13 @@ public: //! returns whether this object allows attachment virtual bool Attachable() {return false;} //! returns the object immediately attached to this object or NULL for no attachment - virtual BufferedTransformation *AttachedTransformation() {assert(!Attachable()); return 0;} + virtual BufferedTransformation *AttachedTransformation() {CRYPTOPP_ASSERT(!Attachable()); return 0;} //! virtual const BufferedTransformation *AttachedTransformation() const {return const_cast(this)->AttachedTransformation();} //! delete the current attachment chain and replace it with newAttachment virtual void Detach(BufferedTransformation *newAttachment = 0) - {assert(!Attachable()); throw NotImplemented("BufferedTransformation: this object is not attachable");} + {CRYPTOPP_ASSERT(!Attachable()); throw NotImplemented("BufferedTransformation: this object is not attachable");} //! add newAttachment to the end of attachment chain virtual void Attach(BufferedTransformation *newAttachment); //@} @@ -1111,13 +1111,13 @@ public: typically it means calculate a table of n objects that can be used later to speed up computation. */ virtual void Precompute(unsigned int n) - {assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");} + {CRYPTOPP_ASSERT(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");} //! retrieve previously saved precomputation virtual void LoadPrecomputation(BufferedTransformation &storedPrecomputation) - {assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");} + {CRYPTOPP_ASSERT(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");} //! save precomputation for later use virtual void SavePrecomputation(BufferedTransformation &storedPrecomputation) const - {assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");} + {CRYPTOPP_ASSERT(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");} // for internal library use void DoQuickSanityCheck() const {ThrowIfInvalid(NullRNG(), 0);} diff --git a/datatest.cpp b/datatest.cpp index a6be37e9..57b5cc05 100644 --- a/datatest.cpp +++ b/datatest.cpp @@ -264,17 +264,17 @@ void TestSignatureScheme(TestData &v) else if (test == "DeterministicSign") { SignalTestError(); - assert(false); // TODO: implement + CRYPTOPP_ASSERT(false); // TODO: implement } else if (test == "RandomSign") { SignalTestError(); - assert(false); // TODO: implement + CRYPTOPP_ASSERT(false); // TODO: implement } else { SignalTestError(); - assert(false); + CRYPTOPP_ASSERT(false); } } @@ -314,7 +314,7 @@ void TestAsymmetricCipher(TestData &v) else { SignalTestError(); - assert(false); + CRYPTOPP_ASSERT(false); } } @@ -412,7 +412,7 @@ void TestSymmetricCipher(TestData &v, const NameValuePairs &overrideParameters) while (ss.Pump(64)) {} ss.PumpAll(); for (int i=0; iSquare(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 66c978b8..99225e76 100644 --- a/eccrypto.cpp +++ b/eccrypto.cpp @@ -447,7 +447,7 @@ template void DL_GroupParameters_EC::Initialize(const OID &oid) Element G; bool result = GetCurve().DecodePoint(G, ssG, (size_t)ssG.MaxRetrievable()); this->SetSubgroupGenerator(G); - assert(result); CRYPTOPP_UNUSED(result); + CRYPTOPP_ASSERT(result); CRYPTOPP_UNUSED(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 10cff341..f908f5c5 100644 --- a/ecp.cpp +++ b/ecp.cpp @@ -139,7 +139,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 @@ -382,7 +382,7 @@ void ECP::SimultaneousMultiply(ECP::Point *results, const ECP::Point &P, const I for (i=0; iNotNegative()); + CRYPTOPP_ASSERT(expBegin->NotNegative()); exponents.push_back(WindowSlider(*expBegin++, InversionIsFast(), 5)); exponents[i].FindNextWindow(); } diff --git a/emsa2.cpp b/emsa2.cpp index 07f7dcf1..eeac009f 100644 --- a/emsa2.cpp +++ b/emsa2.cpp @@ -13,7 +13,7 @@ void EMSA2Pad::ComputeMessageRepresentative(RandomNumberGenerator &rng, HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty, byte *representative, size_t representativeBitLength) const { - 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 ecc6ce70..fbd77105 100644 --- a/eprecomp.cpp +++ b/eprecomp.cpp @@ -26,8 +26,8 @@ template void DL_FixedBasePrecomputationImpl::SetBase(const DL_Grou template void DL_FixedBasePrecomputationImpl::Precompute(const DL_GroupPrecomputation &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 8ac050bf..a4764ffa 100644 --- a/esign.cpp +++ b/esign.cpp @@ -115,7 +115,7 @@ void InvertibleESIGNFunction::GenerateRandom(RandomNumberGenerator &rng, const N m_n = m_p * m_p * m_q; - assert(m_n.BitCount() == modulusSize); + CRYPTOPP_ASSERT(m_n.BitCount() == modulusSize); } void InvertibleESIGNFunction::BERDecode(BufferedTransformation &bt) @@ -164,7 +164,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); /* using namespace std; cout << "f = " << x << endl; diff --git a/files.cpp b/files.cpp index f0bd67f1..01b0c5ed 100644 --- a/files.cpp +++ b/files.cpp @@ -144,7 +144,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(this)->TransferTo2(target, copyMax, channel, blocking); begin += copyMax; diff --git a/filters.cpp b/filters.cpp index 1b46127f..20fb1cc1 100644 --- a/filters.cpp +++ b/filters.cpp @@ -108,7 +108,7 @@ void Filter::PropagateInitialize(const NameValuePairs ¶meters, int propagati size_t Filter::OutputModifiable(int outputSite, byte *inString, size_t length, int messageEnd, bool blocking, const std::string &channel) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } if (messageEnd) @@ -121,7 +121,7 @@ size_t Filter::OutputModifiable(int outputSite, byte *inString, size_t length, i size_t Filter::Output(int outputSite, const byte *inString, size_t length, int messageEnd, bool blocking, const std::string &channel) { // Formerly fired because inString was not NULL, but length was 0. - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } if (messageEnd) @@ -186,7 +186,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; @@ -197,7 +197,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(); } @@ -299,7 +299,7 @@ size_t FilterWithBufferedInput::BlockQueue::Put(const byte *inString, size_t len if (!inString || !length) return length; if (!m_buffer.data()) return length; - 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); @@ -347,7 +347,7 @@ bool FilterWithBufferedInput::IsolatedFlush(bool hardFlush, bool blocking) size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length, int messageEnd, bool blocking, bool modifiable) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } if (!blocking) @@ -362,7 +362,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; @@ -400,7 +400,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; @@ -458,13 +458,13 @@ void FilterWithBufferedInput::ForceNextPut() void FilterWithBufferedInput::NextPutMultiple(const byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } - 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; @@ -577,7 +577,7 @@ StreamTransformationFilter::StreamTransformationFilter(StreamTransformation &c, : FilterWithBufferedInput(attachment) , m_cipher(c) { - assert(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize()); + CRYPTOPP_ASSERT(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize()); if (!allowAuthenticatedSymmetricCipher && dynamic_cast(&c) != 0) throw InvalidArgument("StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher"); @@ -616,14 +616,14 @@ void StreamTransformationFilter::InitializeDerivedAndReturnNewSizes(const NameVa void StreamTransformationFilter::FirstPut(const byte *inString) { // FilterWithBufferedInput::PutMaybeModifiable causes this to fire. - // assert(inString); + // CRYPTOPP_ASSERT(inString); m_optimalBufferSize = m_cipher.OptimalBlockSize(); m_optimalBufferSize = (unsigned int)STDMAX(m_optimalBufferSize, RoundDownToMultipleOf(4096U, m_optimalBufferSize)); } void StreamTransformationFilter::NextPutMultiple(const byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } size_t s = m_cipher.MandatoryBlockSize(); @@ -652,7 +652,7 @@ void StreamTransformationFilter::NextPutMultiple(const byte *inString, size_t le void StreamTransformationFilter::NextPutModifiable(byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } m_cipher.ProcessString(inString, length); @@ -661,7 +661,7 @@ void StreamTransformationFilter::NextPutModifiable(byte *inString, size_t length void StreamTransformationFilter::LastPut(const byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } byte *space = NULL; @@ -707,16 +707,16 @@ 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 && length) 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); } @@ -752,7 +752,7 @@ void StreamTransformationFilter::LastPut(const byte *inString, size_t length) break; default: - assert(false); + CRYPTOPP_ASSERT(false); } } @@ -774,7 +774,7 @@ void HashFilter::IsolatedInitialize(const NameValuePairs ¶meters) size_t HashFilter::Put2(const byte *inString, size_t length, int messageEnd, bool blocking) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } FILTER_BEGIN; @@ -816,7 +816,7 @@ void HashVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameValueP void HashVerificationFilter::FirstPut(const byte *inString) { // FilterWithBufferedInput::PutMaybeModifiable causes this to fire. - // assert(inString); + // CRYPTOPP_ASSERT(inString); if (m_flags & HASH_AT_BEGIN) { @@ -831,7 +831,7 @@ void HashVerificationFilter::FirstPut(const byte *inString) void HashVerificationFilter::NextPutMultiple(const byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } m_hashModule.Update(inString, length); @@ -841,12 +841,12 @@ void HashVerificationFilter::NextPutMultiple(const byte *inString, size_t length void HashVerificationFilter::LastPut(const byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } if (m_flags & HASH_AT_BEGIN) { - assert(length == 0); + CRYPTOPP_ASSERT(length == 0); m_verified = m_hashModule.TruncatedVerify(m_expectedHash, m_digestSize); } else @@ -870,7 +870,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 ¶meters) @@ -903,7 +903,7 @@ size_t AuthenticatedEncryptionFilter::ChannelPut2(const std::string &channel, co void AuthenticatedEncryptionFilter::LastPut(const byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } StreamTransformationFilter::LastPut(inString, length); @@ -917,7 +917,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)); } @@ -962,13 +962,13 @@ size_t AuthenticatedDecryptionFilter::ChannelPut2(const std::string &channel, co void AuthenticatedDecryptionFilter::FirstPut(const byte *inString) { // FilterWithBufferedInput::PutMaybeModifiable causes this to fire. - // assert(inString); + // CRYPTOPP_ASSERT(inString); m_hashVerifier.Put(inString, m_firstSize); } void AuthenticatedDecryptionFilter::NextPutMultiple(const byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } m_streamFilter.Put(inString, length); @@ -976,7 +976,7 @@ void AuthenticatedDecryptionFilter::NextPutMultiple(const byte *inString, size_t void AuthenticatedDecryptionFilter::LastPut(const byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } m_streamFilter.MessageEnd(); @@ -993,7 +993,7 @@ void SignerFilter::IsolatedInitialize(const NameValuePairs ¶meters) size_t SignerFilter::Put2(const byte *inString, size_t length, int messageEnd, bool blocking) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } FILTER_BEGIN; @@ -1022,7 +1022,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; @@ -1032,7 +1032,7 @@ void SignatureVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameV void SignatureVerificationFilter::FirstPut(const byte *inString) { // FilterWithBufferedInput::PutMaybeModifiable causes this to fire. - // assert(inString); + // CRYPTOPP_ASSERT(inString); if (m_flags & SIGNATURE_AT_BEGIN) { @@ -1049,13 +1049,13 @@ void SignatureVerificationFilter::FirstPut(const byte *inString) } else { - assert(!m_verifier.SignatureUpfront()); + CRYPTOPP_ASSERT(!m_verifier.SignatureUpfront()); } } void SignatureVerificationFilter::NextPutMultiple(const byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } m_messageAccumulator->Update(inString, length); @@ -1065,12 +1065,12 @@ void SignatureVerificationFilter::NextPutMultiple(const byte *inString, size_t l void SignatureVerificationFilter::LastPut(const byte *inString, size_t length) { - assert(inString || (!inString && !length)); + CRYPTOPP_ASSERT(inString || (!inString && !length)); if (inString == NULL) { length = 0; } 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 110c3fc7..1da2eb9c 100644 --- a/filters.h +++ b/filters.h @@ -61,7 +61,7 @@ struct CRYPTOPP_DLL FilterPutSpaceHelper // desiredSize is how much to ask target, bufferSize is how much to allocate in m_tempSpace 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); @@ -180,7 +180,7 @@ protected: // or (firstSize == 0 and (totalLength > 0 or a MessageEnd() is received)) virtual void FirstPut(const byte *inString) =0; // NextPut() is called if totalLength >= firstSize+blockSize+lastSize - virtual void NextPutSingle(const byte *inString) {assert(false);} + virtual void NextPutSingle(const byte *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); @@ -204,7 +204,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) {assert(false); return 0;} + virtual int NextPut(const byte *inString, size_t length) {CRYPTOPP_ASSERT(false); return 0;} class BlockQueue { @@ -591,7 +591,7 @@ public: typedef typename T::traits_type::char_type 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 ¶meters) {if (!parameters.GetValue("OutputStringPointer", m_output)) throw InvalidArgument("StringSink: OutputStringPointer not specified");} diff --git a/fips140.cpp b/fips140.cpp index 447e70c0..fe6937d2 100644 --- a/fips140.cpp +++ b/fips140.cpp @@ -61,7 +61,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 88597023..95f8f7c6 100644 --- a/fipsalgt.cpp +++ b/fipsalgt.cpp @@ -259,7 +259,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()); } @@ -634,7 +634,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; @@ -1031,7 +1031,7 @@ protected: } else { - assert(m_test == "KAT"); + CRYPTOPP_ASSERT(m_test == "KAT"); SecByteBlock &input = m_data2[INPUT]; SecByteBlock result(input.size()); @@ -1094,7 +1094,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 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 a46ca1d0..7ff02f33 100644 --- a/gf2n.cpp +++ b/gf2n.cpp @@ -23,7 +23,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) { @@ -550,7 +550,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); @@ -589,7 +589,7 @@ GF2NT::GF2NT(unsigned int t0, unsigned int t1, unsigned int t2) , t0(t0), t1(t1) , result((word)0, m) { - assert(t0 > t1 && t1 > t2 && t2==0); + CRYPTOPP_ASSERT(t0 > t1 && t1 > t2 && t2==0); } const GF2NT::Element& GF2NT::MultiplicativeInverse(const Element &a) const @@ -607,7 +607,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()); @@ -619,7 +619,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]; @@ -650,7 +650,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) @@ -790,7 +790,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/gfpcrypt.cpp b/gfpcrypt.cpp index e51756fc..c9c27705 100644 --- a/gfpcrypt.cpp +++ b/gfpcrypt.cpp @@ -70,8 +70,8 @@ void DL_SignatureMessageEncodingMethod_DSA::ComputeMessageRepresentative(RandomN HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty, byte *representative, size_t representativeBitLength) const { - 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); @@ -92,8 +92,8 @@ void DL_SignatureMessageEncodingMethod_NR::ComputeMessageRepresentative(RandomNu HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty, byte *representative, size_t representativeBitLength) const { - 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 72bbcefc..a8f911c3 100644 --- a/gfpcrypt.h +++ b/gfpcrypt.h @@ -167,7 +167,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 ¶ms, const DL_PublicKey &publicKey, const Integer &e, const Integer &r, const Integer &s) const @@ -199,7 +199,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 ¶ms, const DL_PublicKey &publicKey, const Integer &e, const Integer &r, const Integer &s) const diff --git a/hkdf.h b/hkdf.h index 97e4a7e5..d781b628 100644 --- a/hkdf.h +++ b/hkdf.h @@ -51,9 +51,9 @@ unsigned int HKDF::DeriveKey(byte *derived, size_t derivedLen, const byte *se CRYPTOPP_COMPILE_ASSERT(DIGEST_SIZE <= COUNTOF(s_NullVector)); const unsigned int req = static_cast(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 a30e4394..2df4ff34 100644 --- a/hmac.cpp +++ b/hmac.cpp @@ -31,7 +31,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= 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 ccd3a596..cb2592ae 100644 --- a/integer.cpp +++ b/integer.cpp @@ -61,7 +61,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) @@ -74,7 +74,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) @@ -94,14 +94,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 S DivideThreeWordsByTwo(S *A, S B0, S B1, D *dummy=NULL) { // 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] < B1 || (A[2]==B1 && A[1] < B0)); // estimate the quotient: do a 2 S by 1 S divide S Q; @@ -386,7 +386,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; @@ -797,7 +797,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); @@ -813,7 +813,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); @@ -2064,7 +2064,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); @@ -2095,7 +2095,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); } } @@ -2106,7 +2106,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); @@ -2131,7 +2131,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); @@ -2155,7 +2155,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]); @@ -2197,7 +2197,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); } } @@ -2240,7 +2240,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]) { @@ -2326,7 +2326,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); CopyWords(R, T + ((0-borrow) & N), N); #elif 0 const word u = 0-U[0]; @@ -2393,7 +2393,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) @@ -2422,7 +2422,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) @@ -2459,7 +2459,7 @@ void HalfMontgomeryReduce(word *R, word *T, const word *X, const word *M, const 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] < B1 || (A[2]==B1 && A[1] < B0)); // estimate the quotient: do a 2 word by 1 word divide word Q; @@ -2485,7 +2485,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; @@ -2508,11 +2508,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]= 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 } } @@ -2564,9 +2564,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; @@ -2578,7 +2578,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 @@ -2598,7 +2598,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]; @@ -2632,7 +2632,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; @@ -2660,7 +2660,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]; @@ -2683,7 +2683,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); @@ -2696,7 +2696,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); } } @@ -2816,7 +2816,7 @@ bool Integer::IsConvertableToLong() const signed long Integer::ConvertToLong() const { - assert(IsConvertableToLong()); + CRYPTOPP_ASSERT(IsConvertableToLong()); unsigned long value = (unsigned long)reg[0]; value += SafeLeftShift((unsigned long)reg[1]); @@ -2937,7 +2937,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= inputLen); + CRYPTOPP_ASSERT(bt.MaxRetrievable() >= inputLen); byte b; bt.Peek(b); @@ -3442,7 +3442,7 @@ Integer& Integer::operator++() else { word borrow = Decrement(reg, reg.size()); - assert(!borrow); + CRYPTOPP_ASSERT(!borrow); if (WordCount()==0) *this = Zero(); } @@ -3518,7 +3518,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 @@ -3526,7 +3526,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; } } @@ -3798,7 +3798,7 @@ void Integer::Divide(word &remainder, Integer "ient, const Integer ÷nd if (!divisor) throw Integer::DivideByZero(); - assert(divisor); + CRYPTOPP_ASSERT(divisor); if ((divisor & (divisor-1)) == 0) // divisor is a power of 2 { @@ -3842,7 +3842,7 @@ word Integer::Modulo(word divisor) const if (!divisor) throw Integer::DivideByZero(); - assert(divisor); + CRYPTOPP_ASSERT(divisor); word remainder; @@ -3914,7 +3914,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 { @@ -3959,7 +3959,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); @@ -4175,7 +4175,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()); @@ -4188,7 +4188,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()); @@ -4201,7 +4201,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()); @@ -4215,7 +4215,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()); diff --git a/iterhash.cpp b/iterhash.cpp index 192b286c..f837165d 100644 --- a/iterhash.cpp +++ b/iterhash.cpp @@ -51,7 +51,7 @@ template void IteratedHashBase::Update(const byte { if (input == data) { - assert(len == blockSize); + CRYPTOPP_ASSERT(len == blockSize); HashBlock(dataBuf); return; } diff --git a/luc.h b/luc.h index 54e41326..e669c346 100644 --- a/luc.h +++ b/luc.h @@ -116,7 +116,7 @@ typedef LUCSS::Verifier LUCSSA_PKCS1v15_SHA_Verifier; class DL_GroupPrecomputation_LUC : public DL_GroupPrecomputation { public: - const AbstractGroup & GetGroup() const {assert(false); throw 0;} + const AbstractGroup & 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/misc.cpp b/misc.cpp index 6d14822c..ca6f465f 100644 --- a/misc.cpp +++ b/misc.cpp @@ -27,8 +27,8 @@ void xorbuf(byte *buf, const byte *mask, size_t count) { if (!CRYPTOPP_BOOL_SLOW_WORD64 && IsStrictAligned(buf) && IsStrictAligned(mask)) { - assert(IsAlignedOn(buf, GetStrictAlignmentOf())); - assert(IsAlignedOn(mask, GetStrictAlignmentOf())); + CRYPTOPP_ASSERT(IsAlignedOn(buf, GetStrictAlignmentOf())); + CRYPTOPP_ASSERT(IsAlignedOn(mask, GetStrictAlignmentOf())); for (i=0; i(output) && IsStrictAligned(input) && IsStrictAligned(mask)) { - assert(IsAlignedOn(output, GetStrictAlignmentOf())); - assert(IsAlignedOn(input, GetStrictAlignmentOf())); - assert(IsAlignedOn(mask, GetStrictAlignmentOf())); + CRYPTOPP_ASSERT(IsAlignedOn(output, GetStrictAlignmentOf())); + CRYPTOPP_ASSERT(IsAlignedOn(input, GetStrictAlignmentOf())); + CRYPTOPP_ASSERT(IsAlignedOn(mask, GetStrictAlignmentOf())); for (i=0; i(buf) && IsStrictAligned(mask)) { - assert(IsAlignedOn(buf, GetStrictAlignmentOf())); - assert(IsAlignedOn(mask, GetStrictAlignmentOf())); + CRYPTOPP_ASSERT(IsAlignedOn(buf, GetStrictAlignmentOf())); + CRYPTOPP_ASSERT(IsAlignedOn(mask, GetStrictAlignmentOf())); word64 acc64 = 0; for (i=0; iIsForwardTransformation()); // CFB mode needs the "encrypt" direction of the underlying block cipher, even to decrypt - assert(m_feedbackSize == BlockSize()); + 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) @@ -48,7 +48,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); const unsigned int updateSize = BlockSize()-m_feedbackSize; @@ -59,7 +59,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(); } @@ -79,7 +79,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) @@ -89,7 +89,7 @@ void OFB_ModePolicy::WriteKeystream(byte *keystreamBuffer, size_t iterationCount void OFB_ModePolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length) { - assert(length == BlockSize()); + CRYPTOPP_ASSERT(length == BlockSize()); CopyOrZero(m_register, iv, length); } @@ -112,7 +112,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; @@ -132,7 +132,7 @@ void CTR_ModePolicy::OperateKeystream(KeystreamOperation operation, byte *output void CTR_ModePolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length) { - assert(length == BlockSize()); + CRYPTOPP_ASSERT(length == BlockSize()); CopyOrZero(m_register, iv, length); m_counterArray = m_register; } @@ -151,7 +151,7 @@ void BlockOrientedCipherModeBase::UncheckedSetKey(const byte *key, unsigned int 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); } @@ -159,7 +159,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); @@ -199,7 +199,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 9edf53af..eabd8fd9 100644 --- a/modes.h +++ b/modes.h @@ -62,7 +62,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 e95aa366..135ec753 100644 --- a/nbtheory.cpp +++ b/nbtheory.cpp @@ -78,7 +78,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]3 && b>1 && b3 && b>1 && b3 && b>1 && b3 && b>1 && b3); + CRYPTOPP_ASSERT(n>3); Integer b; for (unsigned int i=0; i2); + CRYPTOPP_ASSERT(n>2); Integer b=3; unsigned int i=0; @@ -192,7 +192,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; @@ -313,7 +313,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); - assert(safe); CRYPTOPP_UNUSED(safe); + CRYPTOPP_ASSERT(safe); CRYPTOPP_UNUSED(safe); if (m_next == m_sieve.size()) { @@ -367,7 +367,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) @@ -384,7 +384,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()) @@ -424,7 +424,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); @@ -448,8 +448,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, @@ -463,7 +463,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); @@ -620,7 +620,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; } @@ -630,21 +630,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; } } @@ -670,7 +670,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); } @@ -680,7 +680,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) { @@ -715,14 +715,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); @@ -790,7 +790,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; @@ -983,7 +983,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); @@ -1042,8 +1042,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) { @@ -1058,9 +1058,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; @@ -1075,11 +1075,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) @@ -1107,11 +1107,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); @@ -1119,7 +1119,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 a75cca75..1b38c9f5 100644 --- a/network.cpp +++ b/network.cpp @@ -434,7 +434,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; } @@ -450,7 +450,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 3b17f0b0..7c1a7ba6 100644 --- a/oaep.cpp +++ b/oaep.cpp @@ -18,7 +18,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 ¶meters) 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 5638078d..f98f9c82 100644 --- a/panama.cpp +++ b/panama.cpp @@ -442,14 +442,14 @@ void PanamaHash::TruncatedFinal(byte *hash, size_t size) template void PanamaCipherPolicy::CipherSetKey(const NameValuePairs ¶ms, const byte *key, size_t length) { - assert(length==32); + CRYPTOPP_ASSERT(length==32); memcpy(m_key, key, 32); } template void PanamaCipherPolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length) { - assert(length==32); + CRYPTOPP_ASSERT(length==32); this->Reset(); this->Iterate(1, m_key); if (iv && IsAligned(iv)) diff --git a/pkcspad.cpp b/pkcspad.cpp index 4f6e62be..275bd57c 100644 --- a/pkcspad.cpp +++ b/pkcspad.cpp @@ -30,7 +30,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 ¶meters) const { - 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) @@ -70,7 +70,7 @@ DecodingResult PKCS_EncryptionPaddingScheme::Unpad(const byte *pkcsBlock, size_t size_t i=1; while (i maxOutputLen) || invalid; @@ -91,7 +91,7 @@ void PKCS1v15_SignatureMessageEncodingMethod::ComputeMessageRepresentative(Rando HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty, byte *representative, size_t representativeBitLength) const { - 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 cbf4fc9c..d7326a0e 100644 --- a/polynomi.cpp +++ b/polynomi.cpp @@ -476,7 +476,7 @@ void RingOfPolynomialsOver::CalculateAlpha(std::vector &alph template typename RingOfPolynomialsOver::Element RingOfPolynomialsOver::Interpolate(const CoefficientType x[], const CoefficientType y[], unsigned int n) const { - assert(n > 0); + CRYPTOPP_ASSERT(n > 0); std::vector alpha(n); CalculateAlpha(alpha, x, y, n); @@ -498,7 +498,7 @@ typename RingOfPolynomialsOver::Element RingOfPolynomialsOver::Interpolate template typename RingOfPolynomialsOver::CoefficientType RingOfPolynomialsOver::InterpolateAt(const CoefficientType &position, const CoefficientType x[], const CoefficientType y[], unsigned int n) const { - assert(n > 0); + CRYPTOPP_ASSERT(n > 0); std::vector alpha(n); CalculateAlpha(alpha, x, y, n); @@ -528,7 +528,7 @@ void PrepareBulkPolynomialInterpolation(const Ring &ring, Element *w, const Elem template 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 a(2*n-1); unsigned int i; diff --git a/pssr.cpp b/pssr.cpp index 1637ba70..2dbe2b27 100644 --- a/pssr.cpp +++ b/pssr.cpp @@ -49,7 +49,7 @@ void PSSR_MEM_Base::ComputeMessageRepresentative(RandomNumberGenerator &rng, HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty, byte *representative, size_t representativeBitLength) const { - 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); @@ -91,7 +91,7 @@ DecodingResult PSSR_MEM_Base::RecoverMessageFromRepresentative( byte *representative, size_t representativeBitLength, byte *recoverableMessage) const { - 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 205a080d..224c51fa 100644 --- a/pubkey.h +++ b/pubkey.h @@ -210,7 +210,7 @@ public: SecByteBlock &semisignature) const { if (RecoverablePartFirst()) - assert(!"ProcessRecoverableMessage() not implemented"); + CRYPTOPP_ASSERT(!"ProcessRecoverableMessage() not implemented"); } virtual void ComputeMessageRepresentative(RandomNumberGenerator &rng, @@ -972,7 +972,7 @@ public: size_t MaxRecoverableLength() const {return GetMessageEncodingInterface().MaxRecoverableLength(0, GetHashIdentifier().second, GetDigestSize());} size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const - {assert(false); return 0;} // TODO + {CRYPTOPP_ASSERT(false); return 0;} // TODO bool IsProbabilistic() const {return true;} @@ -1460,7 +1460,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 bbc8bdff..468db8d0 100644 --- a/pwdbased.h +++ b/pwdbased.h @@ -57,8 +57,8 @@ public: template unsigned int PKCS5_PBKDF1::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; @@ -86,8 +86,8 @@ unsigned int PKCS5_PBKDF1::DeriveKey(byte *derived, size_t derivedLen, byte p template unsigned int PKCS5_PBKDF2_HMAC::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; @@ -150,8 +150,8 @@ public: template unsigned int PKCS12_PBKDF::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 42ccd971..19943215 100644 --- a/queue.cpp +++ b/queue.cpp @@ -462,7 +462,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/rijndael.cpp b/rijndael.cpp index ec2d62a2..0f5ec888 100644 --- a/rijndael.cpp +++ b/rijndael.cpp @@ -1085,7 +1085,7 @@ inline size_t AESNI_AdvancedProcessBlocks(F1 func1, F4 func4, const __m128i *sub if (flags & BlockTransformation::BT_ReverseDirection) { - assert(length % blockSize == 0); + CRYPTOPP_ASSERT(length % blockSize == 0); inBlocks += length - blockSize; xorBlocks += length - blockSize; outBlocks += length - blockSize; @@ -1218,7 +1218,7 @@ size_t Rijndael::Enc::AdvancedProcessBlocks(const byte *inBlocks, const byte *xo 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 07d78ff1..c516888b 100644 --- a/rsa.cpp +++ b/rsa.cpp @@ -124,7 +124,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 5cc0de9a..5d066f4c 100644 --- a/rw.cpp +++ b/rw.cpp @@ -238,7 +238,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 6fe1e2ff..a42e3dff 100644 --- a/salsa.cpp +++ b/salsa.cpp @@ -41,7 +41,7 @@ void Salsa20_Policy::CipherSetKey(const NameValuePairs ¶ms, const byte *key, void Salsa20_Policy::CipherResynchronize(byte *keystreamBuffer, const byte *IV, size_t length) { - assert(length==8); + CRYPTOPP_ASSERT(length==8); GetBlock get(IV); get(m_state[14])(m_state[11]); m_state[8] = m_state[5] = 0; @@ -568,7 +568,7 @@ void XSalsa20_Policy::CipherSetKey(const NameValuePairs ¶ms, const byte *key void XSalsa20_Policy::CipherResynchronize(byte *keystreamBuffer, const byte *IV, size_t 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 8f81f06d..79350aa9 100644 --- a/seal.cpp +++ b/seal.cpp @@ -69,7 +69,7 @@ void SEAL_Policy::CipherSetKey(const NameValuePairs ¶ms, const byte *key, template void SEAL_Policy::CipherResynchronize(byte *keystreamBuffer, const byte *IV, size_t length) { - assert(length==4); + CRYPTOPP_ASSERT(length==4); m_outsideCounter = IV ? GetWord(false, BIG_ENDIAN_ORDER, IV) : 0; m_startCount = m_outsideCounter; m_insideCounter = 0; diff --git a/simple.h b/simple.h index 56e648dd..53e3fcb9 100644 --- a/simple.h +++ b/simple.h @@ -68,7 +68,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) - {assert(false); return false;} + {CRYPTOPP_ASSERT(false); return false;} bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true) { if (hardFlush && !InputBufferIsEmpty()) @@ -111,7 +111,7 @@ public: virtual bool Flush(bool hardFlush, int propagation=-1, bool blocking=true) =0; private: - bool IsolatedFlush(bool hardFlush, bool blocking) {assert(false); return false;} + bool IsolatedFlush(bool hardFlush, bool blocking) {CRYPTOPP_ASSERT(false); return false;} }; //! _ @@ -122,7 +122,7 @@ public: virtual void Initialize(const NameValuePairs ¶meters=g_nullNameValuePairs, int propagation=-1) =0; private: - void IsolatedInitialize(const NameValuePairs ¶meters) {assert(false);} + void IsolatedInitialize(const NameValuePairs ¶meters) {CRYPTOPP_ASSERT(false);} }; //! _ diff --git a/smartptr.h b/smartptr.h index 21987cce..daa53255 100644 --- a/smartptr.h +++ b/smartptr.h @@ -228,9 +228,9 @@ public: {delete [] this->m_ptr;} member_ptr& operator[](size_t index) - {assert(indexm_size); return this->m_ptr[index];} + {CRYPTOPP_ASSERT(indexm_size); return this->m_ptr[index];} const member_ptr& operator[](size_t index) const - {assert(indexm_size); return this->m_ptr[index];} + {CRYPTOPP_ASSERT(indexm_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 fb79169c..7ef40f76 100644 --- a/socketft.cpp +++ b/socketft.cpp @@ -68,7 +68,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; @@ -116,20 +116,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(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)); @@ -155,7 +155,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(psa), saLen); if (result == SOCKET_ERROR && GetLastError() == SOCKET_EWOULDBLOCK) return false; @@ -165,7 +165,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; @@ -176,19 +176,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; @@ -196,7 +196,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; @@ -204,14 +204,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 @@ -328,7 +328,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 @@ -410,7 +410,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}; @@ -430,7 +430,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 188d7d6f..cbfad9e4 100644 --- a/socketft.h +++ b/socketft.h @@ -94,7 +94,7 @@ public: {if (result == 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 diff --git a/sosemanuk.cpp b/sosemanuk.cpp index 1bb06dcb..52dd24b1 100644 --- a/sosemanuk.cpp +++ b/sosemanuk.cpp @@ -22,7 +22,7 @@ void SosemanukPolicy::CipherSetKey(const NameValuePairs ¶ms, const byte *use void SosemanukPolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length) { - assert(length==16); + CRYPTOPP_ASSERT(length==16); word32 a, b, c, d, e; diff --git a/strciphr.cpp b/strciphr.cpp index 39f4d152..49f42cc9 100644 --- a/strciphr.cpp +++ b/strciphr.cpp @@ -40,7 +40,7 @@ void AdditiveCipherTemplate::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(); @@ -79,7 +79,7 @@ void AdditiveCipherTemplate::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(); @@ -177,7 +177,7 @@ void CFB_CipherTemplate::Resynchronize(const byte *iv, int length) template void CFB_CipherTemplate::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(); @@ -197,7 +197,7 @@ void CFB_CipherTemplate::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 aed4af2c..9485e3ce 100644 --- a/strciphr.h +++ b/strciphr.h @@ -74,11 +74,11 @@ struct CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AdditiveCipherAbstractPolicy virtual void WriteKeystream(byte *keystream, size_t iterationCount) {OperateKeystream(KeystreamOperation(INPUT_NULL | (KeystreamOperationFlags)IsAlignedOn(keystream, GetAlignment())), keystream, NULL, iterationCount);} virtual bool CanOperateKeystream() const {return false;} - virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount) {assert(false);} + virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount) {CRYPTOPP_ASSERT(false);} virtual void CipherSetKey(const NameValuePairs ¶ms, const byte *key, size_t length) =0; virtual void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length) {throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");} virtual bool CipherIsRandomAccess() const =0; - virtual void SeekToIteration(lword iterationCount) {assert(!CipherIsRandomAccess()); throw NotImplemented("StreamTransformation: this object doesn't support random access");} + virtual void SeekToIteration(lword iterationCount) {CRYPTOPP_ASSERT(!CipherIsRandomAccess()); throw NotImplemented("StreamTransformation: this object doesn't support random access");} }; template @@ -169,7 +169,7 @@ public: virtual byte * GetRegisterBegin() =0; virtual void TransformRegister() =0; virtual bool CanIterate() const {return false;} - virtual void Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount) {assert(false); throw 0;} + virtual void Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount) {CRYPTOPP_ASSERT(false); throw 0;} virtual void CipherSetKey(const NameValuePairs ¶ms, const byte *key, size_t length) =0; virtual void CipherResynchronize(const byte *iv, size_t length) {throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");} }; @@ -192,8 +192,8 @@ struct CRYPTOPP_NO_VTABLE CFB_CipherConcretePolicy : public BASE inline RegisterOutput& operator()(WordType ®isterWord) { - assert(IsAligned(m_output)); - assert(IsAligned(m_input)); + CRYPTOPP_ASSERT(IsAligned(m_output)); + CRYPTOPP_ASSERT(IsAligned(m_input)); if (!NativeByteOrderIs(B::ToEnum())) registerWord = ByteReverse(registerWord); @@ -201,7 +201,7 @@ 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/validat1.cpp b/validat1.cpp index da1756a3..6ae85cab 100644 --- a/validat1.cpp +++ b/validat1.cpp @@ -469,7 +469,7 @@ public: { std::cerr << "incorrect output " << counter << ", " << (word16)validOutput[counter] << ", " << (word16)inByte << "\n"; fail = true; - assert(false); + CRYPTOPP_ASSERT(false); } counter++; } @@ -482,7 +482,7 @@ public: if (counter != outputLen) { fail = true; - assert(false); + CRYPTOPP_ASSERT(false); } return 0; diff --git a/validat2.cpp b/validat2.cpp index ea722ccb..1197fe5f 100644 --- a/validat2.cpp +++ b/validat2.cpp @@ -452,7 +452,7 @@ bool ValidateDSA(bool thorough) DSA::Verifier pub(priv); FileSource fs2("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("TestVectors/dsa.txt", g_nullNameValuePairs, thorough) && pass; return pass; diff --git a/vmac.cpp b/vmac.cpp index 24673b2a..b67a0e43 100644 --- a/vmac.cpp +++ b/vmac.cpp @@ -133,7 +133,7 @@ void VMAC_Base::Resynchronize(const byte *nonce, int len) void VMAC_Base::HashEndianCorrectedBlock(const word64 *data) { - assert(false); + CRYPTOPP_ASSERT(false); throw 0; } diff --git a/wait.cpp b/wait.cpp index a71cef8e..f00668a5 100644 --- a/wait.cpp +++ b/wait.cpp @@ -171,7 +171,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(); } } diff --git a/winpipes.cpp b/winpipes.cpp index c24219a1..d1b0f4f1 100644 --- a/winpipes.cpp +++ b/winpipes.cpp @@ -89,7 +89,7 @@ WindowsPipeReceiver::WindowsPipeReceiver() bool WindowsPipeReceiver::Receive(byte* buf, size_t bufLen) { - assert(!m_resultPending && !m_eofReceived); + CRYPTOPP_ASSERT(!m_resultPending && !m_eofReceived); 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 7f06135b..43965c40 100644 --- a/winpipes.h +++ b/winpipes.h @@ -56,7 +56,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);} }; //! pipe-based implementation of NetworkReceiver diff --git a/words.h b/words.h index d5fda71d..acaa2f71 100644 --- a/words.h +++ b/words.h @@ -50,7 +50,7 @@ inline void AndWords(word *r, const word *a, size_t n) inline word ShiftWordsLeftByBits(word *r, size_t n, unsigned int shiftBits) { - assert (shiftBits0; i--) diff --git a/xtr.cpp b/xtr.cpp index 9d36e14c..ce687ea1 100644 --- a/xtr.cpp +++ b/xtr.cpp @@ -16,8 +16,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; @@ -28,11 +28,11 @@ void XTR_FindPrimesAndGenerator(RandomNumberGenerator &rng, Integer &p, Integer do { bool qFound = q.Randomize(rng, minQ, maxQ, Integer::PRIME, 7, 12); - assert(qFound); CRYPTOPP_UNUSED(qFound); + CRYPTOPP_ASSERT(qFound); CRYPTOPP_UNUSED(qFound); bool solutionsExist = SolveModularQuadraticEquation(r1, r2, 1, -1, 1, q); - assert(solutionsExist); CRYPTOPP_UNUSED(solutionsExist); + CRYPTOPP_ASSERT(solutionsExist); CRYPTOPP_UNUSED(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 gfp2(p); GFP2Element three = gfp2.ConvertIn(3), t; @@ -48,7 +48,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 9bb0af4f..40766870 100644 --- a/xtr.h +++ b/xtr.h @@ -179,7 +179,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); @@ -191,7 +191,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 8e76df35..b12de1a0 100644 --- a/zdeflate.cpp +++ b/zdeflate.cpp @@ -26,14 +26,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; } @@ -46,7 +46,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 tree(nCodes); @@ -163,7 +163,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]--; } @@ -177,12 +177,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 = *max_element(codeBits, codeBits+nCodes); if (maxCodeBits == 0) return; // assume this object won't be used @@ -201,7 +201,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 0); + CRYPTOPP_ASSERT(m_valueToCode[value].len > 0); writer.PutBits(m_valueToCode[value].code, m_valueToCode[value].len); } @@ -273,7 +273,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; @@ -337,11 +337,11 @@ 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; unsigned int i; @@ -353,9 +353,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; @@ -363,13 +363,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); @@ -387,10 +387,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 @@ -402,7 +402,7 @@ 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; @@ -410,7 +410,7 @@ unsigned int Deflator::LongestMatch(unsigned int &bestMatch) const // TODO: should we throw here? const ptrdiff_t diff = scanEnd - scan; - assert(diff >= 0); + CRYPTOPP_ASSERT(diff >= 0); if (len == static_cast(diff)) break; @@ -489,7 +489,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) @@ -513,7 +513,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) { @@ -580,7 +580,7 @@ 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}; EncodedMatch &m = m_matchBuffer[m_matchBufferEnd++]; - assert(length >= 3); + CRYPTOPP_ASSERT(length >= 3); unsigned int lengthCode = lengthCodes[length-3]; m.literalCode = lengthCode; m.literalExtra = length - lengthBases[lengthCode-257]; @@ -642,8 +642,8 @@ void Deflator::EncodeBlock(bool eof, unsigned int blockType) if (blockType == STORED) { - assert(m_blockStart + m_blockLength <= m_byteBuffer.size()); - assert(m_blockLength <= 65535); + CRYPTOPP_ASSERT(m_blockStart + m_blockLength <= m_byteBuffer.size()); + CRYPTOPP_ASSERT(m_blockLength <= 65535); FlushBitBuffer(); AttachedTransformation()->PutWord16(static_cast(m_blockLength), LITTLE_ENDIAN_ORDER); AttachedTransformation()->PutWord16(static_cast(~m_blockLength), LITTLE_ENDIAN_ORDER); @@ -730,7 +730,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 e3fbdc57..ffc4b9df 100644 --- a/zinflate.cpp +++ b/zinflate.cpp @@ -30,20 +30,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); - assert(result); CRYPTOPP_UNUSED(result); + CRYPTOPP_ASSERT(result); CRYPTOPP_UNUSED(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; } @@ -137,7 +137,7 @@ 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)); if (m_cache.size() != size_t(1) << m_cacheBits) m_cache.resize(1 << m_cacheBits); @@ -175,7 +175,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; @@ -468,7 +468,7 @@ 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; @@ -576,7 +576,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; }