// 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;
|
