zhui-plus 1.0.0 → 1.0.10

package/packages/components/fileViewer/src/liteofd/asn1js/base64.js

@@ -0,0 +1,103 @@
+// Base64 JavaScript decoder
+// Copyright (c) 2008-2024 Lapo Luchini <lapo@lapo.it>
+
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+const
+    haveU8 = (typeof Uint8Array == 'function');
+
+let decoder; // populated on first usage
+
+export class Base64 {
+
+    static decode(a) {
+        let isString = (typeof a == 'string');
+        let i;
+        if (decoder === undefined) {
+            let b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+                ignore = '= \f\n\r\t\u00A0\u2028\u2029';
+            decoder = [];
+            for (i = 0; i < 64; ++i)
+                decoder[b64.charCodeAt(i)] = i;
+            for (i = 0; i < ignore.length; ++i)
+                decoder[ignore.charCodeAt(i)] = -1;
+            // RFC 3548 URL & file safe encoding
+            decoder['-'.charCodeAt(0)] = decoder['+'.charCodeAt(0)];
+            decoder['_'.charCodeAt(0)] = decoder['/'.charCodeAt(0)];
+        }
+        let out = haveU8 ? new Uint8Array(a.length * 3 >> 2) : [];
+        let bits = 0, char_count = 0, len = 0;
+        for (i = 0; i < a.length; ++i) {
+            let c = isString ? a.charCodeAt(i) : a[i];
+            if (c == 61) // '='.charCodeAt(0)
+                break;
+            c = decoder[c];
+            if (c == -1)
+                continue;
+            if (c === undefined)
+                throw 'Illegal character at offset ' + i;
+            bits |= c;
+            if (++char_count >= 4) {
+                out[len++] = (bits >> 16);
+                out[len++] = (bits >> 8) & 0xFF;
+                out[len++] = bits & 0xFF;
+                bits = 0;
+                char_count = 0;
+            } else {
+                bits <<= 6;
+            }
+        }
+        switch (char_count) {
+        case 1:
+            throw 'Base64 encoding incomplete: at least 2 bits missing';
+        case 2:
+            out[len++] = (bits >> 10);
+            break;
+        case 3:
+            out[len++] = (bits >> 16);
+            out[len++] = (bits >> 8) & 0xFF;
+            break;
+        }
+        if (haveU8 && out.length > len) // in case it was originally longer because of ignored characters
+            out = out.subarray(0, len);
+        return out;
+    }
+
+    static pretty(str) {
+        // fix padding
+        if (str.length % 4 > 0)
+            str = (str + '===').slice(0, str.length + str.length % 4);
+        // convert RFC 3548 to standard Base64
+        str = str.replace(/-/g, '+').replace(/_/g, '/');
+        // 80 column width
+        return str.replace(/(.{80})/g, '$1\n');
+    }
+
+    static unarmor(a) {
+        let m = Base64.re.exec(a);
+        if (m) {
+            if (m[1])
+                a = m[1];
+            else if (m[2])
+                a = m[2];
+            else if (m[3])
+                a = m[3];
+            else
+                throw 'RegExp out of sync';
+        }
+        return Base64.decode(a);
+    }
+
+}
+
+Base64.re = /-----BEGIN [^-]+-----([A-Za-z0-9+/=\s]+)-----END [^-]+-----|begin-base64[^\n]+\n([A-Za-z0-9+/=\s]+)====|^([A-Za-z0-9+/=\s]+)$/;

package/packages/components/fileViewer/src/liteofd/asn1js/defs.js

@@ -0,0 +1,138 @@
+// ASN.1 RFC definitions matcher
+// Copyright (c) 2023-2024 Lapo Luchini <lapo@lapo.it>
+
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+import { rfcdef } from './rfcdef.js';
+
+function translate(def, tn, stats) {
+    if (def?.type == 'tag' && !def.explicit)
+        // def.type = def.content[0].type;
+        def = def.content[0].type;
+    if (def?.definedBy)
+        try {
+            // hope current OIDs contain the type name (will need to parse from RFC itself)
+            def = Defs.searchType(firstUpper(stats.defs[def.definedBy][1]));
+        } catch (e) { /*ignore*/ }
+    while (def?.type == 'defined' || def?.type?.type == 'defined') {
+        const name = def?.type?.type ? def.type.name : def.name;
+        def = Object.assign({}, def);
+        def.type = Defs.searchType(name).type;
+    }
+    if (def?.type?.name == 'CHOICE') {
+        for (let c of def.type.content) {
+            if (tn != c.type.name && tn != c.name)
+                c = translate(c);
+            if (tn == c.type.name || tn == c.name) {
+                def = Object.assign({}, def);
+                def.type = c.type.name ? c.type : c;
+                break;
+            }
+        }
+    }
+    const id = def?.id;
+    if (id)
+        def = Object.assign({}, def, { id });
+    return def ?? { type: {} };
+}
+
+function firstUpper(s) {
+    return s[0].toUpperCase() + s.slice(1);
+}
+
+export class Defs {
+
+    static moduleAndType(mod, name) {
+        return Object.assign({ module: { oid: mod.oid, name: mod.name, source: mod.source } }, mod.types[name]);
+    }
+
+    static searchType(name) {
+        for (const mod of Object.values(rfcdef))
+            if (name in mod.types) {
+                // console.log(name + ' found in ' + r.name);
+                // return r.types[name];
+                return Defs.moduleAndType(mod, name);
+            }
+        throw new Error('Type not found: ' + name);
+    }
+
+    static match(value, def, stats = { total: 0, recognized: 0, defs: {} }) {
+        value.def = {};
+        let tn = value.typeName().replaceAll('_', ' ');
+        def = translate(def, tn, stats);
+        ++stats.total;
+        if (def?.type) {
+            // if (def.id || def.name) ++stats.recognized;
+            if (tn == def.type.name || tn == def.name || def.name == 'ANY')
+                ++stats.recognized;
+            else if (def.name)
+                def = Object.assign({ mismatch: 1 }, def);
+            value.def = def;
+        }
+        if (value.sub !== null) {
+            if (def?.type?.type)
+                def = def.type;
+            let j = def?.content ? 0 : -1;
+            for (const subval of value.sub) {
+                let type;
+                if (j >= 0) {
+                    if (def.typeOf)
+                        type = def.content[0];
+                    else {
+                        let tn = subval.typeName().replaceAll('_', ' ');
+                        for (;;) {
+                            type = def.content[j++];
+                            if (!type || typeof type != 'object') break;
+                            if (type?.type?.type)
+                                type = type.type;
+                            if (type.type == 'defined') {
+                                let t2 = translate(type, tn);
+                                if (t2.type.name == tn) break; // exact match
+                                if (t2.type.name == 'ANY') break; // good enough
+                            }
+                            if (type.name == tn) break; // exact match
+                            if (type.name == 'ANY') break; // good enough
+                            if (!('optional' in type || 'default' in type)) break;
+                        }
+                        if (type?.type == 'builtin' || type?.type == 'defined') {
+                            let v = subval.content();
+                            if (typeof v == 'string')
+                                v = v.split(/\n/);
+                            stats.defs[type.id] = v;
+                        } else if (type?.definedBy && stats.defs?.[type.definedBy]?.[1]) { // hope current OIDs contain the type name (will need to parse from RFC itself)
+                            try {
+                                type = Defs.searchType(firstUpper(stats.defs[type.definedBy][1]));
+                            } catch (e) { /*ignore*/ }
+                        }
+                    }
+                }
+                Defs.match(subval, type, stats);
+            }
+        }
+        return stats;
+    }
+
+}
+
+Defs.RFC = rfcdef;
+
+Defs.commonTypes = [
+    [ 'X.509 certificate', '1.3.6.1.5.5.7.0.18', 'Certificate' ], 
+    [ 'X.509 public key info', '1.3.6.1.5.5.7.0.18', 'SubjectPublicKeyInfo' ],
+    [ 'CMS / PKCS#7 envelope', '1.2.840.113549.1.9.16.0.14', 'ContentInfo' ],
+    [ 'PKCS#1 RSA private key', '1.2.840.113549.1.1.0.1', 'RSAPrivateKey' ],
+    [ 'PKCS#8 encrypted private key', '1.2.840.113549.1.8.1.1', 'EncryptedPrivateKeyInfo' ],
+    [ 'PKCS#8 private key', '1.2.840.113549.1.8.1.1', 'PrivateKeyInfo' ],
+    [ 'PKCS#10 certification request', '1.2.840.113549.1.10.1.1', 'CertificationRequest' ],
+    [ 'CMP PKI Message', '1.3.6.1.5.5.7.0.16', 'PKIMessage' ],
+].map(arr => ({ description: arr[0], ...Defs.moduleAndType(rfcdef[arr[1]], arr[2]) }));

package/packages/components/fileViewer/src/liteofd/asn1js/dumpASN1.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+import * as fs from 'node:fs';
+import { Base64 } from './base64.js';
+import { ASN1 } from './asn1.js';
+import { Defs } from './defs.js';
+
+const
+    colYellow = '\x1b[33m',
+    colBlue = '\x1b[34m',
+    colReset = '\x1b[0m',
+    reDataURI = /^data:(?:[a-z-]+[/][a-z.+-]+;)?base64,([A-Za-z0-9+/=\s]+)$/;
+
+function print(value, indent) {
+    if (indent === undefined) indent = '';
+    const def = value.def;
+    let name = '';
+    if (def?.type) {
+        if (def.id) name += colBlue + def.id + colReset;
+        if (typeof def.type == 'object' && def.name) name = (name ? name + ' ' : '') + def.name;
+        if (def.mismatch) name = (name ? name + ' ' : '') + '[?]';
+        if (name) name += ' ';
+    }
+    let s = indent + name + colYellow + value.typeName() + colReset + ' @' + value.stream.pos;
+    if (value.length >= 0)
+        s += '+';
+    s += value.length;
+    if (value.tag.tagConstructed)
+        s += ' (constructed)';
+    else if ((value.tag.isUniversal() && ((value.tag.tagNumber == 0x03) || (value.tag.tagNumber == 0x04))) && (value.sub !== null))
+        s += ' (encapsulates)';
+    let content = value.content();
+    if (content)
+        s += ': ' + content.replace(/\n/g, '|');
+    s += '\n';
+    if (value.sub !== null) {
+        indent += '  ';
+        for (const subval of value.sub)
+            s += print(subval, indent);
+    }
+    return s;
+}
+
+const filename = process.argv[2];
+const match = reDataURI.exec(filename);
+let content = match
+    ? Buffer.from(match[1])
+    : fs.readFileSync(filename);
+try { // try PEM first
+    content = Base64.unarmor(content);
+} catch (e) { // try DER/BER then
+}
+let result = ASN1.decode(content);
+content = null;
+const t0 = performance.now();
+if (process.argv.length == 5) {
+    Defs.match(result, Defs.moduleAndType(Defs.RFC[process.argv[3]], process.argv[4]));
+} else {
+    const types = Defs.commonTypes
+        .map(type => {
+            const stats = Defs.match(result, type);
+            return { type, match: stats.recognized / stats.total };
+        })
+        .sort((a, b) => b.match - a.match);
+    const t1 = performance.now();
+    console.log('Parsed in ' + (t1 - t0).toFixed(2) + ' ms; possible types:');
+    for (const t of types)
+        console.log((t.match * 100).toFixed(2).padStart(6) + '% ' + t.type.description);
+    Defs.match(result, types[0].type);
+    // const stats = Defs.match(result, types[0].type);
+    // console.log('Stats:', stats);
+    console.log('Parsed as:', result.def);
+    // const type = searchType(process.argv[2]);
+    // const stats = applyDef(result, type);
+}
+console.log(print(result));
+// console.log('Stats:', (stats.recognized * 100 / stats.total).toFixed(2) + '%');
+// // print(result, searchType(process.argv[2]), stats);
+// // console.log('Defs:', stats.defs);

package/packages/components/fileViewer/src/liteofd/asn1js/hex.js

@@ -0,0 +1,69 @@
+// Hex JavaScript decoder
+// Copyright (c) 2008-2024 Lapo Luchini <lapo@lapo.it>
+
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+const
+    haveU8 = (typeof Uint8Array == 'function');
+
+let decoder; // populated on first usage
+
+export class Hex {
+
+    /**
+     * Decodes an hexadecimal value.
+     * @param {string|Array|Uint8Array} a - a string representing hexadecimal data, or an array representation of its charcodes
+     */
+    static decode(a) {
+        let isString = (typeof a == 'string');
+        let i;
+        if (decoder === undefined) {
+            let hex = '0123456789ABCDEF',
+                ignore = ' \f\n\r\t\u00A0\u2028\u2029';
+            decoder = [];
+            for (i = 0; i < 16; ++i)
+                decoder[hex.charCodeAt(i)] = i;
+            hex = hex.toLowerCase();
+            for (i = 10; i < 16; ++i)
+                decoder[hex.charCodeAt(i)] = i;
+            for (i = 0; i < ignore.length; ++i)
+                decoder[ignore.charCodeAt(i)] = -1;
+        }
+        let out = haveU8 ? new Uint8Array(a.length >> 1) : [],
+            bits = 0,
+            char_count = 0,
+            len = 0;
+        for (i = 0; i < a.length; ++i) {
+            let c = isString ? a.charCodeAt(i) : a[i];
+            c = decoder[c];
+            if (c == -1)
+                continue;
+            if (c === undefined)
+                throw 'Illegal character at offset ' + i;
+            bits |= c;
+            if (++char_count >= 2) {
+                out[len++] = bits;
+                bits = 0;
+                char_count = 0;
+            } else {
+                bits <<= 4;
+            }
+        }
+        if (char_count)
+            throw 'Hex encoding incomplete: 4 bits missing';
+        if (haveU8 && out.length > len) // in case it was originally longer because of ignored characters
+            out = out.subarray(0, len);
+        return out;
+    }
+
+}

package/packages/components/fileViewer/src/liteofd/asn1js/int10.js

@@ -0,0 +1,106 @@
+// Big integer base-10 printing library
+// Copyright (c) 2008-2024 Lapo Luchini <lapo@lapo.it>
+
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+let max = 10000000000000; // biggest 10^n integer that can still fit 2^53 when multiplied by 256
+
+export class Int10 {
+    /**
+     * Arbitrary length base-10 value.
+     * @param {number} value - Optional initial value (will be 0 otherwise).
+     */
+    constructor(value) {
+        this.buf = [+value || 0];
+    }
+
+    /**
+     * Multiply value by m and add c.
+     * @param {number} m - multiplier, must be < =256
+     * @param {number} c - value to add
+     */
+    mulAdd(m, c) {
+        // assert(m <= 256)
+        let b = this.buf,
+            l = b.length,
+            i, t;
+        for (i = 0; i < l; ++i) {
+            t = b[i] * m + c;
+            if (t < max)
+                c = 0;
+            else {
+                c = 0|(t / max);
+                t -= c * max;
+            }
+            b[i] = t;
+        }
+        if (c > 0)
+            b[i] = c;
+    }
+
+    /**
+     * Subtract value.
+     * @param {number} c - value to subtract
+     */
+    sub(c) {
+        let b = this.buf,
+            l = b.length,
+            i, t;
+        for (i = 0; i < l; ++i) {
+            t = b[i] - c;
+            if (t < 0) {
+                t += max;
+                c = 1;
+            } else
+                c = 0;
+            b[i] = t;
+        }
+        while (b[b.length - 1] === 0)
+            b.pop();
+    }
+
+    /**
+     * Convert to decimal string representation.
+     * @param {*} base - optional value, only value accepted is 10
+     */
+    toString(base) {
+        if ((base || 10) != 10)
+            throw 'only base 10 is supported';
+        let b = this.buf,
+            s = b[b.length - 1].toString();
+        for (let i = b.length - 2; i >= 0; --i)
+            s += (max + b[i]).toString().substring(1);
+        return s;
+    }
+
+    /**
+     * Convert to Number value representation.
+     * Will probably overflow 2^53 and thus become approximate.
+     */
+    valueOf() {
+        let b = this.buf,
+            v = 0;
+        for (let i = b.length - 1; i >= 0; --i)
+            v = v * max + b[i];
+        return v;
+    }
+
+    /**
+     * Return value as a simple Number (if it is <= 10000000000000), or return this.
+     */
+    simplify() {
+        let b = this.buf;
+        return (b.length == 1) ? b[0] : this;
+    }
+
+}