1409 lines
41 KiB
JavaScript
1409 lines
41 KiB
JavaScript
/**
|
|
* Javascript implementation of Abstract Syntax Notation Number One.
|
|
*
|
|
* @author Dave Longley
|
|
*
|
|
* Copyright (c) 2010-2015 Digital Bazaar, Inc.
|
|
*
|
|
* An API for storing data using the Abstract Syntax Notation Number One
|
|
* format using DER (Distinguished Encoding Rules) encoding. This encoding is
|
|
* commonly used to store data for PKI, i.e. X.509 Certificates, and this
|
|
* implementation exists for that purpose.
|
|
*
|
|
* Abstract Syntax Notation Number One (ASN.1) is used to define the abstract
|
|
* syntax of information without restricting the way the information is encoded
|
|
* for transmission. It provides a standard that allows for open systems
|
|
* communication. ASN.1 defines the syntax of information data and a number of
|
|
* simple data types as well as a notation for describing them and specifying
|
|
* values for them.
|
|
*
|
|
* The RSA algorithm creates public and private keys that are often stored in
|
|
* X.509 or PKCS#X formats -- which use ASN.1 (encoded in DER format). This
|
|
* class provides the most basic functionality required to store and load DSA
|
|
* keys that are encoded according to ASN.1.
|
|
*
|
|
* The most common binary encodings for ASN.1 are BER (Basic Encoding Rules)
|
|
* and DER (Distinguished Encoding Rules). DER is just a subset of BER that
|
|
* has stricter requirements for how data must be encoded.
|
|
*
|
|
* Each ASN.1 structure has a tag (a byte identifying the ASN.1 structure type)
|
|
* and a byte array for the value of this ASN1 structure which may be data or a
|
|
* list of ASN.1 structures.
|
|
*
|
|
* Each ASN.1 structure using BER is (Tag-Length-Value):
|
|
*
|
|
* | byte 0 | bytes X | bytes Y |
|
|
* |--------|---------|----------
|
|
* | tag | length | value |
|
|
*
|
|
* ASN.1 allows for tags to be of "High-tag-number form" which allows a tag to
|
|
* be two or more octets, but that is not supported by this class. A tag is
|
|
* only 1 byte. Bits 1-5 give the tag number (ie the data type within a
|
|
* particular 'class'), 6 indicates whether or not the ASN.1 value is
|
|
* constructed from other ASN.1 values, and bits 7 and 8 give the 'class'. If
|
|
* bits 7 and 8 are both zero, the class is UNIVERSAL. If only bit 7 is set,
|
|
* then the class is APPLICATION. If only bit 8 is set, then the class is
|
|
* CONTEXT_SPECIFIC. If both bits 7 and 8 are set, then the class is PRIVATE.
|
|
* The tag numbers for the data types for the class UNIVERSAL are listed below:
|
|
*
|
|
* UNIVERSAL 0 Reserved for use by the encoding rules
|
|
* UNIVERSAL 1 Boolean type
|
|
* UNIVERSAL 2 Integer type
|
|
* UNIVERSAL 3 Bitstring type
|
|
* UNIVERSAL 4 Octetstring type
|
|
* UNIVERSAL 5 Null type
|
|
* UNIVERSAL 6 Object identifier type
|
|
* UNIVERSAL 7 Object descriptor type
|
|
* UNIVERSAL 8 External type and Instance-of type
|
|
* UNIVERSAL 9 Real type
|
|
* UNIVERSAL 10 Enumerated type
|
|
* UNIVERSAL 11 Embedded-pdv type
|
|
* UNIVERSAL 12 UTF8String type
|
|
* UNIVERSAL 13 Relative object identifier type
|
|
* UNIVERSAL 14-15 Reserved for future editions
|
|
* UNIVERSAL 16 Sequence and Sequence-of types
|
|
* UNIVERSAL 17 Set and Set-of types
|
|
* UNIVERSAL 18-22, 25-30 Character string types
|
|
* UNIVERSAL 23-24 Time types
|
|
*
|
|
* The length of an ASN.1 structure is specified after the tag identifier.
|
|
* There is a definite form and an indefinite form. The indefinite form may
|
|
* be used if the encoding is constructed and not all immediately available.
|
|
* The indefinite form is encoded using a length byte with only the 8th bit
|
|
* set. The end of the constructed object is marked using end-of-contents
|
|
* octets (two zero bytes).
|
|
*
|
|
* The definite form looks like this:
|
|
*
|
|
* The length may take up 1 or more bytes, it depends on the length of the
|
|
* value of the ASN.1 structure. DER encoding requires that if the ASN.1
|
|
* structure has a value that has a length greater than 127, more than 1 byte
|
|
* will be used to store its length, otherwise just one byte will be used.
|
|
* This is strict.
|
|
*
|
|
* In the case that the length of the ASN.1 value is less than 127, 1 octet
|
|
* (byte) is used to store the "short form" length. The 8th bit has a value of
|
|
* 0 indicating the length is "short form" and not "long form" and bits 7-1
|
|
* give the length of the data. (The 8th bit is the left-most, most significant
|
|
* bit: also known as big endian or network format).
|
|
*
|
|
* In the case that the length of the ASN.1 value is greater than 127, 2 to
|
|
* 127 octets (bytes) are used to store the "long form" length. The first
|
|
* byte's 8th bit is set to 1 to indicate the length is "long form." Bits 7-1
|
|
* give the number of additional octets. All following octets are in base 256
|
|
* with the most significant digit first (typical big-endian binary unsigned
|
|
* integer storage). So, for instance, if the length of a value was 257, the
|
|
* first byte would be set to:
|
|
*
|
|
* 10000010 = 130 = 0x82.
|
|
*
|
|
* This indicates there are 2 octets (base 256) for the length. The second and
|
|
* third bytes (the octets just mentioned) would store the length in base 256:
|
|
*
|
|
* octet 2: 00000001 = 1 * 256^1 = 256
|
|
* octet 3: 00000001 = 1 * 256^0 = 1
|
|
* total = 257
|
|
*
|
|
* The algorithm for converting a js integer value of 257 to base-256 is:
|
|
*
|
|
* var value = 257;
|
|
* var bytes = [];
|
|
* bytes[0] = (value >>> 8) & 0xFF; // most significant byte first
|
|
* bytes[1] = value & 0xFF; // least significant byte last
|
|
*
|
|
* On the ASN.1 UNIVERSAL Object Identifier (OID) type:
|
|
*
|
|
* An OID can be written like: "value1.value2.value3...valueN"
|
|
*
|
|
* The DER encoding rules:
|
|
*
|
|
* The first byte has the value 40 * value1 + value2.
|
|
* The following bytes, if any, encode the remaining values. Each value is
|
|
* encoded in base 128, most significant digit first (big endian), with as
|
|
* few digits as possible, and the most significant bit of each byte set
|
|
* to 1 except the last in each value's encoding. For example: Given the
|
|
* OID "1.2.840.113549", its DER encoding is (remember each byte except the
|
|
* last one in each encoding is OR'd with 0x80):
|
|
*
|
|
* byte 1: 40 * 1 + 2 = 42 = 0x2A.
|
|
* bytes 2-3: 128 * 6 + 72 = 840 = 6 72 = 6 72 = 0x0648 = 0x8648
|
|
* bytes 4-6: 16384 * 6 + 128 * 119 + 13 = 6 119 13 = 0x06770D = 0x86F70D
|
|
*
|
|
* The final value is: 0x2A864886F70D.
|
|
* The full OID (including ASN.1 tag and length of 6 bytes) is:
|
|
* 0x06062A864886F70D
|
|
*/
|
|
var forge = require('./forge');
|
|
require('./util');
|
|
require('./oids');
|
|
|
|
/* ASN.1 API */
|
|
var asn1 = module.exports = forge.asn1 = forge.asn1 || {};
|
|
|
|
/**
|
|
* ASN.1 classes.
|
|
*/
|
|
asn1.Class = {
|
|
UNIVERSAL: 0x00,
|
|
APPLICATION: 0x40,
|
|
CONTEXT_SPECIFIC: 0x80,
|
|
PRIVATE: 0xC0
|
|
};
|
|
|
|
/**
|
|
* ASN.1 types. Not all types are supported by this implementation, only
|
|
* those necessary to implement a simple PKI are implemented.
|
|
*/
|
|
asn1.Type = {
|
|
NONE: 0,
|
|
BOOLEAN: 1,
|
|
INTEGER: 2,
|
|
BITSTRING: 3,
|
|
OCTETSTRING: 4,
|
|
NULL: 5,
|
|
OID: 6,
|
|
ODESC: 7,
|
|
EXTERNAL: 8,
|
|
REAL: 9,
|
|
ENUMERATED: 10,
|
|
EMBEDDED: 11,
|
|
UTF8: 12,
|
|
ROID: 13,
|
|
SEQUENCE: 16,
|
|
SET: 17,
|
|
PRINTABLESTRING: 19,
|
|
IA5STRING: 22,
|
|
UTCTIME: 23,
|
|
GENERALIZEDTIME: 24,
|
|
BMPSTRING: 30
|
|
};
|
|
|
|
/**
|
|
* Creates a new asn1 object.
|
|
*
|
|
* @param tagClass the tag class for the object.
|
|
* @param type the data type (tag number) for the object.
|
|
* @param constructed true if the asn1 object is in constructed form.
|
|
* @param value the value for the object, if it is not constructed.
|
|
* @param [options] the options to use:
|
|
* [bitStringContents] the plain BIT STRING content including padding
|
|
* byte.
|
|
*
|
|
* @return the asn1 object.
|
|
*/
|
|
asn1.create = function(tagClass, type, constructed, value, options) {
|
|
/* An asn1 object has a tagClass, a type, a constructed flag, and a
|
|
value. The value's type depends on the constructed flag. If
|
|
constructed, it will contain a list of other asn1 objects. If not,
|
|
it will contain the ASN.1 value as an array of bytes formatted
|
|
according to the ASN.1 data type. */
|
|
|
|
// remove undefined values
|
|
if(forge.util.isArray(value)) {
|
|
var tmp = [];
|
|
for(var i = 0; i < value.length; ++i) {
|
|
if(value[i] !== undefined) {
|
|
tmp.push(value[i]);
|
|
}
|
|
}
|
|
value = tmp;
|
|
}
|
|
|
|
var obj = {
|
|
tagClass: tagClass,
|
|
type: type,
|
|
constructed: constructed,
|
|
composed: constructed || forge.util.isArray(value),
|
|
value: value
|
|
};
|
|
if(options && 'bitStringContents' in options) {
|
|
// TODO: copy byte buffer if it's a buffer not a string
|
|
obj.bitStringContents = options.bitStringContents;
|
|
// TODO: add readonly flag to avoid this overhead
|
|
// save copy to detect changes
|
|
obj.original = asn1.copy(obj);
|
|
}
|
|
return obj;
|
|
};
|
|
|
|
/**
|
|
* Copies an asn1 object.
|
|
*
|
|
* @param obj the asn1 object.
|
|
* @param [options] copy options:
|
|
* [excludeBitStringContents] true to not copy bitStringContents
|
|
*
|
|
* @return the a copy of the asn1 object.
|
|
*/
|
|
asn1.copy = function(obj, options) {
|
|
var copy;
|
|
|
|
if(forge.util.isArray(obj)) {
|
|
copy = [];
|
|
for(var i = 0; i < obj.length; ++i) {
|
|
copy.push(asn1.copy(obj[i], options));
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
if(typeof obj === 'string') {
|
|
// TODO: copy byte buffer if it's a buffer not a string
|
|
return obj;
|
|
}
|
|
|
|
copy = {
|
|
tagClass: obj.tagClass,
|
|
type: obj.type,
|
|
constructed: obj.constructed,
|
|
composed: obj.composed,
|
|
value: asn1.copy(obj.value, options)
|
|
};
|
|
if(options && !options.excludeBitStringContents) {
|
|
// TODO: copy byte buffer if it's a buffer not a string
|
|
copy.bitStringContents = obj.bitStringContents;
|
|
}
|
|
return copy;
|
|
};
|
|
|
|
/**
|
|
* Compares asn1 objects for equality.
|
|
*
|
|
* Note this function does not run in constant time.
|
|
*
|
|
* @param obj1 the first asn1 object.
|
|
* @param obj2 the second asn1 object.
|
|
* @param [options] compare options:
|
|
* [includeBitStringContents] true to compare bitStringContents
|
|
*
|
|
* @return true if the asn1 objects are equal.
|
|
*/
|
|
asn1.equals = function(obj1, obj2, options) {
|
|
if(forge.util.isArray(obj1)) {
|
|
if(!forge.util.isArray(obj2)) {
|
|
return false;
|
|
}
|
|
if(obj1.length !== obj2.length) {
|
|
return false;
|
|
}
|
|
for(var i = 0; i < obj1.length; ++i) {
|
|
if(!asn1.equals(obj1[i], obj2[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if(typeof obj1 !== typeof obj2) {
|
|
return false;
|
|
}
|
|
|
|
if(typeof obj1 === 'string') {
|
|
return obj1 === obj2;
|
|
}
|
|
|
|
var equal = obj1.tagClass === obj2.tagClass &&
|
|
obj1.type === obj2.type &&
|
|
obj1.constructed === obj2.constructed &&
|
|
obj1.composed === obj2.composed &&
|
|
asn1.equals(obj1.value, obj2.value);
|
|
if(options && options.includeBitStringContents) {
|
|
equal = equal && (obj1.bitStringContents === obj2.bitStringContents);
|
|
}
|
|
|
|
return equal;
|
|
};
|
|
|
|
/**
|
|
* Gets the length of a BER-encoded ASN.1 value.
|
|
*
|
|
* In case the length is not specified, undefined is returned.
|
|
*
|
|
* @param b the BER-encoded ASN.1 byte buffer, starting with the first
|
|
* length byte.
|
|
*
|
|
* @return the length of the BER-encoded ASN.1 value or undefined.
|
|
*/
|
|
asn1.getBerValueLength = function(b) {
|
|
// TODO: move this function and related DER/BER functions to a der.js
|
|
// file; better abstract ASN.1 away from der/ber.
|
|
var b2 = b.getByte();
|
|
if(b2 === 0x80) {
|
|
return undefined;
|
|
}
|
|
|
|
// see if the length is "short form" or "long form" (bit 8 set)
|
|
var length;
|
|
var longForm = b2 & 0x80;
|
|
if(!longForm) {
|
|
// length is just the first byte
|
|
length = b2;
|
|
} else {
|
|
// the number of bytes the length is specified in bits 7 through 1
|
|
// and each length byte is in big-endian base-256
|
|
length = b.getInt((b2 & 0x7F) << 3);
|
|
}
|
|
return length;
|
|
};
|
|
|
|
/**
|
|
* Check if the byte buffer has enough bytes. Throws an Error if not.
|
|
*
|
|
* @param bytes the byte buffer to parse from.
|
|
* @param remaining the bytes remaining in the current parsing state.
|
|
* @param n the number of bytes the buffer must have.
|
|
*/
|
|
function _checkBufferLength(bytes, remaining, n) {
|
|
if(n > remaining) {
|
|
var error = new Error('Too few bytes to parse DER.');
|
|
error.available = bytes.length();
|
|
error.remaining = remaining;
|
|
error.requested = n;
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the length of a BER-encoded ASN.1 value.
|
|
*
|
|
* In case the length is not specified, undefined is returned.
|
|
*
|
|
* @param bytes the byte buffer to parse from.
|
|
* @param remaining the bytes remaining in the current parsing state.
|
|
*
|
|
* @return the length of the BER-encoded ASN.1 value or undefined.
|
|
*/
|
|
var _getValueLength = function(bytes, remaining) {
|
|
// TODO: move this function and related DER/BER functions to a der.js
|
|
// file; better abstract ASN.1 away from der/ber.
|
|
// fromDer already checked that this byte exists
|
|
var b2 = bytes.getByte();
|
|
remaining--;
|
|
if(b2 === 0x80) {
|
|
return undefined;
|
|
}
|
|
|
|
// see if the length is "short form" or "long form" (bit 8 set)
|
|
var length;
|
|
var longForm = b2 & 0x80;
|
|
if(!longForm) {
|
|
// length is just the first byte
|
|
length = b2;
|
|
} else {
|
|
// the number of bytes the length is specified in bits 7 through 1
|
|
// and each length byte is in big-endian base-256
|
|
var longFormBytes = b2 & 0x7F;
|
|
_checkBufferLength(bytes, remaining, longFormBytes);
|
|
length = bytes.getInt(longFormBytes << 3);
|
|
}
|
|
// FIXME: this will only happen for 32 bit getInt with high bit set
|
|
if(length < 0) {
|
|
throw new Error('Negative length: ' + length);
|
|
}
|
|
return length;
|
|
};
|
|
|
|
/**
|
|
* Parses an asn1 object from a byte buffer in DER format.
|
|
*
|
|
* @param bytes the byte buffer to parse from.
|
|
* @param [strict] true to be strict when checking value lengths, false to
|
|
* allow truncated values (default: true).
|
|
* @param [options] object with options or boolean strict flag
|
|
* [strict] true to be strict when checking value lengths, false to
|
|
* allow truncated values (default: true).
|
|
* [decodeBitStrings] true to attempt to decode the content of
|
|
* BIT STRINGs (not OCTET STRINGs) using strict mode. Note that
|
|
* without schema support to understand the data context this can
|
|
* erroneously decode values that happen to be valid ASN.1. This
|
|
* flag will be deprecated or removed as soon as schema support is
|
|
* available. (default: true)
|
|
*
|
|
* @return the parsed asn1 object.
|
|
*/
|
|
asn1.fromDer = function(bytes, options) {
|
|
if(options === undefined) {
|
|
options = {
|
|
strict: true,
|
|
decodeBitStrings: true
|
|
};
|
|
}
|
|
if(typeof options === 'boolean') {
|
|
options = {
|
|
strict: options,
|
|
decodeBitStrings: true
|
|
};
|
|
}
|
|
if(!('strict' in options)) {
|
|
options.strict = true;
|
|
}
|
|
if(!('decodeBitStrings' in options)) {
|
|
options.decodeBitStrings = true;
|
|
}
|
|
|
|
// wrap in buffer if needed
|
|
if(typeof bytes === 'string') {
|
|
bytes = forge.util.createBuffer(bytes);
|
|
}
|
|
|
|
return _fromDer(bytes, bytes.length(), 0, options);
|
|
};
|
|
|
|
/**
|
|
* Internal function to parse an asn1 object from a byte buffer in DER format.
|
|
*
|
|
* @param bytes the byte buffer to parse from.
|
|
* @param remaining the number of bytes remaining for this chunk.
|
|
* @param depth the current parsing depth.
|
|
* @param options object with same options as fromDer().
|
|
*
|
|
* @return the parsed asn1 object.
|
|
*/
|
|
function _fromDer(bytes, remaining, depth, options) {
|
|
// temporary storage for consumption calculations
|
|
var start;
|
|
|
|
// minimum length for ASN.1 DER structure is 2
|
|
_checkBufferLength(bytes, remaining, 2);
|
|
|
|
// get the first byte
|
|
var b1 = bytes.getByte();
|
|
// consumed one byte
|
|
remaining--;
|
|
|
|
// get the tag class
|
|
var tagClass = (b1 & 0xC0);
|
|
|
|
// get the type (bits 1-5)
|
|
var type = b1 & 0x1F;
|
|
|
|
// get the variable value length and adjust remaining bytes
|
|
start = bytes.length();
|
|
var length = _getValueLength(bytes, remaining);
|
|
remaining -= start - bytes.length();
|
|
|
|
// ensure there are enough bytes to get the value
|
|
if(length !== undefined && length > remaining) {
|
|
if(options.strict) {
|
|
var error = new Error('Too few bytes to read ASN.1 value.');
|
|
error.available = bytes.length();
|
|
error.remaining = remaining;
|
|
error.requested = length;
|
|
throw error;
|
|
}
|
|
// Note: be lenient with truncated values and use remaining state bytes
|
|
length = remaining;
|
|
}
|
|
|
|
// value storage
|
|
var value;
|
|
// possible BIT STRING contents storage
|
|
var bitStringContents;
|
|
|
|
// constructed flag is bit 6 (32 = 0x20) of the first byte
|
|
var constructed = ((b1 & 0x20) === 0x20);
|
|
if(constructed) {
|
|
// parse child asn1 objects from the value
|
|
value = [];
|
|
if(length === undefined) {
|
|
// asn1 object of indefinite length, read until end tag
|
|
for(;;) {
|
|
_checkBufferLength(bytes, remaining, 2);
|
|
if(bytes.bytes(2) === String.fromCharCode(0, 0)) {
|
|
bytes.getBytes(2);
|
|
remaining -= 2;
|
|
break;
|
|
}
|
|
start = bytes.length();
|
|
value.push(_fromDer(bytes, remaining, depth + 1, options));
|
|
remaining -= start - bytes.length();
|
|
}
|
|
} else {
|
|
// parsing asn1 object of definite length
|
|
while(length > 0) {
|
|
start = bytes.length();
|
|
value.push(_fromDer(bytes, length, depth + 1, options));
|
|
remaining -= start - bytes.length();
|
|
length -= start - bytes.length();
|
|
}
|
|
}
|
|
}
|
|
|
|
// if a BIT STRING, save the contents including padding
|
|
if(value === undefined && tagClass === asn1.Class.UNIVERSAL &&
|
|
type === asn1.Type.BITSTRING) {
|
|
bitStringContents = bytes.bytes(length);
|
|
}
|
|
|
|
// determine if a non-constructed value should be decoded as a composed
|
|
// value that contains other ASN.1 objects. BIT STRINGs (and OCTET STRINGs)
|
|
// can be used this way.
|
|
if(value === undefined && options.decodeBitStrings &&
|
|
tagClass === asn1.Class.UNIVERSAL &&
|
|
// FIXME: OCTET STRINGs not yet supported here
|
|
// .. other parts of forge expect to decode OCTET STRINGs manually
|
|
(type === asn1.Type.BITSTRING /*|| type === asn1.Type.OCTETSTRING*/) &&
|
|
length > 1) {
|
|
// save read position
|
|
var savedRead = bytes.read;
|
|
var savedRemaining = remaining;
|
|
var unused = 0;
|
|
if(type === asn1.Type.BITSTRING) {
|
|
/* The first octet gives the number of bits by which the length of the
|
|
bit string is less than the next multiple of eight (this is called
|
|
the "number of unused bits").
|
|
|
|
The second and following octets give the value of the bit string
|
|
converted to an octet string. */
|
|
_checkBufferLength(bytes, remaining, 1);
|
|
unused = bytes.getByte();
|
|
remaining--;
|
|
}
|
|
// if all bits are used, maybe the BIT/OCTET STRING holds ASN.1 objs
|
|
if(unused === 0) {
|
|
try {
|
|
// attempt to parse child asn1 object from the value
|
|
// (stored in array to signal composed value)
|
|
start = bytes.length();
|
|
var subOptions = {
|
|
// enforce strict mode to avoid parsing ASN.1 from plain data
|
|
verbose: options.verbose,
|
|
strict: true,
|
|
decodeBitStrings: true
|
|
};
|
|
var composed = _fromDer(bytes, remaining, depth + 1, subOptions);
|
|
var used = start - bytes.length();
|
|
remaining -= used;
|
|
if(type == asn1.Type.BITSTRING) {
|
|
used++;
|
|
}
|
|
|
|
// if the data all decoded and the class indicates UNIVERSAL or
|
|
// CONTEXT_SPECIFIC then assume we've got an encapsulated ASN.1 object
|
|
var tc = composed.tagClass;
|
|
if(used === length &&
|
|
(tc === asn1.Class.UNIVERSAL || tc === asn1.Class.CONTEXT_SPECIFIC)) {
|
|
value = [composed];
|
|
}
|
|
} catch(ex) {
|
|
}
|
|
}
|
|
if(value === undefined) {
|
|
// restore read position
|
|
bytes.read = savedRead;
|
|
remaining = savedRemaining;
|
|
}
|
|
}
|
|
|
|
if(value === undefined) {
|
|
// asn1 not constructed or composed, get raw value
|
|
// TODO: do DER to OID conversion and vice-versa in .toDer?
|
|
|
|
if(length === undefined) {
|
|
if(options.strict) {
|
|
throw new Error('Non-constructed ASN.1 object of indefinite length.');
|
|
}
|
|
// be lenient and use remaining state bytes
|
|
length = remaining;
|
|
}
|
|
|
|
if(type === asn1.Type.BMPSTRING) {
|
|
value = '';
|
|
for(; length > 0; length -= 2) {
|
|
_checkBufferLength(bytes, remaining, 2);
|
|
value += String.fromCharCode(bytes.getInt16());
|
|
remaining -= 2;
|
|
}
|
|
} else {
|
|
value = bytes.getBytes(length);
|
|
}
|
|
}
|
|
|
|
// add BIT STRING contents if available
|
|
var asn1Options = bitStringContents === undefined ? null : {
|
|
bitStringContents: bitStringContents
|
|
};
|
|
|
|
// create and return asn1 object
|
|
return asn1.create(tagClass, type, constructed, value, asn1Options);
|
|
}
|
|
|
|
/**
|
|
* Converts the given asn1 object to a buffer of bytes in DER format.
|
|
*
|
|
* @param asn1 the asn1 object to convert to bytes.
|
|
*
|
|
* @return the buffer of bytes.
|
|
*/
|
|
asn1.toDer = function(obj) {
|
|
var bytes = forge.util.createBuffer();
|
|
|
|
// build the first byte
|
|
var b1 = obj.tagClass | obj.type;
|
|
|
|
// for storing the ASN.1 value
|
|
var value = forge.util.createBuffer();
|
|
|
|
// use BIT STRING contents if available and data not changed
|
|
var useBitStringContents = false;
|
|
if('bitStringContents' in obj) {
|
|
useBitStringContents = true;
|
|
if(obj.original) {
|
|
useBitStringContents = asn1.equals(obj, obj.original);
|
|
}
|
|
}
|
|
|
|
if(useBitStringContents) {
|
|
value.putBytes(obj.bitStringContents);
|
|
} else if(obj.composed) {
|
|
// if composed, use each child asn1 object's DER bytes as value
|
|
// turn on 6th bit (0x20 = 32) to indicate asn1 is constructed
|
|
// from other asn1 objects
|
|
if(obj.constructed) {
|
|
b1 |= 0x20;
|
|
} else {
|
|
// type is a bit string, add unused bits of 0x00
|
|
value.putByte(0x00);
|
|
}
|
|
|
|
// add all of the child DER bytes together
|
|
for(var i = 0; i < obj.value.length; ++i) {
|
|
if(obj.value[i] !== undefined) {
|
|
value.putBuffer(asn1.toDer(obj.value[i]));
|
|
}
|
|
}
|
|
} else {
|
|
// use asn1.value directly
|
|
if(obj.type === asn1.Type.BMPSTRING) {
|
|
for(var i = 0; i < obj.value.length; ++i) {
|
|
value.putInt16(obj.value.charCodeAt(i));
|
|
}
|
|
} else {
|
|
// ensure integer is minimally-encoded
|
|
// TODO: should all leading bytes be stripped vs just one?
|
|
// .. ex '00 00 01' => '01'?
|
|
if(obj.type === asn1.Type.INTEGER &&
|
|
obj.value.length > 1 &&
|
|
// leading 0x00 for positive integer
|
|
((obj.value.charCodeAt(0) === 0 &&
|
|
(obj.value.charCodeAt(1) & 0x80) === 0) ||
|
|
// leading 0xFF for negative integer
|
|
(obj.value.charCodeAt(0) === 0xFF &&
|
|
(obj.value.charCodeAt(1) & 0x80) === 0x80))) {
|
|
value.putBytes(obj.value.substr(1));
|
|
} else {
|
|
value.putBytes(obj.value);
|
|
}
|
|
}
|
|
}
|
|
|
|
// add tag byte
|
|
bytes.putByte(b1);
|
|
|
|
// use "short form" encoding
|
|
if(value.length() <= 127) {
|
|
// one byte describes the length
|
|
// bit 8 = 0 and bits 7-1 = length
|
|
bytes.putByte(value.length() & 0x7F);
|
|
} else {
|
|
// use "long form" encoding
|
|
// 2 to 127 bytes describe the length
|
|
// first byte: bit 8 = 1 and bits 7-1 = # of additional bytes
|
|
// other bytes: length in base 256, big-endian
|
|
var len = value.length();
|
|
var lenBytes = '';
|
|
do {
|
|
lenBytes += String.fromCharCode(len & 0xFF);
|
|
len = len >>> 8;
|
|
} while(len > 0);
|
|
|
|
// set first byte to # bytes used to store the length and turn on
|
|
// bit 8 to indicate long-form length is used
|
|
bytes.putByte(lenBytes.length | 0x80);
|
|
|
|
// concatenate length bytes in reverse since they were generated
|
|
// little endian and we need big endian
|
|
for(var i = lenBytes.length - 1; i >= 0; --i) {
|
|
bytes.putByte(lenBytes.charCodeAt(i));
|
|
}
|
|
}
|
|
|
|
// concatenate value bytes
|
|
bytes.putBuffer(value);
|
|
return bytes;
|
|
};
|
|
|
|
/**
|
|
* Converts an OID dot-separated string to a byte buffer. The byte buffer
|
|
* contains only the DER-encoded value, not any tag or length bytes.
|
|
*
|
|
* @param oid the OID dot-separated string.
|
|
*
|
|
* @return the byte buffer.
|
|
*/
|
|
asn1.oidToDer = function(oid) {
|
|
// split OID into individual values
|
|
var values = oid.split('.');
|
|
var bytes = forge.util.createBuffer();
|
|
|
|
// first byte is 40 * value1 + value2
|
|
bytes.putByte(40 * parseInt(values[0], 10) + parseInt(values[1], 10));
|
|
// other bytes are each value in base 128 with 8th bit set except for
|
|
// the last byte for each value
|
|
var last, valueBytes, value, b;
|
|
for(var i = 2; i < values.length; ++i) {
|
|
// produce value bytes in reverse because we don't know how many
|
|
// bytes it will take to store the value
|
|
last = true;
|
|
valueBytes = [];
|
|
value = parseInt(values[i], 10);
|
|
do {
|
|
b = value & 0x7F;
|
|
value = value >>> 7;
|
|
// if value is not last, then turn on 8th bit
|
|
if(!last) {
|
|
b |= 0x80;
|
|
}
|
|
valueBytes.push(b);
|
|
last = false;
|
|
} while(value > 0);
|
|
|
|
// add value bytes in reverse (needs to be in big endian)
|
|
for(var n = valueBytes.length - 1; n >= 0; --n) {
|
|
bytes.putByte(valueBytes[n]);
|
|
}
|
|
}
|
|
|
|
return bytes;
|
|
};
|
|
|
|
/**
|
|
* Converts a DER-encoded byte buffer to an OID dot-separated string. The
|
|
* byte buffer should contain only the DER-encoded value, not any tag or
|
|
* length bytes.
|
|
*
|
|
* @param bytes the byte buffer.
|
|
*
|
|
* @return the OID dot-separated string.
|
|
*/
|
|
asn1.derToOid = function(bytes) {
|
|
var oid;
|
|
|
|
// wrap in buffer if needed
|
|
if(typeof bytes === 'string') {
|
|
bytes = forge.util.createBuffer(bytes);
|
|
}
|
|
|
|
// first byte is 40 * value1 + value2
|
|
var b = bytes.getByte();
|
|
oid = Math.floor(b / 40) + '.' + (b % 40);
|
|
|
|
// other bytes are each value in base 128 with 8th bit set except for
|
|
// the last byte for each value
|
|
var value = 0;
|
|
while(bytes.length() > 0) {
|
|
b = bytes.getByte();
|
|
value = value << 7;
|
|
// not the last byte for the value
|
|
if(b & 0x80) {
|
|
value += b & 0x7F;
|
|
} else {
|
|
// last byte
|
|
oid += '.' + (value + b);
|
|
value = 0;
|
|
}
|
|
}
|
|
|
|
return oid;
|
|
};
|
|
|
|
/**
|
|
* Converts a UTCTime value to a date.
|
|
*
|
|
* Note: GeneralizedTime has 4 digits for the year and is used for X.509
|
|
* dates past 2049. Parsing that structure hasn't been implemented yet.
|
|
*
|
|
* @param utc the UTCTime value to convert.
|
|
*
|
|
* @return the date.
|
|
*/
|
|
asn1.utcTimeToDate = function(utc) {
|
|
/* The following formats can be used:
|
|
|
|
YYMMDDhhmmZ
|
|
YYMMDDhhmm+hh'mm'
|
|
YYMMDDhhmm-hh'mm'
|
|
YYMMDDhhmmssZ
|
|
YYMMDDhhmmss+hh'mm'
|
|
YYMMDDhhmmss-hh'mm'
|
|
|
|
Where:
|
|
|
|
YY is the least significant two digits of the year
|
|
MM is the month (01 to 12)
|
|
DD is the day (01 to 31)
|
|
hh is the hour (00 to 23)
|
|
mm are the minutes (00 to 59)
|
|
ss are the seconds (00 to 59)
|
|
Z indicates that local time is GMT, + indicates that local time is
|
|
later than GMT, and - indicates that local time is earlier than GMT
|
|
hh' is the absolute value of the offset from GMT in hours
|
|
mm' is the absolute value of the offset from GMT in minutes */
|
|
var date = new Date();
|
|
|
|
// if YY >= 50 use 19xx, if YY < 50 use 20xx
|
|
var year = parseInt(utc.substr(0, 2), 10);
|
|
year = (year >= 50) ? 1900 + year : 2000 + year;
|
|
var MM = parseInt(utc.substr(2, 2), 10) - 1; // use 0-11 for month
|
|
var DD = parseInt(utc.substr(4, 2), 10);
|
|
var hh = parseInt(utc.substr(6, 2), 10);
|
|
var mm = parseInt(utc.substr(8, 2), 10);
|
|
var ss = 0;
|
|
|
|
// not just YYMMDDhhmmZ
|
|
if(utc.length > 11) {
|
|
// get character after minutes
|
|
var c = utc.charAt(10);
|
|
var end = 10;
|
|
|
|
// see if seconds are present
|
|
if(c !== '+' && c !== '-') {
|
|
// get seconds
|
|
ss = parseInt(utc.substr(10, 2), 10);
|
|
end += 2;
|
|
}
|
|
}
|
|
|
|
// update date
|
|
date.setUTCFullYear(year, MM, DD);
|
|
date.setUTCHours(hh, mm, ss, 0);
|
|
|
|
if(end) {
|
|
// get +/- after end of time
|
|
c = utc.charAt(end);
|
|
if(c === '+' || c === '-') {
|
|
// get hours+minutes offset
|
|
var hhoffset = parseInt(utc.substr(end + 1, 2), 10);
|
|
var mmoffset = parseInt(utc.substr(end + 4, 2), 10);
|
|
|
|
// calculate offset in milliseconds
|
|
var offset = hhoffset * 60 + mmoffset;
|
|
offset *= 60000;
|
|
|
|
// apply offset
|
|
if(c === '+') {
|
|
date.setTime(+date - offset);
|
|
} else {
|
|
date.setTime(+date + offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
return date;
|
|
};
|
|
|
|
/**
|
|
* Converts a GeneralizedTime value to a date.
|
|
*
|
|
* @param gentime the GeneralizedTime value to convert.
|
|
*
|
|
* @return the date.
|
|
*/
|
|
asn1.generalizedTimeToDate = function(gentime) {
|
|
/* The following formats can be used:
|
|
|
|
YYYYMMDDHHMMSS
|
|
YYYYMMDDHHMMSS.fff
|
|
YYYYMMDDHHMMSSZ
|
|
YYYYMMDDHHMMSS.fffZ
|
|
YYYYMMDDHHMMSS+hh'mm'
|
|
YYYYMMDDHHMMSS.fff+hh'mm'
|
|
YYYYMMDDHHMMSS-hh'mm'
|
|
YYYYMMDDHHMMSS.fff-hh'mm'
|
|
|
|
Where:
|
|
|
|
YYYY is the year
|
|
MM is the month (01 to 12)
|
|
DD is the day (01 to 31)
|
|
hh is the hour (00 to 23)
|
|
mm are the minutes (00 to 59)
|
|
ss are the seconds (00 to 59)
|
|
.fff is the second fraction, accurate to three decimal places
|
|
Z indicates that local time is GMT, + indicates that local time is
|
|
later than GMT, and - indicates that local time is earlier than GMT
|
|
hh' is the absolute value of the offset from GMT in hours
|
|
mm' is the absolute value of the offset from GMT in minutes */
|
|
var date = new Date();
|
|
|
|
var YYYY = parseInt(gentime.substr(0, 4), 10);
|
|
var MM = parseInt(gentime.substr(4, 2), 10) - 1; // use 0-11 for month
|
|
var DD = parseInt(gentime.substr(6, 2), 10);
|
|
var hh = parseInt(gentime.substr(8, 2), 10);
|
|
var mm = parseInt(gentime.substr(10, 2), 10);
|
|
var ss = parseInt(gentime.substr(12, 2), 10);
|
|
var fff = 0;
|
|
var offset = 0;
|
|
var isUTC = false;
|
|
|
|
if(gentime.charAt(gentime.length - 1) === 'Z') {
|
|
isUTC = true;
|
|
}
|
|
|
|
var end = gentime.length - 5, c = gentime.charAt(end);
|
|
if(c === '+' || c === '-') {
|
|
// get hours+minutes offset
|
|
var hhoffset = parseInt(gentime.substr(end + 1, 2), 10);
|
|
var mmoffset = parseInt(gentime.substr(end + 4, 2), 10);
|
|
|
|
// calculate offset in milliseconds
|
|
offset = hhoffset * 60 + mmoffset;
|
|
offset *= 60000;
|
|
|
|
// apply offset
|
|
if(c === '+') {
|
|
offset *= -1;
|
|
}
|
|
|
|
isUTC = true;
|
|
}
|
|
|
|
// check for second fraction
|
|
if(gentime.charAt(14) === '.') {
|
|
fff = parseFloat(gentime.substr(14), 10) * 1000;
|
|
}
|
|
|
|
if(isUTC) {
|
|
date.setUTCFullYear(YYYY, MM, DD);
|
|
date.setUTCHours(hh, mm, ss, fff);
|
|
|
|
// apply offset
|
|
date.setTime(+date + offset);
|
|
} else {
|
|
date.setFullYear(YYYY, MM, DD);
|
|
date.setHours(hh, mm, ss, fff);
|
|
}
|
|
|
|
return date;
|
|
};
|
|
|
|
/**
|
|
* Converts a date to a UTCTime value.
|
|
*
|
|
* Note: GeneralizedTime has 4 digits for the year and is used for X.509
|
|
* dates past 2049. Converting to a GeneralizedTime hasn't been
|
|
* implemented yet.
|
|
*
|
|
* @param date the date to convert.
|
|
*
|
|
* @return the UTCTime value.
|
|
*/
|
|
asn1.dateToUtcTime = function(date) {
|
|
// TODO: validate; currently assumes proper format
|
|
if(typeof date === 'string') {
|
|
return date;
|
|
}
|
|
|
|
var rval = '';
|
|
|
|
// create format YYMMDDhhmmssZ
|
|
var format = [];
|
|
format.push(('' + date.getUTCFullYear()).substr(2));
|
|
format.push('' + (date.getUTCMonth() + 1));
|
|
format.push('' + date.getUTCDate());
|
|
format.push('' + date.getUTCHours());
|
|
format.push('' + date.getUTCMinutes());
|
|
format.push('' + date.getUTCSeconds());
|
|
|
|
// ensure 2 digits are used for each format entry
|
|
for(var i = 0; i < format.length; ++i) {
|
|
if(format[i].length < 2) {
|
|
rval += '0';
|
|
}
|
|
rval += format[i];
|
|
}
|
|
rval += 'Z';
|
|
|
|
return rval;
|
|
};
|
|
|
|
/**
|
|
* Converts a date to a GeneralizedTime value.
|
|
*
|
|
* @param date the date to convert.
|
|
*
|
|
* @return the GeneralizedTime value as a string.
|
|
*/
|
|
asn1.dateToGeneralizedTime = function(date) {
|
|
// TODO: validate; currently assumes proper format
|
|
if(typeof date === 'string') {
|
|
return date;
|
|
}
|
|
|
|
var rval = '';
|
|
|
|
// create format YYYYMMDDHHMMSSZ
|
|
var format = [];
|
|
format.push('' + date.getUTCFullYear());
|
|
format.push('' + (date.getUTCMonth() + 1));
|
|
format.push('' + date.getUTCDate());
|
|
format.push('' + date.getUTCHours());
|
|
format.push('' + date.getUTCMinutes());
|
|
format.push('' + date.getUTCSeconds());
|
|
|
|
// ensure 2 digits are used for each format entry
|
|
for(var i = 0; i < format.length; ++i) {
|
|
if(format[i].length < 2) {
|
|
rval += '0';
|
|
}
|
|
rval += format[i];
|
|
}
|
|
rval += 'Z';
|
|
|
|
return rval;
|
|
};
|
|
|
|
/**
|
|
* Converts a javascript integer to a DER-encoded byte buffer to be used
|
|
* as the value for an INTEGER type.
|
|
*
|
|
* @param x the integer.
|
|
*
|
|
* @return the byte buffer.
|
|
*/
|
|
asn1.integerToDer = function(x) {
|
|
var rval = forge.util.createBuffer();
|
|
if(x >= -0x80 && x < 0x80) {
|
|
return rval.putSignedInt(x, 8);
|
|
}
|
|
if(x >= -0x8000 && x < 0x8000) {
|
|
return rval.putSignedInt(x, 16);
|
|
}
|
|
if(x >= -0x800000 && x < 0x800000) {
|
|
return rval.putSignedInt(x, 24);
|
|
}
|
|
if(x >= -0x80000000 && x < 0x80000000) {
|
|
return rval.putSignedInt(x, 32);
|
|
}
|
|
var error = new Error('Integer too large; max is 32-bits.');
|
|
error.integer = x;
|
|
throw error;
|
|
};
|
|
|
|
/**
|
|
* Converts a DER-encoded byte buffer to a javascript integer. This is
|
|
* typically used to decode the value of an INTEGER type.
|
|
*
|
|
* @param bytes the byte buffer.
|
|
*
|
|
* @return the integer.
|
|
*/
|
|
asn1.derToInteger = function(bytes) {
|
|
// wrap in buffer if needed
|
|
if(typeof bytes === 'string') {
|
|
bytes = forge.util.createBuffer(bytes);
|
|
}
|
|
|
|
var n = bytes.length() * 8;
|
|
if(n > 32) {
|
|
throw new Error('Integer too large; max is 32-bits.');
|
|
}
|
|
return bytes.getSignedInt(n);
|
|
};
|
|
|
|
/**
|
|
* Validates that the given ASN.1 object is at least a super set of the
|
|
* given ASN.1 structure. Only tag classes and types are checked. An
|
|
* optional map may also be provided to capture ASN.1 values while the
|
|
* structure is checked.
|
|
*
|
|
* To capture an ASN.1 value, set an object in the validator's 'capture'
|
|
* parameter to the key to use in the capture map. To capture the full
|
|
* ASN.1 object, specify 'captureAsn1'. To capture BIT STRING bytes, including
|
|
* the leading unused bits counter byte, specify 'captureBitStringContents'.
|
|
* To capture BIT STRING bytes, without the leading unused bits counter byte,
|
|
* specify 'captureBitStringValue'.
|
|
*
|
|
* Objects in the validator may set a field 'optional' to true to indicate
|
|
* that it isn't necessary to pass validation.
|
|
*
|
|
* @param obj the ASN.1 object to validate.
|
|
* @param v the ASN.1 structure validator.
|
|
* @param capture an optional map to capture values in.
|
|
* @param errors an optional array for storing validation errors.
|
|
*
|
|
* @return true on success, false on failure.
|
|
*/
|
|
asn1.validate = function(obj, v, capture, errors) {
|
|
var rval = false;
|
|
|
|
// ensure tag class and type are the same if specified
|
|
if((obj.tagClass === v.tagClass || typeof(v.tagClass) === 'undefined') &&
|
|
(obj.type === v.type || typeof(v.type) === 'undefined')) {
|
|
// ensure constructed flag is the same if specified
|
|
if(obj.constructed === v.constructed ||
|
|
typeof(v.constructed) === 'undefined') {
|
|
rval = true;
|
|
|
|
// handle sub values
|
|
if(v.value && forge.util.isArray(v.value)) {
|
|
var j = 0;
|
|
for(var i = 0; rval && i < v.value.length; ++i) {
|
|
rval = v.value[i].optional || false;
|
|
if(obj.value[j]) {
|
|
rval = asn1.validate(obj.value[j], v.value[i], capture, errors);
|
|
if(rval) {
|
|
++j;
|
|
} else if(v.value[i].optional) {
|
|
rval = true;
|
|
}
|
|
}
|
|
if(!rval && errors) {
|
|
errors.push(
|
|
'[' + v.name + '] ' +
|
|
'Tag class "' + v.tagClass + '", type "' +
|
|
v.type + '" expected value length "' +
|
|
v.value.length + '", got "' +
|
|
obj.value.length + '"');
|
|
}
|
|
}
|
|
}
|
|
|
|
if(rval && capture) {
|
|
if(v.capture) {
|
|
capture[v.capture] = obj.value;
|
|
}
|
|
if(v.captureAsn1) {
|
|
capture[v.captureAsn1] = obj;
|
|
}
|
|
if(v.captureBitStringContents && 'bitStringContents' in obj) {
|
|
capture[v.captureBitStringContents] = obj.bitStringContents;
|
|
}
|
|
if(v.captureBitStringValue && 'bitStringContents' in obj) {
|
|
var value;
|
|
if(obj.bitStringContents.length < 2) {
|
|
capture[v.captureBitStringValue] = '';
|
|
} else {
|
|
// FIXME: support unused bits with data shifting
|
|
var unused = obj.bitStringContents.charCodeAt(0);
|
|
if(unused !== 0) {
|
|
throw new Error(
|
|
'captureBitStringValue only supported for zero unused bits');
|
|
}
|
|
capture[v.captureBitStringValue] = obj.bitStringContents.slice(1);
|
|
}
|
|
}
|
|
}
|
|
} else if(errors) {
|
|
errors.push(
|
|
'[' + v.name + '] ' +
|
|
'Expected constructed "' + v.constructed + '", got "' +
|
|
obj.constructed + '"');
|
|
}
|
|
} else if(errors) {
|
|
if(obj.tagClass !== v.tagClass) {
|
|
errors.push(
|
|
'[' + v.name + '] ' +
|
|
'Expected tag class "' + v.tagClass + '", got "' +
|
|
obj.tagClass + '"');
|
|
}
|
|
if(obj.type !== v.type) {
|
|
errors.push(
|
|
'[' + v.name + '] ' +
|
|
'Expected type "' + v.type + '", got "' + obj.type + '"');
|
|
}
|
|
}
|
|
return rval;
|
|
};
|
|
|
|
// regex for testing for non-latin characters
|
|
var _nonLatinRegex = /[^\\u0000-\\u00ff]/;
|
|
|
|
/**
|
|
* Pretty prints an ASN.1 object to a string.
|
|
*
|
|
* @param obj the object to write out.
|
|
* @param level the level in the tree.
|
|
* @param indentation the indentation to use.
|
|
*
|
|
* @return the string.
|
|
*/
|
|
asn1.prettyPrint = function(obj, level, indentation) {
|
|
var rval = '';
|
|
|
|
// set default level and indentation
|
|
level = level || 0;
|
|
indentation = indentation || 2;
|
|
|
|
// start new line for deep levels
|
|
if(level > 0) {
|
|
rval += '\n';
|
|
}
|
|
|
|
// create indent
|
|
var indent = '';
|
|
for(var i = 0; i < level * indentation; ++i) {
|
|
indent += ' ';
|
|
}
|
|
|
|
// print class:type
|
|
rval += indent + 'Tag: ';
|
|
switch(obj.tagClass) {
|
|
case asn1.Class.UNIVERSAL:
|
|
rval += 'Universal:';
|
|
break;
|
|
case asn1.Class.APPLICATION:
|
|
rval += 'Application:';
|
|
break;
|
|
case asn1.Class.CONTEXT_SPECIFIC:
|
|
rval += 'Context-Specific:';
|
|
break;
|
|
case asn1.Class.PRIVATE:
|
|
rval += 'Private:';
|
|
break;
|
|
}
|
|
|
|
if(obj.tagClass === asn1.Class.UNIVERSAL) {
|
|
rval += obj.type;
|
|
|
|
// known types
|
|
switch(obj.type) {
|
|
case asn1.Type.NONE:
|
|
rval += ' (None)';
|
|
break;
|
|
case asn1.Type.BOOLEAN:
|
|
rval += ' (Boolean)';
|
|
break;
|
|
case asn1.Type.INTEGER:
|
|
rval += ' (Integer)';
|
|
break;
|
|
case asn1.Type.BITSTRING:
|
|
rval += ' (Bit string)';
|
|
break;
|
|
case asn1.Type.OCTETSTRING:
|
|
rval += ' (Octet string)';
|
|
break;
|
|
case asn1.Type.NULL:
|
|
rval += ' (Null)';
|
|
break;
|
|
case asn1.Type.OID:
|
|
rval += ' (Object Identifier)';
|
|
break;
|
|
case asn1.Type.ODESC:
|
|
rval += ' (Object Descriptor)';
|
|
break;
|
|
case asn1.Type.EXTERNAL:
|
|
rval += ' (External or Instance of)';
|
|
break;
|
|
case asn1.Type.REAL:
|
|
rval += ' (Real)';
|
|
break;
|
|
case asn1.Type.ENUMERATED:
|
|
rval += ' (Enumerated)';
|
|
break;
|
|
case asn1.Type.EMBEDDED:
|
|
rval += ' (Embedded PDV)';
|
|
break;
|
|
case asn1.Type.UTF8:
|
|
rval += ' (UTF8)';
|
|
break;
|
|
case asn1.Type.ROID:
|
|
rval += ' (Relative Object Identifier)';
|
|
break;
|
|
case asn1.Type.SEQUENCE:
|
|
rval += ' (Sequence)';
|
|
break;
|
|
case asn1.Type.SET:
|
|
rval += ' (Set)';
|
|
break;
|
|
case asn1.Type.PRINTABLESTRING:
|
|
rval += ' (Printable String)';
|
|
break;
|
|
case asn1.Type.IA5String:
|
|
rval += ' (IA5String (ASCII))';
|
|
break;
|
|
case asn1.Type.UTCTIME:
|
|
rval += ' (UTC time)';
|
|
break;
|
|
case asn1.Type.GENERALIZEDTIME:
|
|
rval += ' (Generalized time)';
|
|
break;
|
|
case asn1.Type.BMPSTRING:
|
|
rval += ' (BMP String)';
|
|
break;
|
|
}
|
|
} else {
|
|
rval += obj.type;
|
|
}
|
|
|
|
rval += '\n';
|
|
rval += indent + 'Constructed: ' + obj.constructed + '\n';
|
|
|
|
if(obj.composed) {
|
|
var subvalues = 0;
|
|
var sub = '';
|
|
for(var i = 0; i < obj.value.length; ++i) {
|
|
if(obj.value[i] !== undefined) {
|
|
subvalues += 1;
|
|
sub += asn1.prettyPrint(obj.value[i], level + 1, indentation);
|
|
if((i + 1) < obj.value.length) {
|
|
sub += ',';
|
|
}
|
|
}
|
|
}
|
|
rval += indent + 'Sub values: ' + subvalues + sub;
|
|
} else {
|
|
rval += indent + 'Value: ';
|
|
if(obj.type === asn1.Type.OID) {
|
|
var oid = asn1.derToOid(obj.value);
|
|
rval += oid;
|
|
if(forge.pki && forge.pki.oids) {
|
|
if(oid in forge.pki.oids) {
|
|
rval += ' (' + forge.pki.oids[oid] + ') ';
|
|
}
|
|
}
|
|
}
|
|
if(obj.type === asn1.Type.INTEGER) {
|
|
try {
|
|
rval += asn1.derToInteger(obj.value);
|
|
} catch(ex) {
|
|
rval += '0x' + forge.util.bytesToHex(obj.value);
|
|
}
|
|
} else if(obj.type === asn1.Type.BITSTRING) {
|
|
// TODO: shift bits as needed to display without padding
|
|
if(obj.value.length > 1) {
|
|
// remove unused bits field
|
|
rval += '0x' + forge.util.bytesToHex(obj.value.slice(1));
|
|
} else {
|
|
rval += '(none)';
|
|
}
|
|
// show unused bit count
|
|
if(obj.value.length > 0) {
|
|
var unused = obj.value.charCodeAt(0);
|
|
if(unused == 1) {
|
|
rval += ' (1 unused bit shown)';
|
|
} else if(unused > 1) {
|
|
rval += ' (' + unused + ' unused bits shown)';
|
|
}
|
|
}
|
|
} else if(obj.type === asn1.Type.OCTETSTRING) {
|
|
if(!_nonLatinRegex.test(obj.value)) {
|
|
rval += '(' + obj.value + ') ';
|
|
}
|
|
rval += '0x' + forge.util.bytesToHex(obj.value);
|
|
} else if(obj.type === asn1.Type.UTF8) {
|
|
rval += forge.util.decodeUtf8(obj.value);
|
|
} else if(obj.type === asn1.Type.PRINTABLESTRING ||
|
|
obj.type === asn1.Type.IA5String) {
|
|
rval += obj.value;
|
|
} else if(_nonLatinRegex.test(obj.value)) {
|
|
rval += '0x' + forge.util.bytesToHex(obj.value);
|
|
} else if(obj.value.length === 0) {
|
|
rval += '[null]';
|
|
} else {
|
|
rval += obj.value;
|
|
}
|
|
}
|
|
|
|
return rval;
|
|
};
|