自学教程：C++ CRYPTOPP_UNUSED函数代码示例

void EncryptionPairwiseConsistencyTest_FIPS_140_Only(const PK_Encryptor &encryptor, const PK_Decryptor &decryptor){	CRYPTOPP_UNUSED(encryptor), CRYPTOPP_UNUSED(decryptor);#if CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2	EncryptionPairwiseConsistencyTest(encryptor, decryptor);#endif}

void RDSEED::GenerateBlock(byte *output, size_t size){	CRYPTOPP_UNUSED(output), CRYPTOPP_UNUSED(size);	CRYPTOPP_ASSERT((output && size) || !(output || size));	if(!HasRDSEED())		throw NotImplemented("RDSEED: rdseed is not available on this platform");	int rc; CRYPTOPP_UNUSED(rc);#if MASM_RDSEED_ASM_AVAILABLE	rc = MASM_RSA_GenerateBlock(output, size, m_retries);	if (!rc) { throw RDSEED_Err("MASM_RSA_GenerateBlock"); }#elif NASM_RDSEED_ASM_AVAILABLE	rc = NASM_RSA_GenerateBlock(output, size, m_retries);	if (!rc) { throw RDRAND_Err("NASM_RSA_GenerateBlock"); }#elif ALL_RDSEED_INTRIN_AVAILABLE	rc = ALL_RSI_GenerateBlock(output, size, m_retries);	if (!rc) { throw RDSEED_Err("ALL_RSI_GenerateBlock"); }#elif GCC_RDSEED_ASM_AVAILABLE	rc = GCC_RSA_GenerateBlock(output, size, m_retries);	if (!rc) { throw RDSEED_Err("GCC_RSA_GenerateBlock"); }#else	// RDSEED not detected at compile time, and no suitable compiler found	throw NotImplemented("RDSEED: failed to find a suitable implementation???");#endif}

void OFB_ModePolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length){	CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(length);	CRYPTOPP_ASSERT(length == BlockSize());	CopyOrZero(m_register, iv, length);}

void PKCS1v15_SignatureMessageEncodingMethod::ComputeMessageRepresentative(RandomNumberGenerator &rng,	const byte *recoverableMessage, size_t recoverableMessageLength,	HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,	byte *representative, size_t representativeBitLength) const{	CRYPTOPP_UNUSED(rng), CRYPTOPP_UNUSED(recoverableMessage), CRYPTOPP_UNUSED(recoverableMessageLength);	CRYPTOPP_UNUSED(messageEmpty), CRYPTOPP_UNUSED(hashIdentifier);	CRYPTOPP_ASSERT(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));	size_t pkcsBlockLen = representativeBitLength;	// convert from bit length to byte length	if (pkcsBlockLen % 8 != 0)	{		representative[0] = 0;		representative++;	}	pkcsBlockLen /= 8;	representative[0] = 1;   // block type 1	unsigned int digestSize = hash.DigestSize();	byte *pPadding = representative + 1;	byte *pDigest = representative + pkcsBlockLen - digestSize;	byte *pHashId = pDigest - hashIdentifier.second;	byte *pSeparator = pHashId - 1;	// pad with 0xff	memset(pPadding, 0xff, pSeparator-pPadding);	*pSeparator = 0;	memcpy(pHashId, hashIdentifier.first, hashIdentifier.second);	hash.Final(pDigest);}

void SignaturePairwiseConsistencyTest_FIPS_140_Only(const PK_Signer &signer, const PK_Verifier &verifier){	CRYPTOPP_UNUSED(signer), CRYPTOPP_UNUSED(verifier);#if CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2	SignaturePairwiseConsistencyTest(signer, verifier);#endif}

void CTR_ModePolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length){	CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(length);	assert(length == BlockSize());	CopyOrZero(m_register, iv, length);	m_counterArray = m_register;}

bool RWFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const{	CRYPTOPP_UNUSED(rng), CRYPTOPP_UNUSED(level);	bool pass = true;	pass = pass && m_n > Integer::One() && m_n%8 == 5;	CRYPTOPP_ASSERT(pass);	return pass;}

bool LUCFunction::Validate(RandomNumberGenerator &rng, unsigned int level) const{	CRYPTOPP_UNUSED(rng), CRYPTOPP_UNUSED(level);	bool pass = true;	pass = pass && m_n > Integer::One() && m_n.IsOdd();	pass = pass && m_e > Integer::One() && m_e.IsOdd() && m_e < m_n;	return pass;}

void ChaCha_Policy::CipherResynchronize(byte *keystreamBuffer, const byte *IV, size_t length){    CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(length);    CRYPTOPP_ASSERT(length==8);    GetBlock<word32, LittleEndian> get(IV);    m_state[12] = m_state[13] = 0;    get(m_state[14])(m_state[15]);}

void BenchMarkByNameKeyLess(const char *factoryName, const char *displayName=NULL, const NameValuePairs &params = g_nullNameValuePairs, T *x=NULL){	CRYPTOPP_UNUSED(x), CRYPTOPP_UNUSED(params);	std::string name = factoryName;	if (displayName)		name = displayName;	member_ptr<T> obj(ObjectFactoryRegistry<T>::Registry().CreateObject(factoryName));	BenchMark(name.c_str(), *obj, g_allocatedTime);}

void RandomNumberGenerator::GenerateBlock(byte *output, size_t size){	CRYPTOPP_UNUSED(output), CRYPTOPP_UNUSED(size);#if 0	// This breaks AutoSeededX917RNG<T> generators.	throw NotImplemented("RandomNumberGenerator: GenerateBlock not implemented");#endif	ArraySink s(output, size);	GenerateIntoBufferedTransformation(s, DEFAULT_CHANNEL, size);}

bool FileSink::IsolatedFlush(bool hardFlush, bool blocking){	CRYPTOPP_UNUSED(hardFlush), CRYPTOPP_UNUSED(blocking);	if (!m_stream)		throw Err("FileSink: output stream not opened");	m_stream->flush();	if (!m_stream->good())		throw WriteErr();	return false;}

size_t ArrayXorSink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking){	CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);	// Avoid passing NULL pointer to xorbuf	size_t copied = 0;	if (m_buf && begin)	{		copied = STDMIN(length, SaturatingSubtract(m_size, m_total));		xorbuf(m_buf+m_total, begin, copied);	}	m_total += copied;	return length - copied;}

void SetPowerUpSelfTestInProgressOnThisThread(bool inProgress){	CRYPTOPP_UNUSED(inProgress);#if CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2	s_inProgress = inProgress;#endif}

void SetPowerUpSelfTestInProgressOnThisThread(bool inProgress){	CRYPTOPP_UNUSED(inProgress);#if CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2	AccessPowerUpSelfTestInProgress().SetValue((void *)inProgress);#endif}

bool ChannelSwitch::ChannelMessageSeriesEnd(const std::string &channel, int propagation, bool blocking){	CRYPTOPP_UNUSED(blocking);	if (m_blocked)	{		m_blocked = false;		goto WasBlocked;	}	m_it.Reset(channel);	while (!m_it.End())	{	  WasBlocked:		if (m_it.Destination().ChannelMessageSeriesEnd(m_it.Channel(), propagation))		{			m_blocked = true;			return true;		}		m_it.Next();	}	return false;}

void BenchMarkVerification(const char *name, const PK_Signer &priv, PK_Verifier &pub, double timeTotal, bool pc=false){	unsigned int len = 16;	AlignedSecByteBlock message(len), signature(pub.SignatureLength());	GlobalRNG().GenerateBlock(message, len);	priv.SignMessage(GlobalRNG(), message, len, signature);	const clock_t start = clock();	unsigned int i;	double timeTaken;	for (timeTaken=(double)0, i=0; timeTaken < timeTotal; timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)	{		// The return value is ignored because we are interested in throughput		bool unused = pub.VerifyMessage(message, len, signature, signature.size());		CRYPTOPP_UNUSED(unused);	}	OutputResultOperations(name, "Verification", pc, i, timeTaken);	if (!pc && pub.GetMaterial().SupportsPrecomputation())	{		pub.AccessMaterial().Precompute(16);		BenchMarkVerification(name, priv, pub, timeTotal, true);	}}

size_t BufferedTransformation::TransferMessagesTo2(BufferedTransformation &target, unsigned int &messageCount, const std::string &channel, bool blocking){	if (AttachedTransformation())		return AttachedTransformation()->TransferMessagesTo2(target, messageCount, channel, blocking);	else	{		unsigned int maxMessages = messageCount;		for (messageCount=0; messageCount < maxMessages && AnyMessages(); messageCount++)		{			size_t blockedBytes;			lword transferredBytes;			while (AnyRetrievable())			{				transferredBytes = LWORD_MAX;				blockedBytes = TransferTo2(target, transferredBytes, channel, blocking);				if (blockedBytes > 0)					return blockedBytes;			}			if (target.ChannelMessageEnd(channel, GetAutoSignalPropagation(), blocking))				return 1;			bool result = GetNextMessage();			CRYPTOPP_UNUSED(result); CRYPTOPP_ASSERT(result);		}		return 0;	}}

PolynomialMod2& PolynomialMod2::operator<<=(unsigned int n){#if !defined(NDEBUG)	int x; CRYPTOPP_UNUSED(x);	assert(SafeConvert(n,x));#endif	if (!reg.size())		return *this;	int i;	word u;	word carry=0;	word *r=reg;	if (n==1)	// special case code for most frequent case	{		i = (int)reg.size();		while (i--)		{			u = *r;			*r = (u << 1) | carry;			carry = u >> (WORD_BITS-1);			r++;		}		if (carry)		{			reg.Grow(reg.size()+1);			reg[reg.size()-1] = carry;		}		return *this;	}

void BenchMarkKeyAgreement(const char *filename, const char *name, double timeTotal, D *x=NULL){	CRYPTOPP_UNUSED(x);	FileSource f(filename, true, new HexDecoder());	D d(f);	BenchMarkKeyGen(name, d, timeTotal);	BenchMarkAgreement(name, d, timeTotal);}

void BenchMarkByName2(const char *factoryName, size_t keyLength = 0, const char *displayName=NULL, const NameValuePairs &params = g_nullNameValuePairs, T_FactoryOutput *x=NULL, T_Interface *y=NULL){	CRYPTOPP_UNUSED(x), CRYPTOPP_UNUSED(y), CRYPTOPP_UNUSED(params);	std::string name(factoryName ? factoryName : "");	member_ptr<T_FactoryOutput> obj(ObjectFactoryRegistry<T_FactoryOutput>::Registry().CreateObject(name.c_str()));		if (!keyLength)		keyLength = obj->DefaultKeyLength();	if (displayName)		name = displayName;	else if (keyLength)		name += " (" + IntToString(keyLength * 8) + "-bit key)";	obj->SetKey(defaultKey, keyLength, CombinedNameValuePairs(params, MakeParameters(Name::IV(), ConstByteArrayParameter(defaultKey, obj->IVSize()), false)));	BenchMark(name.c_str(), *static_cast<T_Interface *>(obj.get()), g_allocatedTime);	BenchMarkKeying(*obj, keyLength, CombinedNameValuePairs(params, MakeParameters(Name::IV(), ConstByteArrayParameter(defaultKey, obj->IVSize()), false)));}

void ByteQueue::Walker::IsolatedInitialize(const NameValuePairs &parameters){	CRYPTOPP_UNUSED(parameters);	m_node = m_queue.m_head;	m_position = 0;	m_offset = 0;	m_lazyString = m_queue.m_lazyString;	m_lazyLength = m_queue.m_lazyLength;}

void BenchMarkSignature(const char *filename, const char *name, double timeTotal, SCHEME *x=NULL){	CRYPTOPP_UNUSED(x);	FileSource f(filename, true, new HexDecoder());	typename SCHEME::Signer priv(f);	typename SCHEME::Verifier pub(priv);	BenchMarkSigning(name, priv, timeTotal);	BenchMarkVerification(name, priv, pub, timeTotal);}

void BenchMarkCrypto(const char *filename, const char *name, double timeTotal, SCHEME *x=NULL){	CRYPTOPP_UNUSED(x);	FileSource f(filename, true, new HexDecoder());	typename SCHEME::Decryptor priv(f);	typename SCHEME::Encryptor pub(priv);	BenchMarkEncryption(name, pub, timeTotal);	BenchMarkDecryption(name, priv, pub, timeTotal);}

bool HuffmanDecoder::Decode(LowFirstBitReader &reader, value_t &value) const{	bool result = reader.FillBuffer(m_maxCodeBits);	CRYPTOPP_UNUSED(result); // CRYPTOPP_ASSERT(result);	unsigned int codeBits = Decode(reader.PeekBuffer(), value);	if (codeBits > reader.BitsBuffered())		return false;	reader.SkipBits(codeBits);	return true;}