twitst4tz

reader.js (5650B)

---

 // Copyright 2011 Mark Cavage <mcavage@gmail.com> All rights reserved.
 
 var assert = require('assert');
 var Buffer = require('safer-buffer').Buffer;
 
 var ASN1 = require('./types');
 var errors = require('./errors');
 
 
 // --- Globals
 
 var newInvalidAsn1Error = errors.newInvalidAsn1Error;
 
 
 
 // --- API
 
 function Reader(data) {
   if (!data || !Buffer.isBuffer(data))
     throw new TypeError('data must be a node Buffer');
 
   this._buf = data;
   this._size = data.length;
 
   // These hold the "current" state
   this._len = 0;
   this._offset = 0;
 }
 
 Object.defineProperty(Reader.prototype, 'length', {
   enumerable: true,
   get: function () { return (this._len); }
 });
 
 Object.defineProperty(Reader.prototype, 'offset', {
   enumerable: true,
   get: function () { return (this._offset); }
 });
 
 Object.defineProperty(Reader.prototype, 'remain', {
   get: function () { return (this._size - this._offset); }
 });
 
 Object.defineProperty(Reader.prototype, 'buffer', {
   get: function () { return (this._buf.slice(this._offset)); }
 });
 
 
 /**
  * Reads a single byte and advances offset; you can pass in `true` to make this
  * a "peek" operation (i.e., get the byte, but don't advance the offset).
  *
  * @param {Boolean} peek true means don't move offset.
  * @return {Number} the next byte, null if not enough data.
  */
 Reader.prototype.readByte = function (peek) {
   if (this._size - this._offset < 1)
     return null;
 
   var b = this._buf[this._offset] & 0xff;
 
   if (!peek)
     this._offset += 1;
 
   return b;
 };
 
 
 Reader.prototype.peek = function () {
   return this.readByte(true);
 };
 
 
 /**
  * Reads a (potentially) variable length off the BER buffer.  This call is
  * not really meant to be called directly, as callers have to manipulate
  * the internal buffer afterwards.
  *
  * As a result of this call, you can call `Reader.length`, until the
  * next thing called that does a readLength.
  *
  * @return {Number} the amount of offset to advance the buffer.
  * @throws {InvalidAsn1Error} on bad ASN.1
  */
 Reader.prototype.readLength = function (offset) {
   if (offset === undefined)
     offset = this._offset;
 
   if (offset >= this._size)
     return null;
 
   var lenB = this._buf[offset++] & 0xff;
   if (lenB === null)
     return null;
 
   if ((lenB & 0x80) === 0x80) {
     lenB &= 0x7f;
 
     if (lenB === 0)
       throw newInvalidAsn1Error('Indefinite length not supported');
 
     if (lenB > 4)
       throw newInvalidAsn1Error('encoding too long');
 
     if (this._size - offset < lenB)
       return null;
 
     this._len = 0;
     for (var i = 0; i < lenB; i++)
       this._len = (this._len << 8) + (this._buf[offset++] & 0xff);
 
   } else {
     // Wasn't a variable length
     this._len = lenB;
   }
 
   return offset;
 };
 
 
 /**
  * Parses the next sequence in this BER buffer.
  *
  * To get the length of the sequence, call `Reader.length`.
  *
  * @return {Number} the sequence's tag.
  */
 Reader.prototype.readSequence = function (tag) {
   var seq = this.peek();
   if (seq === null)
     return null;
   if (tag !== undefined && tag !== seq)
     throw newInvalidAsn1Error('Expected 0x' + tag.toString(16) +
                               ': got 0x' + seq.toString(16));
 
   var o = this.readLength(this._offset + 1); // stored in `length`
   if (o === null)
     return null;
 
   this._offset = o;
   return seq;
 };
 
 
 Reader.prototype.readInt = function () {
   return this._readTag(ASN1.Integer);
 };
 
 
 Reader.prototype.readBoolean = function () {
   return (this._readTag(ASN1.Boolean) === 0 ? false : true);
 };
 
 
 Reader.prototype.readEnumeration = function () {
   return this._readTag(ASN1.Enumeration);
 };
 
 
 Reader.prototype.readString = function (tag, retbuf) {
   if (!tag)
     tag = ASN1.OctetString;
 
   var b = this.peek();
   if (b === null)
     return null;
 
   if (b !== tag)
     throw newInvalidAsn1Error('Expected 0x' + tag.toString(16) +
                               ': got 0x' + b.toString(16));
 
   var o = this.readLength(this._offset + 1); // stored in `length`
 
   if (o === null)
     return null;
 
   if (this.length > this._size - o)
     return null;
 
   this._offset = o;
 
   if (this.length === 0)
     return retbuf ? Buffer.alloc(0) : '';
 
   var str = this._buf.slice(this._offset, this._offset + this.length);
   this._offset += this.length;
 
   return retbuf ? str : str.toString('utf8');
 };
 
 Reader.prototype.readOID = function (tag) {
   if (!tag)
     tag = ASN1.OID;
 
   var b = this.readString(tag, true);
   if (b === null)
     return null;
 
   var values = [];
   var value = 0;
 
   for (var i = 0; i < b.length; i++) {
     var byte = b[i] & 0xff;
 
     value <<= 7;
     value += byte & 0x7f;
     if ((byte & 0x80) === 0) {
       values.push(value);
       value = 0;
     }
   }
 
   value = values.shift();
   values.unshift(value % 40);
   values.unshift((value / 40) >> 0);
 
   return values.join('.');
 };
 
 
 Reader.prototype._readTag = function (tag) {
   assert.ok(tag !== undefined);
 
   var b = this.peek();
 
   if (b === null)
     return null;
 
   if (b !== tag)
     throw newInvalidAsn1Error('Expected 0x' + tag.toString(16) +
                               ': got 0x' + b.toString(16));
 
   var o = this.readLength(this._offset + 1); // stored in `length`
   if (o === null)
     return null;
 
   if (this.length > 4)
     throw newInvalidAsn1Error('Integer too long: ' + this.length);
 
   if (this.length > this._size - o)
     return null;
   this._offset = o;
 
   var fb = this._buf[this._offset];
   var value = 0;
 
   for (var i = 0; i < this.length; i++) {
     value <<= 8;
     value |= (this._buf[this._offset++] & 0xff);
   }
 
   if ((fb & 0x80) === 0x80 && i !== 4)
     value -= (1 << (i * 8));
 
   return value >> 0;
 };
 
 
 
 // --- Exported API
 
 module.exports = Reader;