00001
00002
00003
#include "pch.h"
00004
#include "asn.h"
00005
00006
#include <iomanip>
00007
#include <time.h>
00008
00009 NAMESPACE_BEGIN(CryptoPP)
00010 USING_NAMESPACE(std)
00011
00012
00013
unsigned int DERLengthEncode(
BufferedTransformation &bt,
unsigned int length)
00014 {
00015
unsigned int i=0;
00016
if (length <= 0x7f)
00017 {
00018 bt.Put(byte(length));
00019 i++;
00020 }
00021
else
00022 {
00023 bt.Put(byte(BytePrecision(length) | 0x80));
00024 i++;
00025
for (
int j=BytePrecision(length); j; --j)
00026 {
00027 bt.Put(byte(length >> (j-1)*8));
00028 i++;
00029 }
00030 }
00031
return i;
00032 }
00033
00034
bool BERLengthDecode(
BufferedTransformation &bt,
unsigned int &length,
bool &definiteLength)
00035 {
00036 byte b;
00037
00038
if (!bt.
Get(b))
00039
return false;
00040
00041
if (!(b & 0x80))
00042 {
00043 definiteLength =
true;
00044 length = b;
00045 }
00046
else
00047 {
00048
unsigned int lengthBytes = b & 0x7f;
00049
00050
if (lengthBytes == 0)
00051 {
00052 definiteLength =
false;
00053
return true;
00054 }
00055
00056 definiteLength =
true;
00057 length = 0;
00058
while (lengthBytes--)
00059 {
00060
if (length >> (8*(
sizeof(length)-1)))
00061 BERDecodeError();
00062
00063
if (!bt.
Get(b))
00064
return false;
00065
00066 length = (length << 8) | b;
00067 }
00068 }
00069
return true;
00070 }
00071
00072
bool BERLengthDecode(
BufferedTransformation &bt,
unsigned int &length)
00073 {
00074
bool definiteLength;
00075
if (!BERLengthDecode(bt, length, definiteLength))
00076 BERDecodeError();
00077
return definiteLength;
00078 }
00079
00080
void DEREncodeNull(
BufferedTransformation &out)
00081 {
00082 out.
Put(TAG_NULL);
00083 out.
Put(0);
00084 }
00085
00086
void BERDecodeNull(
BufferedTransformation &in)
00087 {
00088 byte b;
00089
if (!in.
Get(b) || b != TAG_NULL)
00090 BERDecodeError();
00091
unsigned int length;
00092
if (!BERLengthDecode(in, length) || length != 0)
00093 BERDecodeError();
00094 }
00095
00096
00097
unsigned int DEREncodeOctetString(
BufferedTransformation &bt,
const byte *str,
unsigned int strLen)
00098 {
00099 bt.
Put(OCTET_STRING);
00100
unsigned int lengthBytes = DERLengthEncode(bt, strLen);
00101 bt.
Put(str, strLen);
00102
return 1+lengthBytes+strLen;
00103 }
00104
00105
unsigned int DEREncodeOctetString(
BufferedTransformation &bt,
const SecByteBlock &str)
00106 {
00107
return DEREncodeOctetString(bt, str.
begin(), str.
size());
00108 }
00109
00110
unsigned int BERDecodeOctetString(
BufferedTransformation &bt,
SecByteBlock &str)
00111 {
00112 byte b;
00113
if (!bt.
Get(b) || b != OCTET_STRING)
00114 BERDecodeError();
00115
00116
unsigned int bc;
00117
if (!BERLengthDecode(bt, bc))
00118 BERDecodeError();
00119
00120 str.
resize(bc);
00121
if (bc != bt.
Get(str, bc))
00122 BERDecodeError();
00123
return bc;
00124 }
00125
00126
unsigned int BERDecodeOctetString(
BufferedTransformation &bt,
BufferedTransformation &str)
00127 {
00128 byte b;
00129
if (!bt.
Get(b) || b != OCTET_STRING)
00130 BERDecodeError();
00131
00132
unsigned int bc;
00133
if (!BERLengthDecode(bt, bc))
00134 BERDecodeError();
00135
00136 bt.
TransferTo(str, bc);
00137
return bc;
00138 }
00139
00140
unsigned int DEREncodeTextString(
BufferedTransformation &bt,
const std::string &str, byte asnTag)
00141 {
00142 bt.
Put(asnTag);
00143
unsigned int lengthBytes = DERLengthEncode(bt, str.size());
00144 bt.
Put((
const byte *)str.data(), str.size());
00145
return 1+lengthBytes+str.size();
00146 }
00147
00148
unsigned int BERDecodeTextString(
BufferedTransformation &bt, std::string &str, byte asnTag)
00149 {
00150 byte b;
00151
if (!bt.
Get(b) || b != asnTag)
00152 BERDecodeError();
00153
00154
unsigned int bc;
00155
if (!BERLengthDecode(bt, bc))
00156 BERDecodeError();
00157
00158
SecByteBlock temp(bc);
00159
if (bc != bt.
Get(temp, bc))
00160 BERDecodeError();
00161 str.assign((
char *)temp.
begin(), bc);
00162
return bc;
00163 }
00164
00165
00166
unsigned int DEREncodeBitString(
BufferedTransformation &bt,
const byte *str,
unsigned int strLen,
unsigned int unusedBits)
00167 {
00168 bt.
Put(BIT_STRING);
00169
unsigned int lengthBytes = DERLengthEncode(bt, strLen+1);
00170 bt.
Put((byte)unusedBits);
00171 bt.
Put(str, strLen);
00172
return 2+lengthBytes+strLen;
00173 }
00174
00175
unsigned int BERDecodeBitString(
BufferedTransformation &bt,
SecByteBlock &str,
unsigned int &unusedBits)
00176 {
00177 byte b;
00178
if (!bt.
Get(b) || b != BIT_STRING)
00179 BERDecodeError();
00180
00181
unsigned int bc;
00182
if (!BERLengthDecode(bt, bc))
00183 BERDecodeError();
00184
00185 byte unused;
00186
if (!bt.
Get(unused))
00187 BERDecodeError();
00188 unusedBits = unused;
00189 str.
resize(bc-1);
00190
if ((bc-1) != bt.
Get(str, bc-1))
00191 BERDecodeError();
00192
return bc-1;
00193 }
00194
00195
void OID::EncodeValue(
BufferedTransformation &bt,
unsigned long v)
00196 {
00197
for (
unsigned int i=RoundUpToMultipleOf(STDMAX(7U,BitPrecision(v)), 7U)-7; i != 0; i-=7)
00198 bt.
Put((byte)(0x80 | ((v >> i) & 0x7f)));
00199 bt.
Put((byte)(v & 0x7f));
00200 }
00201
00202
unsigned int OID::DecodeValue(
BufferedTransformation &bt,
unsigned long &v)
00203 {
00204 byte b;
00205
unsigned int i=0;
00206 v = 0;
00207
while (
true)
00208 {
00209
if (!bt.
Get(b))
00210 BERDecodeError();
00211 i++;
00212 v <<= 7;
00213 v += b & 0x7f;
00214
if (!(b & 0x80))
00215
return i;
00216 }
00217 }
00218
00219
void OID::DEREncode(
BufferedTransformation &bt)
const
00220
{
00221 assert(m_values.size() >= 2);
00222
ByteQueue temp;
00223 temp.Put(byte(m_values[0] * 40 + m_values[1]));
00224
for (
unsigned int i=2; i<m_values.size(); i++)
00225 EncodeValue(temp, m_values[i]);
00226 bt.
Put(OBJECT_IDENTIFIER);
00227 DERLengthEncode(bt, temp.
CurrentSize());
00228 temp.TransferTo(bt);
00229 }
00230
00231
void OID::BERDecode(
BufferedTransformation &bt)
00232 {
00233 byte b;
00234
if (!bt.
Get(b) || b != OBJECT_IDENTIFIER)
00235 BERDecodeError();
00236
00237
unsigned int length;
00238
if (!BERLengthDecode(bt, length) || length < 1)
00239 BERDecodeError();
00240
00241
if (!bt.
Get(b))
00242 BERDecodeError();
00243
00244 length--;
00245 m_values.resize(2);
00246 m_values[0] = b / 40;
00247 m_values[1] = b % 40;
00248
00249
while (length > 0)
00250 {
00251
unsigned long v;
00252
unsigned int valueLen = DecodeValue(bt, v);
00253
if (valueLen > length)
00254 BERDecodeError();
00255 m_values.push_back(v);
00256 length -= valueLen;
00257 }
00258 }
00259
00260
void OID::BERDecodeAndCheck(
BufferedTransformation &bt)
const
00261
{
00262
OID oid(bt);
00263
if (*
this != oid)
00264 BERDecodeError();
00265 }
00266
00267
inline BufferedTransformation & EncodedObjectFilter::CurrentTarget()
00268 {
00269
if (m_flags & PUT_OBJECTS)
00270
return *AttachedTransformation();
00271
else
00272
return TheBitBucket();
00273 }
00274
00275
void EncodedObjectFilter::Put(
const byte *inString,
unsigned int length)
00276 {
00277
if (m_nCurrentObject == m_nObjects)
00278 {
00279 AttachedTransformation()->Put(inString, length);
00280
return;
00281 }
00282
00283
LazyPutter lazyPutter(m_queue, inString, length);
00284
00285
while (m_queue.AnyRetrievable())
00286 {
00287
switch (m_state)
00288 {
00289
case IDENTIFIER:
00290
if (!m_queue.Get(m_id))
00291
return;
00292 m_queue.TransferTo(CurrentTarget(), 1);
00293 m_state = LENGTH;
00294
case LENGTH:
00295 {
00296 byte b;
00297
if (m_level > 0 && m_id == 0 && m_queue.Peek(b) && b == 0)
00298 {
00299 m_queue.TransferTo(CurrentTarget(), 1);
00300 m_level--;
00301 m_state = IDENTIFIER;
00302
break;
00303 }
00304 ByteQueue::Walker walker(m_queue);
00305
bool definiteLength;
00306
if (!BERLengthDecode(walker, m_lengthRemaining, definiteLength))
00307
return;
00308 m_queue.TransferTo(CurrentTarget(), walker.GetCurrentPosition());
00309
if (!((m_id & CONSTRUCTED) || definiteLength))
00310 BERDecodeError();
00311
if (!definiteLength)
00312 {
00313
if (!(m_id & CONSTRUCTED))
00314 BERDecodeError();
00315 m_level++;
00316 m_state = IDENTIFIER;
00317
break;
00318 }
00319 m_state = BODY;
00320 }
00321
case BODY:
00322 m_lengthRemaining -= m_queue.TransferTo(CurrentTarget(), m_lengthRemaining);
00323
00324
if (m_lengthRemaining == 0)
00325 m_state = IDENTIFIER;
00326 }
00327
00328
if (m_state == IDENTIFIER && m_level == 0)
00329 {
00330
00331 ++m_nCurrentObject;
00332
00333
if (m_flags & PUT_MESSANGE_END_AFTER_EACH_OBJECT)
00334 AttachedTransformation()->MessageEnd();
00335
00336
if (m_nCurrentObject == m_nObjects)
00337 {
00338
if (m_flags & PUT_MESSANGE_END_AFTER_ALL_OBJECTS)
00339 AttachedTransformation()->MessageEnd();
00340
00341
if (m_flags & PUT_MESSANGE_SERIES_END_AFTER_ALL_OBJECTS)
00342 AttachedTransformation()->MessageSeriesEnd();
00343
00344 m_queue.TransferAllTo(*AttachedTransformation());
00345
return;
00346 }
00347 }
00348 }
00349 }
00350
00351 BERGeneralDecoder::BERGeneralDecoder(
BufferedTransformation &inQueue, byte asnTag)
00352 : m_inQueue(inQueue), m_finished(false)
00353 {
00354 byte b;
00355
if (!m_inQueue.Get(b) || b != asnTag)
00356 BERDecodeError();
00357
00358 m_definiteLength = BERLengthDecode(m_inQueue, m_length);
00359 }
00360
00361 BERGeneralDecoder::BERGeneralDecoder(
BERGeneralDecoder &inQueue, byte asnTag)
00362 : m_inQueue(inQueue), m_finished(false)
00363 {
00364 byte b;
00365
if (!m_inQueue.Get(b) || b != asnTag)
00366 BERDecodeError();
00367
00368 m_definiteLength = BERLengthDecode(m_inQueue, m_length);
00369
if (!m_definiteLength && !(asnTag & CONSTRUCTED))
00370 BERDecodeError();
00371 }
00372
00373 BERGeneralDecoder::~BERGeneralDecoder()
00374 {
00375
try
00376 {
00377
if (!m_finished)
00378 MessageEnd();
00379 }
00380
catch (...)
00381 {
00382 }
00383 }
00384
00385
bool BERGeneralDecoder::EndReached()
const
00386
{
00387
if (m_definiteLength)
00388
return m_length == 0;
00389
else
00390 {
00391 word16 i;
00392
return (m_inQueue.
PeekWord16(i)==2 && i==0);
00393 }
00394 }
00395
00396 byte BERGeneralDecoder::PeekByte()
const
00397
{
00398 byte b;
00399
if (!Peek(b))
00400 BERDecodeError();
00401
return b;
00402 }
00403
00404
void BERGeneralDecoder::CheckByte(byte check)
00405 {
00406 byte b;
00407
if (!Get(b) || b != check)
00408 BERDecodeError();
00409 }
00410
00411
void BERGeneralDecoder::MessageEnd()
00412 {
00413 m_finished =
true;
00414
if (m_definiteLength)
00415 {
00416
if (m_length != 0)
00417 BERDecodeError();
00418 }
00419
else
00420 {
00421 word16 i;
00422
if (m_inQueue.
GetWord16(i) != 2 || i != 0)
00423 BERDecodeError();
00424 }
00425 }
00426
00427
unsigned int BERGeneralDecoder::TransferTo2(
BufferedTransformation &target,
unsigned long &transferBytes,
const std::string &channel,
bool blocking)
00428 {
00429
if (m_definiteLength && transferBytes > m_length)
00430 transferBytes = m_length;
00431
unsigned int blockedBytes = m_inQueue.
TransferTo2(target, transferBytes, channel, blocking);
00432 ReduceLength(transferBytes);
00433
return blockedBytes;
00434 }
00435
00436
unsigned int BERGeneralDecoder::CopyRangeTo2(
BufferedTransformation &target,
unsigned long &begin,
unsigned long end,
const std::string &channel,
bool blocking)
const
00437
{
00438
if (m_definiteLength)
00439 end = STDMIN((
unsigned long)m_length, end);
00440
return m_inQueue.
CopyRangeTo2(target, begin, end, channel, blocking);
00441 }
00442
00443
unsigned int BERGeneralDecoder::ReduceLength(
unsigned int delta)
00444 {
00445
if (m_definiteLength)
00446 {
00447
if (m_length < delta)
00448 BERDecodeError();
00449 m_length -= delta;
00450 }
00451
return delta;
00452 }
00453
00454 DERGeneralEncoder::DERGeneralEncoder(
BufferedTransformation &outQueue, byte asnTag)
00455 : m_outQueue(outQueue), m_finished(false), m_asnTag(asnTag)
00456 {
00457 }
00458
00459 DERGeneralEncoder::DERGeneralEncoder(
DERGeneralEncoder &outQueue, byte asnTag)
00460 : m_outQueue(outQueue), m_finished(false), m_asnTag(asnTag)
00461 {
00462 }
00463
00464 DERGeneralEncoder::~DERGeneralEncoder()
00465 {
00466
try
00467 {
00468
if (!m_finished)
00469 MessageEnd();
00470 }
00471
catch (...)
00472 {
00473 }
00474 }
00475
00476
void DERGeneralEncoder::MessageEnd()
00477 {
00478 m_finished =
true;
00479
unsigned int length = (
unsigned int)CurrentSize();
00480 m_outQueue.
Put(m_asnTag);
00481 DERLengthEncode(m_outQueue, length);
00482 TransferTo(m_outQueue);
00483 }
00484
00485
00486
00487 void X509PublicKey::BERDecode(
BufferedTransformation &bt)
00488 {
00489
BERSequenceDecoder subjectPublicKeyInfo(bt);
00490
BERSequenceDecoder algorithm(subjectPublicKeyInfo);
00491 GetAlgorithmID().
BERDecodeAndCheck(algorithm);
00492
bool parametersPresent = algorithm.
EndReached() ?
false : BERDecodeAlgorithmParameters(algorithm);
00493 algorithm.
MessageEnd();
00494
00495
BERGeneralDecoder subjectPublicKey(subjectPublicKeyInfo, BIT_STRING);
00496 subjectPublicKey.
CheckByte(0);
00497 BERDecodeKey2(subjectPublicKey, parametersPresent, subjectPublicKey.
RemainingLength());
00498 subjectPublicKey.
MessageEnd();
00499 subjectPublicKeyInfo.
MessageEnd();
00500 }
00501
00502 void X509PublicKey::DEREncode(
BufferedTransformation &bt)
const
00503
{
00504
DERSequenceEncoder subjectPublicKeyInfo(bt);
00505
00506
DERSequenceEncoder algorithm(subjectPublicKeyInfo);
00507 GetAlgorithmID().
DEREncode(algorithm);
00508 DEREncodeAlgorithmParameters(algorithm);
00509 algorithm.
MessageEnd();
00510
00511
DERGeneralEncoder subjectPublicKey(subjectPublicKeyInfo, BIT_STRING);
00512 subjectPublicKey.Put(0);
00513 DEREncodeKey(subjectPublicKey);
00514 subjectPublicKey.
MessageEnd();
00515
00516 subjectPublicKeyInfo.
MessageEnd();
00517 }
00518
00519 void PKCS8PrivateKey::BERDecode(
BufferedTransformation &bt)
00520 {
00521
BERSequenceDecoder privateKeyInfo(bt);
00522 word32 version;
00523 BERDecodeUnsigned<word32>(privateKeyInfo, version, INTEGER, 0, 0);
00524
00525
BERSequenceDecoder algorithm(privateKeyInfo);
00526 GetAlgorithmID().
BERDecodeAndCheck(algorithm);
00527
bool parametersPresent = BERDecodeAlgorithmParameters(algorithm);
00528 algorithm.
MessageEnd();
00529
00530
BERGeneralDecoder octetString(privateKeyInfo, OCTET_STRING);
00531 BERDecodeKey2(octetString, parametersPresent, privateKeyInfo.
RemainingLength());
00532 octetString.
MessageEnd();
00533
00534 BERDecodeOptionalAttributes(privateKeyInfo);
00535 privateKeyInfo.MessageEnd();
00536 }
00537
00538 void PKCS8PrivateKey::DEREncode(
BufferedTransformation &bt)
const
00539
{
00540
DERSequenceEncoder privateKeyInfo(bt);
00541 DEREncodeUnsigned<word32>(privateKeyInfo, 0);
00542
00543
DERSequenceEncoder algorithm(privateKeyInfo);
00544 GetAlgorithmID().
DEREncode(algorithm);
00545 DEREncodeAlgorithmParameters(algorithm);
00546 algorithm.
MessageEnd();
00547
00548
DERGeneralEncoder octetString(privateKeyInfo, OCTET_STRING);
00549 DEREncodeKey(octetString);
00550 octetString.
MessageEnd();
00551
00552 DEREncodeOptionalAttributes(privateKeyInfo);
00553 privateKeyInfo.MessageEnd();
00554 }
00555
00556 NAMESPACE_END