vap1 0.0.1

package/login/Password.d.ts

@@ -0,0 +1,61 @@
+type PasswordCheckerOptions = {
+    /**
+     * 最小长度，默认：6
+    */
+    minLength?: number;
+    /**
+     * 最大长度，默认：32
+    */
+    maxLength?: number;
+    /**
+     * 必须包含数字
+    */
+    requireNumber?: boolean;
+    /**
+     * 必须包含大写字母
+    */
+    requireLowerLetter?: boolean;
+    /**
+     * 必须包含大写字母
+    */
+    requireUpperLetter?: boolean;
+    /**
+     * 必须包含小写字母
+    */
+    rqueireSymbol?: boolean;
+};
+/**
+ * 密码复杂度,安全等级判断
+*/
+export declare class PasswordChecker {
+    options: PasswordCheckerOptions;
+    constructor(options: PasswordCheckerOptions);
+    check(txt: string): true | string;
+    /**
+     * 说明
+     * 一. 密码长度
+     *  1) 5 分: 小于等于 4 个字符
+     *  2) 10 分: 5 到 7 字符
+     *  3) 25 分: 大于等于 8 个字符
+     * 二. 字母
+     *  1) 0 分: 没有字母
+     *  2) 10 分: 全都是小（大）写字母
+     *  1) 2 分: 字母和数字
+     *  2) 3 分: 字母、数字和符号
+     *  3) 5 分: 大小写字母、数字和符号
+    */
+    strong(txt: string): number;
+    /**
+     * 0: 非常弱
+     * 25: 弱（Weak）
+     * 50: 一般（Average）
+     * 60: 强（Strong）
+     * 70: 非常强
+     * 80: 安全（Secure）
+     * 90: 非常安全
+     *
+     * 说明，返回 false , 说明密码没有通过验证
+    */
+    safeCheck(txt: string): string | false;
+}
+export {};

package/login/Password.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordChecker = void 0;
+const CHARS_NUMBER = new Set('0123456789'.split(''));
+const CHARS_LOW = new Set('abcdefghijklmnopqrstuvwxyz'.split(''));
+const CHARS_UP = new Set('ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''));
+const CHARS_SYMBOL = new Set('-_+.~!@#$%^&*<>'.split(''));
+/**
+ * 密码复杂度,安全等级判断
+*/
+class PasswordChecker {
+    constructor(options) {
+        this.options = {};
+        this.options = options;
+    }
+    check(txt) {
+        const { options } = this;
+        if (txt == '' || txt == null) {
+            return '密码不能为空';
+        }
+        if (options.minLength && txt.length < options.minLength) {
+            return `至少输入${options.minLength}个字符`;
+        }
+        if (options.maxLength && txt.length > options.maxLength) {
+            return `最多输入${options.maxLength}个字符`;
+        }
+        let chars = txt.split('');
+        if (options.requireLowerLetter) {
+            let checked = false;
+            for (let char of chars) {
+                if (CHARS_LOW.has(char)) {
+                    checked = true;
+                    break;
+                }
+            }
+            if (!checked) {
+                return '必须要包含小写字母';
+            }
+        }
+        if (options.requireUpperLetter) {
+            let checked = false;
+            for (let char of chars) {
+                if (CHARS_UP.has(char)) {
+                    checked = true;
+                    break;
+                }
+            }
+            if (!checked) {
+                return '必须要包含大写字母';
+            }
+        }
+        if (options.requireNumber) {
+            let checked = false;
+            for (let char of chars) {
+                if (CHARS_NUMBER.has(char)) {
+                    checked = true;
+                    break;
+                }
+            }
+            if (!checked) {
+                return '必须要包含数字';
+            }
+        }
+        if (options.rqueireSymbol) {
+            let checked = false;
+            for (let char of chars) {
+                if (CHARS_SYMBOL.has(char)) {
+                    checked = true;
+                    break;
+                }
+            }
+            if (!checked) {
+                return '必须要包含一个特殊符号';
+            }
+        }
+        return true;
+    }
+    /**
+     * 说明
+     * 一. 密码长度
+     *  1) 5 分: 小于等于 4 个字符
+     *  2) 10 分: 5 到 7 字符
+     *  3) 25 分: 大于等于 8 个字符
+     * 二. 字母
+     *  1) 0 分: 没有字母
+     *  2) 10 分: 全都是小（大）写字母
+     *  1) 2 分: 字母和数字
+     *  2) 3 分: 字母、数字和符号
+     *  3) 5 分: 大小写字母、数字和符号
+    */
+    strong(txt) {
+        return 1;
+    }
+    /**
+     * 0: 非常弱
+     * 25: 弱（Weak）
+     * 50: 一般（Average）
+     * 60: 强（Strong）
+     * 70: 非常强
+     * 80: 安全（Secure）
+     * 90: 非常安全
+     *
+     * 说明，返回 false , 说明密码没有通过验证
+    */
+    safeCheck(txt) {
+        if (!this.check(txt))
+            return false;
+        const score = this.strong(txt);
+        if (score < 25)
+            return '非常弱';
+        if (score < 50)
+            return '弱';
+        if (score < 60)
+            return '一般';
+        if (score < 70)
+            return '强';
+        if (score < 80)
+            return '非常强';
+        if (score < 90)
+            return '安全';
+        return '非常安全';
+    }
+}
+exports.PasswordChecker = PasswordChecker;

package/login/SM4.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 国密SM4 加密算法
+ * 使用
+ * import { SM4 } from 'vap/utils/SM4';
+ * const key = 'xxxxxxxxxxxxxxxx';
+ * const sm4 = new SM4(key);
+*/
+export declare class SM4 {
+    key: string;
+    constructor(key: string);
+    encrypt(content: any): string;
+    arrayBufferToBase64(buffer: any): string;
+    sm4_setkey_enc(sk: any, key: any): void;
+    sm4_crypt_ecb(sk: any, length: any, input: any, output: any): void;
+    parseUtf8StringToHex(input: any): string;
+    /**
+     * 转成ascii码数组
+     */
+    hexToArray(hexStr: any): any[];
+}

package/login/SM4.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SM4 = void 0;
+const FK = [0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc];
+const SboxTable = [
+    [0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05],
+    [0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99],
+    [0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62],
+    [0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6],
+    [0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8],
+    [0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35],
+    [0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87],
+    [0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e],
+    [0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1],
+    [0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3],
+    [0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f],
+    [0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51],
+    [0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8],
+    [0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0],
+    [0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84],
+    [0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48]
+];
+const CK = [
+    0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
+    0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
+    0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
+    0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
+    0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
+    0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
+    0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
+    0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279
+];
+const GET_ULONG_BE = function (n, b, i) {
+    return (b[i] << 24) | (b[i + 1] << 16) | (b[i + 2]) << 8 | (b[i + 3]);
+};
+const PUT_ULONG_BE = function (n, b, i) {
+    b[i] = n >>> 24;
+    b[i + 1] = n >>> 16;
+    b[i + 2] = n >>> 8;
+    b[i + 3] = n;
+};
+const sm4Sbox = function (n) {
+    var l = n >>> 4;
+    var r = n % 16;
+    return SboxTable[l][r];
+};
+const sm4CalciRK = function (ka) {
+    var bb = 0;
+    var rk = 0;
+    var a = new Uint8Array(4);
+    var b = new Array(4);
+    PUT_ULONG_BE(ka, a, 0);
+    b[0] = sm4Sbox(a[0]);
+    b[1] = sm4Sbox(a[1]);
+    b[2] = sm4Sbox(a[2]);
+    b[3] = sm4Sbox(a[3]);
+    bb = GET_ULONG_BE(bb, b, 0);
+    rk = bb ^ (ROTL(bb, 13)) ^ (ROTL(bb, 23));
+    return rk;
+};
+const ROTL = function (x, n) {
+    var a = (x & 0xFFFFFFFF) << n;
+    var b = x >>> (32 - n);
+    return a | b;
+};
+const sm4_one_round = function (sk, input, output) {
+    var i = 0;
+    var ulbuf = new Array(36);
+    ulbuf[0] = GET_ULONG_BE(ulbuf[0], input, 0);
+    ulbuf[1] = GET_ULONG_BE(ulbuf[1], input, 4);
+    ulbuf[2] = GET_ULONG_BE(ulbuf[2], input, 8);
+    ulbuf[3] = GET_ULONG_BE(ulbuf[3], input, 12);
+    while (i < 32) {
+        ulbuf[i + 4] = sm4F(ulbuf[i], ulbuf[i + 1], ulbuf[i + 2], ulbuf[i + 3], sk[i]);
+        i++;
+    }
+    PUT_ULONG_BE(ulbuf[35], output, 0);
+    PUT_ULONG_BE(ulbuf[34], output, 4);
+    PUT_ULONG_BE(ulbuf[33], output, 8);
+    PUT_ULONG_BE(ulbuf[32], output, 12);
+};
+const sm4F = function (x0, x1, x2, x3, rk) {
+    return (x0 ^ sm4Lt(x1 ^ x2 ^ x3 ^ rk));
+};
+const sm4Lt = function (ka) {
+    var bb = 0;
+    var c = 0;
+    var a = new Uint8Array(4);
+    var b = new Array(4);
+    PUT_ULONG_BE(ka, a, 0);
+    b[0] = sm4Sbox(a[0]);
+    b[1] = sm4Sbox(a[1]);
+    b[2] = sm4Sbox(a[2]);
+    b[3] = sm4Sbox(a[3]);
+    bb = GET_ULONG_BE(bb, b, 0);
+    c = bb ^ (ROTL(bb, 2)) ^ (ROTL(bb, 10)) ^ (ROTL(bb, 18)) ^ (ROTL(bb, 24));
+    return c;
+};
+const sm4_setkey = function (SK, key) {
+    var MK = new Array(4);
+    var k = new Array(36);
+    var i = 0;
+    MK[0] = GET_ULONG_BE(MK[0], key, 0);
+    MK[1] = GET_ULONG_BE(MK[1], key, 4);
+    MK[2] = GET_ULONG_BE(MK[2], key, 8);
+    MK[3] = GET_ULONG_BE(MK[3], key, 12);
+    k[0] = MK[0] ^ FK[0];
+    k[1] = MK[1] ^ FK[1];
+    k[2] = MK[2] ^ FK[2];
+    k[3] = MK[3] ^ FK[3];
+    for (; i < 32; i++) {
+        k[i + 4] = k[i] ^ (sm4CalciRK(k[i + 1] ^ k[i + 2] ^ k[i + 3] ^ CK[i]));
+        SK[i] = k[i + 4];
+    }
+};
+/**
+ * 国密SM4 加密算法
+ * 使用
+ * import { SM4 } from 'vap/utils/SM4';
+ * const key = 'xxxxxxxxxxxxxxxx';
+ * const sm4 = new SM4(key);
+*/
+class SM4 {
+    constructor(key) {
+        this.key = null;
+        this.key = key;
+    }
+    encrypt(content) {
+        let hData = this.parseUtf8StringToHex(content);
+        let sk = [];
+        let lpbKey = this.hexToArray(this.parseUtf8StringToHex(this.key));
+        this.sm4_setkey_enc(sk, lpbKey); //加密
+        let lpbData = this.hexToArray(hData); // hex2Array(szData)
+        let pbyCryptResult = new Array();
+        let len = lpbData.length;
+        this.sm4_crypt_ecb(sk, len, lpbData, pbyCryptResult);
+        return this.arrayBufferToBase64(pbyCryptResult);
+    }
+    // arrayBuffer 转 Base64
+    arrayBufferToBase64(buffer) {
+        let binary = '';
+        let len = buffer.length;
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(buffer[i]);
+        }
+        return window.btoa(binary);
+    }
+    sm4_setkey_enc(sk, key) {
+        sm4_setkey(sk, key);
+    }
+    sm4_crypt_ecb(sk, length, input, output) {
+        let index = 0;
+        while (length > 0) {
+            let oneInput = input.slice(index, index + 16);
+            let oneOutput = new Uint8Array(16);
+            sm4_one_round(sk, oneInput, oneOutput);
+            for (let i = 0; i < 16; i++) {
+                output[index + i] = oneOutput[i];
+            }
+            index += 16;
+            length -= 16;
+        }
+    }
+    parseUtf8StringToHex(input) {
+        input = unescape(encodeURIComponent(input));
+        let length = input.length;
+        // 转换到字数组
+        let words = [];
+        for (let i = 0; i < length; i++) {
+            words[i >>> 2] |= (input.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
+        }
+        // 转换到16进制
+        let hexChars = [];
+        for (let i = 0; i < length; i++) {
+            let bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+            hexChars.push((bite >>> 4).toString(16));
+            hexChars.push((bite & 0x0f).toString(16));
+        }
+        return hexChars.join('');
+    }
+    /**
+     * 转成ascii码数组
+     */
+    hexToArray(hexStr) {
+        let words = [];
+        let hexStrLength = hexStr.length;
+        for (let i = 0; i < hexStrLength; i += 2) {
+            words.push(parseInt(hexStr.substr(i, 2), 16));
+        }
+        return words;
+    }
+}
+exports.SM4 = SM4;

package/login/cems/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * CEMS 登录
+ *
+*/
+export declare const login: () => void;
+/**
+ * CEMS 登录
+ *
+*/
+export declare const sso: (token: string) => void;

package/login/cems/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * CEMS 登录
+ *
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sso = exports.login = void 0;
+const login = () => {
+};
+exports.login = login;
+/**
+ * CEMS 登录
+ *
+*/
+const sso = (token) => {
+};
+exports.sso = sso;

package/login/jit/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 吉大正元 PKI 证书登录, 已经内置所有已知的KEY，
+ *
+ * 大致使用方式 如下
+ * import { JitClient } from 'vap2/login/jit'
+ * const client = JitClient();                                  // 接收 1-3个参数，用于不同版本的控制
+ * const randomNumber = await Ajax.GET('/api/randomNumber');    // 后端 生成一个随机数
+ * const param = client.getLoginParam(randomNumber);            // 插件 获取登录参数
+ * const loginResult = await Ajax.GET('/api/pkilogin');         // 后端 登录接口
+ *
+ * 如果 key 未知时，getLoginParam 需要传新的KEY
+*/
+export declare enum BROWSER_MODE {
+    IE = 0,
+    CHROME = 1,
+    CHROME_OLD = 2
+}
+export declare class JitClient {
+    private initParam;
+    /**
+     * @param initParam         插件初始化参数，是一个XML字符串，在不同的项目，参数会不同，可以配置在后端返回
+     * @param enablectiveX      是否支持 旧版本 IE ActiveX 登录 , 默认支持
+     * @param enableNPPlugin    是否支持 旧版本 Chrome NppPlugin 登录 ， 默认支持，部分地区不支持
+    */
+    constructor(initParam?: string, enablectiveX?: boolean, enableNPPlugin?: boolean);
+    getBrowserInfo(): BROWSER_MODE;
+    getLoginParam(randNum: any, initParam?: string): {
+        original: string;
+        signed_data: string;
+        authMode: 'cert';
+    } | false;
+}

package/login/jit/index.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * 吉大正元 PKI 证书登录, 已经内置所有已知的KEY，
+ *
+ * 大致使用方式 如下
+ * import { JitClient } from 'vap2/login/jit'
+ * const client = JitClient();                                  // 接收 1-3个参数，用于不同版本的控制
+ * const randomNumber = await Ajax.GET('/api/randomNumber');    // 后端 生成一个随机数
+ * const param = client.getLoginParam(randomNumber);            // 插件 获取登录参数
+ * const loginResult = await Ajax.GET('/api/pkilogin');         // 后端 登录接口
+ *
+ * 如果 key 未知时，getLoginParam 需要传新的KEY
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JitClient = exports.BROWSER_MODE = void 0;
+var BROWSER_MODE;
+(function (BROWSER_MODE) {
+    BROWSER_MODE[BROWSER_MODE["IE"] = 0] = "IE";
+    BROWSER_MODE[BROWSER_MODE["CHROME"] = 1] = "CHROME";
+    BROWSER_MODE[BROWSER_MODE["CHROME_OLD"] = 2] = "CHROME_OLD";
+})(BROWSER_MODE || (exports.BROWSER_MODE = BROWSER_MODE = {}));
+const pnxclient_1 = require("./pnxclient");
+class JitClient {
+    /**
+     * @param initParam         插件初始化参数，是一个XML字符串，在不同的项目，参数会不同，可以配置在后端返回
+     * @param enablectiveX      是否支持 旧版本 IE ActiveX 登录 , 默认支持
+     * @param enableNPPlugin    是否支持 旧版本 Chrome NppPlugin 登录 ， 默认支持，部分地区不支持
+    */
+    constructor(initParam, enablectiveX = true, enableNPPlugin = true) {
+        // 内置所有已知的吉大KEY
+        this.initParam = `<\?xml version=\"1.0\" encoding=\"utf-8\"\?>
+<authinfo>
+    <liblist>
+        <lib type=\"SKF\" version=\"1.1\" dllname=\"U2h1dHRsZUNzcDExXzMwMDBHTS5kbGw=\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SM3\" />
+        </lib>
+        <lib type=\"CSP\" version=\"1.0\" dllname=\"RkVJVElBTiBlUGFzc05HIENTUCBGb3IgSklUM0sgVjEuMA==\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SHA1\" />
+        </lib>
+        <lib type=\"SKF\" version=\"1.0\" dllname=\"RW50ZXJTYWZlIGVQYXNzMzAwMyBDU1AgdjEuMA==\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SM3\" />
+        </lib>
+        <lib type=\"PM\" version=\"1.0\" dllname=\"Q3J5cHRPY3guZGxs\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SM3\" />
+        </lib>
+        <lib type=\"CSP\" version=\"1.0\" dllname=\"RUlUSUFOIGVQYXNzTkcgUlNBIENyeXB0b2dyYXBoaWMgU2VydmljZSBQcm92aWRlcg==\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SHA1\" />
+        </lib>
+        <lib type=\"CSP\" version=\"1.0\" dllname=\"SklUIFVTQiBLZXkgQ1NQIHYxLjA=\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SHA1\" />
+        </lib>
+        <lib type=\"CSP\" version=\"1.0\" dllname=\"RW50ZXJTYWZlIGVQYXNzMjAwMSBDU1AgdjEuMA==\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SHA1\" />
+        </lib>
+        <lib type=\"CSP\" version=\"1.0\" dllname=\"SklUIFVTQiBLZXkzMDAzIENTUCB2MS4w\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SHA1\" />
+        </lib>
+        <lib type=\"CSP\" version=\"1.0\" dllname=\"RkVJVElBTiBlUGFzc05HIFJTQSBDcnlwdG9ncmFwaGljIFNlcnZpY2UgUHJvdmlkZXI=\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SHA1\" />
+        </lib>
+        <lib type=\"SKF\" version=\"1.1\" dllname=\"ZXNhZmlucy5kbGw=\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SM3\" />
+        </lib>
+        <lib type=\"CSP\" version=\"1.0\" dllname=\"TWljcm9zb2Z0IEVuaGFuY2VkIENyeXB0b2dyYXBoaWMgUHJvdmlkZXIgdjEuMA==\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SHA1\" />
+        </lib>
+        <lib type=\"CSP\" version=\"1.0\" dllname=\"TWljcm9zb2Z0IFN0cm9uZyBDcnlwdG9ncmFwaGljIFByb3ZpZGVy\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SHA1\" />
+        </lib>
+        <lib type=\"CSP\" version=\"1.0\" dllname=\"TWljcm9zb2Z0IEJhc2UgQ3J5cHRvZ3JhcGhpYyBQcm92aWRlciB2MS4w\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SHA1\" />
+        </lib>
+        <lib type=\"SKF\" version=\"1.0\" dllname=\"R0FLRVlfU0tGLmRsbA==\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SM3\" />
+        </lib>
+        <lib type=\"SKF\" version=\"1.0\" dllname=\"L3Vzci9sb2NhbC9saWI2NC9saWJTS0ZfR0FfYXBpLnNv\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SM3\" />
+        </lib>
+        <lib type=\"SKF\" version=\"1.0\" dllname=\"b3B0L0dBU1MvbGliU0tGL2xpYlNLRl9HQV9hcGkuc28=\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SM3\" />
+        </lib>
+        <lib type=\"SKF\" version=\"1.0\" dllname=\"SklUR01LRVlfU0pLMTQyNC5kbGw=\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SM3\" />
+        </lib>
+        <lib type=\"CSP\" version=\"1.1\" dllname=\"ZVNhZmUgQ3J5cHRvZ3JhcGhpYyBTZXJ2aWNlIFByb3ZpZGVyIHYxLjA=\">
+            <algid val=\"SHA1\" sm2_hashalg=\"SHA1\" />
+        </lib>
+    </liblist>
+</authinfo>`;
+        pnxclient_1.JIT_GW_ExtInterface.Init(enablectiveX, enableNPPlugin);
+        if (initParam) {
+            this.initParam = initParam;
+        }
+    }
+    getBrowserInfo() {
+        const userAgent = navigator.userAgent.toLowerCase();
+        if (userAgent.indexOf("chrome") < 0) {
+            // 非 Chrome ： 使用 IE ActiveX 组件
+            // let obj = document.createElement('object');
+            // obj.setAttribute('id', 'JITDSignOcx')
+            // obj.setAttribute('classid', 'clsid:B0EF56AD-D711-412D-BE74-A751595F3633');
+            // document.body.append(obj);
+            return BROWSER_MODE.IE;
+        }
+        let version = 0;
+        userAgent.split(" ").map(ptn => {
+            if (ptn.indexOf("chrome") > -1) {
+                version = parseInt(ptn.split("/")[1]);
+            }
+        });
+        if (version < 45) {
+            // 老旧 Chrome ： 使用 x-vctk 组件
+            // let embed = document.createElement('embed');
+            // embed.setAttribute('width', '0')
+            // embed.setAttribute('height', '0')
+            // embed.setAttribute('id', 'JITDSignOcx')
+            // embed.setAttribute('type', 'application/x-jit-sign-vctk-s-plugin-boc');
+            // document.body.append(embed);
+            return BROWSER_MODE.CHROME_OLD;
+        }
+        // 新版  Chrome ，使用 Chrome 插件
+        return BROWSER_MODE.CHROME;
+    }
+    getLoginParam(randNum, initParam) {
+        var signSubject = ""; //document.getElementById("rootCADN").value;
+        // 验证认证原文是否为空
+        // VCTK初始化参数，数据可从网关系统：认证管理->Key类型管理中导出
+        // 调用网关工具脚本中的detachSignStr方法进行签名，返回签名结果
+        // 参数说明：initParam：vctk控件初始化参数，authContent：认证原文，signSubject：证书版本者主题
+        let signResult = detachSignStr(initParam || this.initParam, randNum, signSubject);
+        if (signResult === false) {
+            return false;
+        }
+        return { original: randNum, signed_data: signResult, authMode: "cert" };
+    }
+}
+exports.JitClient = JitClient;
+// 根据原文和证书产生认证数据包
+// 参数说明：initParam：vctk控件初始化参数
+// 参数说明：authContent：认证原文
+// 参数说明：signSubject：证书版发者主题
+function detachSignStr(initParam, authContent, signSubject) {
+    // 验证认证原文不能为空
+    if (authContent == "") {
+        alert("认证原文不能为空!");
+        return false;
+    }
+    try {
+        pnxclient_1.JIT_GW_ExtInterface.GetVersion();
+    }
+    catch (e) {
+        alert("未安装控件，请进行安装控件");
+        return false;
+    }
+    pnxclient_1.JIT_GW_ExtInterface.ClearFilter();
+    // 初始化vctk控件
+    pnxclient_1.JIT_GW_ExtInterface.Initialize("", initParam);
+    // 控制证书为一个时，不弹出证书选择框
+    pnxclient_1.JIT_GW_ExtInterface.SetChooseSingleCert(1);
+    // 生成签名信息 
+    var sign_Result = pnxclient_1.JIT_GW_ExtInterface.P7SignString(authContent, true, true);
+    if (pnxclient_1.JIT_GW_ExtInterface.GetLastError() != 0) {
+        if (pnxclient_1.JIT_GW_ExtInterface.GetLastError() == 3758096386
+            || pnxclient_1.JIT_GW_ExtInterface.GetLastError() == 2148532334) {
+            alert("用户取消操作");
+            return false;
+        }
+        else if (pnxclient_1.JIT_GW_ExtInterface.GetLastError() == -536870815
+            || pnxclient_1.JIT_GW_ExtInterface.GetLastError() == 3758096481) {
+            alert("没有找到有效的证书，如果使用的是KEY，请确认已经插入key");
+            return false;
+        }
+        else {
+            alert(pnxclient_1.JIT_GW_ExtInterface.GetLastErrorMessage());
+            return false;
+        }
+    }
+    // 返回签名结果
+    return sign_Result;
+}