mirror of https://github.com/fyrfli/CyberChef.git
1161 lines
47 KiB
JavaScript
1161 lines
47 KiB
JavaScript
/**
|
||
* Coding algorithms: Base64, Hex, Int16, Chars, BER and PEM
|
||
* version 1.76
|
||
* 2014-2016, Rudolf Nickolaev. All rights reserved.
|
||
*
|
||
* Exported for CyberChef by mshwed [m@ttshwed.com]
|
||
*/
|
||
|
||
/*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*
|
||
* THIS SOfTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||
* WARRANTIES Of MERCHANTABILITY AND fITNESS fOR A PARTICULAR PURPOSE ARE
|
||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||
* fOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT Of SUBSTITUTE GOODS OR
|
||
* SERVICES; LOSS Of USE, DATA, OR PROfITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||
* CAUSED AND ON ANY THEORY Of LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT Of THE USE
|
||
* Of THIS SOfTWARE, EVEN If ADVISED Of THE POSSIBILITY OF SUCH DAMAGE.
|
||
*
|
||
*/
|
||
|
||
import gostCrypto from './gostCrypto.mjs';
|
||
|
||
/**
|
||
* The Coding interface provides string converting methods: Base64, Hex,
|
||
* Int16, Chars, BER and PEM
|
||
* @class GostCoding
|
||
*
|
||
*/ // <editor-fold defaultstate="collapsed">
|
||
var root = {};
|
||
var DataError = Error;
|
||
var CryptoOperationData = ArrayBuffer;
|
||
var Date = Date;
|
||
|
||
function buffer(d) {
|
||
if (d instanceof CryptoOperationData)
|
||
return d;
|
||
else if (d && d?.buffer instanceof CryptoOperationData)
|
||
return d.byteOffset === 0 && d.byteLength === d.buffer.byteLength ?
|
||
d.buffer : new Uint8Array(new Uint8Array(d, d.byteOffset, d.byteLength)).buffer;
|
||
else
|
||
throw new DataError('CryptoOperationData required');
|
||
} // </editor-fold>
|
||
|
||
function GostCoding() {
|
||
}
|
||
|
||
/**
|
||
* BASE64 conversion
|
||
*
|
||
* @class GostCoding.Base64
|
||
*/
|
||
var Base64 = {// <editor-fold defaultstate="collapsed">
|
||
/**
|
||
* Base64.decode convert BASE64 string s to CryptoOperationData
|
||
*
|
||
* @memberOf GostCoding.Base64
|
||
* @param {String} s BASE64 encoded string value
|
||
* @returns {CryptoOperationData} Binary decoded data
|
||
*/
|
||
decode: function (s) {
|
||
s = s.replace(/[^A-Za-z0-9\+\/]/g, '');
|
||
var n = s.length,
|
||
k = n * 3 + 1 >> 2, r = new Uint8Array(k);
|
||
|
||
for (var m3, m4, u24 = 0, j = 0, i = 0; i < n; i++) {
|
||
m4 = i & 3;
|
||
var c = s.charCodeAt(i);
|
||
|
||
c = c > 64 && c < 91 ?
|
||
c - 65 : c > 96 && c < 123 ?
|
||
c - 71 : c > 47 && c < 58 ?
|
||
c + 4 : c === 43 ?
|
||
62 : c === 47 ?
|
||
63 : 0;
|
||
|
||
u24 |= c << 18 - 6 * m4;
|
||
if (m4 === 3 || n - i === 1) {
|
||
for (m3 = 0; m3 < 3 && j < k; m3++, j++) {
|
||
r[j] = u24 >>> (16 >>> m3 & 24) & 255;
|
||
}
|
||
u24 = 0;
|
||
|
||
}
|
||
}
|
||
return r.buffer;
|
||
},
|
||
/**
|
||
* Base64.encode(data) convert CryptoOperationData data to BASE64 string
|
||
*
|
||
* @memberOf GostCoding.Base64
|
||
* @param {CryptoOperationData} data Bynary data for encoding
|
||
* @returns {String} BASE64 encoded data
|
||
*/
|
||
encode: function (data) {
|
||
var slen = 8, d = new Uint8Array(buffer(data));
|
||
var m3 = 2, s = '';
|
||
for (var n = d.length, u24 = 0, i = 0; i < n; i++) {
|
||
m3 = i % 3;
|
||
if (i > 0 && (i * 4 / 3) % (12 * slen) === 0)
|
||
s += '\r\n';
|
||
u24 |= d[i] << (16 >>> m3 & 24);
|
||
if (m3 === 2 || n - i === 1) {
|
||
for (var j = 18; j >= 0; j -= 6) {
|
||
var c = u24 >>> j & 63;
|
||
c = c < 26 ? c + 65 : c < 52 ? c + 71 : c < 62 ? c - 4 :
|
||
c === 62 ? 43 : c === 63 ? 47 : 65;
|
||
s += String.fromCharCode(c);
|
||
}
|
||
u24 = 0;
|
||
}
|
||
}
|
||
return s.substr(0, s.length - 2 + m3) + (m3 === 2 ? '' : m3 === 1 ? '=' : '==');
|
||
} // </editor-fold>
|
||
};
|
||
|
||
/**
|
||
* BASE64 conversion
|
||
*
|
||
* @memberOf GostCoding
|
||
* @insnance
|
||
* @type GostCoding.Base64
|
||
*/
|
||
GostCoding.prototype.Base64 = Base64;
|
||
|
||
/**
|
||
* Text string conversion <br>
|
||
* Methods support charsets: ascii, win1251, utf8, utf16 (ucs2, unicode), utf32 (ucs4)
|
||
*
|
||
* @class GostCoding.Chars
|
||
*/
|
||
var Chars = (function () { // <editor-fold defaultstate="collapsed">
|
||
|
||
var _win1251_ = {
|
||
0x402: 0x80, 0x403: 0x81, 0x201A: 0x82, 0x453: 0x83, 0x201E: 0x84, 0x2026: 0x85, 0x2020: 0x86, 0x2021: 0x87,
|
||
0x20AC: 0x88, 0x2030: 0x89, 0x409: 0x8A, 0x2039: 0x8B, 0x40A: 0x8C, 0x40C: 0x8D, 0x40B: 0x8E, 0x40f: 0x8f,
|
||
0x452: 0x90, 0x2018: 0x91, 0x2019: 0x92, 0x201C: 0x93, 0x201D: 0x94, 0x2022: 0x95, 0x2013: 0x96, 0x2014: 0x97,
|
||
0x2122: 0x99, 0x459: 0x9A, 0x203A: 0x9B, 0x45A: 0x9C, 0x45C: 0x9D, 0x45B: 0x9E, 0x45f: 0x9f,
|
||
0xA0: 0xA0, 0x40E: 0xA1, 0x45E: 0xA2, 0x408: 0xA3, 0xA4: 0xA4, 0x490: 0xA5, 0xA6: 0xA6, 0xA7: 0xA7,
|
||
0x401: 0xA8, 0xA9: 0xA9, 0x404: 0xAA, 0xAB: 0xAB, 0xAC: 0xAC, 0xAD: 0xAD, 0xAE: 0xAE, 0x407: 0xAf,
|
||
0xB0: 0xB0, 0xB1: 0xB1, 0x406: 0xB2, 0x456: 0xB3, 0x491: 0xB4, 0xB5: 0xB5, 0xB6: 0xB6, 0xB7: 0xB7,
|
||
0x451: 0xB8, 0x2116: 0xB9, 0x454: 0xBA, 0xBB: 0xBB, 0x458: 0xBC, 0x405: 0xBD, 0x455: 0xBE, 0x457: 0xBf
|
||
};
|
||
var _win1251back_ = {};
|
||
for (var from in _win1251_) {
|
||
var to = _win1251_[from];
|
||
_win1251back_[to] = from;
|
||
}
|
||
|
||
return {
|
||
/**
|
||
* Chars.decode(s, charset) convert string s with defined charset to CryptoOperationData
|
||
*
|
||
* @memberOf GostCoding.Chars
|
||
* @param {string} s Javascript string
|
||
* @param {string} charset Charset, default 'win1251'
|
||
* @returns {CryptoOperationData} Decoded binary data
|
||
*/
|
||
decode: function (s, charset) {
|
||
charset = (charset || 'win1251').toLowerCase().replace('-', '');
|
||
var r = [];
|
||
for (var i = 0, j = s.length; i < j; i++) {
|
||
var c = s.charCodeAt(i);
|
||
if (charset === 'utf8') {
|
||
if (c < 0x80) {
|
||
r.push(c);
|
||
} else if (c < 0x800) {
|
||
r.push(0xc0 + (c >>> 6));
|
||
r.push(0x80 + (c & 63));
|
||
} else if (c < 0x10000) {
|
||
r.push(0xe0 + (c >>> 12));
|
||
r.push(0x80 + (c >>> 6 & 63));
|
||
r.push(0x80 + (c & 63));
|
||
} else if (c < 0x200000) {
|
||
r.push(0xf0 + (c >>> 18));
|
||
r.push(0x80 + (c >>> 12 & 63));
|
||
r.push(0x80 + (c >>> 6 & 63));
|
||
r.push(0x80 + (c & 63));
|
||
} else if (c < 0x4000000) {
|
||
r.push(0xf8 + (c >>> 24));
|
||
r.push(0x80 + (c >>> 18 & 63));
|
||
r.push(0x80 + (c >>> 12 & 63));
|
||
r.push(0x80 + (c >>> 6 & 63));
|
||
r.push(0x80 + (c & 63));
|
||
} else {
|
||
r.push(0xfc + (c >>> 30));
|
||
r.push(0x80 + (c >>> 24 & 63));
|
||
r.push(0x80 + (c >>> 18 & 63));
|
||
r.push(0x80 + (c >>> 12 & 63));
|
||
r.push(0x80 + (c >>> 6 & 63));
|
||
r.push(0x80 + (c & 63));
|
||
}
|
||
} else if (charset === 'unicode' || charset === 'ucs2' || charset === 'utf16') {
|
||
if (c < 0xD800 || (c >= 0xE000 && c <= 0x10000)) {
|
||
r.push(c >>> 8);
|
||
r.push(c & 0xff);
|
||
} else if (c >= 0x10000 && c < 0x110000) {
|
||
c -= 0x10000;
|
||
var first = ((0xffc00 & c) >> 10) + 0xD800;
|
||
var second = (0x3ff & c) + 0xDC00;
|
||
r.push(first >>> 8);
|
||
r.push(first & 0xff);
|
||
r.push(second >>> 8);
|
||
r.push(second & 0xff);
|
||
}
|
||
} else if (charset === 'utf32' || charset === 'ucs4') {
|
||
r.push(c >>> 24 & 0xff);
|
||
r.push(c >>> 16 & 0xff);
|
||
r.push(c >>> 8 & 0xff);
|
||
r.push(c & 0xff);
|
||
} else if (charset === 'win1251') {
|
||
if (c >= 0x80) {
|
||
if (c >= 0x410 && c < 0x450) // А..Яа..я
|
||
c -= 0x350;
|
||
else
|
||
c = _win1251_[c] || 0;
|
||
}
|
||
r.push(c);
|
||
} else
|
||
r.push(c & 0xff);
|
||
}
|
||
return new Uint8Array(r).buffer;
|
||
},
|
||
/**
|
||
* Chars.encode(data, charset) convert CryptoOperationData data to string with defined charset
|
||
*
|
||
* @memberOf GostCoding.Chars
|
||
* @param {CryptoOperationData} data Binary data
|
||
* @param {string} charset Charset, default win1251
|
||
* @returns {string} Encoded javascript string
|
||
*/
|
||
encode: function (data, charset) {
|
||
charset = (charset || 'win1251').toLowerCase().replace('-', '');
|
||
var r = [], d = new Uint8Array(buffer(data));
|
||
for (var i = 0, n = d.length; i < n; i++) {
|
||
var c = d[i];
|
||
if (charset === 'utf8') {
|
||
c = c >= 0xfc && c < 0xfe && i + 5 < n ? // six bytes
|
||
(c - 0xfc) * 1073741824 + (d[++i] - 0x80 << 24) + (d[++i] - 0x80 << 18) + (d[++i] - 0x80 << 12) + (d[++i] - 0x80 << 6) + d[++i] - 0x80
|
||
: c >> 0xf8 && c < 0xfc && i + 4 < n ? // five bytes
|
||
(c - 0xf8 << 24) + (d[++i] - 0x80 << 18) + (d[++i] - 0x80 << 12) + (d[++i] - 0x80 << 6) + d[++i] - 0x80
|
||
: c >> 0xf0 && c < 0xf8 && i + 3 < n ? // four bytes
|
||
(c - 0xf0 << 18) + (d[++i] - 0x80 << 12) + (d[++i] - 0x80 << 6) + d[++i] - 0x80
|
||
: c >= 0xe0 && c < 0xf0 && i + 2 < n ? // three bytes
|
||
(c - 0xe0 << 12) + (d[++i] - 0x80 << 6) + d[++i] - 0x80
|
||
: c >= 0xc0 && c < 0xe0 && i + 1 < n ? // two bytes
|
||
(c - 0xc0 << 6) + d[++i] - 0x80
|
||
: c; // one byte
|
||
} else if (charset === 'unicode' || charset === 'ucs2' || charset === 'utf16') {
|
||
c = (c << 8) + d[++i];
|
||
if (c >= 0xD800 && c < 0xE000) {
|
||
var first = (c - 0xD800) << 10;
|
||
c = d[++i];
|
||
c = (c << 8) + d[++i];
|
||
var second = c - 0xDC00;
|
||
c = first + second + 0x10000;
|
||
}
|
||
} else if (charset === 'utf32' || charset === 'ucs4') {
|
||
c = (c << 8) + d[++i];
|
||
c = (c << 8) + d[++i];
|
||
c = (c << 8) + d[++i];
|
||
} else if (charset === 'win1251') {
|
||
if (c >= 0x80) {
|
||
if (c >= 0xC0 && c < 0x100)
|
||
c += 0x350; // А..Яа..я
|
||
else
|
||
c = _win1251back_[c] || 0;
|
||
}
|
||
}
|
||
r.push(String.fromCharCode(c));
|
||
}
|
||
return r.join('');
|
||
}
|
||
}; // </editor-fold>
|
||
})();
|
||
|
||
/**
|
||
* Text string conversion
|
||
*
|
||
* @memberOf GostCoding
|
||
* @insnance
|
||
* @type GostCoding.Chars
|
||
*/
|
||
GostCoding.prototype.Chars = Chars;
|
||
|
||
/**
|
||
* HEX conversion
|
||
*
|
||
* @class GostCoding.Hex
|
||
*/
|
||
var Hex = {// <editor-fold defaultstate="collapsed">
|
||
/**
|
||
* Hex.decode(s, endean) convert HEX string s to CryptoOperationData in endean mode
|
||
*
|
||
* @memberOf GostCoding.Hex
|
||
* @param {string} s Hex encoded string
|
||
* @param {boolean} endean Little or Big Endean, default Little
|
||
* @returns {CryptoOperationData} Decoded binary data
|
||
*/
|
||
decode: function (s, endean) {
|
||
s = s.replace(/[^A-fa-f0-9]/g, '');
|
||
var n = Math.ceil(s.length / 2), r = new Uint8Array(n);
|
||
s = (s.length % 2 > 0 ? '0' : '') + s;
|
||
if (endean && ((typeof endean !== 'string') ||
|
||
(endean.toLowerCase().indexOf('little') < 0)))
|
||
for (var i = 0; i < n; i++)
|
||
r[i] = parseInt(s.substr((n - i - 1) * 2, 2), 16);
|
||
else
|
||
for (var i = 0; i < n; i++)
|
||
r[i] = parseInt(s.substr(i * 2, 2), 16);
|
||
return r.buffer;
|
||
},
|
||
/**
|
||
* Hex.encode(data, endean) convert CryptoOperationData data to HEX string in endean mode
|
||
*
|
||
* @memberOf GostCoding.Hex
|
||
* @param {CryptoOperationData} data Binary data
|
||
* @param {boolean} endean Little/Big Endean, default Little
|
||
* @returns {string} Hex decoded string
|
||
*/
|
||
encode: function (data, endean) {
|
||
var s = [], d = new Uint8Array(buffer(data)), n = d.length;
|
||
if (endean && ((typeof endean !== 'string') ||
|
||
(endean.toLowerCase().indexOf('little') < 0)))
|
||
for (var i = 0; i < n; i++) {
|
||
var j = n - i - 1;
|
||
s[j] = (j > 0 && j % 32 === 0 ? '\r\n' : '') +
|
||
('00' + d[i].toString(16)).slice(-2);
|
||
}
|
||
else
|
||
for (var i = 0; i < n; i++)
|
||
s[i] = (i > 0 && i % 32 === 0 ? '\r\n' : '') +
|
||
('00' + d[i].toString(16)).slice(-2);
|
||
return s.join('');
|
||
} // </editor-fold>
|
||
};
|
||
|
||
/**
|
||
* HEX conversion
|
||
* @memberOf GostCoding
|
||
* @insnance
|
||
* @type GostCoding.Hex
|
||
*/
|
||
GostCoding.prototype.Hex = Hex;
|
||
|
||
/**
|
||
* String hex-encoded integer conversion
|
||
*
|
||
* @class GostCoding.Int16
|
||
*/
|
||
var Int16 = {// <editor-fold defaultstate="collapsed">
|
||
/**
|
||
* Int16.decode(s) convert hex big insteger s to CryptoOperationData
|
||
*
|
||
* @memberOf GostCoding.Int16
|
||
* @param {string} s Int16 string
|
||
* @returns {CryptoOperationData} Decoded binary data
|
||
*/
|
||
decode: function (s) {
|
||
s = (s || '').replace(/[^\-A-fa-f0-9]/g, '');
|
||
if (s.length === 0)
|
||
s = '0';
|
||
// Signature
|
||
var neg = false;
|
||
if (s.charAt(0) === '-') {
|
||
neg = true;
|
||
s = s.substring(1);
|
||
}
|
||
// Align 2 chars
|
||
while (s.charAt(0) === '0' && s.length > 1)
|
||
s = s.substring(1);
|
||
s = (s.length % 2 > 0 ? '0' : '') + s;
|
||
// Padding for singanuture
|
||
// '800000' - 'ffffff' - for positive
|
||
// '800001' - 'ffffff' - for negative
|
||
if ((!neg && !/^[0-7]/.test(s)) ||
|
||
(neg && !/^[0-7]|8[0]+$/.test(s)))
|
||
s = '00' + s;
|
||
// Convert hex
|
||
var n = s.length / 2, r = new Uint8Array(n), t = 0;
|
||
for (var i = n - 1; i >= 0; --i) {
|
||
var c = parseInt(s.substr(i * 2, 2), 16);
|
||
if (neg && (c + t > 0)) {
|
||
c = 256 - c - t;
|
||
t = 1;
|
||
}
|
||
r[i] = c;
|
||
}
|
||
return r.buffer;
|
||
},
|
||
/**
|
||
* Int16.encode(data) convert CryptoOperationData data to big integer hex string
|
||
*
|
||
* @memberOf GostCoding.Int16
|
||
* @param {CryptoOperationData} data Binary data
|
||
* @returns {string} Int16 encoded string
|
||
*/
|
||
encode: function (data) {
|
||
var d = new Uint8Array(buffer(data)), n = d.length;
|
||
if (d.length === 0)
|
||
return '0x00';
|
||
var s = [], neg = d[0] > 0x7f, t = 0;
|
||
for (var i = n - 1; i >= 0; --i) {
|
||
var v = d[i];
|
||
if (neg && (v + t > 0)) {
|
||
v = 256 - v - t;
|
||
t = 1;
|
||
}
|
||
s[i] = ('00' + v.toString(16)).slice(-2);
|
||
}
|
||
s = s.join('');
|
||
while (s.charAt(0) === '0')
|
||
s = s.substring(1);
|
||
return (neg ? '-' : '') + '0x' + s;
|
||
} // </editor-fold>
|
||
};
|
||
|
||
/**
|
||
* String hex-encoded integer conversion
|
||
* @memberOf GostCoding
|
||
* @insnance
|
||
* @type GostCoding.Int16
|
||
*/
|
||
GostCoding.prototype.Int16 = Int16;
|
||
|
||
/**
|
||
* BER, DER, CER conversion
|
||
*
|
||
* @class GostCoding.BER
|
||
*/
|
||
var BER = (function () { // <editor-fold defaultstate="collapsed">
|
||
|
||
// Predefenition block
|
||
function encodeBER(source, format, onlyContent) {
|
||
// Correct primitive type
|
||
var object = source.object;
|
||
if (object === undefined)
|
||
object = source;
|
||
|
||
// Determinate tagClass
|
||
var tagClass = source.tagClass = source.tagClass || 0; // Universial default
|
||
|
||
// Determinate tagNumber. Use only for Universal class
|
||
if (tagClass === 0) {
|
||
var tagNumber = source.tagNumber;
|
||
if (typeof tagNumber === 'undefined') {
|
||
if (typeof object === 'string') {
|
||
if (object === '') // NULL
|
||
tagNumber = 0x05;
|
||
else if (/^\-?0x[0-9a-fA-F]+$/.test(object)) // INTEGER
|
||
tagNumber = 0x02;
|
||
else if (/^(\d+\.)+\d+$/.test(object)) // OID
|
||
tagNumber = 0x06;
|
||
else if (/^[01]+$/.test(object)) // BIT STRING
|
||
tagNumber = 0x03;
|
||
else if (/^(true|false)$/.test(object)) // BOOLEAN
|
||
tagNumber = 0x01;
|
||
else if (/^[0-9a-fA-F]+$/.test(object)) // OCTET STRING
|
||
tagNumber = 0x04;
|
||
else
|
||
tagNumber = 0x13; // Printable string (later can be changed to UTF8String)
|
||
} else if (typeof object === 'number') { // INTEGER
|
||
tagNumber = 0x02;
|
||
} else if (typeof object === 'boolean') { // BOOLEAN
|
||
tagNumber = 0x01;
|
||
} else if (object instanceof Array) { // SEQUENCE
|
||
tagNumber = 0x10;
|
||
} else if (object instanceof Date) { // GeneralizedTime
|
||
tagNumber = 0x18;
|
||
} else if (object instanceof CryptoOperationData || (object && object.buffer instanceof CryptoOperationData)) {
|
||
tagNumber = 0x04;
|
||
} else
|
||
throw new DataError('Unrecognized type for ' + object);
|
||
}
|
||
}
|
||
|
||
// Determinate constructed
|
||
var tagConstructed = source.tagConstructed;
|
||
if (typeof tagConstructed === 'undefined')
|
||
tagConstructed = source.tagConstructed = object instanceof Array;
|
||
|
||
// Create content
|
||
var content;
|
||
if (object instanceof CryptoOperationData || (object && object.buffer instanceof CryptoOperationData)) { // Direct
|
||
content = new Uint8Array(buffer(object));
|
||
if (tagNumber === 0x03) { // BITSTRING
|
||
// Set unused bits
|
||
var a = new Uint8Array(buffer(content));
|
||
content = new Uint8Array(a.length + 1);
|
||
content[0] = 0; // No unused bits
|
||
content.set(a, 1);
|
||
}
|
||
} else if (tagConstructed) { // Sub items coding
|
||
if (object instanceof Array) {
|
||
var bytelen = 0, ba = [], offset = 0;
|
||
for (var i = 0, n = object.length; i < n; i++) {
|
||
ba[i] = encodeBER(object[i], format);
|
||
bytelen += ba[i].length;
|
||
}
|
||
if (tagNumber === 0x11)
|
||
ba.sort(function (a, b) { // Sort order for SET components
|
||
for (var i = 0, n = Math.min(a.length, b.length); i < n; i++) {
|
||
var r = a[i] - b[i];
|
||
if (r !== 0)
|
||
return r;
|
||
}
|
||
return a.length - b.length;
|
||
});
|
||
if (format === 'CER') { // final for CER 00 00
|
||
ba[n] = new Uint8Array(2);
|
||
bytelen += 2;
|
||
}
|
||
content = new Uint8Array(bytelen);
|
||
for (var i = 0, n = ba.length; i < n; i++) {
|
||
content.set(ba[i], offset);
|
||
offset = offset + ba[i].length;
|
||
}
|
||
} else
|
||
throw new DataError('Constracted block can\'t be primitive');
|
||
} else {
|
||
switch (tagNumber) {
|
||
// 0x00: // EOC
|
||
case 0x01: // BOOLEAN
|
||
content = new Uint8Array(1);
|
||
content[0] = object ? 0xff : 0;
|
||
break;
|
||
case 0x02: // INTEGER
|
||
case 0x0a: // ENUMIRATED
|
||
content = Int16.decode(
|
||
typeof object === 'number' ? object.toString(16) : object);
|
||
break;
|
||
case 0x03: // BIT STRING
|
||
if (typeof object === 'string') {
|
||
var unusedBits = 7 - (object.length + 7) % 8;
|
||
var n = Math.ceil(object.length / 8);
|
||
content = new Uint8Array(n + 1);
|
||
content[0] = unusedBits;
|
||
for (var i = 0; i < n; i++) {
|
||
var c = 0;
|
||
for (var j = 0; j < 8; j++) {
|
||
var k = i * 8 + j;
|
||
c = (c << 1) + (k < object.length ? (object.charAt(k) === '1' ? 1 : 0) : 0);
|
||
}
|
||
content[i + 1] = c;
|
||
}
|
||
}
|
||
break;
|
||
case 0x04:
|
||
content = Hex.decode(
|
||
typeof object === 'number' ? object.toString(16) : object);
|
||
break;
|
||
// case 0x05: // NULL
|
||
case 0x06: // OBJECT IDENTIFIER
|
||
var a = object.match(/\d+/g), r = [];
|
||
for (var i = 1; i < a.length; i++) {
|
||
var n = +a[i], r1 = [];
|
||
if (i === 1)
|
||
n = n + a[0] * 40;
|
||
do {
|
||
r1.push(n & 0x7F);
|
||
n = n >>> 7;
|
||
} while (n);
|
||
// reverse order
|
||
for (j = r1.length - 1; j >= 0; --j)
|
||
r.push(r1[j] + (j === 0 ? 0x00 : 0x80));
|
||
}
|
||
content = new Uint8Array(r);
|
||
break;
|
||
// case 0x07: // ObjectDescriptor
|
||
// case 0x08: // EXTERNAL
|
||
// case 0x09: // REAL
|
||
// case 0x0A: // ENUMERATED
|
||
// case 0x0B: // EMBEDDED PDV
|
||
case 0x0C: // UTF8String
|
||
content = Chars.decode(object, 'utf8');
|
||
break;
|
||
// case 0x10: // SEQUENCE
|
||
// case 0x11: // SET
|
||
case 0x12: // NumericString
|
||
case 0x16: // IA5String // ASCII
|
||
case 0x13: // PrintableString // ASCII subset
|
||
case 0x14: // TeletexString // aka T61String
|
||
case 0x15: // VideotexString
|
||
case 0x19: // GraphicString
|
||
case 0x1A: // VisibleString // ASCII subset
|
||
case 0x1B: // GeneralString
|
||
// Reflect on character encoding
|
||
for (var i = 0, n = object.length; i < n; i++)
|
||
if (object.charCodeAt(i) > 255)
|
||
tagNumber = 0x0C;
|
||
if (tagNumber === 0x0C)
|
||
content = Chars.decode(object, 'utf8');
|
||
else
|
||
content = Chars.decode(object, 'ascii');
|
||
break;
|
||
case 0x17: // UTCTime
|
||
case 0x18: // GeneralizedTime
|
||
var result = object.original;
|
||
if (!result) {
|
||
var date = new Date(object);
|
||
date.setMinutes(date.getMinutes() + date.getTimezoneOffset()); // to UTC
|
||
var ms = tagNumber === 0x18 ? date.getMilliseconds().toString() : ''; // Milliseconds, remove trailing zeros
|
||
while (ms.length > 0 && ms.charAt(ms.length - 1) === '0')
|
||
ms = ms.substring(0, ms.length - 1);
|
||
if (ms.length > 0)
|
||
ms = '.' + ms;
|
||
result = (tagNumber === 0x17 ? date.getYear().toString().slice(-2) : date.getFullYear().toString()) +
|
||
('00' + (date.getMonth() + 1)).slice(-2) +
|
||
('00' + date.getDate()).slice(-2) +
|
||
('00' + date.getHours()).slice(-2) +
|
||
('00' + date.getMinutes()).slice(-2) +
|
||
('00' + date.getSeconds()).slice(-2) + ms + 'Z';
|
||
}
|
||
content = Chars.decode(result, 'ascii');
|
||
break;
|
||
case 0x1C: // UniversalString
|
||
content = Chars.decode(object, 'utf32');
|
||
break;
|
||
case 0x1E: // BMPString
|
||
content = Chars.decode(object, 'utf16');
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!content)
|
||
content = new Uint8Array(0);
|
||
if (content instanceof CryptoOperationData)
|
||
content = new Uint8Array(content);
|
||
|
||
if (!tagConstructed && format === 'CER') {
|
||
// Encoding CER-form for string types
|
||
var k;
|
||
switch (tagNumber) {
|
||
case 0x03: // BIT_STRING
|
||
k = 1; // ingnore unused bit for bit string
|
||
case 0x04: // OCTET_STRING
|
||
case 0x0C: // UTF8String
|
||
case 0x12: // NumericString
|
||
case 0x13: // PrintableString
|
||
case 0x14: // TeletexString
|
||
case 0x15: // VideotexString
|
||
case 0x16: // IA5String
|
||
case 0x19: // GraphicString
|
||
case 0x1A: // VisibleString
|
||
case 0x1B: // GeneralString
|
||
case 0x1C: // UniversalString
|
||
case 0x1E: // BMPString
|
||
k = k || 0;
|
||
// Split content on 1000 octet len parts
|
||
var size = 1000;
|
||
var bytelen = 0, ba = [], offset = 0;
|
||
for (var i = k, n = content.length; i < n; i += size - k) {
|
||
ba[i] = encodeBER({
|
||
object: new Unit8Array(content.buffer, i, Math.min(size - k, n - i)),
|
||
tagNumber: tagNumber,
|
||
tagClass: 0,
|
||
tagConstructed: false
|
||
}, format);
|
||
bytelen += ba[i].length;
|
||
}
|
||
ba[n] = new Uint8Array(2); // final for CER 00 00
|
||
bytelen += 2;
|
||
content = new Uint8Array(bytelen);
|
||
for (var i = 0, n = ba.length; i < n; i++) {
|
||
content.set(ba[i], offset);
|
||
offset = offset + ba[i].length;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Restore tagNumber for all classes
|
||
if (tagClass === 0)
|
||
source.tagNumber = tagNumber;
|
||
else
|
||
source.tagNumber = tagNumber = source.tagNumber || 0;
|
||
source.content = content;
|
||
|
||
if (onlyContent)
|
||
return content;
|
||
|
||
// Create header
|
||
// tagNumber
|
||
var ha = [], first = tagClass === 3 ? 0xC0 : tagClass === 2 ? 0x80 :
|
||
tagClass === 1 ? 0x40 : 0x00;
|
||
if (tagConstructed)
|
||
first |= 0x20;
|
||
if (tagNumber < 0x1F) {
|
||
first |= tagNumber & 0x1F;
|
||
ha.push(first);
|
||
} else {
|
||
first |= 0x1F;
|
||
ha.push(first);
|
||
var n = tagNumber, ha1 = [];
|
||
do {
|
||
ha1.push(n & 0x7F);
|
||
n = n >>> 7;
|
||
} while (n)
|
||
// reverse order
|
||
for (var j = ha1.length - 1; j >= 0; --j)
|
||
ha.push(ha1[j] + (j === 0 ? 0x00 : 0x80));
|
||
}
|
||
// Length
|
||
if (tagConstructed && format === 'CER') {
|
||
ha.push(0x80);
|
||
} else {
|
||
var len = content.length;
|
||
if (len > 0x7F) {
|
||
var l2 = len, ha2 = [];
|
||
do {
|
||
ha2.push(l2 & 0xff);
|
||
l2 = l2 >>> 8;
|
||
} while (l2);
|
||
ha.push(ha2.length + 0x80); // reverse order
|
||
for (var j = ha2.length - 1; j >= 0; --j)
|
||
ha.push(ha2[j]);
|
||
} else {
|
||
// simple len
|
||
ha.push(len);
|
||
}
|
||
}
|
||
var header = source.header = new Uint8Array(ha);
|
||
|
||
// Result - complete buffer
|
||
var block = new Uint8Array(header.length + content.length);
|
||
block.set(header, 0);
|
||
block.set(content, header.length);
|
||
return block;
|
||
}
|
||
|
||
function decodeBER(source, offset) {
|
||
|
||
// start pos
|
||
var pos = offset || 0, start = pos;
|
||
var tagNumber, tagClass, tagConstructed,
|
||
content, header, buffer, sub, len;
|
||
|
||
if (source.object) {
|
||
// Ready from source
|
||
tagNumber = source.tagNumber;
|
||
tagClass = source.tagClass;
|
||
tagConstructed = source.tagConstructed;
|
||
content = source.content;
|
||
header = source.header;
|
||
buffer = source.object instanceof CryptoOperationData ?
|
||
new Uint8Array(source.object) : null;
|
||
sub = source.object instanceof Array ? source.object : null;
|
||
len = buffer && buffer.length || null;
|
||
} else {
|
||
// Decode header
|
||
var d = source;
|
||
|
||
// Read tag
|
||
var buf = d[pos++];
|
||
tagNumber = buf & 0x1f;
|
||
tagClass = buf >> 6;
|
||
tagConstructed = (buf & 0x20) !== 0;
|
||
if (tagNumber === 0x1f) { // long tag
|
||
tagNumber = 0;
|
||
do {
|
||
if (tagNumber > 0x1fffffffffff80)
|
||
throw new DataError('Convertor not supported tag number more then (2^53 - 1) at position ' + offset);
|
||
buf = d[pos++];
|
||
tagNumber = (tagNumber << 7) + (buf & 0x7f);
|
||
} while (buf & 0x80);
|
||
}
|
||
|
||
// Read len
|
||
buf = d[pos++];
|
||
len = buf & 0x7f;
|
||
if (len !== buf) {
|
||
if (len > 6) // no reason to use Int10, as it would be a huge buffer anyways
|
||
throw new DataError('Length over 48 bits not supported at position ' + offset);
|
||
if (len === 0)
|
||
len = null; // undefined
|
||
else {
|
||
buf = 0;
|
||
for (var i = 0; i < len; ++i)
|
||
buf = (buf << 8) + d[pos++];
|
||
len = buf;
|
||
}
|
||
}
|
||
|
||
start = pos;
|
||
sub = null;
|
||
|
||
if (tagConstructed) {
|
||
// must have valid content
|
||
sub = [];
|
||
if (len !== null) {
|
||
// definite length
|
||
var end = start + len;
|
||
while (pos < end) {
|
||
var s = decodeBER(d, pos);
|
||
sub.push(s);
|
||
pos += s.header.length + s.content.length;
|
||
}
|
||
if (pos !== end)
|
||
throw new DataError('Content size is not correct for container starting at offset ' + start);
|
||
} else {
|
||
// undefined length
|
||
try {
|
||
for (; ; ) {
|
||
var s = decodeBER(d, pos);
|
||
pos += s.header.length + s.content.length;
|
||
if (s.tagClass === 0x00 && s.tagNumber === 0x00)
|
||
break;
|
||
sub.push(s);
|
||
}
|
||
len = pos - start;
|
||
} catch (e) {
|
||
throw new DataError('Exception ' + e + ' while decoding undefined length content at offset ' + start);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Header and content
|
||
header = new Uint8Array(d.buffer, offset, start - offset);
|
||
content = new Uint8Array(d.buffer, start, len);
|
||
buffer = content;
|
||
}
|
||
|
||
// Constructed types - check for string concationation
|
||
if (sub !== null && tagClass === 0) {
|
||
var k;
|
||
switch (tagNumber) {
|
||
case 0x03: // BIT_STRING
|
||
k = 1; // ingnore unused bit for bit string
|
||
case 0x04: // OCTET_STRING
|
||
case 0x0C: // UTF8String
|
||
case 0x12: // NumericString
|
||
case 0x13: // PrintableString
|
||
case 0x14: // TeletexString
|
||
case 0x15: // VideotexString
|
||
case 0x16: // IA5String
|
||
case 0x19: // GraphicString
|
||
case 0x1A: // VisibleString
|
||
case 0x1B: // GeneralString
|
||
case 0x1C: // UniversalString
|
||
case 0x1E: // BMPString
|
||
k = k || 0;
|
||
// Concatination
|
||
if (sub.length === 0)
|
||
throw new DataError('No constructed encoding content of string type at offset ' + start);
|
||
len = k;
|
||
for (var i = 0, n = sub.length; i < n; i++) {
|
||
var s = sub[i];
|
||
if (s.tagClass !== tagClass || s.tagNumber !== tagNumber || s.tagConstructed)
|
||
throw new DataError('Invalid constructed encoding of string type at offset ' + start);
|
||
len += s.content.length - k;
|
||
}
|
||
buffer = new Uint8Array(len);
|
||
for (var i = 0, n = sub.length, j = k; i < n; i++) {
|
||
var s = sub[i];
|
||
if (k > 0)
|
||
buffer.set(s.content.subarray(1), j);
|
||
else
|
||
buffer.set(s.content, j);
|
||
j += s.content.length - k;
|
||
}
|
||
tagConstructed = false; // follow not required
|
||
sub = null;
|
||
break;
|
||
}
|
||
}
|
||
// Primitive types
|
||
var object = '';
|
||
if (sub === null) {
|
||
if (len === null)
|
||
throw new DataError('Invalid tag with undefined length at offset ' + start);
|
||
|
||
if (tagClass === 0) {
|
||
switch (tagNumber) {
|
||
case 0x01: // BOOLEAN
|
||
object = buffer[0] !== 0;
|
||
break;
|
||
case 0x02: // INTEGER
|
||
case 0x0a: // ENUMIRATED
|
||
if (len > 6) {
|
||
object = Int16.encode(buffer);
|
||
} else {
|
||
var v = buffer[0];
|
||
if (buffer[0] > 0x7f)
|
||
v = v - 256;
|
||
for (var i = 1; i < len; i++)
|
||
v = v * 256 + buffer[i];
|
||
object = v;
|
||
}
|
||
break;
|
||
case 0x03: // BIT_STRING
|
||
if (len > 5) { // Content buffer
|
||
object = new Uint8Array(buffer.subarray(1)).buffer;
|
||
} else { // Max bit mask only for 32 bit
|
||
var unusedBit = buffer[0],
|
||
skip = unusedBit, s = [];
|
||
for (var i = len - 1; i >= 1; --i) {
|
||
var b = buffer[i];
|
||
for (var j = skip; j < 8; ++j)
|
||
s.push((b >> j) & 1 ? '1' : '0');
|
||
skip = 0;
|
||
}
|
||
object = s.reverse().join('');
|
||
}
|
||
break;
|
||
case 0x04: // OCTET_STRING
|
||
object = new Uint8Array(buffer).buffer;
|
||
break;
|
||
// case 0x05: // NULL
|
||
case 0x06: // OBJECT_IDENTIFIER
|
||
var s = '',
|
||
n = 0,
|
||
bits = 0;
|
||
for (var i = 0; i < len; ++i) {
|
||
var v = buffer[i];
|
||
n = (n << 7) + (v & 0x7F);
|
||
bits += 7;
|
||
if (!(v & 0x80)) { // finished
|
||
if (s === '') {
|
||
var m = n < 80 ? n < 40 ? 0 : 1 : 2;
|
||
s = m + "." + (n - m * 40);
|
||
} else
|
||
s += "." + n.toString();
|
||
n = 0;
|
||
bits = 0;
|
||
}
|
||
}
|
||
if (bits > 0)
|
||
throw new DataError('Incompleted OID at offset ' + start);
|
||
object = s;
|
||
break;
|
||
//case 0x07: // ObjectDescriptor
|
||
//case 0x08: // EXTERNAL
|
||
//case 0x09: // REAL
|
||
//case 0x0A: // ENUMERATED
|
||
//case 0x0B: // EMBEDDED_PDV
|
||
case 0x10: // SEQUENCE
|
||
case 0x11: // SET
|
||
object = [];
|
||
break;
|
||
case 0x0C: // UTF8String
|
||
object = Chars.encode(buffer, 'utf8');
|
||
break;
|
||
case 0x12: // NumericString
|
||
case 0x13: // PrintableString
|
||
case 0x14: // TeletexString
|
||
case 0x15: // VideotexString
|
||
case 0x16: // IA5String
|
||
case 0x19: // GraphicString
|
||
case 0x1A: // VisibleString
|
||
case 0x1B: // GeneralString
|
||
object = Chars.encode(buffer, 'ascii');
|
||
break;
|
||
case 0x1C: // UniversalString
|
||
object = Chars.encode(buffer, 'utf32');
|
||
break;
|
||
case 0x1E: // BMPString
|
||
object = Chars.encode(buffer, 'utf16');
|
||
break;
|
||
case 0x17: // UTCTime
|
||
case 0x18: // GeneralizedTime
|
||
var shortYear = tagNumber === 0x17;
|
||
var s = Chars.encode(buffer, 'ascii'),
|
||
m = (shortYear ?
|
||
/^(\d\d)(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])(?:([0-5]\d)(?:([0-5]\d)(?:[.,](\d{1,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/ :
|
||
/^(\d\d\d\d)(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])(?:([0-5]\d)(?:([0-5]\d)(?:[.,](\d{1,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/).exec(s);
|
||
if (!m)
|
||
throw new DataError('Unrecognized time format "' + s + '" at offset ' + start);
|
||
if (shortYear) {
|
||
// Where YY is greater than or equal to 50, the year SHALL be interpreted as 19YY; and
|
||
// Where YY is less than 50, the year SHALL be interpreted as 20YY
|
||
m[1] = +m[1];
|
||
m[1] += (m[1] < 50) ? 2000 : 1900;
|
||
}
|
||
var dt = new Date(m[1], +m[2] - 1, +m[3], +(m[4] || '0'), +(m[5] || '0'), +(m[6] || '0'), +(m[7] || '0')),
|
||
tz = dt.getTimezoneOffset();
|
||
if (m[8] || tagNumber === 0x17) {
|
||
if (m[8].toUpperCase() !== 'Z' && m[9]) {
|
||
tz = tz + parseInt(m[9]);
|
||
}
|
||
dt.setMinutes(dt.getMinutes() - tz);
|
||
}
|
||
dt.original = s;
|
||
object = dt;
|
||
break;
|
||
}
|
||
} else // OCTET_STRING
|
||
object = new Uint8Array(buffer).buffer;
|
||
} else
|
||
object = sub;
|
||
|
||
// result
|
||
return {
|
||
tagConstructed: tagConstructed,
|
||
tagClass: tagClass,
|
||
tagNumber: tagNumber,
|
||
header: header,
|
||
content: content,
|
||
object: object
|
||
};
|
||
}
|
||
|
||
return {
|
||
/**
|
||
* BER.decode(object, format) convert javascript object to ASN.1 format CryptoOperationData<br><br>
|
||
* If object has members tagNumber, tagClass and tagConstructed
|
||
* it is clear define encoding rules. Else method use defaul rules:
|
||
* <ul>
|
||
* <li>Empty string or null - NULL</li>
|
||
* <li>String starts with '0x' and has 0-9 and a-f characters - INTEGER</li>
|
||
* <li>String like d.d.d.d (d - set of digits) - OBJECT IDENTIFIER</li>
|
||
* <li>String with characters 0 and 1 - BIT STRING</li>
|
||
* <li>Strings 'true' or 'false' - BOOLEAN</li>
|
||
* <li>String has only 0-9 and a-f characters - OCTET STRING</li>
|
||
* <li>String has only characters with code 0-255 - PrintableString</li>
|
||
* <li>Other strings - UTF8String</li>
|
||
* <li>Number - INTEGER</li>
|
||
* <li>Date - GeneralizedTime</li>
|
||
* <li>Boolean - SEQUENCE</li>
|
||
* <li>CryptoOperationData - OCTET STRING</li>
|
||
* </ul>
|
||
* SEQUENCE or SET arrays recursively encoded for each item.<br>
|
||
* OCTET STRING and BIT STRING can presents as array with one item.
|
||
* It means encapsulates encoding for child element.<br>
|
||
*
|
||
* If CONTEXT or APPLICATION classes item presents as array with one
|
||
* item we use EXPLICIT encoding for element, else IMPLICIT encoding.<br>
|
||
*
|
||
* @memberOf GostCoding.BER
|
||
* @param {Object} object Object to encoding
|
||
* @param {string} format Encoding rule: 'DER' or 'CER', default 'DER'
|
||
* @param {boolean} onlyContent Encode content only, without header
|
||
* @returns {CryptoOperationData} BER encoded data
|
||
*/
|
||
encode: function (object, format, onlyContent) {
|
||
return encodeBER(object, format, onlyContent).buffer;
|
||
},
|
||
/**
|
||
* BER.encode(data) convert ASN.1 format CryptoOperationData data to javascript object<br><br>
|
||
*
|
||
* Conversion rules to javascript object:
|
||
* <ul>
|
||
* <li>BOOLEAN - Boolean object</li>
|
||
* <li>INTEGER, ENUMIRATED - Integer object if len <= 6 (48 bits) else Int16 encoded string</li>
|
||
* <li>BIT STRING - Integer object if len <= 5 (w/o unsedBit octet - 32 bits) else String like '10111100' or Array with one item in case of incapsulates encoding</li>
|
||
* <li>OCTET STRING - Hex encoded string or Array with one item in case of incapsulates encoding</li>
|
||
* <li>OBJECT IDENTIFIER - String with object identifier</li>
|
||
* <li>SEQUENCE, SET - Array of encoded items</li>
|
||
* <li>UTF8String, NumericString, PrintableString, TeletexString, VideotexString,
|
||
* IA5String, GraphicString, VisibleString, GeneralString, UniversalString,
|
||
* BMPString - encoded String</li>
|
||
* <li>UTCTime, GeneralizedTime - Date</li>
|
||
* </ul>
|
||
* @memberOf GostCoding.BER
|
||
* @param {(CryptoOperationData|GostCoding.BER)} data Binary data to decode
|
||
* @returns {Object} Javascript object with result of decoding
|
||
*/
|
||
decode: function (data) {
|
||
return decodeBER(data.object ? data : new Uint8Array(buffer(data)), 0);
|
||
}
|
||
}; // </editor-fold>
|
||
})();
|
||
|
||
/**
|
||
* BER, DER, CER conversion
|
||
* @memberOf GostCoding
|
||
* @insnance
|
||
* @type GostCoding.BER
|
||
*/
|
||
GostCoding.prototype.BER = BER;
|
||
|
||
/**
|
||
* PEM conversion
|
||
* @class GostCoding.PEM
|
||
*/
|
||
var PEM = {// <editor-fold defaultstate="collapsed">
|
||
/**
|
||
* PEM.encode(data, name) encode CryptoOperationData to PEM format with name label
|
||
*
|
||
* @memberOf GostCoding.PEM
|
||
* @param {(Object|CryptoOperationData)} data Java script object or BER-encoded binary data
|
||
* @param {string} name Name of PEM object: 'certificate', 'private key' etc.
|
||
* @returns {string} Encoded object
|
||
*/
|
||
encode: function (data, name) {
|
||
return (name ? '-----BEGIN ' + name.toUpperCase() + '-----\r\n' : '') +
|
||
Base64.encode(data instanceof CryptoOperationData ? data : BER.encode(data)) +
|
||
(name ? '\r\n-----END ' + name.toUpperCase() + '-----' : '');
|
||
},
|
||
/**
|
||
* PEM.decode(s, name, deep) decode PEM format s labeled name to CryptoOperationData or javascript object in according to deep parameter
|
||
*
|
||
* @memberOf GostCoding.PEM
|
||
* @param {string} s PEM encoded string
|
||
* @param {string} name Name of PEM object: 'certificate', 'private key' etc.
|
||
* @param {boolean} deep If true method do BER-decoding, else only BASE64 decoding
|
||
* @param {integer} index Index of decoded value
|
||
* @returns {(Object|CryptoOperationData)} Decoded javascript object if deep=true, else CryptoOperationData for father BER decoding
|
||
*/
|
||
decode: function (s, name, deep, index) {
|
||
// Try clear base64
|
||
var re1 = /([A-Za-z0-9\+\/\s\=]+)/g,
|
||
valid = re1.exec(s);
|
||
if (valid[1].length !== s.length)
|
||
valid = false;
|
||
if (!valid && name) {
|
||
// Try with the name
|
||
var re2 = new RegExp(
|
||
'-----\\s?BEGIN ' + name.toUpperCase() +
|
||
'-----([A-Za-z0-9\\+\\/\\s\\=]+)-----\\s?END ' +
|
||
name.toUpperCase() + '-----', 'g');
|
||
valid = re2.exec(s);
|
||
}
|
||
if (!valid) {
|
||
// Try with some name
|
||
var re3 = new RegExp(
|
||
'-----\\s?BEGIN [A-Z0-9\\s]+' +
|
||
'-----([A-Za-z0-9\\+\\/\\s\\=]+)-----\\s?END ' +
|
||
'[A-Z0-9\\s]+-----', 'g');
|
||
valid = re3.exec(s);
|
||
}
|
||
var r = valid && valid[1 + (index || 0)];
|
||
if (!r)
|
||
throw new DataError('Not valid PEM format');
|
||
var out = Base64.decode(r);
|
||
if (deep)
|
||
out = BER.decode(out);
|
||
return out;
|
||
} // </editor-fold>
|
||
};
|
||
|
||
/**
|
||
* PEM conversion
|
||
* @memberOf GostCoding
|
||
* @insnance
|
||
* @type GostCoding.PEM
|
||
*/
|
||
GostCoding.prototype.PEM = PEM;
|
||
|
||
if (gostCrypto)
|
||
/**
|
||
* Coding algorithms: Base64, Hex, Int16, Chars, BER and PEM
|
||
*
|
||
* @memberOf gostCrypto
|
||
* @type GostCoding
|
||
*/
|
||
gostCrypto.coding = new GostCoding();
|
||
|
||
export default GostCoding;
|