Clear clang-tidy warnings

2024-11-26 19:30:21 +00:00 · 2018-01-24 20:04:16 -05:00 · 2018-01-24 20:04:16 -05:00 · 51db9eb436
commit 51db9eb436
parent e546b2af85
4 changed files with 127 additions and 91 deletions
--- a/arc4.cpp
+++ b/arc4.cpp
@ -25,9 +25,9 @@ ARC4_Base::~ARC4_Base()
 	m_x = m_y = 0;
 }

-void ARC4_Base::UncheckedSetKey(const byte *key, unsigned int keyLen, const NameValuePairs &params)
+void ARC4_Base::UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params)
 {
-	AssertValidKeyLength(keyLen);
+	AssertValidKeyLength(length);

 	m_x = 1;
 	m_y = 0;
@ -44,7 +44,7 @@ void ARC4_Base::UncheckedSetKey(const byte *key, unsigned int keyLen, const Name
 		stateIndex &= 0xff;
 		m_state[i] = m_state[stateIndex];
 		m_state[stateIndex] = byte(a);
-		if (++keyIndex >= keyLen)
+		if (++keyIndex >= length)
 			keyIndex = 0;
 	}

@ -99,9 +99,9 @@ void ARC4_Base::ProcessData(byte *outString, const byte *inString, size_t length
 	m_y = byte(y);
 }

-void ARC4_Base::DiscardBytes(size_t length)
+void ARC4_Base::DiscardBytes(size_t n)
 {
-	if (length == 0)
+	if (n == 0)
 		return;

 	byte *const s = m_state;
@ -112,7 +112,7 @@ void ARC4_Base::DiscardBytes(size_t length)
 	{
 		MakeByte(x, y, s);
 	}
-	while(--length);
+	while(--n);

 	m_x = byte(x);
 	m_y = byte(y);
--- a/blumshub.cpp
+++ b/blumshub.cpp
@ -22,7 +22,7 @@ unsigned int PublicBlumBlumShub::GenerateBit()
 		bitsLeft = maxBits;
 	}

-	return current.GetBit(--bitsLeft);
+	return static_cast<unsigned int>(current.GetBit(--bitsLeft));
 }

 byte PublicBlumBlumShub::GenerateByte()
--- a/cpu.cpp
+++ b/cpu.cpp
@ -58,8 +58,9 @@ extern "C" {
 extern "C"
 {
 	static jmp_buf s_jmpNoCPUID;
-	static void SigIllHandlerCPUID(int)
+	static void SigIllHandlerCPUID(int unused)
 	{
+		CRYPTOPP_UNUSED(unused);
 		longjmp(s_jmpNoCPUID, 1);
 	}
 }
@ -127,7 +128,7 @@ bool CpuId(word32 func, word32 subfunc, word32 output[4])
 	// not return non-0, then it is mostly useless. The code below converts basic
 	// function value to a true/false return value.
 	if(func == 0)
-		return !!output[0];
+		return output[0] != 0;

 	return true;
 #else
@ -141,7 +142,7 @@ bool CpuId(word32 func, word32 subfunc, word32 output[4])

 # ifndef __MINGW32__
 	volatile sigset_t oldMask;
-	if (sigprocmask(0, NULLPTR, (sigset_t*)&oldMask))
+	if (sigprocmask(0, NULLPTR, (sigset_t*)&oldMask) != 0)
 		return false;
 # endif

@ -221,13 +222,13 @@ void DetectX86Features()
 	// cpuid1[2] & (1 << 27) is XSAVE/XRESTORE and signals OS support for SSE; use it to avoid probes.
 	// See http://github.com/weidai11/cryptopp/issues/511 and http://stackoverflow.com/a/22521619/608639
 	if ((cpuid1[3] & (1 << 26)) != 0)
-		g_hasSSE2 = (cpuid1[2] & (1 << 27)) || CPU_ProbeSSE2();
+		g_hasSSE2 = ((cpuid1[2] & (1 << 27)) != 0) || CPU_ProbeSSE2();

-	g_hasSSSE3 = g_hasSSE2 && (cpuid1[2] & (1<<9));
-	g_hasSSE41 = g_hasSSE2 && (cpuid1[2] & (1<<19));
-	g_hasSSE42 = g_hasSSE2 && (cpuid1[2] & (1<<20));
-	g_hasAESNI = g_hasSSE2 && (cpuid1[2] & (1<<25));
-	g_hasCLMUL = g_hasSSE2 && (cpuid1[2] & (1<<1));
+	g_hasSSSE3 = g_hasSSE2 && ((cpuid1[2] & (1<< 9)) != 0);
+	g_hasSSE41 = g_hasSSE2 && ((cpuid1[2] & (1<<19)) != 0);
+	g_hasSSE42 = g_hasSSE2 && ((cpuid1[2] & (1<<20)) != 0);
+	g_hasAESNI = g_hasSSE2 && ((cpuid1[2] & (1<<25)) != 0);
+	g_hasCLMUL = g_hasSSE2 && ((cpuid1[2] & (1<< 1)) != 0);

 	if (IsIntel(cpuid0))
 	{
@ -238,15 +239,15 @@ void DetectX86Features()

 		g_isP4 = ((cpuid1[0] >> 8) & 0xf) == 0xf;
 		g_cacheLineSize = 8 * GETBYTE(cpuid1[1], 1);
-		g_hasRDRAND = !!(cpuid1[2] /*ECX*/ & RDRAND_FLAG);
+		g_hasRDRAND = (cpuid1[2] /*ECX*/ & RDRAND_FLAG) != 0;

 		if (cpuid0[0] /*EAX*/ >= 7)
 		{
 			if (CpuId(7, 0, cpuid2))
 			{
-				g_hasRDSEED = !!(cpuid2[1] /*EBX*/ & RDSEED_FLAG);
-				g_hasADX = !!(cpuid2[1] /*EBX*/ & ADX_FLAG);
-				g_hasSHA = !!(cpuid2[1] /*EBX*/ & SHA_FLAG);
+				g_hasRDSEED = (cpuid2[1] /*EBX*/ & RDSEED_FLAG) != 0;
+				g_hasADX = (cpuid2[1] /*EBX*/ & ADX_FLAG) != 0;
+				g_hasSHA = (cpuid2[1] /*EBX*/ & SHA_FLAG) != 0;
 			}
 		}
 	}
@ -259,15 +260,15 @@ void DetectX86Features()

 		CpuId(0x80000005, 0, cpuid2);
 		g_cacheLineSize = GETBYTE(cpuid2[2], 0);
-		g_hasRDRAND = !!(cpuid1[2] /*ECX*/ & RDRAND_FLAG);
+		g_hasRDRAND = (cpuid1[2] /*ECX*/ & RDRAND_FLAG) != 0;

 		if (cpuid0[0] /*EAX*/ >= 7)
 		{
 			if (CpuId(7, 0, cpuid2))
 			{
-				g_hasRDSEED = !!(cpuid2[1] /*EBX*/ & RDSEED_FLAG);
-				g_hasADX = !!(cpuid2[1] /*EBX*/ & ADX_FLAG);
-				g_hasSHA = !!(cpuid2[1] /*EBX*/ & SHA_FLAG);
+				g_hasRDSEED = (cpuid2[1] /*EBX*/ & RDSEED_FLAG) != 0;
+				g_hasADX = (cpuid2[1] /*EBX*/ & ADX_FLAG) != 0;
+				g_hasSHA = (cpuid2[1] /*EBX*/ & SHA_FLAG) != 0;
 			}
 		}
 	}
@ -284,11 +285,11 @@ void DetectX86Features()
 		{
 			// Extended features available
 			CpuId(0xC0000001, 0, cpuid2);
-			g_hasPadlockRNG  = !!(cpuid2[3] /*EDX*/ & RNG_FLAGS);
-			g_hasPadlockACE  = !!(cpuid2[3] /*EDX*/ & ACE_FLAGS);
-			g_hasPadlockACE2 = !!(cpuid2[3] /*EDX*/ & ACE2_FLAGS);
-			g_hasPadlockPHE  = !!(cpuid2[3] /*EDX*/ & PHE_FLAGS);
-			g_hasPadlockPMM  = !!(cpuid2[3] /*EDX*/ & PMM_FLAGS);
+			g_hasPadlockRNG  = (cpuid2[3] /*EDX*/ & RNG_FLAGS) != 0;
+			g_hasPadlockACE  = (cpuid2[3] /*EDX*/ & ACE_FLAGS) != 0;
+			g_hasPadlockACE2 = (cpuid2[3] /*EDX*/ & ACE2_FLAGS) != 0;
+			g_hasPadlockPHE  = (cpuid2[3] /*EDX*/ & PHE_FLAGS) != 0;
+			g_hasPadlockPMM  = (cpuid2[3] /*EDX*/ & PMM_FLAGS) != 0;
 		}
 	}

--- a/cryptlib.cpp
+++ b/cryptlib.cpp
@ -95,22 +95,25 @@ void SimpleKeyingInterface::ThrowIfInvalidIV(const byte *iv)
 		throw InvalidArgument(GetAlgorithm().AlgorithmName() + ": this object cannot use a null IV");
 }

-size_t SimpleKeyingInterface::ThrowIfInvalidIVLength(int size)
+size_t SimpleKeyingInterface::ThrowIfInvalidIVLength(int length)
 {
-	if (size < 0)
-		return (size_t)IVSize();
-	else if ((size_t)size < MinIVLength())
-		throw InvalidArgument(GetAlgorithm().AlgorithmName() + ": IV length " + IntToString(size) + " is less than the minimum of " + IntToString(MinIVLength()));
-	else if ((size_t)size > MaxIVLength())
-		throw InvalidArgument(GetAlgorithm().AlgorithmName() + ": IV length " + IntToString(size) + " exceeds the maximum of " + IntToString(MaxIVLength()));
+	size_t size = 0;
+	if (length < 0)
+		size = static_cast<size_t>(IVSize());
+	else if ((size_t)length < MinIVLength())
+		throw InvalidArgument(GetAlgorithm().AlgorithmName() + ": IV length " + IntToString(length) + " is less than the minimum of " + IntToString(MinIVLength()));
+	else if ((size_t)length > MaxIVLength())
+		throw InvalidArgument(GetAlgorithm().AlgorithmName() + ": IV length " + IntToString(length) + " exceeds the maximum of " + IntToString(MaxIVLength()));
 	else
-		return (size_t)size;
+		size = static_cast<size_t>(length);
+
+	return size;
 }

 const byte * SimpleKeyingInterface::GetIVAndThrowIfInvalid(const NameValuePairs &params, size_t &size)
 {
 	ConstByteArrayParameter ivWithLength;
-	const byte *iv;
+	const byte *iv = NULLPTR;
 	bool found = false;

 	try {found = params.GetValue(Name::IV(), ivWithLength);}
@ -121,25 +124,24 @@ const byte * SimpleKeyingInterface::GetIVAndThrowIfInvalid(const NameValuePairs
 		iv = ivWithLength.begin();
 		ThrowIfInvalidIV(iv);
 		size = ThrowIfInvalidIVLength(static_cast<int>(ivWithLength.size()));
-		return iv;
 	}
 	else if (params.GetValue(Name::IV(), iv))
 	{
 		ThrowIfInvalidIV(iv);
-		size = IVSize();
-		return iv;
+		size = static_cast<size_t>(IVSize());
 	}
 	else
 	{
 		ThrowIfResynchronizable();
 		size = 0;
-		return NULLPTR;
 	}
+
+	return iv;
 }

-void SimpleKeyingInterface::GetNextIV(RandomNumberGenerator &rng, byte *IV)
+void SimpleKeyingInterface::GetNextIV(RandomNumberGenerator &rng, byte *iv)
 {
-	rng.GenerateBlock(IV, IVSize());
+	rng.GenerateBlock(iv, IVSize());
 }

 size_t BlockTransformation::AdvancedProcessBlocks(const byte *inBlocks, const byte *xorBlocks, byte *outBlocks, size_t length, word32 flags) const
@ -227,11 +229,11 @@ size_t StreamTransformation::ProcessLastBlock(byte *outString, size_t outLength,
 	{
 		outLength = inLength; // squash unused warning
 		ProcessData(outString, inString, inLength);
-		return outLength;
 	}
 	else if (inLength != 0)
 		throw NotImplemented(AlgorithmName() + ": this object doesn't support a special last block");
-	return 0;
+
+	return outLength;
 }

 void AuthenticatedSymmetricCipher::SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength)
@ -381,12 +383,12 @@ RandomNumberGenerator & NullRNG()
 	return s_nullRNG;
 }

-bool HashTransformation::TruncatedVerify(const byte *digestIn, size_t digestLength)
+bool HashTransformation::TruncatedVerify(const byte *digest, size_t digestLength)
 {
 	ThrowIfInvalidTruncatedSize(digestLength);
-	SecByteBlock digest(digestLength);
-	TruncatedFinal(digest, digestLength);
-	return VerifyBufsEqual(digest, digestIn, digestLength);
+	SecByteBlock calculated(digestLength);
+	TruncatedFinal(calculated, digestLength);
+	return VerifyBufsEqual(calculated, digest, digestLength);
 }

 void HashTransformation::ThrowIfInvalidTruncatedSize(size_t size) const
@ -431,150 +433,183 @@ bool BufferedTransformation::MessageSeriesEnd(int propagation, bool blocking)

 byte * BufferedTransformation::ChannelCreatePutSpace(const std::string &channel, size_t &size)
 {
+	byte* space = NULLPTR;
 	if (channel.empty())
-		return CreatePutSpace(size);
+		space = CreatePutSpace(size);
 	else
 		throw NoChannelSupport(AlgorithmName());
+	return space;
 }

-size_t BufferedTransformation::ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
+size_t BufferedTransformation::ChannelPut2(const std::string &channel, const byte *inString, size_t length, int messageEnd, bool blocking)
 {
+	size_t size = 0;
 	if (channel.empty())
-		return Put2(begin, length, messageEnd, blocking);
+		size = Put2(inString, length, messageEnd, blocking);
 	else
 		throw NoChannelSupport(AlgorithmName());
+	return size;
 }

-size_t BufferedTransformation::ChannelPutModifiable2(const std::string &channel, byte *begin, size_t length, int messageEnd, bool blocking)
+size_t BufferedTransformation::ChannelPutModifiable2(const std::string &channel, byte *inString, size_t length, int messageEnd, bool blocking)
 {
+	size_t size = 0;
 	if (channel.empty())
-		return PutModifiable2(begin, length, messageEnd, blocking);
+		size = PutModifiable2(inString, length, messageEnd, blocking);
 	else
-		return ChannelPut2(channel, begin, length, messageEnd, blocking);
+		size = ChannelPut2(channel, inString, length, messageEnd, blocking);
+	return size;
 }

-bool BufferedTransformation::ChannelFlush(const std::string &channel, bool completeFlush, int propagation, bool blocking)
+bool BufferedTransformation::ChannelFlush(const std::string &channel, bool hardFlush, int propagation, bool blocking)
 {
+	bool result = 0;
 	if (channel.empty())
-		return Flush(completeFlush, propagation, blocking);
+		result = Flush(hardFlush, propagation, blocking);
 	else
 		throw NoChannelSupport(AlgorithmName());
+	return result;
 }

 bool BufferedTransformation::ChannelMessageSeriesEnd(const std::string &channel, int propagation, bool blocking)
 {
+	bool result = false;
 	if (channel.empty())
-		return MessageSeriesEnd(propagation, blocking);
+		result = MessageSeriesEnd(propagation, blocking);
 	else
 		throw NoChannelSupport(AlgorithmName());
+	return result;
 }

 lword BufferedTransformation::MaxRetrievable() const
 {
+	lword size = 0;
 	if (AttachedTransformation())
-		return AttachedTransformation()->MaxRetrievable();
+		size = AttachedTransformation()->MaxRetrievable();
 	else
-		return CopyTo(TheBitBucket());
+		size = CopyTo(TheBitBucket());
+	return size;
 }

 bool BufferedTransformation::AnyRetrievable() const
 {
+	bool result = false;
 	if (AttachedTransformation())
-		return AttachedTransformation()->AnyRetrievable();
+		result = AttachedTransformation()->AnyRetrievable();
 	else
 	{
 		byte b;
-		return Peek(b) != 0;
+		result = Peek(b) != 0;
 	}
+	return result;
 }

 size_t BufferedTransformation::Get(byte &outByte)
 {
+	size_t size = 0;
 	if (AttachedTransformation())
-		return AttachedTransformation()->Get(outByte);
+		size = AttachedTransformation()->Get(outByte);
 	else
-		return Get(&outByte, 1);
+		size = Get(&outByte, 1);
+	return size;
 }

 size_t BufferedTransformation::Get(byte *outString, size_t getMax)
 {
+	size_t size = 0;
 	if (AttachedTransformation())
-		return AttachedTransformation()->Get(outString, getMax);
+		size = AttachedTransformation()->Get(outString, getMax);
 	else
 	{
 		ArraySink arraySink(outString, getMax);
-		return (size_t)TransferTo(arraySink, getMax);
+		size = (size_t)TransferTo(arraySink, getMax);
 	}
+	return size;
 }

 size_t BufferedTransformation::Peek(byte &outByte) const
 {
+	size_t size = 0;
 	if (AttachedTransformation())
-		return AttachedTransformation()->Peek(outByte);
+		size = AttachedTransformation()->Peek(outByte);
 	else
-		return Peek(&outByte, 1);
+		size = Peek(&outByte, 1);
+	return size;
 }

 size_t BufferedTransformation::Peek(byte *outString, size_t peekMax) const
 {
+	size_t size = 0;
 	if (AttachedTransformation())
-		return AttachedTransformation()->Peek(outString, peekMax);
+		size = AttachedTransformation()->Peek(outString, peekMax);
 	else
 	{
 		ArraySink arraySink(outString, peekMax);
-		return (size_t)CopyTo(arraySink, peekMax);
+		size = (size_t)CopyTo(arraySink, peekMax);
 	}
+	return size;
 }

 lword BufferedTransformation::Skip(lword skipMax)
 {
+	lword size = 0;
 	if (AttachedTransformation())
-		return AttachedTransformation()->Skip(skipMax);
+		size = AttachedTransformation()->Skip(skipMax);
 	else
-		return TransferTo(TheBitBucket(), skipMax);
+		size = TransferTo(TheBitBucket(), skipMax);
+	return size;
 }

 lword BufferedTransformation::TotalBytesRetrievable() const
 {
+	lword size = 0;
 	if (AttachedTransformation())
-		return AttachedTransformation()->TotalBytesRetrievable();
+		size = AttachedTransformation()->TotalBytesRetrievable();
 	else
-		return MaxRetrievable();
+		size = MaxRetrievable();
+	return size;
 }

 unsigned int BufferedTransformation::NumberOfMessages() const
 {
+	unsigned int size = 0;
 	if (AttachedTransformation())
-		return AttachedTransformation()->NumberOfMessages();
+		size = AttachedTransformation()->NumberOfMessages();
 	else
-		return CopyMessagesTo(TheBitBucket());
+		size = CopyMessagesTo(TheBitBucket());
+	return size;
 }

 bool BufferedTransformation::AnyMessages() const
 {
+	bool result = false;
 	if (AttachedTransformation())
-		return AttachedTransformation()->AnyMessages();
+		result = AttachedTransformation()->AnyMessages();
 	else
-		return NumberOfMessages() != 0;
+		result = NumberOfMessages() != 0;
+	return result;
 }

 bool BufferedTransformation::GetNextMessage()
 {
+	bool result = false;
 	if (AttachedTransformation())
-		return AttachedTransformation()->GetNextMessage();
+		result = AttachedTransformation()->GetNextMessage();
 	else
 	{
 		CRYPTOPP_ASSERT(!AnyMessages());
-		return false;
 	}
+	return result;
 }

 unsigned int BufferedTransformation::SkipMessages(unsigned int count)
 {
+	unsigned int size = 0;
 	if (AttachedTransformation())
-		return AttachedTransformation()->SkipMessages(count);
+		size = AttachedTransformation()->SkipMessages(count);
 	else
-		return TransferMessagesTo(TheBitBucket(), count);
+		size = TransferMessagesTo(TheBitBucket(), count);
+	return size;
 }

 size_t BufferedTransformation::TransferMessagesTo2(BufferedTransformation &target, unsigned int &messageCount, const std::string &channel, bool blocking)
@ -609,10 +644,10 @@ size_t BufferedTransformation::TransferMessagesTo2(BufferedTransformation &targe

 unsigned int BufferedTransformation::CopyMessagesTo(BufferedTransformation &target, unsigned int count, const std::string &channel) const
 {
+	unsigned int size = 0;
 	if (AttachedTransformation())
-		return AttachedTransformation()->CopyMessagesTo(target, count, channel);
-	else
-		return 0;
+		size = AttachedTransformation()->CopyMessagesTo(target, count, channel);
+	return size;
 }

 void BufferedTransformation::SkipAll()
@ -745,12 +780,12 @@ size_t BufferedTransformation::GetWord32(word32 &value, ByteOrder order)
 	return (size_t)Skip(PeekWord32(value, order));
 }

-void BufferedTransformation::Attach(BufferedTransformation *newOut)
+void BufferedTransformation::Attach(BufferedTransformation *newAttachment)
 {
 	if (AttachedTransformation() && AttachedTransformation()->Attachable())
-		AttachedTransformation()->Attach(newOut);
+		AttachedTransformation()->Attach(newAttachment);
 	else
-		Detach(newOut);
+		Detach(newAttachment);
 }

 void GeneratableCryptoMaterial::GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize)
@ -879,10 +914,10 @@ bool PK_Verifier::Verify(PK_MessageAccumulator *messageAccumulator) const
 	return VerifyAndRestart(*m);
 }

-bool PK_Verifier::VerifyMessage(const byte *message, size_t messageLen, const byte *signature, size_t signatureLength) const
+bool PK_Verifier::VerifyMessage(const byte *message, size_t messageLen, const byte *signature, size_t signatureLen) const
 {
 	member_ptr<PK_MessageAccumulator> m(NewVerificationAccumulator());
-	InputSignature(*m, signature, signatureLength);
+	InputSignature(*m, signature, signatureLen);
 	m->Update(message, messageLen);
 	return VerifyAndRestart(*m);
 }