607 lines
14 KiB
JavaScript
607 lines
14 KiB
JavaScript
/*
|
|
* Copyright (c) 2014-2015 Sylvain Peyrefitte
|
|
*
|
|
* This file is part of node-rdpjs.
|
|
*
|
|
* node-rdpjs is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
var spec = require('./spec');
|
|
var type = require('../core').type;
|
|
var error = require('../core').error;
|
|
var inherits = require('util').inherits;
|
|
|
|
/**
|
|
* ASN.1 Universal tags
|
|
* @see http://www.obj-sys.com/asn1tutorial/node124.html
|
|
*/
|
|
var UniversalTag = {
|
|
Boolean : 1,
|
|
Integer : 2,
|
|
BitString : 3,
|
|
OctetString : 4,
|
|
Null : 5,
|
|
ObjectIdentifier : 6,
|
|
ObjectDescriptor : 7,
|
|
Enumerate : 10,
|
|
UTF8String : 12,
|
|
Sequence : 16,
|
|
Set : 17,
|
|
PrintableString : 19,
|
|
T61String : 20,
|
|
IA5String : 22,
|
|
UTCTime : 23,
|
|
GeneralizedTime : 24,
|
|
UniversalString : 28,
|
|
BMPString : 30
|
|
};
|
|
|
|
/**
|
|
* Boolean type
|
|
* @param value {boolean} inner value
|
|
*/
|
|
function Boolean(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.Boolean));
|
|
this.value = value || false;
|
|
}
|
|
|
|
inherits(Boolean, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {Boolean}
|
|
*/
|
|
Boolean.prototype.decode = function(s, decoder) {
|
|
this.value = new type.UInt8().read(new type.Stream(decoder.decode(s, this.tag).value)).value !== 0;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* @param decoder {ber.decoder}
|
|
* @returns {type.*}
|
|
*/
|
|
Boolean.prototype.encode = function(encoder) {
|
|
if(this.value) {
|
|
return encoder.encode(this.tag, new type.UInt8(0xff));
|
|
}
|
|
else {
|
|
return encoder.encode(this.tag, new type.UInt8(0));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Integer type
|
|
* @param value {integer | Buffer}
|
|
*/
|
|
function Integer(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.Integer));
|
|
this.value = value || 0;
|
|
}
|
|
|
|
inherits(Integer, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {Integer}
|
|
*/
|
|
Integer.prototype.decode = function(s, decoder) {
|
|
var integerBuffer = decoder.decode(s, this.tag).value;
|
|
if(integerBuffer.length < 5) {
|
|
var integerStream = new type.Stream(integerBuffer);
|
|
while (integerStream.availableLength() > 0) {
|
|
this.value = this.value << 8;
|
|
this.value |= new type.UInt8().read(integerStream).value;
|
|
}
|
|
}
|
|
// bignum case
|
|
else {
|
|
this.value = integerBuffer;
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* @param encoder {ber.decoder}
|
|
* @returns {type.*}
|
|
*/
|
|
Integer.prototype.encode = function(encoder) {
|
|
if(this.value <= 0xff) {
|
|
return encoder.encode(this.tag, new type.UInt8(this.value));
|
|
}
|
|
else if(this.value <= 0xffff) {
|
|
return encoder.encode(this.tag, new type.UInt16Be(this.value));
|
|
}
|
|
else {
|
|
return encoder.encode(this.tag, new type.UInt32Be(this.value));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Sequence type
|
|
* @param value {object}
|
|
*/
|
|
function Sequence(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Constructed, UniversalTag.Sequence));
|
|
this.value = value || [];
|
|
}
|
|
|
|
inherits(Sequence, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {Sequence}
|
|
*/
|
|
Sequence.prototype.decode = function(s, decoder) {
|
|
var sequenceStream = new type.Stream(decoder.decode(s, this.tag).value);
|
|
for (var i in this.value) {
|
|
var rec = sequenceStream.offset;
|
|
try {
|
|
this.value[i].decode(sequenceStream, decoder);
|
|
} catch(e) {
|
|
if ((e.message === 'NODE_RDP_ASN1_BER_INVALID_TAG') && !this.value[i].opt) {
|
|
throw new error.ProtocolError('NODE_RDP_ASN1_UNIV_SEQUENCE_FIELD_NOT_PRESENT');
|
|
}
|
|
sequenceStream.offset = rec;
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Encode sequence
|
|
* @param encoder
|
|
* @returns {type.Component}
|
|
*/
|
|
Sequence.prototype.encode = function(encoder) {
|
|
var sequence = new type.Component([]);
|
|
for (var i in this.value) {
|
|
sequence.obj.push(this.value[i].encode(encoder))
|
|
}
|
|
return encoder.encode(this.tag, sequence);
|
|
};
|
|
|
|
|
|
/**
|
|
* Enumerate type
|
|
* @param value {integer}
|
|
*/
|
|
function Enumerate(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.Enumerate));
|
|
this.value = value || 0;
|
|
}
|
|
|
|
inherits(Enumerate, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {Enumerate}
|
|
*/
|
|
Enumerate.prototype.decode = function(s, decoder) {
|
|
this.value = new type.UInt8().read(new type.Stream(decoder.decode(s, this.tag).value)).value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Encode enumerate type
|
|
* @param encoder
|
|
* @returns {type.Component}
|
|
*/
|
|
Enumerate.prototype.encode = function(encoder) {
|
|
return encoder.encode(this.tag, new type.UInt8(this.value));
|
|
};
|
|
|
|
/**
|
|
* OctetString type
|
|
* @param value {Buffer}
|
|
*/
|
|
function OctetString(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.OctetString));
|
|
this.value = value || Buffer.alloc(0);
|
|
}
|
|
|
|
inherits(OctetString, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {OctetString}
|
|
*/
|
|
OctetString.prototype.decode = function(s, decoder) {
|
|
this.value = decoder.decode(s, this.tag).value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Encode Octet String
|
|
* @param encoder
|
|
* @returns {type.Component}
|
|
*/
|
|
OctetString.prototype.encode = function(encoder) {
|
|
return encoder.encode(this.tag, new type.BinaryString(this.value));
|
|
};
|
|
|
|
/**
|
|
* ObjectIdentifier type
|
|
* @param value {Buffer}
|
|
*/
|
|
function ObjectIdentifier(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.ObjectIdentifier));
|
|
this.value = value || Buffer.alloc(5);
|
|
}
|
|
|
|
inherits(ObjectIdentifier, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {ObjectIdentifier}
|
|
*/
|
|
ObjectIdentifier.prototype.decode = function(s, decoder) {
|
|
this.value = decoder.decode(s, this.tag).value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Null type
|
|
*/
|
|
function Null() {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.Null));
|
|
}
|
|
|
|
inherits(Null, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {Null}
|
|
*/
|
|
Null.prototype.decode = function(s, decoder) {
|
|
decoder.decode(s, this.tag);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Choice type
|
|
* @param value {object} list of available type
|
|
*/
|
|
function Choice(value) {
|
|
// not tagged type
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag());
|
|
this.value = value;
|
|
}
|
|
|
|
inherits(Choice, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {Choice}
|
|
*/
|
|
Choice.prototype.decode = function(s, decoder) {
|
|
for (var i in this.value) {
|
|
var rec = s.offset;
|
|
try {
|
|
this.value[i].decode(s, decoder);
|
|
break;
|
|
}
|
|
catch(e) {
|
|
s.offset = rec;
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* SetOf type
|
|
* @param factory {function} type builder
|
|
* @param value {object} list of available type
|
|
*/
|
|
function SetOf(factory, value) {
|
|
// not tagged type
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Constructed, UniversalTag.Set));
|
|
this.factory = factory;
|
|
this.value = value || [];
|
|
}
|
|
|
|
inherits(SetOf, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {SetOf}
|
|
*/
|
|
SetOf.prototype.decode = function(s, decoder) {
|
|
var setOfStream = new type.Stream(decoder.decode(s, this.tag).value);
|
|
while (setOfStream.availableLength() > 0) {
|
|
this.value.push(this.factory().decode(setOfStream, decoder));
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* SequenceOf type
|
|
* @param factory {function} type builder
|
|
* @param value {object} list of available type
|
|
*/
|
|
function SequenceOf(factory, value) {
|
|
// not tagged type
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Constructed, UniversalTag.Sequence));
|
|
this.factory = factory;
|
|
this.value = value || [];
|
|
}
|
|
|
|
inherits(SequenceOf, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {SequenceOf}
|
|
*/
|
|
SequenceOf.prototype.decode = function(s, decoder) {
|
|
var sequenceOfStream = new type.Stream(decoder.decode(s, this.tag).value);
|
|
while (sequenceOfStream.availableLength() > 0) {
|
|
this.value.push(this.factory().decode(sequenceOfStream, decoder));
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* BitString type
|
|
* @param value {Buffer}
|
|
*/
|
|
function BitString(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.BitString));
|
|
this.value = [];
|
|
}
|
|
|
|
inherits(BitString, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {BitString}
|
|
*/
|
|
BitString.prototype.decode = function(s, decoder) {
|
|
var bitStream = new type.Stream(decoder.decode(s, this.tag).value);
|
|
var padding = new type.UInt8().read(bitStream).value;
|
|
var value = [];
|
|
for(var i = 0; i < padding; i++) {
|
|
value.push(0);
|
|
}
|
|
|
|
while(bitStream.availableLength() > 0) {
|
|
var octet = new type.UInt8().read(bitStream).value;
|
|
var currentPadding = 0;
|
|
if(bitStream.availableLength() === 0) {
|
|
currentPadding = padding;
|
|
}
|
|
for(var i = 7; i >= currentPadding; i--) {
|
|
value.push(((octet >> i) & 1)?1:0);
|
|
}
|
|
}
|
|
this.value = value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Convert bit string to buffer object
|
|
* @returns {Buffer}
|
|
*/
|
|
BitString.prototype.toBuffer = function () {
|
|
var length = this.value.length / 8;
|
|
var resultStream = new type.Stream(length);
|
|
for (var i = 0; i < length; i ++) {
|
|
var currentOctet = 0;
|
|
for (var j = 0; j < 8; j++) {
|
|
currentOctet = currentOctet | (this.value[i * 8 + j] << (7 - j));
|
|
}
|
|
new type.UInt8(currentOctet).write(resultStream);
|
|
}
|
|
return resultStream.buffer;
|
|
}
|
|
|
|
/**
|
|
* T61String type
|
|
* @param value {Buffer}
|
|
*/
|
|
function T61String(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.T61String));
|
|
this.value = value;
|
|
}
|
|
|
|
inherits(T61String, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {T61String}
|
|
*/
|
|
T61String.prototype.decode = function(s, decoder) {
|
|
this.value = decoder.decode(s, this.tag).value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* PrintableString type
|
|
* @param value {Buffer}
|
|
*/
|
|
function PrintableString(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.PrintableString));
|
|
this.value = value;
|
|
}
|
|
|
|
inherits(PrintableString, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {PrintableString}
|
|
*/
|
|
PrintableString.prototype.decode = function(s, decoder) {
|
|
this.value = decoder.decode(s, this.tag).value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* UniversalString type
|
|
* @param value {Buffer}
|
|
*/
|
|
function UniversalString(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.UniversalString));
|
|
this.value = value;
|
|
}
|
|
|
|
inherits(UniversalString, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {UniversalString}
|
|
*/
|
|
UniversalString.prototype.decode = function(s, decoder) {
|
|
this.value = decoder.decode(s, this.tag).value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* UTF8String type
|
|
* @param value {Buffer}
|
|
*/
|
|
function UTF8String(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.UTF8String));
|
|
this.value = value;
|
|
}
|
|
|
|
inherits(UTF8String, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {UTF8String}
|
|
*/
|
|
UTF8String.prototype.decode = function(s, decoder) {
|
|
this.value = decoder.decode(s, this.tag).value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* BMPString type
|
|
* @param value {Buffer}
|
|
*/
|
|
function BMPString(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.BMPString));
|
|
this.value = value;
|
|
}
|
|
|
|
inherits(BMPString, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {BMPString}
|
|
*/
|
|
BMPString.prototype.decode = function(s, decoder) {
|
|
this.value = decoder.decode(s, this.tag).value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* IA5String type
|
|
* @param value {Buffer}
|
|
*/
|
|
function IA5String(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.IA5String));
|
|
this.value = value;
|
|
}
|
|
|
|
inherits(IA5String, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {IA5String}
|
|
*/
|
|
IA5String.prototype.decode = function(s, decoder) {
|
|
this.value = decoder.decode(s, this.tag).value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* UTCTime type
|
|
* @param value {Buffer}
|
|
*/
|
|
function UTCTime(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.UTCTime));
|
|
this.value = value;
|
|
}
|
|
|
|
inherits(UTCTime, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {UTCTime}
|
|
*/
|
|
UTCTime.prototype.decode = function(s, decoder) {
|
|
this.value = decoder.decode(s, this.tag).value;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* GeneralizedTime type
|
|
* @param value {Buffer}
|
|
*/
|
|
function GeneralizedTime(value) {
|
|
spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.GeneralizedTime));
|
|
this.value = value;
|
|
}
|
|
|
|
inherits(GeneralizedTime, spec.Asn1Spec);
|
|
|
|
/**
|
|
* @param s {type.Stream}
|
|
* @param decoder {ber.decoder}
|
|
* @returns {GeneralizedTime}
|
|
*/
|
|
GeneralizedTime.prototype.decode = function(s, decoder) {
|
|
this.value = decoder.decode(s, this.tag).value;
|
|
return this;
|
|
};
|
|
|
|
module.exports = {
|
|
Boolean : Boolean,
|
|
Integer : Integer,
|
|
Sequence : Sequence,
|
|
Enumerate : Enumerate,
|
|
OctetString : OctetString,
|
|
ObjectIdentifier : ObjectIdentifier,
|
|
Null : Null,
|
|
Choice : Choice,
|
|
SequenceOf : SequenceOf,
|
|
SetOf : SetOf,
|
|
BitString : BitString,
|
|
T61String : T61String,
|
|
PrintableString : PrintableString,
|
|
UniversalString : UniversalString,
|
|
UTF8String : UTF8String,
|
|
BMPString : BMPString,
|
|
IA5String : IA5String,
|
|
UTCTime : UTCTime,
|
|
GeneralizedTime : GeneralizedTime
|
|
};
|