@ray-js/wechat-rsa 0.0.1-beta-1

package/src/lib/jsbn/base64.d.ts

@@ -0,0 +1,3 @@
+export declare function hex2b64(h: string): string;
+export declare function b64tohex(s: string): string;
+export declare function b64toBA(s: string): number[];

package/src/lib/jsbn/jsbn.d.ts

@@ -0,0 +1,98 @@
+import { SecureRandom } from './rng';
+export declare class BigInteger {
+    constructor(a: number | number[] | string | null, b?: number | SecureRandom, c?: number | SecureRandom);
+    toString(b: number): string;
+    protected negate(): BigInteger;
+    abs(): BigInteger;
+    compareTo(a: BigInteger): number;
+    bitLength(): number;
+    mod(a: BigInteger): BigInteger;
+    modPowInt(e: number, m: BigInteger): BigInteger;
+    protected clone(): BigInteger;
+    protected intValue(): number;
+    protected byteValue(): number;
+    protected shortValue(): number;
+    protected signum(): 1 | 0 | -1;
+    toByteArray(): number[];
+    protected equals(a: BigInteger): boolean;
+    protected min(a: BigInteger): BigInteger;
+    protected max(a: BigInteger): BigInteger;
+    protected and(a: BigInteger): BigInteger;
+    protected or(a: BigInteger): BigInteger;
+    protected xor(a: BigInteger): BigInteger;
+    protected andNot(a: BigInteger): BigInteger;
+    protected not(): BigInteger;
+    protected shiftLeft(n: number): BigInteger;
+    protected shiftRight(n: number): BigInteger;
+    protected getLowestSetBit(): number;
+    protected bitCount(): number;
+    protected testBit(n: number): boolean;
+    protected setBit(n: number): BigInteger;
+    protected clearBit(n: number): BigInteger;
+    protected flipBit(n: number): BigInteger;
+    add(a: BigInteger): BigInteger;
+    subtract(a: BigInteger): BigInteger;
+    multiply(a: BigInteger): BigInteger;
+    divide(a: BigInteger): BigInteger;
+    protected remainder(a: BigInteger): BigInteger;
+    protected divideAndRemainder(a: BigInteger): BigInteger[];
+    modPow(e: BigInteger, m: BigInteger): BigInteger;
+    modInverse(m: BigInteger): BigInteger;
+    protected pow(e: number): BigInteger;
+    gcd(a: BigInteger): BigInteger;
+    isProbablePrime(t: number): boolean;
+    copyTo(r: BigInteger): void;
+    fromInt(x: number): void;
+    protected fromString(s: string | number[], b: number): void;
+    clamp(): void;
+    dlShiftTo(n: number, r: BigInteger): void;
+    drShiftTo(n: number, r: BigInteger): void;
+    protected lShiftTo(n: number, r: BigInteger): void;
+    protected rShiftTo(n: number, r: BigInteger): void;
+    subTo(a: BigInteger, r: BigInteger): void;
+    multiplyTo(a: BigInteger, r: BigInteger): void;
+    squareTo(r: BigInteger): void;
+    divRemTo(m: BigInteger, q: BigInteger | null, r: BigInteger | null): void;
+    invDigit(): number;
+    protected isEven(): boolean;
+    protected exp(e: number, z: IReduction): BigInteger;
+    protected chunkSize(r: number): number;
+    protected toRadix(b: number): string;
+    fromRadix(s: string, b: number): void;
+    protected fromNumber(a: number, b: number | SecureRandom, c?: number | SecureRandom): void;
+    protected bitwiseTo(a: BigInteger, op: (a: number, b: number) => number, r: BigInteger): void;
+    protected changeBit(n: number, op: (a: number, b: number) => number): BigInteger;
+    protected addTo(a: BigInteger, r: BigInteger): void;
+    protected dMultiply(n: number): void;
+    dAddOffset(n: number, w: number): void;
+    multiplyLowerTo(a: BigInteger, n: number, r: BigInteger): void;
+    multiplyUpperTo(a: BigInteger, n: number, r: BigInteger): void;
+    protected modInt(n: number): number;
+    protected millerRabin(t: number): boolean;
+    protected square(): BigInteger;
+    gcda(a: BigInteger, callback: (x: BigInteger) => void): void;
+    fromNumberAsync(a: number, b: number | SecureRandom, c: number | SecureRandom, callback: () => void): void;
+    am(i: number, x: number, w: BigInteger, j: number, c: number, n: number): number;
+    s: number;
+    t: number;
+    DB: number;
+    DM: number;
+    DV: number;
+    FV: number;
+    F1: number;
+    F2: number;
+    [index: number]: number;
+    static ONE: BigInteger;
+    static ZERO: BigInteger;
+}
+export interface IReduction {
+    convert(x: BigInteger): BigInteger;
+    revert(x: BigInteger): BigInteger;
+    mulTo(x: BigInteger, y: BigInteger, r: BigInteger): void;
+    sqrTo(x: BigInteger, r: BigInteger): void;
+}
+export declare function nbi(): BigInteger;
+export declare function parseBigInt(str: string, r: number): BigInteger;
+export declare function intAt(s: string, i: number): number;
+export declare function nbv(i: number): BigInteger;
+export declare function nbits(x: number): number;

package/src/lib/jsbn/prng4.d.ts

@@ -0,0 +1,10 @@
+export declare class Arcfour {
+    constructor();
+    init(key: number[]): void;
+    next(): number;
+    private i;
+    private j;
+    private S;
+}
+export declare function prng_newstate(): Arcfour;
+export declare const rng_psize = 256;

package/src/lib/jsbn/rng.d.ts

@@ -0,0 +1,3 @@
+export declare class SecureRandom {
+    nextBytes(ba: number[]): void;
+}

package/src/lib/jsbn/rsa.d.ts

@@ -0,0 +1,16 @@
+import { BigInteger } from './jsbn';
+export declare class RSAKey {
+    doPublic(x: BigInteger): BigInteger | null;
+    setPublic(N: string, E: string): void;
+    encrypt(text: string): string | null;
+    protected n?: BigInteger;
+    protected e: number;
+    protected d: BigInteger;
+    protected p: BigInteger;
+    protected q: BigInteger;
+    protected dmp1: BigInteger;
+    protected dmq1: BigInteger;
+    protected coeff: BigInteger;
+    generate(B: number, E: string): void;
+    generateAsync(B: number, E: string, callback: () => void): void;
+}

package/src/lib/jsbn/util.d.ts

@@ -0,0 +1,7 @@
+export declare function int2char(n: number): string;
+export declare function op_and(x: number, y: number): number;
+export declare function op_or(x: number, y: number): number;
+export declare function op_xor(x: number, y: number): number;
+export declare function op_andnot(x: number, y: number): number;
+export declare function lbit(x: number): number;
+export declare function cbit(x: number): number;