Add functions for DER parsing a BIT STRING.

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 "base/compiler_specific.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
@@ skipping 127 matching lines @@
   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 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.
+  //
+  // 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 |bytes| is set to the octet string
+  // containing the bits, and |unused_bits| is set to the number of
+  // bits (in the range 0-7) that are unused.

[davidben, 2015/07/27 20:19:59]

Probably add: The bits are ordered within each octet of |bytes| from most to
least significant, as in the DER encoding.

[eroman, 2015/07/27 21:19:23]

Done.

+  //
+  // Note that on failure the Parser is left in an undefined state (the
+  // input may or may not have been advanced).
+  bool ReadBitString(Input* bytes, uint8_t* unused_bits) WARN_UNUSED_RESULT;
+
+  // Same as ReadBitString() except it will only succeed when the number of
+  // bits in the bit string is a multiple of 8. In other words, there can be
+  // no unused bits in the octet string |*bytes|.
+  bool ReadBitStringNoUnusedBits(Input* bytes) 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_