Универсальный синтаксический анализатор ASN.1 для декодирования .key, .cer, .der, .p7m, .p7s, .crt, .pem

ASN1.prototype.content = function (maxLength) {
    if (this.tag === undefined)
        return null;
    if (maxLength === undefined)
        maxLength = Infinity;
    var content = this.posContent(),
        len = Math.abs(this.length);
    if (!this.tag.isUniversal()) {
        if (this.sub !== null)
            return "(" + this.sub.length + " elem)";
        var d1 = this.stream.parseOctetString(content, content + len, maxLength);
        return "(" + d1.size + " byte)\n" + d1.str;
    }
    switch (this.tag.tagNumber) {
    case 0x01: // BOOLEAN
        return (this.stream.get(content) === 0) ? "false" : "true";
    case 0x02: // INTEGER
        return this.stream.parseInteger(content, content + len);
    case 0x03: // BIT_STRING
        var d = recurse(this, 'parseBitString', maxLength);
        return "(" + d.size + " bit)\n" + d.str;
    case 0x04: // OCTET_STRING
        d = recurse(this, 'parseOctetString', maxLength);
        return "(" + d.size + " byte)\n" + d.str;
    //case 0x05: // NULL
    case 0x06: // OBJECT_IDENTIFIER
        return this.stream.parseOID(content, content + len, maxLength);
    //case 0x07: // ObjectDescriptor
    //case 0x08: // EXTERNAL
    //case 0x09: // REAL
    case 0x0A: // ENUMERATED
        return this.stream.parseInteger(content, content + len);
    //case 0x0B: // EMBEDDED_PDV
    case 0x0D: // RELATIVE-OID
        return this.stream.parseRelativeOID(content, content + len, maxLength);
    case 0x10: // SEQUENCE
    case 0x11: // SET
        if (this.sub !== null)
            return "(" + this.sub.length + " elem)";
        else
            return "(no elem)";
    case 0x0C: // UTF8String
        return recurse(this, 'parseStringUTF', maxLength).str;
    case 0x14: // TeletexString
        return recurse(this, 'parseStringT61', maxLength).str;
    case 0x12: // NumericString
    case 0x13: // PrintableString
    case 0x15: // VideotexString
    case 0x16: // IA5String
    case 0x1A: // VisibleString
    case 0x1B: // GeneralString
    //case 0x19: // GraphicString
    //case 0x1C: // UniversalString
        return recurse(this, 'parseStringISO', maxLength).str;
    case 0x1E: // BMPString
        return recurse(this, 'parseStringBMP', maxLength).str;
    case 0x17: // UTCTime
    case 0x18: // GeneralizedTime
        return this.stream.parseTime(content, content + len, (this.tag.tagNumber == 0x17));
    }
    return null;
};

Функция content(maxLength, asn1, oids)
	
	Если (asn1.tag = Неопределено) Тогда
		Возврат null
	КонецЕсли;
	
	Если (maxLength = Неопределено) Тогда
		maxLength = 600;	
	КонецЕсли;
	
	content = posContent(asn1);
	
	len = math_abs(asn1.length); 
	
	Если НЕ (isUniversal(asn1.tag.tagClass)) Тогда
		Если (asn1.sub <> null) Тогда
			Возврат СтрШаблон("(%1 elem)", asn1.sub.Количество());	
		КонецЕсли;
		d1 = parseOctetString(asn1, content, content + len, maxLength);
		Возврат СтрШаблон("(%1 byte) %2", d1.size, d1.str);
	КонецЕсли;
	
	tagNumber = asn1.tag.tagNumber; 
	
	Если tagNumber = 1 Тогда 
		Возврат ?(asn1.stream.enc[pos(asn1.stream, content)] = 0, "False", "True");	
	ИначеЕсли tagNumber = 2 Тогда
		Возврат parseInteger(content, content + len, asn1); 	
	ИначеЕсли tagNumber = 3 Тогда
		d = recurse(asn1, "parseBitString", maxLength);
		Возврат СтрШаблон("(%1 bit) %2", d.size, d.str);
	ИначеЕсли tagNumber = 4 Тогда
		d = recurse(asn1, "parseOctetString", maxLength);
		Возврат СтрШаблон("(%1 byte) %2", d.size, d.str);
	//ИначеЕсли tagNumber = 5 Тогда
			
	ИначеЕсли tagNumber = 6 Тогда
		Возврат parseOID(asn1, content, content + len, maxLength, oids);	
	//ИначеЕсли tagNumber = 7 Тогда
	//	
	//ИначеЕсли tagNumber = 8 Тогда
	//	
	//ИначеЕсли tagNumber = 9 Тогда
		
	ИначеЕсли tagNumber = 10 Тогда
		Возврат parseInteger(content, content + len, asn1);	
	//ИначеЕсли tagNumber = 11 Тогда
		
	ИначеЕсли tagNumber = 12 Тогда
		d = recurse(asn1, "parseStringUTF", maxLength);
		Возврат d.str;
	ИначеЕсли tagNumber = 20 Тогда
		d = recurse(asn1, "parseStringT61", maxLength);
		Возврат d.str;
	ИначеЕсли tagNumber = 13 Тогда
		Возврат parseRelativeOID(asn1, content, content + len, maxLength, oids);	
	ИначеЕсли ((tagNumber = 16)
		ИЛИ (tagNumber = 17)) Тогда
		
		Если (asn1.sub <> null) Тогда
			Возврат "(" + Строка(asn1.sub.Количество()) + " elem)"; 
		Иначе
			Возврат "(no elem)";	
		КонецЕсли;
		
	ИначеЕсли (tagNumber = 18)
		ИЛИ (tagNumber = 19)
		ИЛИ (tagNumber = 21)
		ИЛИ (tagNumber = 22)
		ИЛИ (tagNumber = 26)
		ИЛИ (tagNumber = 27) Тогда
		
		d = recurse(asn1, "parseStringISO", maxLength);
		Возврат d.str; 
	//ИначеЕсли tagNumber = 28 Тогда
		
	ИначеЕсли tagNumber = 30 Тогда
		d = recurse(asn1, "parseStringBMP", maxLength);
		Возврат d.str;
		
	ИначеЕсли (tagNumber = 23) ИЛИ (tagNumber = 24) Тогда
		Возврат parseTime(asn1, content, content + len, tagNumber = 23, maxLength);	
	Иначе
		Возврат null;	
	КонецЕсли
	
КонецФункции

Stream.prototype.parseBitString = function (start, end, maxLength) {
    var unusedBits = this.get(start);
    if (unusedBits > 7)
        throw 'Invalid BitString with unusedBits=' + unusedBits;
    var lenBit = ((end - start - 1) << 3) - unusedBits,
        s = "";
    for (var i = start + 1; i < end; ++i) {
        var b = this.get(i),
            skip = (i == end - 1) ? unusedBits : 0;
        for (var j = 7; j >= skip; --j)
            s += (b >> j) & 1 ? "1" : "0";
        if (s.length > maxLength)
            s = stringCut(s, maxLength);
    }
    return { size: lenBit, str: s };
};

Функция parseBitString(el, start, end, maxLength)
	
	unusedBits = get(pos(el.Stream, start), el.stream.enc);
	
	Если (unusedBits > 7) Тогда
		ТекстИсключения = Нстр("ru = 'Неверная битовая строка с unusedBits=%1'");
		ТекстИсключения = СтрШаблон(ТекстИсключения, unusedBits);
		ВызватьИсключение(ТекстИсключения);
	КонецЕсли;
	
	lenBit = ПобитовыйСдвигВлево((end - start - 1), 3) - unusedBits;
	s = "";
	i = start + 1;
	Пока (i < end) Цикл
		b = get(i, el.stream.enc);
		skip = ?(i = (end - 1), unusedBits, 0);
		j = 7;
		Пока (j >= skip) Цикл
			s = s + ?(ПобитовоеИ(ПобитовыйСдвигВправо(b, j), 1) <> 0, "1", "0");
			Если (СтрДлина(s) > maxLength) Тогда
				s = Лев(s, maxLength);
			КонецЕсли;
			j = j - 1;
		КонецЦикла;
		i = i + 1;
	КонецЦикла;
	
	Возврат Новый Структура("size, str", lenBit, s);
	
КонецФункции

Stream.prototype.parseInteger = function (start, end) {
    var v = this.get(start),
        neg = (v > 127),
        pad = neg ? 255 : 0,
        len,
        s = '';
    // skip unuseful bits (not allowed in DER)
    while (v == pad && ++start < end)
        v = this.get(start);
    len = end - start;
    if (len === 0)
        return neg ? '-1' : '0';
    // show bit length of huge integers
    if (len > 4) {
        s = v;
        len <<= 3;
        while (((s ^ pad) & 0x80) == 0) {
            s <<= 1;
            --len;
        }
        s = "(" + len + " bit)\n";
    }
    // decode the integer
    if (neg) v = v - 256;
    var n = new Int10(v);
    for (var i = start + 1; i < end; ++i)
        n.mulAdd(256, this.get(i));
    return s + n.toString();
};

Функция parseInteger(start, end, asn1)
	
	v = pos(asn1.stream, start);
	v = asn1.stream.enc[v]; 
	neg = (v > 127);
	pad = ?(neg, 255, 0);
	s = "";
	
	Пока (v = pad И start < end) Цикл
		start = start + 1;
		v = pos(asn1.stream, start);
		v = asn1.stream.enc[v];
	КонецЦикла;
	
	len = end - start;
	
	Если (len = 0) Тогда
		Возврат ?(neg, "-1", "0");
	КонецЕсли;
	
	Если (len > 4) Тогда
		s = v;
		len = ПобитовыйСдвигВлево(len, 3);
		Пока ((ПобитовоеИ(ПобитовоеИсключительноеИли(s, pad), 128)) = 0) Цикл
			s = ПобитовыйСдвигВлево(s, 1);
			len = len - 1;
		КонецЦикла;
		s = "(" + len + " bit) ";
	КонецЕсли;
	
	Если neg Тогда
		v = v - 256;	
	КонецЕсли;
	
	buf = Новый Массив;
	n = Int10(buf, v); 
	
	i = start + 1;
	Пока i < end Цикл
		n = asn1.stream.enc[pos(asn1.stream, i)];
		n = mulAdd(256, n, asn1, buf);
		i = i + 1;
	КонецЦикла;
	
	Возврат s + toString(, asn1, buf);
	
КонецФункции

Stream.prototype.parseTime = function (start, end, shortYear) {
    var s = this.parseStringISO(start, end).str,
        m = (shortYear ? reTimeS : reTimeL).exec(s);
    if (!m)
        return "Unrecognized time: " + s;
    if (shortYear) {
        // to avoid querying the timer, use the fixed range [1970, 2069]
        // it will conform with ITU X.400 [-10, +40] sliding window until 2030
        m[1] = +m[1];
        m[1] += (m[1] < 70) ? 2000 : 1900;
    }
    s = m[1] + "-" + m[2] + "-" + m[3] + " " + m[4];
    if (m[5]) {
        s += ":" + m[5];
        if (m[6]) {
            s += ":" + m[6];
            if (m[7])
                s += "." + m[7];
        }
    }
    if (m[8]) {
        s += " UTC";
        if (m[9])
            s += m[9] + ":" + (m[10] || "00");
    }
    return s;
};

Функция parseTime(el, start, end, shortYear, maxLength)
	
	s = parseStringISO(el, start, end, maxLength).str;
	// s = "171213000000Z" вид хранимой даты
	Попытка
		m = Новый Массив;
		start = СтрДлина(s);
		i = 1;
		Пока (i < start) Цикл
			m.Добавить(Сред(s, i, 2));
			i = i + 2;
		КонецЦикла;
		
		m[0] = (?(Число(m[0]) < 70, 2000, 1900) + Число(m[0])); 
		
		s = СтрШаблон("%1-%2-%3 %4:%5:%6", 
						Формат(m[0], "ЧН=0; ЧГ="),
						m[1],
						m[2],
						m[3],
						m[4],
						m[5]);
		
	Исключение
		Возврат СтрШаблон("Нераспознанное время: %1", s);	
	КонецПопытки;
	
	Возврат s;
		 
КонецФункции