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 ¶ms = 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; }
size_t ArraySink::Put2(const byte *begin, size_t length, int messageEnd, bool blocking) { CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking); // Avoid passing NULL pointer to memcpy. Using memmove due to // Valgrind finding on overlapping buffers. size_t copied = 0; if (m_buf && begin) { copied = STDMIN(length, SaturatingSubtract(m_size, m_total)); memmove(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 ChannelSwitch::IsolatedInitialize(const NameValuePairs& parameters) { CRYPTOPP_UNUSED(parameters); m_routeMap.clear(); m_defaultRoutes.clear(); m_blocked = false; }
Integer InvertibleLUCFunction::CalculateInverse(RandomNumberGenerator &rng, const Integer &x) const { // not clear how to do blinding with LUC CRYPTOPP_UNUSED(rng); DoQuickSanityCheck(); return InverseLucas(m_e, x, m_q, m_p, m_u); }
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; }
DecodingResult PKCS_EncryptionPaddingScheme::Unpad(const byte *pkcsBlock, size_t pkcsBlockLen, byte *output, const NameValuePairs& parameters) const { CRYPTOPP_UNUSED(parameters); bool invalid = false; size_t maxOutputLen = MaxUnpaddedLength(pkcsBlockLen); // convert from bit length to byte length if (pkcsBlockLen % 8 != 0) { invalid = (pkcsBlock[0] != 0) || invalid; pkcsBlock++; } pkcsBlockLen /= 8; // Require block type 2. invalid = (pkcsBlock[0] != 2) || invalid; // skip past the padding until we find the separator size_t i=1; while (i<pkcsBlockLen && pkcsBlock[i++]) { // null body } CRYPTOPP_ASSERT(i==pkcsBlockLen || pkcsBlock[i-1]==0); size_t outputLen = pkcsBlockLen - i; invalid = (outputLen > maxOutputLen) || invalid; if (invalid) return DecodingResult(); memcpy (output, pkcsBlock+i, outputLen); return DecodingResult(outputLen); }
bool MeterFilter::IsolatedMessageSeriesEnd(bool blocking) { CRYPTOPP_UNUSED(blocking); m_currentMessageBytes = 0; m_currentSeriesMessages = 0; m_totalMessageSeries++; return false; }
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 ¶ms = 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 ¶meters) { 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; }