Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members

# cryptlib.cpp

    00001 // cryptlib.cpp - written and placed in the public domain by Wei Dai
    00002
    00003 #include "pch.h"
    00004
    00005 #ifndef CRYPTOPP_IMPORTS
    00006
    00007 #include "cryptlib.h"
    00008 #include "misc.h"
    00009 #include "filters.h"
    00010 #include "algparam.h"
    00011 #include "fips140.h"
    00012 #include "argnames.h"
    00013 #include "fltrimpl.h"
    00014
    00015 #include <memory>
    00016
    00017 NAMESPACE_BEGIN(CryptoPP)
    00018
    00019 CRYPTOPP_COMPILE_ASSERT(sizeof(byte) == 1);
    00020 CRYPTOPP_COMPILE_ASSERT(sizeof(word16) == 2);
    00021 CRYPTOPP_COMPILE_ASSERT(sizeof(word32) == 4);
    00022 #ifdef WORD64_AVAILABLE
    00023 CRYPTOPP_COMPILE_ASSERT(sizeof(word64) == 8);
    00024 #endif
    00025 #ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
    00026 CRYPTOPP_COMPILE_ASSERT(sizeof(dword) == 2*sizeof(word));
    00027 #endif
    00028
    00029 const std::string BufferedTransformation::NULL_CHANNEL;
    00030 const NullNameValuePairs g_nullNameValuePairs;
    00031
    00032 BufferedTransformation & TheBitBucket()
    00033 {
    00034         static BitBucket bitBucket;
    00035         return bitBucket;
    00036 }
    00037
    00038 Algorithm::Algorithm(bool checkSelfTestStatus)
    00039 {
    00040         if (checkSelfTestStatus && FIPS_140_2_ComplianceEnabled())
    00041         {
    00042                 if (GetPowerUpSelfTestStatus() == POWER_UP_SELF_TEST_NOT_DONE && !PowerUpSelfTestInProgressOnThisThread())
    00043                         throw SelfTestFailure("Cryptographic algorithms are disabled before the power-up self tests are performed.");
    00044
    00045                 if (GetPowerUpSelfTestStatus() == POWER_UP_SELF_TEST_FAILED)
    00046                         throw SelfTestFailure("Cryptographic algorithms are disabled after a power-up self test failed.");
    00047         }
    00048 }
    00049
    00050 void SimpleKeyingInterface::SetKeyWithRounds(const byte *key, unsigned int length, int rounds)
    00051 {
    00052         SetKey(key, length, MakeParameters(Name::Rounds(), rounds));
    00053 }
    00054
    00055 void SimpleKeyingInterface::SetKeyWithIV(const byte *key, unsigned int length, const byte *iv)
    00056 {
    00057         SetKey(key, length, MakeParameters(Name::IV(), iv));
    00058 }
    00059
    00060 void SimpleKeyingInterface::ThrowIfInvalidKeyLength(const Algorithm &algorithm, unsigned int length)
    00061 {
    00062         if (!IsValidKeyLength(length))
    00063                 throw InvalidKeyLength(algorithm.AlgorithmName(), length);
    00064 }
    00065
    00066 void SimpleKeyingInterface::ThrowIfResynchronizable()
    00067 {
    00068         if (IsResynchronizable())
    00069                 throw InvalidArgument("SimpleKeyingInterface: this object requires an IV");
    00070 }
    00071
    00072 void SimpleKeyingInterface::ThrowIfInvalidIV(const byte *iv)
    00073 {
    00074         if (!iv && !(IVRequirement() == INTERNALLY_GENERATED_IV || IVRequirement() == STRUCTURED_IV || !IsResynchronizable()))
    00075                 throw InvalidArgument("SimpleKeyingInterface: this object cannot use a null IV");
    00076 }
    00077
    00078 const byte * SimpleKeyingInterface::GetIVAndThrowIfInvalid(const NameValuePairs &params)
    00079 {
    00080         const byte *iv;
    00081         if (params.GetValue(Name::IV(), iv))
    00082                 ThrowIfInvalidIV(iv);
    00083         else
    00084                 ThrowIfResynchronizable();
    00085         return iv;
    00086 }
    00087
    00088 void BlockTransformation::ProcessAndXorMultipleBlocks(const byte *inBlocks, const byte *xorBlocks, byte *outBlocks, unsigned int numberOfBlocks) const
    00089 {
    00090         unsigned int blockSize = BlockSize();
    00091         while (numberOfBlocks--)
    00092         {
    00093                 ProcessAndXorBlock(inBlocks, xorBlocks, outBlocks);
    00094                 inBlocks += blockSize;
    00095                 outBlocks += blockSize;
    00096                 if (xorBlocks)
    00097                         xorBlocks += blockSize;
    00098         }
    00099 }
    00100
    00101 void StreamTransformation::ProcessLastBlock(byte *outString, const byte *inString, unsigned int length)
    00102 {
    00103         assert(MinLastBlockSize() == 0);        // this function should be overriden otherwise
    00104
    00105         if (length == MandatoryBlockSize())
    00106                 ProcessData(outString, inString, length);
    00107         else if (length != 0)
    00108                 throw NotImplemented("StreamTransformation: this object does't support a special last block");
    00109 }
    00110
    00111 unsigned int RandomNumberGenerator::GenerateBit()
    00112 {
    00113         return Parity(GenerateByte());
    00114 }
    00115
    00116 void RandomNumberGenerator::GenerateBlock(byte *output, unsigned int size)
    00117 {
    00118         while (size--)
    00119                 *output++ = GenerateByte();
    00120 }
    00121
    00122 word32 RandomNumberGenerator::GenerateWord32(word32 min, word32 max)
    00123 {
    00124         word32 range = max-min;
    00125         const int maxBytes = BytePrecision(range);
    00126         const int maxBits = BitPrecision(range);
    00127
    00128         word32 value;
    00129
    00130         do
    00131         {
    00132                 value = 0;
    00133                 for (int i=0; i<maxBytes; i++)
    00134                         value = (value << 8) | GenerateByte();
    00135
    00136                 value = Crop(value, maxBits);
    00137         } while (value > range);
    00138
    00139         return value+min;
    00140 }
    00141
    00142 void RandomNumberGenerator::DiscardBytes(unsigned int n)
    00143 {
    00144         while (n--)
    00145                 GenerateByte();
    00146 }
    00147
    00148 //! see NullRNG()
    00149 class ClassNullRNG : public RandomNumberGenerator
    00150 {
    00151 public:
    00152         std::string AlgorithmName() const {return "NullRNG";}
    00153         byte GenerateByte() {throw NotImplemented("NullRNG: NullRNG should only be passed to functions that don't need to generate random bytes");}
    00154 };
    00155
    00156 RandomNumberGenerator & NullRNG()
    00157 {
    00158         static ClassNullRNG s_nullRNG;
    00159         return s_nullRNG;
    00160 }
    00161
    00162 bool HashTransformation::TruncatedVerify(const byte *digestIn, unsigned int digestLength)
    00163 {
    00164         ThrowIfInvalidTruncatedSize(digestLength);
    00165         SecByteBlock digest(digestLength);
    00166         TruncatedFinal(digest, digestLength);
    00167         return memcmp(digest, digestIn, digestLength) == 0;
    00168 }
    00169
    00170 void HashTransformation::ThrowIfInvalidTruncatedSize(unsigned int size) const
    00171 {
    00172         if (size > DigestSize())
    00173                 throw InvalidArgument("HashTransformation: can't truncate a " + IntToString(DigestSize()) + " byte digest to " + IntToString(size) + " bytes");
    00174 }
    00175
    00176 unsigned int BufferedTransformation::GetMaxWaitObjectCount() const
    00177 {
    00178         const BufferedTransformation *t = AttachedTransformation();
    00179         return t ? t->GetMaxWaitObjectCount() : 0;
    00180 }
    00181
    00182 void BufferedTransformation::GetWaitObjects(WaitObjectContainer &container)
    00183 {
    00184         BufferedTransformation *t = AttachedTransformation();
    00185         if (t)
    00186                 t->GetWaitObjects(container);
    00187 }
    00188
    00189 void BufferedTransformation::Initialize(const NameValuePairs &parameters, int propagation)
    00190 {
    00191         assert(!AttachedTransformation());
    00192         IsolatedInitialize(parameters);
    00193 }
    00194
    00195 bool BufferedTransformation::Flush(bool hardFlush, int propagation, bool blocking)
    00196 {
    00197         assert(!AttachedTransformation());
    00198         return IsolatedFlush(hardFlush, blocking);
    00199 }
    00200
    00201 bool BufferedTransformation::MessageSeriesEnd(int propagation, bool blocking)
    00202 {
    00203         assert(!AttachedTransformation());
    00204         return IsolatedMessageSeriesEnd(blocking);
    00205 }
    00206
    00207 byte * BufferedTransformation::ChannelCreatePutSpace(const std::string &channel, unsigned int &size)
    00208 {
    00209         if (channel.empty())
    00210                 return CreatePutSpace(size);
    00211         else
    00212                 throw NoChannelSupport();
    00213 }
    00214
    00215 unsigned int BufferedTransformation::ChannelPut2(const std::string &channel, const byte *begin, unsigned int length, int messageEnd, bool blocking)
    00216 {
    00217         if (channel.empty())
    00218                 return Put2(begin, length, messageEnd, blocking);
    00219         else
    00220                 throw NoChannelSupport();
    00221 }
    00222
    00223 unsigned int BufferedTransformation::ChannelPutModifiable2(const std::string &channel, byte *begin, unsigned int length, int messageEnd, bool blocking)
    00224 {
    00225         if (channel.empty())
    00226                 return PutModifiable2(begin, length, messageEnd, blocking);
    00227         else
    00228                 return ChannelPut2(channel, begin, length, messageEnd, blocking);
    00229 }
    00230
    00231 bool BufferedTransformation::ChannelFlush(const std::string &channel, bool completeFlush, int propagation, bool blocking)
    00232 {
    00233         if (channel.empty())
    00234                 return Flush(completeFlush, propagation, blocking);
    00235         else
    00236                 throw NoChannelSupport();
    00237 }
    00238
    00239 bool BufferedTransformation::ChannelMessageSeriesEnd(const std::string &channel, int propagation, bool blocking)
    00240 {
    00241         if (channel.empty())
    00242                 return MessageSeriesEnd(propagation, blocking);
    00243         else
    00244                 throw NoChannelSupport();
    00245 }
    00246
    00247 unsigned long BufferedTransformation::MaxRetrievable() const
    00248 {
    00249         if (AttachedTransformation())
    00250                 return AttachedTransformation()->MaxRetrievable();
    00251         else
    00252                 return CopyTo(TheBitBucket());
    00253 }
    00254
    00255 bool BufferedTransformation::AnyRetrievable() const
    00256 {
    00257         if (AttachedTransformation())
    00258                 return AttachedTransformation()->AnyRetrievable();
    00259         else
    00260         {
    00261                 byte b;
    00262                 return Peek(b) != 0;
    00263         }
    00264 }
    00265
    00266 unsigned int BufferedTransformation::Get(byte &outByte)
    00267 {
    00268         if (AttachedTransformation())
    00269                 return AttachedTransformation()->Get(outByte);
    00270         else
    00271                 return Get(&outByte, 1);
    00272 }
    00273
    00274 unsigned int BufferedTransformation::Get(byte *outString, unsigned int getMax)
    00275 {
    00276         if (AttachedTransformation())
    00277                 return AttachedTransformation()->Get(outString, getMax);
    00278         else
    00279         {
    00280                 ArraySink arraySink(outString, getMax);
    00281                 return TransferTo(arraySink, getMax);
    00282         }
    00283 }
    00284
    00285 unsigned int BufferedTransformation::Peek(byte &outByte) const
    00286 {
    00287         if (AttachedTransformation())
    00288                 return AttachedTransformation()->Peek(outByte);
    00289         else
    00290                 return Peek(&outByte, 1);
    00291 }
    00292
    00293 unsigned int BufferedTransformation::Peek(byte *outString, unsigned int peekMax) const
    00294 {
    00295         if (AttachedTransformation())
    00296                 return AttachedTransformation()->Peek(outString, peekMax);
    00297         else
    00298         {
    00299                 ArraySink arraySink(outString, peekMax);
    00300                 return CopyTo(arraySink, peekMax);
    00301         }
    00302 }
    00303
    00304 unsigned long BufferedTransformation::Skip(unsigned long skipMax)
    00305 {
    00306         if (AttachedTransformation())
    00307                 return AttachedTransformation()->Skip(skipMax);
    00308         else
    00309                 return TransferTo(TheBitBucket(), skipMax);
    00310 }
    00311
    00312 unsigned long BufferedTransformation::TotalBytesRetrievable() const
    00313 {
    00314         if (AttachedTransformation())
    00315                 return AttachedTransformation()->TotalBytesRetrievable();
    00316         else
    00317                 return MaxRetrievable();
    00318 }
    00319
    00320 unsigned int BufferedTransformation::NumberOfMessages() const
    00321 {
    00322         if (AttachedTransformation())
    00323                 return AttachedTransformation()->NumberOfMessages();
    00324         else
    00325                 return CopyMessagesTo(TheBitBucket());
    00326 }
    00327
    00328 bool BufferedTransformation::AnyMessages() const
    00329 {
    00330         if (AttachedTransformation())
    00331                 return AttachedTransformation()->AnyMessages();
    00332         else
    00333                 return NumberOfMessages() != 0;
    00334 }
    00335
    00336 bool BufferedTransformation::GetNextMessage()
    00337 {
    00338         if (AttachedTransformation())
    00339                 return AttachedTransformation()->GetNextMessage();
    00340         else
    00341         {
    00342                 assert(!AnyMessages());
    00343                 return false;
    00344         }
    00345 }
    00346
    00347 unsigned int BufferedTransformation::SkipMessages(unsigned int count)
    00348 {
    00349         if (AttachedTransformation())
    00350                 return AttachedTransformation()->SkipMessages(count);
    00351         else
    00352                 return TransferMessagesTo(TheBitBucket(), count);
    00353 }
    00354
    00355 unsigned int BufferedTransformation::TransferMessagesTo2(BufferedTransformation &target, unsigned int &messageCount, const std::string &channel, bool blocking)
    00356 {
    00357         if (AttachedTransformation())
    00358                 return AttachedTransformation()->TransferMessagesTo2(target, messageCount, channel, blocking);
    00359         else
    00360         {
    00361                 unsigned int maxMessages = messageCount;
    00362                 for (messageCount=0; messageCount < maxMessages && AnyMessages(); messageCount++)
    00363                 {
    00364                         unsigned int blockedBytes;
    00365                         unsigned long transferredBytes;
    00366
    00367                         while (AnyRetrievable())
    00368                         {
    00369                                 transferredBytes = ULONG_MAX;
    00370                                 blockedBytes = TransferTo2(target, transferredBytes, channel, blocking);
    00371                                 if (blockedBytes > 0)
    00372                                         return blockedBytes;
    00373                         }
    00374
    00375                         if (target.ChannelMessageEnd(channel, GetAutoSignalPropagation(), blocking))
    00376                                 return 1;
    00377
    00378                         bool result = GetNextMessage();
    00379                         assert(result);
    00380                 }
    00381                 return 0;
    00382         }
    00383 }
    00384
    00385 unsigned int BufferedTransformation::CopyMessagesTo(BufferedTransformation &target, unsigned int count, const std::string &channel) const
    00386 {
    00387         if (AttachedTransformation())
    00388                 return AttachedTransformation()->CopyMessagesTo(target, count, channel);
    00389         else
    00390                 return 0;
    00391 }
    00392
    00393 void BufferedTransformation::SkipAll()
    00394 {
    00395         if (AttachedTransformation())
    00396                 AttachedTransformation()->SkipAll();
    00397         else
    00398         {
    00399                 while (SkipMessages()) {}
    00400                 while (Skip()) {}
    00401         }
    00402 }
    00403
    00404 unsigned int BufferedTransformation::TransferAllTo2(BufferedTransformation &target, const std::string &channel, bool blocking)
    00405 {
    00406         if (AttachedTransformation())
    00407                 return AttachedTransformation()->TransferAllTo2(target, channel, blocking);
    00408         else
    00409         {
    00410                 assert(!NumberOfMessageSeries());
    00411
    00412                 unsigned int messageCount;
    00413                 do
    00414                 {
    00415                         messageCount = UINT_MAX;
    00416                         unsigned int blockedBytes = TransferMessagesTo2(target, messageCount, channel, blocking);
    00417                         if (blockedBytes)
    00418                                 return blockedBytes;
    00419                 }
    00420                 while (messageCount != 0);
    00421
    00422                 unsigned long byteCount;
    00423                 do
    00424                 {
    00425                         byteCount = ULONG_MAX;
    00426                         unsigned int blockedBytes = TransferTo2(target, byteCount, channel, blocking);
    00427                         if (blockedBytes)
    00428                                 return blockedBytes;
    00429                 }
    00430                 while (byteCount != 0);
    00431
    00432                 return 0;
    00433         }
    00434 }
    00435
    00436 void BufferedTransformation::CopyAllTo(BufferedTransformation &target, const std::string &channel) const
    00437 {
    00438         if (AttachedTransformation())
    00439                 AttachedTransformation()->CopyAllTo(target, channel);
    00440         else
    00441         {
    00442                 assert(!NumberOfMessageSeries());
    00443                 while (CopyMessagesTo(target, UINT_MAX, channel)) {}
    00444         }
    00445 }
    00446
    00447 void BufferedTransformation::SetRetrievalChannel(const std::string &channel)
    00448 {
    00449         if (AttachedTransformation())
    00450                 AttachedTransformation()->SetRetrievalChannel(channel);
    00451 }
    00452
    00453 unsigned int BufferedTransformation::ChannelPutWord16(const std::string &channel, word16 value, ByteOrder order, bool blocking)
    00454 {
    00455         FixedSizeSecBlock<byte, 2> buf;
    00456         PutWord(false, order, buf, value);
    00457         return ChannelPut(channel, buf, 2, blocking);
    00458 }
    00459
    00460 unsigned int BufferedTransformation::ChannelPutWord32(const std::string &channel, word32 value, ByteOrder order, bool blocking)
    00461 {
    00462         FixedSizeSecBlock<byte, 4> buf;
    00463         PutWord(false, order, buf, value);
    00464         return ChannelPut(channel, buf, 4, blocking);
    00465 }
    00466
    00467 unsigned int BufferedTransformation::PutWord16(word16 value, ByteOrder order, bool blocking)
    00468 {
    00469         return ChannelPutWord16(NULL_CHANNEL, value, order, blocking);
    00470 }
    00471
    00472 unsigned int BufferedTransformation::PutWord32(word32 value, ByteOrder order, bool blocking)
    00473 {
    00474         return ChannelPutWord32(NULL_CHANNEL, value, order, blocking);
    00475 }
    00476
    00477 unsigned int BufferedTransformation::PeekWord16(word16 &value, ByteOrder order) const
    00478 {
    00479         byte buf[2] = {0, 0};
    00480         unsigned int len = Peek(buf, 2);
    00481
    00482         if (order)
    00483                 value = (buf[0] << 8) | buf[1];
    00484         else
    00485                 value = (buf[1] << 8) | buf[0];
    00486
    00487         return len;
    00488 }
    00489
    00490 unsigned int BufferedTransformation::PeekWord32(word32 &value, ByteOrder order) const
    00491 {
    00492         byte buf[4] = {0, 0, 0, 0};
    00493         unsigned int len = Peek(buf, 4);
    00494
    00495         if (order)
    00496                 value = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf [3];
    00497         else
    00498                 value = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf [0];
    00499
    00500         return len;
    00501 }
    00502
    00503 unsigned int BufferedTransformation::GetWord16(word16 &value, ByteOrder order)
    00504 {
    00505         return Skip(PeekWord16(value, order));
    00506 }
    00507
    00508 unsigned int BufferedTransformation::GetWord32(word32 &value, ByteOrder order)
    00509 {
    00510         return Skip(PeekWord32(value, order));
    00511 }
    00512
    00513 void BufferedTransformation::Attach(BufferedTransformation *newOut)
    00514 {
    00515         if (AttachedTransformation() && AttachedTransformation()->Attachable())
    00516                 AttachedTransformation()->Attach(newOut);
    00517         else
    00518                 Detach(newOut);
    00519 }
    00520
    00521 void GeneratableCryptoMaterial::GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize)
    00522 {
    00523         GenerateRandom(rng, MakeParameters("KeySize", (int)keySize));
    00524 }
    00525
    00526 class PK_DefaultEncryptionFilter : public Unflushable<Filter>
    00527 {
    00528 public:
    00529         PK_DefaultEncryptionFilter(RandomNumberGenerator &rng, const PK_Encryptor &encryptor, BufferedTransformation *attachment, const NameValuePairs &parameters)
    00530                 : m_rng(rng), m_encryptor(encryptor), m_parameters(parameters)
    00531         {
    00532                 Detach(attachment);
    00533         }
    00534
    00535         unsigned int Put2(const byte *inString, unsigned int length, int messageEnd, bool blocking)
    00536         {
    00537                 FILTER_BEGIN;
    00538                 m_plaintextQueue.Put(inString, length);
    00539
    00540                 if (messageEnd)
    00541                 {
    00542                         {
    00543                         unsigned int plaintextLength = m_plaintextQueue.CurrentSize();
    00544                         unsigned int ciphertextLength = m_encryptor.CiphertextLength(plaintextLength);
    00545
    00546                         SecByteBlock plaintext(plaintextLength);
    00547                         m_plaintextQueue.Get(plaintext, plaintextLength);
    00548                         m_ciphertext.resize(ciphertextLength);
    00549                         m_encryptor.Encrypt(m_rng, plaintext, plaintextLength, m_ciphertext, m_parameters);
    00550                         }
    00551
    00552                         FILTER_OUTPUT(1, m_ciphertext, m_ciphertext.size(), messageEnd);
    00553                 }
    00554                 FILTER_END_NO_MESSAGE_END;
    00555         }
    00556
    00557         RandomNumberGenerator &m_rng;
    00558         const PK_Encryptor &m_encryptor;
    00559         const NameValuePairs &m_parameters;
    00560         ByteQueue m_plaintextQueue;
    00561         SecByteBlock m_ciphertext;
    00562 };
    00563
    00564 BufferedTransformation * PK_Encryptor::CreateEncryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment, const NameValuePairs &parameters) const
    00565 {
    00566         return new PK_DefaultEncryptionFilter(rng, *this, attachment, parameters);
    00567 }
    00568
    00569 class PK_DefaultDecryptionFilter : public Unflushable<Filter>
    00570 {
    00571 public:
    00572         PK_DefaultDecryptionFilter(RandomNumberGenerator &rng, const PK_Decryptor &decryptor, BufferedTransformation *attachment, const NameValuePairs &parameters)
    00573                 : m_rng(rng), m_decryptor(decryptor), m_parameters(parameters)
    00574         {
    00575                 Detach(attachment);
    00576         }
    00577
    00578         unsigned int Put2(const byte *inString, unsigned int length, int messageEnd, bool blocking)
    00579         {
    00580                 FILTER_BEGIN;
    00581                 m_ciphertextQueue.Put(inString, length);
    00582
    00583                 if (messageEnd)
    00584                 {
    00585                         {
    00586                         unsigned int ciphertextLength = m_ciphertextQueue.CurrentSize();
    00587                         unsigned int maxPlaintextLength = m_decryptor.MaxPlaintextLength(ciphertextLength);
    00588
    00589                         SecByteBlock ciphertext(ciphertextLength);
    00590                         m_ciphertextQueue.Get(ciphertext, ciphertextLength);
    00591                         m_plaintext.resize(maxPlaintextLength);
    00592                         m_result = m_decryptor.Decrypt(m_rng, ciphertext, ciphertextLength, m_plaintext, m_parameters);
    00593                         if (!m_result.isValidCoding)
    00594                                 throw InvalidCiphertext(m_decryptor.AlgorithmName() + ": invalid ciphertext");
    00595                         }
    00596
    00597                         FILTER_OUTPUT(1, m_plaintext, m_result.messageLength, messageEnd);
    00598                 }
    00599                 FILTER_END_NO_MESSAGE_END;
    00600         }
    00601
    00602         RandomNumberGenerator &m_rng;
    00603         const PK_Decryptor &m_decryptor;
    00604         const NameValuePairs &m_parameters;
    00605         ByteQueue m_ciphertextQueue;
    00606         SecByteBlock m_plaintext;
    00607         DecodingResult m_result;
    00608 };
    00609
    00610 BufferedTransformation * PK_Decryptor::CreateDecryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment, const NameValuePairs &parameters) const
    00611 {
    00612         return new PK_DefaultDecryptionFilter(rng, *this, attachment, parameters);
    00613 }
    00614
    00615 unsigned int PK_Signer::Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const
    00616 {
    00617         std::auto_ptr<PK_MessageAccumulator> m(messageAccumulator);
    00618         return SignAndRestart(rng, *m, signature, false);
    00619 }
    00620
    00621 unsigned int PK_Signer::SignMessage(RandomNumberGenerator &rng, const byte *message, unsigned int messageLen, byte *signature) const
    00622 {
    00623         std::auto_ptr<PK_MessageAccumulator> m(NewSignatureAccumulator(rng));
    00624         m->Update(message, messageLen);
    00625         return SignAndRestart(rng, *m, signature, false);
    00626 }
    00627
    00628 unsigned int PK_Signer::SignMessageWithRecovery(RandomNumberGenerator &rng, const byte *recoverableMessage, unsigned int recoverableMessageLength,
    00629         const byte *nonrecoverableMessage, unsigned int nonrecoverableMessageLength, byte *signature) const
    00630 {
    00631         std::auto_ptr<PK_MessageAccumulator> m(NewSignatureAccumulator(rng));
    00632         InputRecoverableMessage(*m, recoverableMessage, recoverableMessageLength);
    00633         m->Update(nonrecoverableMessage, nonrecoverableMessageLength);
    00634         return SignAndRestart(rng, *m, signature, false);
    00635 }
    00636
    00637 bool PK_Verifier::Verify(PK_MessageAccumulator *messageAccumulator) const
    00638 {
    00639         std::auto_ptr<PK_MessageAccumulator> m(messageAccumulator);
    00640         return VerifyAndRestart(*m);
    00641 }
    00642
    00643 bool PK_Verifier::VerifyMessage(const byte *message, unsigned int messageLen, const byte *signature, unsigned int signatureLength) const
    00644 {
    00645         std::auto_ptr<PK_MessageAccumulator> m(NewVerificationAccumulator());
    00646         InputSignature(*m, signature, signatureLength);
    00647         m->Update(message, messageLen);
    00648         return VerifyAndRestart(*m);
    00649 }
    00650
    00651 DecodingResult PK_Verifier::Recover(byte *recoveredMessage, PK_MessageAccumulator *messageAccumulator) const
    00652 {
    00653         std::auto_ptr<PK_MessageAccumulator> m(messageAccumulator);
    00654         return RecoverAndRestart(recoveredMessage, *m);
    00655 }
    00656
    00657 DecodingResult PK_Verifier::RecoverMessage(byte *recoveredMessage,
    00658         const byte *nonrecoverableMessage, unsigned int nonrecoverableMessageLength,
    00659         const byte *signature, unsigned int signatureLength) const
    00660 {
    00661         std::auto_ptr<PK_MessageAccumulator> m(NewVerificationAccumulator());
    00662         InputSignature(*m, signature, signatureLength);
    00663         m->Update(nonrecoverableMessage, nonrecoverableMessageLength);
    00664         return RecoverAndRestart(recoveredMessage, *m);
    00665 }
    00666
    00667 void SimpleKeyAgreementDomain::GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
    00668 {
    00669         GeneratePrivateKey(rng, privateKey);
    00670         GeneratePublicKey(rng, privateKey, publicKey);
    00671 }
    00672
    00673 void AuthenticatedKeyAgreementDomain::GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
    00674 {
    00675         GenerateStaticPrivateKey(rng, privateKey);
    00676         GenerateStaticPublicKey(rng, privateKey, publicKey);
    00677 }
    00678
    00679 void AuthenticatedKeyAgreementDomain::GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
    00680 {
    00681         GenerateEphemeralPrivateKey(rng, privateKey);
    00682         GenerateEphemeralPublicKey(rng, privateKey, publicKey);
    00683 }
    00684
    00685 NAMESPACE_END
    00686
    00687 #endif