Crypto++  5.6.5
Free C++ class library of cryptographic schemes
asn.h
Go to the documentation of this file.
1 // asn.h - originally written and placed in the public domain by Wei Dai
2 
3 //! \file asn.h
4 //! \brief Classes and functions for working with ANS.1 objects
5 
6 #ifndef CRYPTOPP_ASN_H
7 #define CRYPTOPP_ASN_H
8 
9 #include "cryptlib.h"
10 #include "filters.h"
11 #include "smartptr.h"
12 #include "stdcpp.h"
13 #include "queue.h"
14 #include "misc.h"
15 
16 // Issue 340
17 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
18 # pragma GCC diagnostic push
19 # pragma GCC diagnostic ignored "-Wconversion"
20 # pragma GCC diagnostic ignored "-Wsign-conversion"
21 #endif
22 
23 NAMESPACE_BEGIN(CryptoPP)
24 
25 //! \brief ASN.1 types
26 //! \note These tags and flags are not complete
27 enum ASNTag
28 {
29  BOOLEAN = 0x01,
30  INTEGER = 0x02,
31  BIT_STRING = 0x03,
32  OCTET_STRING = 0x04,
33  TAG_NULL = 0x05,
34  OBJECT_IDENTIFIER = 0x06,
35  OBJECT_DESCRIPTOR = 0x07,
36  EXTERNAL = 0x08,
37  REAL = 0x09,
38  ENUMERATED = 0x0a,
39  UTF8_STRING = 0x0c,
40  SEQUENCE = 0x10,
41  SET = 0x11,
42  NUMERIC_STRING = 0x12,
43  PRINTABLE_STRING = 0x13,
44  T61_STRING = 0x14,
45  VIDEOTEXT_STRING = 0x15,
46  IA5_STRING = 0x16,
47  UTC_TIME = 0x17,
48  GENERALIZED_TIME = 0x18,
49  GRAPHIC_STRING = 0x19,
50  VISIBLE_STRING = 0x1a,
51  GENERAL_STRING = 0x1b
52 };
53 
54 //! \brief ASN.1 flags
55 //! \note These tags and flags are not complete
57 {
58  UNIVERSAL = 0x00,
59 // DATA = 0x01,
60 // HEADER = 0x02,
61  PRIMITIVE = 0x00,
62  CONSTRUCTED = 0x20,
63  APPLICATION = 0x40,
64  CONTEXT_SPECIFIC = 0x80,
65  PRIVATE = 0xc0
66 };
67 
68 //! \brief Raises a BERDecodeErr
69 inline void BERDecodeError() {throw BERDecodeErr();}
70 
71 //! \brief Exception thrown when an unknown object identifier is encountered
72 class CRYPTOPP_DLL UnknownOID : public BERDecodeErr
73 {
74 public:
75  //! \brief Construct an UnknownOID
76  UnknownOID() : BERDecodeErr("BER decode error: unknown object identifier") {}
77  //! \brief Construct an UnknownOID
78  //! \param err error message to use for the execption
79  UnknownOID(const char *err) : BERDecodeErr(err) {}
80 };
81 
82 // unsigned int DERLengthEncode(unsigned int length, byte *output=0);
83 
84 //! \brief DER encode a length
85 //! \param bt BufferedTransformation object for writing
86 //! \param length the size to encode
87 //! \returns the number of octets used for the encoding
88 CRYPTOPP_DLL size_t CRYPTOPP_API DERLengthEncode(BufferedTransformation &bt, lword length);
89 
90 //! \brief BER decode a length
91 //! \param bt BufferedTransformation object for reading
92 //! \param length the decoded size
93 //! \returns true if the value was decoded
94 //! \throws BERDecodeError if the value fails to decode or is too large for size_t
95 //! \details BERLengthDecode() returns false if the encoding is indefinite length.
96 CRYPTOPP_DLL bool CRYPTOPP_API BERLengthDecode(BufferedTransformation &bt, size_t &length);
97 
98 //! \brief DER encode NULL
99 //! \param bt BufferedTransformation object for writing
100 CRYPTOPP_DLL void CRYPTOPP_API DEREncodeNull(BufferedTransformation &bt);
101 
102 //! \brief BER decode NULL
103 //! \param bt BufferedTransformation object for reading
104 CRYPTOPP_DLL void CRYPTOPP_API BERDecodeNull(BufferedTransformation &bt);
105 
106 //! \brief DER encode octet string
107 //! \param bt BufferedTransformation object for writing
108 //! \param str the string to encode
109 //! \param strLen the length of the string
110 //! \returns the number of octets used for the encoding
111 CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeOctetString(BufferedTransformation &bt, const byte *str, size_t strLen);
112 
113 //! \brief DER encode octet string
114 //! \param bt BufferedTransformation object for reading
115 //! \param str the string to encode
116 //! \returns the number of octets used for the encoding
117 CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeOctetString(BufferedTransformation &bt, const SecByteBlock &str);
118 
119 //! \brief BER decode octet string
120 //! \param bt BufferedTransformation object for reading
121 //! \param str the decoded string
122 //! \returns the number of octets used for the encoding
123 CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodeOctetString(BufferedTransformation &bt, SecByteBlock &str);
124 
125 //! \brief BER decode octet string
126 //! \param bt BufferedTransformation object for reading
127 //! \param str the decoded string
128 //! \returns the number of octets used for the encoding
129 CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodeOctetString(BufferedTransformation &bt, BufferedTransformation &str);
130 
131 //! \brief DER encode text string
132 //! \param bt BufferedTransformation object for writing
133 //! \param str the string to encode
134 //! \param asnTag the ASN.1 type
135 //! \returns the number of octets used for the encoding
136 //! \details DEREncodeTextString() can be used for UTF8_STRING, PRINTABLE_STRING, and IA5_STRING
137 CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeTextString(BufferedTransformation &bt, const std::string &str, byte asnTag);
138 
139 //! \brief BER decode text string
140 //! \param bt BufferedTransformation object for reading
141 //! \param str the string to encode
142 //! \param asnTag the ASN.1 type
143 //! \details DEREncodeTextString() can be used for UTF8_STRING, PRINTABLE_STRING, and IA5_STRING
144 CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodeTextString(BufferedTransformation &bt, std::string &str, byte asnTag);
145 
146 //! \brief DER encode bit string
147 //! \param bt BufferedTransformation object for writing
148 //! \param str the string to encode
149 //! \param strLen the length of the string
150 //! \param unusedBits the number of unused bits
151 //! \returns the number of octets used for the encoding
152 CRYPTOPP_DLL size_t CRYPTOPP_API DEREncodeBitString(BufferedTransformation &bt, const byte *str, size_t strLen, unsigned int unusedBits=0);
153 
154 //! \brief DER decode bit string
155 //! \param bt BufferedTransformation object for reading
156 //! \param str the decoded string
157 //! \param unusedBits the number of unused bits
158 CRYPTOPP_DLL size_t CRYPTOPP_API BERDecodeBitString(BufferedTransformation &bt, SecByteBlock &str, unsigned int &unusedBits);
159 
160 //! \brief BER decode and DER re-encode
161 //! \param bt BufferedTransformation object for writing
162 //! \param dest BufferedTransformation object
163 CRYPTOPP_DLL void CRYPTOPP_API DERReencode(BufferedTransformation &bt, BufferedTransformation &dest);
164 
165 //! \brief Object Identifier
166 class CRYPTOPP_DLL OID
167 {
168 public:
169  virtual ~OID() {}
170 
171  //! \brief Construct an OID
172  OID() {}
173  //! \brief Construct an OID
174  //! \param v value to initialize the OID
175  OID(word32 v) : m_values(1, v) {}
176  //! \brief Construct an OID
177  //! \param bt BufferedTransformation object
178  OID(BufferedTransformation &bt) {BERDecode(bt);}
179 
180  //! \brief Append a value to an OID
181  //! \param rhs the value to append
182  inline OID & operator+=(word32 rhs) {m_values.push_back(rhs); return *this;}
183 
184  //! \brief DER encode this OID
185  //! \param bt BufferedTransformation object
186  void DEREncode(BufferedTransformation &bt) const;
187 
188  //! \brief BER decode an OID
189  //! \param bt BufferedTransformation object
190  void BERDecode(BufferedTransformation &bt);
191 
192  //! \brief BER decode an OID
193  //! \param bt BufferedTransformation object
194  //! \throws BERDecodeErr() if decoded value doesn't match an expected OID
195  //! \details BERDecodeAndCheck() can be used to parse an OID and verify it matches an expected.
196  //! <pre>
197  //! BERSequenceDecoder key(bt);
198  //! ...
199  //! BERSequenceDecoder algorithm(key);
200  //! GetAlgorithmID().BERDecodeAndCheck(algorithm);
201  //! </pre>
202  void BERDecodeAndCheck(BufferedTransformation &bt) const;
203 
204  std::vector<word32> m_values;
205 
206 private:
207  static void EncodeValue(BufferedTransformation &bt, word32 v);
208  static size_t DecodeValue(BufferedTransformation &bt, word32 &v);
209 };
210 
211 //! \brief ASN.1 encoded object filter
213 {
214 public:
215  enum Flag {PUT_OBJECTS=1, PUT_MESSANGE_END_AFTER_EACH_OBJECT=2, PUT_MESSANGE_END_AFTER_ALL_OBJECTS=4, PUT_MESSANGE_SERIES_END_AFTER_ALL_OBJECTS=8};
216 
217  virtual ~EncodedObjectFilter() {}
218 
219  //! \brief Construct an EncodedObjectFilter
220  //! \param attachment a BufferedTrasformation to attach to this object
221  //! \param nObjects
222  //! \param flags bitwise OR of EncodedObjectFilter::Flag
223  EncodedObjectFilter(BufferedTransformation *attachment = NULLPTR, unsigned int nObjects = 1, word32 flags = 0);
224 
225  //! \brief Input a byte buffer for processing
226  //! \param inString the byte buffer to process
227  //! \param length the size of the string, in bytes
228  void Put(const byte *inString, size_t length);
229 
230  unsigned int GetNumberOfCompletedObjects() const {return m_nCurrentObject;}
231  unsigned long GetPositionOfObject(unsigned int i) const {return m_positions[i];}
232 
233 private:
234  BufferedTransformation & CurrentTarget();
235 
236  word32 m_flags;
237  unsigned int m_nObjects, m_nCurrentObject, m_level;
238  std::vector<unsigned int> m_positions;
239  ByteQueue m_queue;
240  enum State {IDENTIFIER, LENGTH, BODY, TAIL, ALL_DONE} m_state;
241  byte m_id;
242  lword m_lengthRemaining;
243 };
244 
245 //! \brief BER General Decoder
246 class CRYPTOPP_DLL BERGeneralDecoder : public Store
247 {
248 public:
249  virtual ~BERGeneralDecoder();
250 
251  explicit BERGeneralDecoder(BufferedTransformation &inQueue, byte asnTag);
252  explicit BERGeneralDecoder(BERGeneralDecoder &inQueue, byte asnTag);
253 
254  bool IsDefiniteLength() const {return m_definiteLength;}
255  lword RemainingLength() const {CRYPTOPP_ASSERT(m_definiteLength); return m_length;}
256  bool EndReached() const;
257  byte PeekByte() const;
258  void CheckByte(byte b);
259 
260  size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
261  size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const;
262 
263  // call this to denote end of sequence
264  void MessageEnd();
265 
266 protected:
267  BufferedTransformation &m_inQueue;
268  bool m_finished, m_definiteLength;
269  lword m_length;
270 
271 private:
272  void Init(byte asnTag);
273  void StoreInitialize(const NameValuePairs &parameters)
274  {CRYPTOPP_UNUSED(parameters); CRYPTOPP_ASSERT(false);}
275  lword ReduceLength(lword delta);
276 };
277 
278 // GCC (and likely other compilers) identify the explicit DERGeneralEncoder as a copy constructor;
279 // and not a constructor. We had to remove the default asnTag value to point the compiler in the
280 // proper direction. We did not break the library or versioning based on the output of
281 // `nm --demangle libcryptopp.a | grep DERGeneralEncoder::DERGeneralEncoder | grep -v " U "`.
282 
283 //! \brief DER General Encoder
284 class CRYPTOPP_DLL DERGeneralEncoder : public ByteQueue
285 {
286 public:
287  virtual ~DERGeneralEncoder();
288 
289  explicit DERGeneralEncoder(BufferedTransformation &outQueue, byte asnTag = SEQUENCE | CONSTRUCTED);
290  explicit DERGeneralEncoder(DERGeneralEncoder &outQueue, byte asnTag = SEQUENCE | CONSTRUCTED);
291 
292  // call this to denote end of sequence
293  void MessageEnd();
294 
295 private:
296  BufferedTransformation &m_outQueue;
297  bool m_finished;
298 
299  byte m_asnTag;
300 };
301 
302 //! \brief BER Sequence Decoder
303 class CRYPTOPP_DLL BERSequenceDecoder : public BERGeneralDecoder
304 {
305 public:
306  explicit BERSequenceDecoder(BufferedTransformation &inQueue, byte asnTag = SEQUENCE | CONSTRUCTED)
307  : BERGeneralDecoder(inQueue, asnTag) {}
308  explicit BERSequenceDecoder(BERSequenceDecoder &inQueue, byte asnTag = SEQUENCE | CONSTRUCTED)
309  : BERGeneralDecoder(inQueue, asnTag) {}
310 };
311 
312 //! \brief DER Sequence Encoder
313 class CRYPTOPP_DLL DERSequenceEncoder : public DERGeneralEncoder
314 {
315 public:
316  explicit DERSequenceEncoder(BufferedTransformation &outQueue, byte asnTag = SEQUENCE | CONSTRUCTED)
317  : DERGeneralEncoder(outQueue, asnTag) {}
318  explicit DERSequenceEncoder(DERSequenceEncoder &outQueue, byte asnTag = SEQUENCE | CONSTRUCTED)
319  : DERGeneralEncoder(outQueue, asnTag) {}
320 };
321 
322 //! \brief BER Set Decoder
323 class CRYPTOPP_DLL BERSetDecoder : public BERGeneralDecoder
324 {
325 public:
326  explicit BERSetDecoder(BufferedTransformation &inQueue, byte asnTag = SET | CONSTRUCTED)
327  : BERGeneralDecoder(inQueue, asnTag) {}
328  explicit BERSetDecoder(BERSetDecoder &inQueue, byte asnTag = SET | CONSTRUCTED)
329  : BERGeneralDecoder(inQueue, asnTag) {}
330 };
331 
332 //! \brief DER Set Encoder
333 class CRYPTOPP_DLL DERSetEncoder : public DERGeneralEncoder
334 {
335 public:
336  explicit DERSetEncoder(BufferedTransformation &outQueue, byte asnTag = SET | CONSTRUCTED)
337  : DERGeneralEncoder(outQueue, asnTag) {}
338  explicit DERSetEncoder(DERSetEncoder &outQueue, byte asnTag = SET | CONSTRUCTED)
339  : DERGeneralEncoder(outQueue, asnTag) {}
340 };
341 
342 //! \brief Optional data encoder and decoder
343 //! \tparam T class or type
344 template <class T>
345 class ASNOptional : public member_ptr<T>
346 {
347 public:
348  //! \brief BER decode optional data
349  //! \param seqDecoder sequence with the optional ASN.1 data
350  //! \param tag ASN.1 tag to match as optional data
351  //! \param mask the mask to apply when matching the tag
352  //! \sa ASNTag and ASNIdFlag
353  void BERDecode(BERSequenceDecoder &seqDecoder, byte tag, byte mask = ~CONSTRUCTED)
354  {
355  byte b;
356  if (seqDecoder.Peek(b) && (b & mask) == tag)
357  reset(new T(seqDecoder));
358  }
359 
360  //! \brief DER encode optional data
361  //! \param out BufferedTransformation object
363  {
364  if (this->get() != NULLPTR)
365  this->get()->DEREncode(out);
366  }
367 };
368 
369 //! \brief Encode and decode ASN.1 objects with additional information
370 //! \tparam BASE base class or type
371 //! \details Encodes and decodes public keys, private keys and group
372 //! parameters with OID identifying the algorithm or scheme.
373 template <class BASE>
374 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE ASN1CryptoMaterial : public ASN1Object, public BASE
375 {
376 public:
377  //! \brief DER encode ASN.1 object
378  //! \param bt BufferedTransformation object
379  //! \details Save() will write the OID associated with algorithm or scheme.
380  //! In the case of public and private keys, this function writes the
381  //! subjectPubicKeyInfo and privateKeyInfo parts.
382  void Save(BufferedTransformation &bt) const
383  {BEREncode(bt);}
384 
385  //! \brief BER decode ASN.1 object
386  //! \param bt BufferedTransformation object
388  {BERDecode(bt);}
389 };
390 
391 //! \brief Encodes and decodes subjectPublicKeyInfo
392 class CRYPTOPP_DLL X509PublicKey : public ASN1CryptoMaterial<PublicKey>
393 {
394 public:
395  virtual ~X509PublicKey() {}
396 
397  void BERDecode(BufferedTransformation &bt);
398  void DEREncode(BufferedTransformation &bt) const;
399 
400  //! \brief Retrieves the OID of the algorithm
401  //! \returns OID of the algorithm
402  virtual OID GetAlgorithmID() const =0;
403  virtual bool BERDecodeAlgorithmParameters(BufferedTransformation &bt)
404  {BERDecodeNull(bt); return false;}
405  virtual bool DEREncodeAlgorithmParameters(BufferedTransformation &bt) const
406  {DEREncodeNull(bt); return false;} // see RFC 2459, section 7.3.1
407 
408  //! decode subjectPublicKey part of subjectPublicKeyInfo, without the BIT STRING header
409  virtual void BERDecodePublicKey(BufferedTransformation &bt, bool parametersPresent, size_t size) =0;
410  //! encode subjectPublicKey part of subjectPublicKeyInfo, without the BIT STRING header
411  virtual void DEREncodePublicKey(BufferedTransformation &bt) const =0;
412 };
413 
414 //! \brief Encodes and decodesprivateKeyInfo
415 class CRYPTOPP_DLL PKCS8PrivateKey : public ASN1CryptoMaterial<PrivateKey>
416 {
417 public:
418  virtual ~PKCS8PrivateKey() {}
419 
420  void BERDecode(BufferedTransformation &bt);
421  void DEREncode(BufferedTransformation &bt) const;
422 
423  //! \brief Retrieves the OID of the algorithm
424  //! \returns OID of the algorithm
425  virtual OID GetAlgorithmID() const =0;
426  virtual bool BERDecodeAlgorithmParameters(BufferedTransformation &bt)
427  {BERDecodeNull(bt); return false;}
428  virtual bool DEREncodeAlgorithmParameters(BufferedTransformation &bt) const
429  {DEREncodeNull(bt); return false;} // see RFC 2459, section 7.3.1
430 
431  //! decode privateKey part of privateKeyInfo, without the OCTET STRING header
432  virtual void BERDecodePrivateKey(BufferedTransformation &bt, bool parametersPresent, size_t size) =0;
433  //! encode privateKey part of privateKeyInfo, without the OCTET STRING header
434  virtual void DEREncodePrivateKey(BufferedTransformation &bt) const =0;
435 
436  //! decode optional attributes including context-specific tag
437  /*! /note default implementation stores attributes to be output in DEREncodeOptionalAttributes */
438  virtual void BERDecodeOptionalAttributes(BufferedTransformation &bt);
439  //! encode optional attributes including context-specific tag
440  virtual void DEREncodeOptionalAttributes(BufferedTransformation &bt) const;
441 
442 protected:
443  ByteQueue m_optionalAttributes;
444 };
445 
446 // ********************************************************
447 
448 //! \brief DER Encode unsigned value
449 //! \tparam T class or type
450 //! \param out BufferedTransformation object
451 //! \param w unsigned value to encode
452 //! \param asnTag the ASN.1 type
453 //! \details DEREncodeUnsigned() can be used with INTEGER, BOOLEAN, and ENUM
454 template <class T>
455 size_t DEREncodeUnsigned(BufferedTransformation &out, T w, byte asnTag = INTEGER)
456 {
457  byte buf[sizeof(w)+1];
458  unsigned int bc;
459  if (asnTag == BOOLEAN)
460  {
461  buf[sizeof(w)] = w ? 0xff : 0;
462  bc = 1;
463  }
464  else
465  {
466  buf[0] = 0;
467  for (unsigned int i=0; i<sizeof(w); i++)
468  buf[i+1] = byte(w >> (sizeof(w)-1-i)*8);
469  bc = sizeof(w);
470  while (bc > 1 && buf[sizeof(w)+1-bc] == 0)
471  --bc;
472  if (buf[sizeof(w)+1-bc] & 0x80)
473  ++bc;
474  }
475  out.Put(asnTag);
476  size_t lengthBytes = DERLengthEncode(out, bc);
477  out.Put(buf+sizeof(w)+1-bc, bc);
478  return 1+lengthBytes+bc;
479 }
480 
481 //! \brief BER Decode unsigned value
482 //! \tparam T fundamental C++ type
483 //! \param in BufferedTransformation object
484 //! \param w the decoded value
485 //! \param asnTag the ASN.1 type
486 //! \param minValue the minimum expected value
487 //! \param maxValue the maximum expected value
488 //! \throws BERDecodeErr() if the value cannot be parsed or the decoded value is not within range.
489 //! \details DEREncodeUnsigned() can be used with INTEGER, BOOLEAN, and ENUM
490 template <class T>
491 void BERDecodeUnsigned(BufferedTransformation &in, T &w, byte asnTag = INTEGER,
492  T minValue = 0, T maxValue = T(0xffffffff))
493 {
494  byte b;
495  if (!in.Get(b) || b != asnTag)
496  BERDecodeError();
497 
498  size_t bc;
499  bool definite = BERLengthDecode(in, bc);
500  if (!definite)
501  BERDecodeError();
502  if (bc > in.MaxRetrievable()) // Issue 346
503  BERDecodeError();
504  if (asnTag == BOOLEAN && bc != 1) // X.690, 8.2.1
505  BERDecodeError();
506  if ((asnTag == INTEGER || asnTag == ENUMERATED) && bc == 0) // X.690, 8.3.1 and 8.4
507  BERDecodeError();
508 
509  SecByteBlock buf(bc);
510 
511  if (bc != in.Get(buf, bc))
512  BERDecodeError();
513 
514  // This consumes leading 0 octets. According to X.690, 8.3.2, it could be non-conforming behavior.
515  // X.690, 8.3.2 says "the bits of the first octet and bit 8 of the second octet ... (a) shall
516  // not all be ones and (b) shall not all be zeros ... These rules ensure that an integer value
517  // is always encoded in the smallest possible number of octet".
518  // We invented AER (Alternate Encoding Rules), which is more relaxed than BER, CER, and DER.
519  const byte *ptr = buf;
520  while (bc > sizeof(w) && *ptr == 0)
521  {
522  bc--;
523  ptr++;
524  }
525  if (bc > sizeof(w))
526  BERDecodeError();
527 
528  w = 0;
529  for (unsigned int i=0; i<bc; i++)
530  w = (w << 8) | ptr[i];
531 
532  if (w < minValue || w > maxValue)
533  BERDecodeError();
534 }
535 
536 #ifdef CRYPTOPP_DOXYGEN_PROCESSING
537 //! \brief Compare two OIDs for equality
538 //! \param lhs the first OID
539 //! \param rhs the second OID
540 //! \returns true if the OIDs are equal, false otherwise
541 inline bool operator==(const OID &lhs, const OID &rhs);
542 //! \brief Compare two OIDs for inequality
543 //! \param lhs the first OID
544 //! \param rhs the second OID
545 //! \returns true if the OIDs are not equal, false otherwise
546 inline bool operator!=(const OID &lhs, const OID &rhs);
547 //! \brief Compare two OIDs for ordering
548 //! \param lhs the first OID
549 //! \param rhs the second OID
550 //! \returns true if the first OID is less than the second OID, false otherwise
551 //! \details operator<() calls std::lexicographical_compare() on each element in the array of values.
552 inline bool operator<(const OID &lhs, const OID &rhs);
553 //! \brief Append a value to an OID
554 //! \param lhs the OID
555 //! \param rhs the value to append
556 inline OID operator+(const OID &lhs, unsigned long rhs);
557 #else
558 inline bool operator==(const ::CryptoPP::OID &lhs, const ::CryptoPP::OID &rhs)
559  {return lhs.m_values == rhs.m_values;}
560 inline bool operator!=(const ::CryptoPP::OID &lhs, const ::CryptoPP::OID &rhs)
561  {return lhs.m_values != rhs.m_values;}
562 inline bool operator<(const ::CryptoPP::OID &lhs, const ::CryptoPP::OID &rhs)
563  {return std::lexicographical_compare(lhs.m_values.begin(), lhs.m_values.end(), rhs.m_values.begin(), rhs.m_values.end());}
564 inline ::CryptoPP::OID operator+(const ::CryptoPP::OID &lhs, unsigned long rhs)
565  {return ::CryptoPP::OID(lhs)+=rhs;}
566 #endif
567 
568 NAMESPACE_END
569 
570 // Issue 340
571 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
572 # pragma GCC diagnostic pop
573 #endif
574 
575 #endif
UnknownOID(const char *err)
Construct an UnknownOID.
Definition: asn.h:79
Utility functions for the Crypto++ library.
virtual size_t Peek(byte &outByte) const
Peek a 8-bit byte.
Definition: cryptlib.cpp:508
size_t DEREncodeUnsigned(BufferedTransformation &out, T w, byte asnTag=INTEGER)
DER Encode unsigned value.
Definition: asn.h:455
Encodes and decodesprivateKeyInfo.
Definition: asn.h:415
void DEREncodeNull(BufferedTransformation &bt)
DER encode NULL.
Definition: asn.cpp:87
Abstract base classes that provide a uniform interface to this library.
void BERDecodeUnsigned(BufferedTransformation &in, T &w, byte asnTag=INTEGER, T minValue=0, T maxValue=T(0xffffffff))
BER Decode unsigned value.
Definition: asn.h:491
OID()
Construct an OID.
Definition: asn.h:172
Classes for automatic resource management.
void DEREncode(BufferedTransformation &out)
DER encode optional data.
Definition: asn.h:362
Acts as a Source for pre-existing, static data.
Definition: simple.h:299
BER Set Decoder.
Definition: asn.h:323
SecBlock<byte> typedef.
Definition: secblock.h:810
BER Sequence Decoder.
Definition: asn.h:303
Interface for buffered transformations.
Definition: cryptlib.h:1345
OID(BufferedTransformation &bt)
Construct an OID.
Definition: asn.h:178
bool operator==(const OID &lhs, const OID &rhs)
Compare two OIDs for equality.
Pointer that overloads operator ->
Definition: smartptr.h:39
Optional data encoder and decoder.
Definition: asn.h:345
ASNIdFlag
ASN.1 flags.
Definition: asn.h:56
void BERDecode(BERSequenceDecoder &seqDecoder, byte tag, byte mask=~CONSTRUCTED)
BER decode optional data.
Definition: asn.h:353
bool operator!=(const OID &lhs, const OID &rhs)
Compare two OIDs for inequality.
Classes for an unlimited queue to store bytes.
void BERDecodeNull(BufferedTransformation &bt)
BER decode NULL.
Definition: asn.cpp:93
bool operator<(const OID &lhs, const OID &rhs)
Compare two OIDs for ordering.
size_t Put(byte inByte, bool blocking=true)
Input a byte for processing.
Definition: cryptlib.h:1366
size_t BERDecodeOctetString(BufferedTransformation &bt, SecByteBlock &str)
BER decode octet string.
Definition: asn.cpp:117
const std::string DEFAULT_CHANNEL
Default channel for BufferedTransformation.
Definition: cryptlib.cpp:950
UnknownOID()
Construct an UnknownOID.
Definition: asn.h:76
OID & operator+=(word32 rhs)
Append a value to an OID.
Definition: asn.h:182
ASN.1 encoded object filter.
Definition: asn.h:212
Interface for encoding and decoding ASN1 objects.
Definition: cryptlib.h:2902
DER Set Encoder.
Definition: asn.h:333
OID operator+(const OID &lhs, unsigned long rhs)
Append a value to an OID.
size_t DEREncodeTextString(BufferedTransformation &bt, const std::string &str, byte asnTag)
DER encode text string.
Definition: asn.cpp:151
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Definition: trap.h:61
void Save(BufferedTransformation &bt) const
DER encode ASN.1 object.
Definition: asn.h:382
void BERDecodeError()
Raises a BERDecodeErr.
Definition: asn.h:69
Data structure used to store byte strings.
Definition: queue.h:19
size_t DERLengthEncode(BufferedTransformation &bt, lword length)
DER encode a length.
Definition: asn.cpp:17
Implementation of BufferedTransformation&#39;s attachment interface.
void DERReencode(BufferedTransformation &bt, BufferedTransformation &dest)
BER decode and DER re-encode.
Definition: asn.cpp:216
DER Sequence Encoder.
Definition: asn.h:313
OID(word32 v)
Construct an OID.
Definition: asn.h:175
virtual lword MaxRetrievable() const
Provides the number of bytes ready for retrieval.
Definition: cryptlib.cpp:470
DER General Encoder.
Definition: asn.h:284
void Load(BufferedTransformation &bt)
BER decode ASN.1 object.
Definition: asn.h:387
Exception thrown when an unknown object identifier is encountered.
Definition: asn.h:72
Implementation of BufferedTransformation&#39;s attachment interface.
Definition: filters.h:36
size_t DEREncodeOctetString(BufferedTransformation &bt, const byte *str, size_t strLen)
DER encode octet string.
Definition: asn.cpp:104
size_t BERDecodeBitString(BufferedTransformation &bt, SecByteBlock &str, unsigned int &unusedBits)
DER decode bit string.
Definition: asn.cpp:191
virtual size_t Get(byte &outByte)
Retrieve a 8-bit byte.
Definition: cryptlib.cpp:489
Crypto++ library namespace.
ASNTag
ASN.1 types.
Definition: asn.h:27
Encodes and decodes subjectPublicKeyInfo.
Definition: asn.h:392
BER General Decoder.
Definition: asn.h:246
size_t BERDecodeTextString(BufferedTransformation &bt, std::string &str, byte asnTag)
BER decode text string.
Definition: asn.cpp:159
Encode and decode ASN.1 objects with additional information.
Definition: asn.h:374
Object Identifier.
Definition: asn.h:166
bool BERLengthDecode(BufferedTransformation &bt, size_t &length)
BER decode a length.
Definition: asn.cpp:76
size_t DEREncodeBitString(BufferedTransformation &bt, const byte *str, size_t strLen, unsigned int unusedBits=0)
DER encode bit string.
Definition: asn.cpp:182
Interface for retrieving values given their names.
Definition: cryptlib.h:285
Exception thrown when an ASN.1 BER decoing error is encountered.
Definition: cryptlib.h:2891