sm-crypto-v2 0.3.12

package/dist/index.d.ts

@@ -0,0 +1,409 @@
+import { BigInteger, RandomGenerator } from 'jsbn';
+
+/**
+ * 椭圆曲线域元素
+ */
+declare class ECFieldElementFp {
+    q: BigInteger;
+    x: BigInteger;
+    constructor(q: BigInteger, x: BigInteger);
+    /**
+     * 判断相等
+     */
+    equals(other: ECFieldElementFp): boolean;
+    /**
+     * 返回具体数值
+     */
+    toBigInteger(): BigInteger;
+    /**
+     * 取反
+     */
+    negate(): ECFieldElementFp;
+    /**
+     * 相加
+     */
+    add(b: any): ECFieldElementFp;
+    /**
+     * 相减
+     */
+    subtract(b: any): ECFieldElementFp;
+    /**
+     * 相乘
+     */
+    multiply(b: any): ECFieldElementFp;
+    /**
+     * 相除
+     */
+    divide(b: any): ECFieldElementFp;
+    /**
+     * 平方
+     */
+    square(): ECFieldElementFp;
+}
+declare class ECPointFp {
+    curve: ECCurveFp;
+    x: ECFieldElementFp | null;
+    y: ECFieldElementFp | null;
+    zinv: BigInteger | null;
+    z: BigInteger;
+    constructor(curve: ECCurveFp, x: ECFieldElementFp | null, y: ECFieldElementFp | null, z?: BigInteger);
+    getX(): ECFieldElementFp;
+    getY(): ECFieldElementFp;
+    /**
+     * 判断相等
+     */
+    equals(other: ECPointFp): boolean;
+    /**
+     * 是否是无穷远点
+     */
+    isInfinity(): boolean;
+    /**
+     * 取反，x 轴对称点
+     */
+    negate(): ECPointFp;
+    /**
+     * 相加
+     *
+     * 标准射影坐标系：
+     *
+     * λ1 = x1 * z2
+     * λ2 = x2 * z1
+     * λ3 = λ1 − λ2
+     * λ4 = y1 * z2
+     * λ5 = y2 * z1
+     * λ6 = λ4 − λ5
+     * λ7 = λ1 + λ2
+     * λ8 = z1 * z2
+     * λ9 = λ3^2
+     * λ10 = λ3 * λ9
+     * λ11 = λ8 * λ6^2 − λ7 * λ9
+     * x3 = λ3 * λ11
+     * y3 = λ6 * (λ9 * λ1 − λ11) − λ4 * λ10
+     * z3 = λ10 * λ8
+     */
+    add(b: ECPointFp): ECPointFp;
+    /**
+     * 自加
+     *
+     * 标准射影坐标系：
+     *
+     * λ1 = 3 * x1^2 + a * z1^2
+     * λ2 = 2 * y1 * z1
+     * λ3 = y1^2
+     * λ4 = λ3 * x1 * z1
+     * λ5 = λ2^2
+     * λ6 = λ1^2 − 8 * λ4
+     * x3 = λ2 * λ6
+     * y3 = λ1 * (4 * λ4 − λ6) − 2 * λ5 * λ3
+     * z3 = λ2 * λ5
+     */
+    twice(): ECPointFp;
+    /**
+     * 倍点计算
+     */
+    multiply(k: BigInteger): ECPointFp;
+}
+/**
+ * 椭圆曲线 y^2 = x^3 + ax + b
+ */
+declare class ECCurveFp {
+    q: BigInteger;
+    infinity: ECPointFp;
+    a: ECFieldElementFp;
+    b: ECFieldElementFp;
+    constructor(q: BigInteger, a: BigInteger, b: BigInteger);
+    /**
+     * 判断两个椭圆曲线是否相等
+     */
+    equals(other: ECCurveFp): boolean;
+    /**
+     * 生成椭圆曲线域元素
+     */
+    fromBigInteger(x: BigInteger): ECFieldElementFp;
+    /**
+     * 解析 16 进制串为椭圆曲线点
+     */
+    decodePointHex(s: string): ECPointFp | null;
+}
+
+declare module 'jsbn' {
+    class SecureRandom implements RandomGenerator {
+        nextBytes(bytes: number[]): void;
+    }
+}
+/**
+ * 获取公共椭圆曲线
+ */
+declare function getGlobalCurve(): ECCurveFp;
+/**
+ * 生成ecparam
+ */
+declare function generateEcparam(): {
+    curve: ECCurveFp;
+    G: {
+        zinv: BigInteger | null;
+        z: BigInteger;
+        curve: ECCurveFp;
+        x: {
+            /**
+             * 生成ecparam
+             */
+            q: BigInteger;
+            x: BigInteger;
+            equals(other: any): boolean;
+            toBigInteger(): BigInteger;
+            negate(): any;
+            add(b: any): any;
+            subtract(b: any): any;
+            multiply(b: any): any;
+            divide(b: any): any;
+            square(): any;
+        } | null;
+        y: {
+            /**
+             * 生成ecparam
+             */
+            q: BigInteger;
+            x: BigInteger;
+            equals(other: any): boolean;
+            toBigInteger(): BigInteger;
+            negate(): any;
+            add(b: any): any;
+            subtract(b: any): any;
+            multiply(b: any): any;
+            divide(b: any): any;
+            square(): any;
+        } | null;
+        getX(): {
+            /**
+             * 生成ecparam
+             */
+            q: BigInteger;
+            x: BigInteger;
+            equals(other: any): boolean;
+            toBigInteger(): BigInteger;
+            negate(): any;
+            add(b: any): any;
+            subtract(b: any): any;
+            multiply(b: any): any;
+            divide(b: any): any;
+            square(): any;
+        };
+        getY(): {
+            /**
+             * 生成ecparam
+             */
+            q: BigInteger;
+            x: BigInteger;
+            equals(other: any): boolean;
+            toBigInteger(): BigInteger;
+            negate(): any;
+            add(b: any): any;
+            subtract(b: any): any;
+            multiply(b: any): any;
+            divide(b: any): any;
+            square(): any;
+        };
+        equals(other: any): boolean;
+        isInfinity(): boolean;
+        negate(): any;
+        add(b: any): any;
+        twice(): any;
+        multiply(k: BigInteger): any;
+    };
+    n: BigInteger;
+};
+/**
+ * 生成密钥对：publicKey = privateKey * G
+ */
+declare function generateKeyPairHex(a?: number | string, b?: number, c?: RandomGenerator): {
+    privateKey: string;
+    publicKey: string;
+};
+/**
+ * 生成压缩公钥
+ */
+declare function compressPublicKeyHex(s: string): string;
+/**
+ * utf8串转16进制串
+ */
+declare function utf8ToHex(input: string): string;
+/**
+ * 补全16进制字符串
+ */
+declare function leftPad(input: string, num: number): string;
+/**
+ * 转成16进制串
+ */
+declare function arrayToHex(arr: number[]): string;
+/**
+ * 转成utf8串
+ */
+declare function arrayToUtf8(arr: Uint8Array): string;
+/**
+ * 转成字节数组
+ */
+declare function hexToArray(hexStr: string): Uint8Array;
+/**
+ * 验证公钥是否为椭圆曲线上的点
+ */
+declare function verifyPublicKey(publicKey: string): boolean;
+/**
+ * 验证公钥是否等价，等价返回true
+ */
+declare function comparePublicKeyHex(publicKey1: string, publicKey2: string): boolean;
+declare function concatArray(...arrays: Uint8Array[]): Uint8Array;
+
+/**
+ * 加密
+ */
+declare function doEncrypt(msg: string | Uint8Array, publicKey: string, cipherMode?: number): string;
+/**
+ * 解密
+ */
+declare function doDecrypt(encryptData: string, privateKey: string, cipherMode?: number, options?: {
+    output: 'array';
+}): Uint8Array;
+declare function doDecrypt(encryptData: string, privateKey: string, cipherMode?: number, options?: {
+    output: 'string';
+}): string;
+interface SignaturePoint {
+    k: BigInteger;
+    x1: BigInteger;
+}
+/**
+ * 签名
+ */
+declare function doSignature(msg: Uint8Array | string, privateKey: string, options?: {
+    pointPool?: SignaturePoint[];
+    der?: boolean;
+    hash?: boolean;
+    publicKey?: string;
+    userId?: string;
+}): string;
+/**
+ * 验签
+ */
+declare function doVerifySignature(msg: string | Uint8Array, signHex: string, publicKey: string, options?: {
+    der?: boolean;
+    hash?: boolean;
+    userId?: string;
+}): boolean;
+/**
+ * sm3杂凑算法
+ */
+declare function getHash(hashHex: string | Uint8Array, publicKey: string, userId?: string): string;
+/**
+ * 计算公钥
+ */
+declare function getPublicKeyFromPrivateKey(privateKey: string): string;
+/**
+ * 获取椭圆曲线点
+ */
+declare function getPoint(): {
+    k: BigInteger;
+    x1: BigInteger;
+    privateKey: string;
+    publicKey: string;
+};
+
+declare const index$2_doEncrypt: typeof doEncrypt;
+declare const index$2_doDecrypt: typeof doDecrypt;
+type index$2_SignaturePoint = SignaturePoint;
+declare const index$2_doSignature: typeof doSignature;
+declare const index$2_doVerifySignature: typeof doVerifySignature;
+declare const index$2_getHash: typeof getHash;
+declare const index$2_getPublicKeyFromPrivateKey: typeof getPublicKeyFromPrivateKey;
+declare const index$2_getPoint: typeof getPoint;
+declare const index$2_getGlobalCurve: typeof getGlobalCurve;
+declare const index$2_generateEcparam: typeof generateEcparam;
+declare const index$2_generateKeyPairHex: typeof generateKeyPairHex;
+declare const index$2_compressPublicKeyHex: typeof compressPublicKeyHex;
+declare const index$2_utf8ToHex: typeof utf8ToHex;
+declare const index$2_leftPad: typeof leftPad;
+declare const index$2_arrayToHex: typeof arrayToHex;
+declare const index$2_arrayToUtf8: typeof arrayToUtf8;
+declare const index$2_hexToArray: typeof hexToArray;
+declare const index$2_verifyPublicKey: typeof verifyPublicKey;
+declare const index$2_comparePublicKeyHex: typeof comparePublicKeyHex;
+declare const index$2_concatArray: typeof concatArray;
+declare namespace index$2 {
+  export {
+    index$2_doEncrypt as doEncrypt,
+    index$2_doDecrypt as doDecrypt,
+    index$2_SignaturePoint as SignaturePoint,
+    index$2_doSignature as doSignature,
+    index$2_doVerifySignature as doVerifySignature,
+    index$2_getHash as getHash,
+    index$2_getPublicKeyFromPrivateKey as getPublicKeyFromPrivateKey,
+    index$2_getPoint as getPoint,
+    index$2_getGlobalCurve as getGlobalCurve,
+    index$2_generateEcparam as generateEcparam,
+    index$2_generateKeyPairHex as generateKeyPairHex,
+    index$2_compressPublicKeyHex as compressPublicKeyHex,
+    index$2_utf8ToHex as utf8ToHex,
+    index$2_leftPad as leftPad,
+    index$2_arrayToHex as arrayToHex,
+    index$2_arrayToUtf8 as arrayToUtf8,
+    index$2_hexToArray as hexToArray,
+    index$2_verifyPublicKey as verifyPublicKey,
+    index$2_comparePublicKeyHex as comparePublicKeyHex,
+    index$2_concatArray as concatArray,
+  };
+}
+
+/**
+ * 补全16进制字符串
+ */
+/**
+ * utf8 串转字节数组
+ */
+declare function utf8ToArray(str: string): Uint8Array;
+declare function sm3(input: string | Uint8Array, options?: {
+    key: Uint8Array | string;
+    mode?: 'hmac' | 'mac';
+}): string;
+
+declare const index$1_utf8ToArray: typeof utf8ToArray;
+declare const index$1_sm3: typeof sm3;
+declare namespace index$1 {
+  export {
+    index$1_utf8ToArray as utf8ToArray,
+    index$1_sm3 as sm3,
+  };
+}
+
+interface SM4Options {
+    padding?: 'pkcs#7' | 'pkcs#5' | 'none' | null;
+    mode?: 'cbc' | 'ecb';
+    iv?: Uint8Array | string;
+    output?: 'string' | 'array';
+}
+declare function sm4(inArray: Uint8Array | string, key: Uint8Array | string, cryptFlag: 0 | 1, options?: SM4Options): string | Uint8Array;
+declare function encrypt(inArray: Uint8Array | string, key: Uint8Array | string, options?: {
+    output: 'array';
+} | SM4Options): Uint8Array;
+declare function encrypt(inArray: Uint8Array | string, key: Uint8Array | string, options?: {
+    output: 'string';
+} | SM4Options): string;
+declare function decrypt(inArray: Uint8Array | string, key: Uint8Array | string, options?: {
+    output: 'array';
+} | SM4Options): Uint8Array;
+declare function decrypt(inArray: Uint8Array | string, key: Uint8Array | string, options?: {
+    output: 'string';
+} | SM4Options): string;
+
+type index_SM4Options = SM4Options;
+declare const index_sm4: typeof sm4;
+declare const index_encrypt: typeof encrypt;
+declare const index_decrypt: typeof decrypt;
+declare namespace index {
+  export {
+    index_SM4Options as SM4Options,
+    index_sm4 as sm4,
+    index_encrypt as encrypt,
+    index_decrypt as decrypt,
+  };
+}
+
+export { index$2 as sm2, index$1 as sm3, index as sm4 };