Adding OCSP Parser

net/der/parser.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_DER_PARSER_H_
 #define NET_DER_PARSER_H_
 
 #include <stdint.h>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "net/der/input.h"
 #include "net/der/tag.h"
 
 namespace net {
 
 namespace der {
 
 class BitString;
+struct GeneralizedTime;
 
 // Parses a DER-encoded ASN.1 structure. DER (distinguished encoding rules)
 // encodes each data value with a tag, length, and value (TLV). The tag
 // indicates the type of the ASN.1 value. Depending on the type of the value,
 // it could contain arbitrary bytes, so the length of the value is encoded
 // after the tag and before the value to indicate how many bytes of value
 // follow. DER also defines how the values are encoded for particular types.
 //
 // This Parser places a few restrictions on the DER encoding it can parse. The
 // largest restriction is that it only supports tags which have a tag number
@@ skipping 107 matching lines @@
   // encoding for a specific type.
 
   // Reads the current TLV from the input, checks that the tag matches |tag|
   // and is a constructed tag, and creates a new Parser from the value.
   bool ReadConstructed(Tag tag, Parser* out) WARN_UNUSED_RESULT;
 
   // A more specific form of ReadConstructed that expects the current tag
   // to be 0x30 (SEQUENCE).
   bool ReadSequence(Parser* out) WARN_UNUSED_RESULT;
 
+  // Expects the current tag to be kInteger, and calls ParseUint8 on the
+  // current value. Note that DER-encoded integers are arbitrary precision,
+  // so this method will fail for valid input that represents an integer
+  // outside the range of an uint8_t.
+  //
+  // Note that on failure the Parser is left in an undefined state (the
+  // input may or may not have been advanced).
+  bool ReadUint8(uint8_t* out) WARN_UNUSED_RESULT;
+
   // Expects the current tag to be kInteger, and calls ParseUint64 on the
   // current value. Note that DER-encoded integers are arbitrary precision,
   // so this method will fail for valid input that represents an integer
-  // outside the range of an int64_t.
+  // outside the range of an uint64_t.
   //
   // Note that on failure the Parser is left in an undefined state (the
   // input may or may not have been advanced).
   bool ReadUint64(uint64_t* out) WARN_UNUSED_RESULT;
 
   // Reads a BIT STRING. On success fills |out| and returns true.
   //
   // Note that on failure the Parser is left in an undefined state (the
   // input may or may not have been advanced).
   bool ReadBitString(BitString* out) WARN_UNUSED_RESULT;
 
+  // Reads a GeneralizeTime. On success fills |out| and returns true.
+  //
+  // Note that on failure the Parser is left in an undefined state (the
+  // input may or may not have been advanced).
+  bool ReadGeneralizedTime(GeneralizedTime* out) WARN_UNUSED_RESULT;
+
   // Lower level methods. The previous methods couple reading data from the
   // input with advancing the Parser's internal pointer to the next TLV; these
   // lower level methods decouple those two steps into methods that read from
   // the current TLV and a method that advances the internal pointer to the
   // next TLV.
 
   // Reads the current TLV from the input, putting the tag in |tag| and the raw
   // value in |out|, but does not advance the input. Returns true if the tag
   // and length are successfully read and the output exists.
   bool PeekTagAndValue(Tag* tag, Input* out) WARN_UNUSED_RESULT;
 
   // Advances the input to the next TLV. This method only needs to be called
   // after PeekTagAndValue; all other methods will advance the input if they
   // read something.
   bool Advance();
 
  private:
   ByteReader input_;
   Mark advance_mark_;
 
   DISALLOW_COPY(Parser);
 };
 
 }  // namespace der
 
 }  // namespace net
 
 #endif  // NET_DER_PARSER_H_