00001
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 ¶ms)
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);
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
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 ¶meters,
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)
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)
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 ¶meters)
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 ¶meters)
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 ¶meters)
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 ¶meters)
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