@types/node-rsa/index.d.ts

// Type definitions for node-rsa 1.1
// Project: https://github.com/rzcoder/node-rsa
// Definitions by: Ali Taheri <https://github.com/alitaheri>
//                 Christian Moniz <https://github.com/xm>
//                 Florian Imdahl <https://github.com/ffflorian>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2

/// <reference types="node" />

declare class NodeRSA {
    /**
     * Generate new key with length specified.
     */
    constructor(key?: NodeRSA.KeyBits);

    /**
     * Load key from string/buffer/components.
     */
    constructor(key: NodeRSA.Key, format?: NodeRSA.Format, options?: NodeRSA.Options);

    /**
     * Set and validate options for key instance.
     */
    setOptions(options: NodeRSA.Options): void;

    /**
     * @param bits Key size in bits. 2048 by default.
     * @param exponent public exponent. 65537 by default.
     */
    generateKeyPair(bits?: number, exponent?: number): NodeRSA;

    /**
     * Import key from PEM string, PEM/DER Buffer or components.
     */
    importKey(key: NodeRSA.Key, format?: NodeRSA.Format): NodeRSA;

    /**
     * Export key to PEM string, PEM/DER Buffer or components.
     */
    exportKey(format?: NodeRSA.FormatPem): string;
    exportKey(format: NodeRSA.FormatDer): Buffer;
    exportKey(format: NodeRSA.FormatComponentsPrivate): NodeRSA.KeyComponentsPrivate;
    exportKey(format: NodeRSA.FormatComponentsPublic): NodeRSA.KeyComponentsPublic;

    isPrivate(): boolean;

    /**
     * @param strict if true method will return false if key pair have private exponent. Default false.
     */
    isPublic(strict?: boolean): boolean;

    /**
     * Return true if key pair doesn't have any data.
     */
    isEmpty(): boolean;

    /**
     * Return key size in bits.
     */
    getKeySize(): number;

    /**
     * Return max data size for encrypt in bytes.
     */
    getMaxMessageSize(): number;

    encrypt(data: NodeRSA.Data, encoding?: 'buffer'): Buffer;
    encrypt(data: NodeRSA.Data, encoding: NodeRSA.Encoding): string;
    encrypt(data: Buffer, encoding: 'buffer', sourceEncoding?: NodeRSA.Encoding): Buffer;
    encrypt(data: Buffer, encoding: NodeRSA.Encoding, sourceEncoding?: NodeRSA.Encoding): string;

    encryptPrivate(data: NodeRSA.Data, encoding?: 'buffer'): Buffer;
    encryptPrivate(data: NodeRSA.Data, encoding: NodeRSA.Encoding): string;
    encryptPrivate(data: Buffer, encoding: 'buffer', sourceEncoding?: NodeRSA.Encoding): Buffer;
    encryptPrivate(data: Buffer, encoding: NodeRSA.Encoding, sourceEncoding?: NodeRSA.Encoding): string;

    decrypt(data: Buffer | string, encoding?: 'buffer'): Buffer;
    decrypt(data: Buffer | string, encoding: NodeRSA.Encoding): string;
    decrypt<T extends object>(data: Buffer | string, encoding: 'json'): T;

    decryptPublic(data: Buffer | string, encoding?: 'buffer'): Buffer;
    decryptPublic(data: Buffer | string, encoding: NodeRSA.Encoding): string;
    decryptPublic<T extends object>(data: Buffer | string, encoding: 'json'): T;

    sign(data: NodeRSA.Data, encoding?: 'buffer'): Buffer;
    sign(data: NodeRSA.Data, encoding: NodeRSA.Encoding): string;
    sign(data: Buffer, encoding: 'buffer', sourceEncoding?: NodeRSA.Encoding): Buffer;
    sign(data: Buffer, encoding: NodeRSA.Encoding, sourceEncoding?: NodeRSA.Encoding): string;

    verify(data: NodeRSA.Data, signature: Buffer): boolean;
    verify(data: Buffer, signature: Buffer, sourceEncoding?: NodeRSA.Encoding): boolean;
    verify(
        data: Buffer,
        signature: string,
        sourceEncoding: NodeRSA.Encoding,
        signatureEncoding: NodeRSA.Encoding,
    ): boolean;
    verify(
        data: NodeRSA.Data,
        signature: string,
        sourceEncoding: undefined,
        signatureEncoding: NodeRSA.Encoding,
    ): boolean;
}

declare namespace NodeRSA {
    type Key = string | Buffer | KeyComponentsPrivate | KeyComponentsPublic;
    type Data = string | object | any[];

    type FormatPem =
        | 'private'
        | 'public'
        | 'pkcs1'
        | 'pkcs1-pem'
        | 'pkcs1-private'
        | 'pkcs1-private-pem'
        | 'pkcs1-public'
        | 'pkcs1-public-pem'
        | 'pkcs8'
        | 'pkcs8-pem'
        | 'pkcs8-private'
        | 'pkcs8-private-pem'
        | 'pkcs8-public'
        | 'pkcs8-public-pem'
        | 'openssh-public'
        | 'openssh-private';
    type FormatDer =
        | 'pkcs1-der'
        | 'pkcs1-private-der'
        | 'pkcs1-public-der'
        | 'pkcs8-der'
        | 'pkcs8-private-der'
        | 'pkcs8-public-der';
    type FormatComponentsPrivate =
        | 'components'
        | 'components-pem'
        | 'components-der'
        | 'components-private'
        | 'components-private-pem'
        | 'components-private-der';
    type FormatComponentsPublic = 'components-public' | 'components-public-pem' | 'components-public-der';
    type Format = FormatPem | FormatDer | FormatComponentsPrivate | FormatComponentsPublic;

    type EncryptionScheme = 'pkcs1_oaep' | 'pkcs1';

    type HashingAlgorithm = 'ripemd160' | 'md4' | 'md5' | 'sha1' | 'sha224' | 'sha256' | 'sha384' | 'sha512';

    type SigningScheme = 'pkcs1' | 'pss';

    type SigningSchemeHash =
        | 'pkcs1-ripemd160'
        | 'pkcs1-md4'
        | 'pkcs1-md5'
        | 'pkcs1-sha'
        | 'pkcs1-sha1'
        | 'pkcs1-sha224'
        | 'pkcs1-sha256'
        | 'pkcs1-sha384'
        | 'pkcs1-sha512'
        | 'pss-ripemd160'
        | 'pss-md4'
        | 'pss-md5'
        | 'pss-sha'
        | 'pss-sha1'
        | 'pss-sha224'
        | 'pss-sha256'
        | 'pss-sha384'
        | 'pss-sha512';

    type Encoding = 'ascii' | 'utf8' | 'utf16le' | 'ucs2' | 'latin1' | 'base64' | 'hex' | 'binary' | 'buffer';

    interface KeyComponentsPrivate {
        n: Buffer;
        e: Buffer | number;
        d: Buffer;
        p: Buffer;
        q: Buffer;
        dmp1: Buffer;
        dmq1: Buffer;
        coeff: Buffer;
    }

    interface KeyComponentsPublic {
        n: Buffer;
        e: Buffer | number;
    }

    interface KeyBits {
        /**
         * The length of the key in bits.
         */
        b: number;
    }

    interface AdvancedEncryptionSchemePKCS1 {
        scheme: 'pkcs1';
        padding: number;
    }

    interface AdvancedEncryptionSchemePKCS1OAEP {
        scheme: 'pkcs1_oaep';
        hash: HashingAlgorithm;

        /**
         * Mask generation function.
         */
        mgf?(data: Buffer, length: number, hash: HashingAlgorithm): Buffer;
    }

    type AdvancedEncryptionScheme = AdvancedEncryptionSchemePKCS1 | AdvancedEncryptionSchemePKCS1OAEP;

    interface AdvancedSigningSchemePSS {
        scheme: 'pss';
        hash: HashingAlgorithm;
        saltLength: number;
    }

    interface AdvancedSigningSchemePKCS1 {
        scheme: 'pkcs1';
        hash: HashingAlgorithm;
    }

    type AdvancedSigningScheme = AdvancedSigningSchemePSS | AdvancedSigningSchemePKCS1;

    interface Options {
        /**
         * Working environment. (auto detects by default)
         */
        environment?: 'browser' | 'node' | undefined;

        /**
         * Padding scheme for encrypt/decrypt. Default is 'pkcs1_oaep'.
         */
        encryptionScheme?: EncryptionScheme | AdvancedEncryptionScheme | undefined;

        /**
         * scheme used for signing and verifying.. Default 'pkcs1-sha256', or, if chosen pss: 'pss-sha1'.
         */
        signingScheme?: SigningScheme | SigningSchemeHash | AdvancedSigningScheme | undefined;
    }
}

export = NodeRSA;