@types/node-forge

Version 1.3.2
Published 2 months ago
60.3 kB
1 dependency
MIT license

Install

npm i @types/node-forge

yarn add @types/node-forge

pnpm add @types/node-forge

Overview

TypeScript definitions for node-forge

Index

Namespaces

node-forge
- Base64
- Byte
- Bytes
- Encoding
- Hex
- md
- md5
- OID
- sha1
- sha256
- sha384
- sha512
- Utf8
node-forge.asn1
node-forge.cipher
node-forge.hmac
node-forge.jsbn
- BigInteger
- RandomGenerator
node-forge.kem
node-forge.kem.rsa
node-forge.md
- Algorithm
- MessageDigest
node-forge.md.md5
- Algorithm
- MessageDigest
node-forge.md.sha1
- Algorithm
- MessageDigest
node-forge.md.sha256
- Algorithm
- MessageDigest
node-forge.md.sha512
node-forge.md.sha512.Algorithm
node-forge.md.sha512.AlgorithmSelection
node-forge.mgf
node-forge.mgf.mgf1
- create()
node-forge.pem
node-forge.pkcs12
node-forge.pkcs5
- pbkdf2()
node-forge.pkcs7
node-forge.pki
node-forge.pki.ed25519
node-forge.pki.ed25519.constants
node-forge.pki.rsa
node-forge.pss
- create()
- PSS
node-forge.random
node-forge.rc2
node-forge.ssh
node-forge.tls
node-forge.tls.Alert
- Description
- Level
node-forge.util
node-forge.util.binary
node-forge.util.binary.base64
- decode()
- encode()
node-forge.util.binary.hex
- decode()
- encode()
node-forge.util.binary.raw
- decode()
- encode()
node-forge.util.text
node-forge.util.text.utf16
- decode()
- encode()
node-forge.util.text.utf8
- decode()
- encode()

Namespaces

namespace node-forge

module 'node-forge' {}

variable md

const md: {
    sha1: { create(): md.sha1.MessageDigest };
    sha256: { create(): md.sha256.MessageDigest };
    sha512: {
        create<TAlg extends md.sha512.AlgorithmSelection = 'SHA-512'>(
            algorithm?: TAlg
        ): TAlg extends 'SHA-384'
            ? md.sha512.Sha384MessageDigest
            : TAlg extends 'SHA-512/224'
            ? md.sha512.Sha512224MessageDigest
            : TAlg extends 'SHA-512/256'
            ? md.sha512.Sha512256MessageDigest
            : TAlg extends 'SHA-512'
            ? md.sha512.Sha512MessageDigest
            : never;
        sha224: { create(): md.sha512.Sha512224MessageDigest };
        sha256: { create(): md.sha512.Sha512256MessageDigest };
        sha384: { create(): md.sha512.Sha384MessageDigest };
    };
    sha384: typeof md.sha512.sha384;
    'sha512/224': typeof md.sha512.sha224;
    'sha512/256': typeof md.sha512.sha256;
    md5: { create(): md.md5.MessageDigest };
    algorithms: {
        md5: typeof md.md5;
        sha1: typeof md.sha1;
        sha256: typeof md.sha256;
        sha384: typeof md.sha384;
        sha512: typeof md.sha512;
        'sha512/224': typeof md['sha512/224'];
        'sha512/256': typeof md['sha512/256'];
    };
};

variable md5

const md5: { create(): md.md5.MessageDigest };

variable sha1

const sha1: { create(): md.sha1.MessageDigest };

variable sha256

const sha256: { create(): md.sha256.MessageDigest };

variable sha384

const sha384: { create(): md.sha512.Sha384MessageDigest };

variable sha512

const sha512: {
    create<TAlg extends md.sha512.AlgorithmSelection = 'SHA-512'>(
        algorithm?: TAlg
    ): TAlg extends 'SHA-384'
        ? md.sha512.Sha384MessageDigest
        : TAlg extends 'SHA-512/224'
        ? md.sha512.Sha512224MessageDigest
        : TAlg extends 'SHA-512/256'
        ? md.sha512.Sha512256MessageDigest
        : TAlg extends 'SHA-512'
        ? md.sha512.Sha512MessageDigest
        : never;
    sha224: { create(): md.sha512.Sha512224MessageDigest };
    sha256: { create(): md.sha512.Sha512256MessageDigest };
    sha384: { create(): md.sha512.Sha384MessageDigest };
};

type Base64

type Base64 = string;

type Byte

type Byte = number;

type Bytes

type Bytes = string;

type Encoding

type Encoding = 'raw' | 'utf8';

type Hex

type Hex = string;

type OID

type OID = string;

type Utf8

type Utf8 = string;

namespace node-forge.asn1

namespace node-forge.asn1 {}

function create

create: (
    tagClass: Class,
    type: Type,
    constructed: boolean,
    value: Bytes | Asn1[]
) => Asn1;

function derToOid

derToOid: (der: util.ByteStringBuffer) => OID;

function fromDer

fromDer: (bytes: Bytes | util.ByteBuffer, strict?: boolean) => Asn1;

function oidToDer

oidToDer: (oid: OID) => util.ByteStringBuffer;

function toDer

toDer: (obj: Asn1) => util.ByteBuffer;

interface Asn1

interface Asn1 {}

property composed

composed: boolean;

property constructed

constructed: boolean;

property tagClass

tagClass: Class;

property type

type: Type;

property value

value: Bytes | Asn1[];

enum Class

enum Class {
    UNIVERSAL = 0x00,
    APPLICATION = 0x40,
    CONTEXT_SPECIFIC = 0x80,
    PRIVATE = 0xc0,
}

member APPLICATION

APPLICATION = 0x40

member CONTEXT_SPECIFIC

CONTEXT_SPECIFIC = 0x80

member PRIVATE

PRIVATE = 0xc0

member UNIVERSAL

UNIVERSAL = 0x00

enum Type

enum Type {
    NONE = 0,
    BOOLEAN = 1,
    INTEGER = 2,
    BITSTRING = 3,
    OCTETSTRING = 4,
    NULL = 5,
    OID = 6,
    ODESC = 7,
    EXTERNAL = 8,
    REAL = 9,
    ENUMERATED = 10,
    EMBEDDED = 11,
    UTF8 = 12,
    ROID = 13,
    SEQUENCE = 16,
    SET = 17,
    PRINTABLESTRING = 19,
    IA5STRING = 22,
    UTCTIME = 23,
    GENERALIZEDTIME = 24,
    BMPSTRING = 30,
}

member BITSTRING

BITSTRING = 3

member BMPSTRING

BMPSTRING = 30

member BOOLEAN

BOOLEAN = 1

member EMBEDDED

EMBEDDED = 11

member ENUMERATED

ENUMERATED = 10

member EXTERNAL

EXTERNAL = 8

member GENERALIZEDTIME

GENERALIZEDTIME = 24

member IA5STRING

IA5STRING = 22

member INTEGER

INTEGER = 2

member NONE

NONE = 0

member NULL

NULL = 5

member OCTETSTRING

OCTETSTRING = 4

member ODESC

ODESC = 7

member OID

OID = 6

member PRINTABLESTRING

PRINTABLESTRING = 19

member REAL

REAL = 9

member ROID

ROID = 13

member SEQUENCE

SEQUENCE = 16

member SET

SET = 17

member UTCTIME

UTCTIME = 23

member UTF8

UTF8 = 12

namespace node-forge.cipher

namespace node-forge.cipher {}

function createCipher

createCipher: (
    algorithm: Algorithm,
    payload: util.ByteBuffer | Bytes
) => BlockCipher;

function createDecipher

createDecipher: (
    algorithm: Algorithm,
    payload: util.ByteBuffer | Bytes
) => BlockCipher;

interface BlockCipher

interface BlockCipher {}

property finish

finish: () => boolean;

property mode

mode: Mode;

property output

output: util.ByteStringBuffer;

property start

start: (options?: StartOptions) => void;

property update

update: (payload: util.ByteBuffer) => void;

interface Mode

interface Mode {}

property tag

tag: util.ByteStringBuffer;

interface StartOptions

interface StartOptions {}

property additionalData

additionalData?: string | undefined;

property iv

iv?: util.ByteBuffer | Byte[] | Bytes | undefined;

property tag

tag?: util.ByteStringBuffer | undefined;

property tagLength

tagLength?: number | undefined;

type Algorithm

type Algorithm =
    | 'AES-ECB'
    | 'AES-CBC'
    | 'AES-CFB'
    | 'AES-OFB'
    | 'AES-CTR'
    | 'AES-GCM'
    | '3DES-ECB'
    | '3DES-CBC'
    | 'DES-ECB'
    | 'DES-CBC';

namespace node-forge.hmac

namespace node-forge.hmac {}

function create

create: () => HMAC;

interface HMAC

interface HMAC {}

method digest

digest: () => util.ByteBuffer;

method getMac

getMac: () => util.ByteBuffer;

method start

start: (
    md: Algorithm | md.MessageDigest,
    key: string | util.ByteBuffer | null
) => void;

method update

update: (bytes: string) => void;

type Algorithm

type Algorithm = md.Algorithm;

namespace node-forge.jsbn

namespace node-forge.jsbn {}

class BigInteger

class BigInteger {}

constructor

constructor(a: null);

constructor

constructor(a: number, c: RandomGenerator);

constructor

constructor(a: number, b: number, c: RandomGenerator);

constructor

constructor(a: string, b?: number);

constructor

constructor(a: number[], b?: number);

constructor

constructor(a: BigInteger);

property data

data: number[];

property ONE

static ONE: BigInteger;

property s

s: number;

property t

t: number;

property ZERO

static ZERO: BigInteger;

method abs

abs: () => BigInteger;

method add

add: (a: BigInteger) => BigInteger;

method am

am: (
    i: number,
    x: number,
    w: BigInteger,
    j: number,
    c: number,
    n: number
) => number;

method and

and: (a: BigInteger) => BigInteger;

method andNot

andNot: (a: BigInteger) => BigInteger;

method bitCount

bitCount: () => number;

method bitLength

bitLength: { (): number; (): number };

method byteValue

byteValue: () => number;

method clearBit

clearBit: (n: number) => BigInteger;

method clone

clone: () => BigInteger;

method compareTo

compareTo: (a: BigInteger) => number;

method divide

divide: (a: BigInteger) => BigInteger;

method divideAndRemainder

divideAndRemainder: (a: BigInteger) => BigInteger[];

method equals

equals: (a: BigInteger) => boolean;

method flipBit

flipBit: (n: number) => BigInteger;

method gcd

gcd: (a: BigInteger) => BigInteger;

method getLowestSetBit

getLowestSetBit: () => number;

method intValue

intValue: () => number;

method isProbablePrime

isProbablePrime: (t: number) => boolean;

method max

max: (a: BigInteger) => BigInteger;

method min

min: (a: BigInteger) => BigInteger;

method mod

mod: (a: BigInteger) => BigInteger;

method modInverse

modInverse: (m: BigInteger) => BigInteger;

method modPow

modPow: (e: BigInteger, m: BigInteger) => BigInteger;

method modPowInt

modPowInt: (e: number, m: BigInteger) => BigInteger;

method multiply

multiply: (a: BigInteger) => BigInteger;

method negate

negate: () => BigInteger;

method not

not: () => BigInteger;

method or

or: (a: BigInteger) => BigInteger;

method pow

pow: (e: number) => BigInteger;

method remainder

remainder: (a: BigInteger) => BigInteger;

method shiftLeft

shiftLeft: (n: number) => BigInteger;

method shiftRight

shiftRight: (n: number) => BigInteger;

method shortValue

shortValue: () => number;

method signum

signum: () => number;

method squareTo

squareTo: (a: BigInteger) => BigInteger;

method subtract

subtract: (a: BigInteger) => BigInteger;

method testBit

testBit: (n: number) => boolean;

method toByteArray

toByteArray: () => number[];

method toString

toString: (b?: number) => string;

method xor

xor: (a: BigInteger) => BigInteger;

interface RandomGenerator

interface RandomGenerator {}

method nextBytes

nextBytes: (bytes: number[]) => void;

namespace node-forge.kem

namespace node-forge.kem {}

class kdf1

class kdf1 implements KDF {}

Creates a key derivation API object that implements KDF1 per ISO 18033-2.
Parameter md
the hash API to use.
Parameter digestLength
a digest length that must be positive and less than or equal to md.digestLength.
a KDF1 API object.

constructor

constructor(md: md.MessageDigest, digestLength?: number);

method generate

generate: (x: string, length: number) => string;

Generate a key of the specified length.
Parameter x
the binary-encoded byte string to generate a key from.
Parameter length
the number of bytes to generate (the size of the key).
the key as a binary-encoded string.

class kdf2

class kdf2 implements KDF {}

Creates a key derivation API object that implements KDF2 per ISO 18033-2.
Parameter md
the hash API to use.
Parameter digestLength
a digest length that must be positive and less than or equal to md.digestLength.
a KDF2 API object.

constructor

constructor(md: md.MessageDigest, digestLength?: number);

method generate

generate: (x: string, length: number) => string;

Generate a key of the specified length.
Parameter x
the binary-encoded byte string to generate a key from.
Parameter length
the number of bytes to generate (the size of the key).
the key as a binary-encoded string.

interface EncryptResult

interface EncryptResult {}

property encapsulation

encapsulation: string;

The ciphertext for generating the secret key, as a binary-encoded string of bytes.

property key

key: string;

The secret key to use for encrypting a message.

interface KDF

interface KDF {}

method generate

generate: (x: string, length: number) => string;

Generate a key of the specified length.
Parameter x
the binary-encoded byte string to generate a key from.
Parameter length
the number of bytes to generate (the size of the key).
the key as a binary-encoded string.

namespace node-forge.kem.rsa

namespace node-forge.kem.rsa {}

function create

create: (kdf: KDF, options?: Options) => kem;

Creates an RSA KEM API object for generating a secret asymmetric key.
The symmetric key may be generated via a call to 'encrypt', which will produce a ciphertext to be transmitted to the recipient and a key to be kept secret. The ciphertext is a parameter to be passed to 'decrypt' which will produce the same secret key for the recipient to use to decrypt a message that was encrypted with the secret key.
Parameter kdf
the KDF API to use (eg: new forge.kem.kdf1()).
Parameter options
the options to use.

interface kem

interface kem {}

method decrypt

decrypt: (
    privateKey: pki.rsa.PrivateKey,
    encapsulation: string,
    keyLength: number
) => string;

Decrypts an encapsulated secret key.
Parameter privateKey
the RSA private key to decrypt with.
Parameter encapsulation
the ciphertext for generating the secret key, as a binary-encoded string of bytes.
Parameter keyLength
the length, in bytes, of the secret key to generate.
the secret key as a binary-encoded string of bytes.

method encrypt

encrypt: (publicKey: pki.rsa.PublicKey, keyLength: number) => EncryptResult;

Generates a secret key and its encapsulation.
Parameter publicKey
the RSA public key to encrypt with.
Parameter keyLength
the length, in bytes, of the secret key to generate.

interface Options

interface Options {}

property prng

prng?: random | undefined;

A custom crypto-secure pseudo-random number generator to use.

interface random

interface random {}

method getBytesSync

getBytesSync: (count: number) => Bytes;

namespace node-forge.md

namespace node-forge.md {}

interface MessageDigest

interface MessageDigest {}

property algorithm

readonly algorithm: Algorithm;

property blockLength

readonly blockLength: number;

property digestLength

readonly digestLength: number;

property fullMessageLength

fullMessageLength: number[] | null;

property messageLength

messageLength: number;

property messageLengthSize

readonly messageLengthSize: number;

method digest

digest: () => util.ByteStringBuffer;

method update

update: (msg: string, encoding?: Encoding) => this;

type Algorithm

type Algorithm =
    | md5.Algorithm
    | sha1.Algorithm
    | sha256.Algorithm
    | sha512.Algorithm;

namespace node-forge.md.md5

namespace node-forge.md.md5 {}

interface MessageDigest

interface MessageDigest extends md.MessageDigest {}

property algorithm

readonly algorithm: Algorithm;

property blockLength

readonly blockLength: 64;

property digestLength

readonly digestLength: 16;

property messageLengthSize

readonly messageLengthSize: 8;

type Algorithm

type Algorithm = 'md5';

namespace node-forge.md.sha1

namespace node-forge.md.sha1 {}

interface MessageDigest

interface MessageDigest extends md.MessageDigest {}

property algorithm

readonly algorithm: Algorithm;

property blockLength

readonly blockLength: 64;

property digestLength

readonly digestLength: 20;

property messageLengthSize

readonly messageLengthSize: 8;

type Algorithm

type Algorithm = 'sha1';

namespace node-forge.md.sha256

namespace node-forge.md.sha256 {}

interface MessageDigest

interface MessageDigest extends md.MessageDigest {}

property algorithm

readonly algorithm: Algorithm;

property blockLength

readonly blockLength: 64;

property digestLength

readonly digestLength: 32;

property messageLengthSize

readonly messageLengthSize: 8;

type Algorithm

type Algorithm = 'sha256';

namespace node-forge.md.sha512

namespace node-forge.md.sha512 {}

interface MessageDigest

interface MessageDigest extends md.MessageDigest {}

property algorithm

readonly algorithm: Algorithm;

property blockLength

readonly blockLength: 128;

property messageLengthSize

readonly messageLengthSize: 16;

interface Sha384MessageDigest

interface Sha384MessageDigest extends MessageDigest {}

property algorithm

readonly algorithm: Algorithm.Sha384;

property digestLength

readonly digestLength: 48;

interface Sha512224MessageDigest

interface Sha512224MessageDigest extends MessageDigest {}

property algorithm

readonly algorithm: Algorithm.Sha512224;

property digestLength

readonly digestLength: 28;

interface Sha512256MessageDigest

interface Sha512256MessageDigest extends MessageDigest {}

property algorithm

readonly algorithm: Algorithm.Sha512256;

property digestLength

readonly digestLength: 32;

interface Sha512MessageDigest

interface Sha512MessageDigest extends MessageDigest {}

property algorithm

readonly algorithm: Algorithm.Sha512;

property digestLength

readonly digestLength: 64;

type Algorithm

type Algorithm =
    | Algorithm.Sha384
    | Algorithm.Sha512
    | Algorithm.Sha512224
    | Algorithm.Sha512256;

type AlgorithmSelection

type AlgorithmSelection =
    | AlgorithmSelection.Sha384
    | AlgorithmSelection.Sha512
    | AlgorithmSelection.Sha512224
    | AlgorithmSelection.Sha512256;

namespace node-forge.md.sha512.Algorithm

namespace node-forge.md.sha512.Algorithm {}

type Sha384

type Sha384 = 'sha384';

type Sha512

type Sha512 = 'sha512';

type Sha512224

type Sha512224 = 'sha512/224';

type Sha512256

type Sha512256 = 'sha512/256';

namespace node-forge.md.sha512.AlgorithmSelection

namespace node-forge.md.sha512.AlgorithmSelection {}

type Sha384

type Sha384 = 'SHA-384';

type Sha512

type Sha512 = 'SHA-512';

type Sha512224

type Sha512224 = 'SHA-512/224';

type Sha512256

type Sha512256 = 'SHA-512/256';

namespace node-forge.mgf

namespace node-forge.mgf {}

namespace node-forge.mgf.mgf1

namespace node-forge.mgf.mgf1 {}

function create

create: (any: any) => any;

namespace node-forge.pem

namespace node-forge.pem {}

function decode

decode: (str: string) => ObjectPEM[];

function encode

encode: (msg: ObjectPEM, options?: EncodeOptions) => string;

interface EncodeOptions

interface EncodeOptions {}

property maxline

maxline?: number | undefined;

interface ObjectPEM

interface ObjectPEM {}

property body

body: Bytes;

property contentDomain

contentDomain?: any;

property dekInfo

dekInfo?: any;

property headers

headers?: any[] | undefined;

property procType

procType?: any;

property type

type: string;

namespace node-forge.pkcs12

namespace node-forge.pkcs12 {}

function generateKey

generateKey: (
    password: string | null | undefined,
    salt: util.ByteBuffer,
    id: Byte,
    iter: number,
    n: number,
    md?: md.MessageDigest
) => util.ByteBuffer;

function pkcs12FromAsn1

pkcs12FromAsn1: {
    (obj: any, strict?: boolean, password?: string): Pkcs12Pfx;
    (obj: any, password?: string): Pkcs12Pfx;
};

function toPkcs12Asn1

toPkcs12Asn1: (
    key: pki.PrivateKey | null,
    cert: pki.Certificate | pki.Certificate[],
    password: string | null,
    options?: {
        algorithm?: 'aes128' | 'aes192' | 'aes256' | '3des' | undefined;
        count?: number | undefined;
        saltSize?: number | undefined;
        useMac?: boolean | undefined;
        localKeyId?: Hex | undefined;
        friendlyName?: string | undefined;
        generateLocalKeyId?: boolean | undefined;
    }
) => asn1.Asn1;

interface Bag

interface Bag {}

property asn1

asn1: asn1.Asn1;

property attributes

attributes: any;

property cert

cert?: pki.Certificate | undefined;

property key

key?: pki.PrivateKey | undefined;

property type

type: string;

interface BagsFilter

interface BagsFilter {}

property bagType

bagType?: string | undefined;

property friendlyName

friendlyName?: string | undefined;

property localKeyId

localKeyId?: string | undefined;

property localKeyIdHex

localKeyIdHex?: string | undefined;

interface Pkcs12Pfx

interface Pkcs12Pfx {}

property getBags

getBags: (filter: BagsFilter) => {
    [key: string]: Bag[] | undefined;
    localKeyId?: Bag[] | undefined;
    friendlyName?: Bag[] | undefined;
};

property getBagsByFriendlyName

getBagsByFriendlyName: (fiendlyName: string, bagType: string) => Bag[];

property getBagsByLocalKeyId

getBagsByLocalKeyId: (localKeyId: string, bagType: string) => Bag[];

property safeContents

safeContents: {
    encrypted: boolean;
    safeBags: Bag[];
}[];

property version

version: string;

namespace node-forge.pkcs5

namespace node-forge.pkcs5 {}

function pbkdf2

pbkdf2: {
    (password: string, salt: string, iterations: number, keySize: number): string;
    (
        password: string,
        salt: string,
        iterations: number,
        keySize: number,
        messageDigest: md.MessageDigest | md.Algorithm
    ): string;
    (
        password: string,
        salt: string,
        iterations: number,
        keySize: number,
        callback: (err: Error, dk: string) => any
    ): void;
    (
        password: string,
        salt: string,
        iterations: number,
        keySize: number,
        messageDigest?: md.MessageDigest | md.Algorithm,
        callback?: (err: Error, dk: string) => any
    ): void;
};

namespace node-forge.pkcs7

namespace node-forge.pkcs7 {}

function createEnvelopedData

createEnvelopedData: () => PkcsEnvelopedData;

function createSignedData

createSignedData: () => PkcsSignedData;

function messageFromAsn1

messageFromAsn1: (
    asn: asn1.Asn1
) => Captured<PkcsEnvelopedData | PkcsSignedData>;

Converts a PKCS#7 message from an ASN.1 object.
Parameter asn
the ASN.1 representation of a ContentInfo.
the PKCS#7 message.

function messageFromPem

messageFromPem: (pem: pki.PEM) => Captured<PkcsEnvelopedData | PkcsSignedData>;

Converts a PKCS#7 message from PEM format.
Parameter pem
the PEM-formatted PKCS#7 message.
the PKCS#7 message.

function messageToPem

messageToPem: (msg: PkcsSignedData, maxline?: number) => string;

Converts a PKCS#7 message to PEM format.
Parameter msg
The PKCS#7 message object
Parameter maxline
The maximum characters per line, defaults to 64.
The PEM-formatted PKCS#7 message.

interface PkcsEnvelopedData

interface PkcsEnvelopedData {}

property content

content?: string | util.ByteBuffer | undefined;

method addRecipient

addRecipient: (certificate: pki.Certificate) => void;

method encrypt

encrypt: () => void;

method toAsn1

toAsn1: () => asn1.Asn1;

interface PkcsSignedData

interface PkcsSignedData {}

property certificates

certificates: pki.Certificate[];

property content

content?: string | util.ByteBuffer | undefined;

property contentInfo

contentInfo?: { value: any[] } | undefined;

method addCertificate

addCertificate: (certificate: pki.Certificate | string) => void;

method addSigner

addSigner: (options: {
    key: pki.rsa.PrivateKey | string;
    certificate: pki.Certificate | string;
    digestAlgorithm: string;
    authenticatedAttributes?:
        | { type: string; value?: string | undefined }[]
        | undefined;
}) => void;

method sign

sign: (options?: { detached?: boolean | undefined }) => void;

method toAsn1

toAsn1: () => asn1.Asn1;

type Captured

type Captured<T> = T & {
    rawCapture: any;
};

When a PKCS#7 object has been created by reading from a message, the raw captured object is joined

namespace node-forge.pki

namespace node-forge.pki {}

variable oids

var oids: oids;

variable setRsaPrivateKey

const setRsaPrivateKey: (
    n: jsbn.BigInteger,
    e: jsbn.BigInteger,
    d: jsbn.BigInteger,
    p: jsbn.BigInteger,
    q: jsbn.BigInteger,
    dP: jsbn.BigInteger,
    dQ: jsbn.BigInteger,
    qInv: jsbn.BigInteger
) => rsa.PrivateKey;

variable setRsaPublicKey

const setRsaPublicKey: (n: jsbn.BigInteger, e: jsbn.BigInteger) => rsa.PublicKey;

function certificateFromAsn1

certificateFromAsn1: (obj: asn1.Asn1, computeHash?: boolean) => Certificate;

function certificateFromPem

certificateFromPem: (
    pem: PEM,
    computeHash?: boolean,
    strict?: boolean
) => Certificate;

function certificateToAsn1

certificateToAsn1: (cert: Certificate) => asn1.Asn1;

function certificateToPem

certificateToPem: (cert: Certificate, maxline?: number) => PEM;

function certificationRequestFromAsn1

certificationRequestFromAsn1: (
    obj: asn1.Asn1,
    computeHash?: boolean
) => Certificate;

function certificationRequestFromPem

certificationRequestFromPem: (
    pem: PEM,
    computeHash?: boolean,
    strict?: boolean
) => Certificate;

function certificationRequestToAsn1

certificationRequestToAsn1: (cert: Certificate) => asn1.Asn1;

function certificationRequestToPem

certificationRequestToPem: (cert: Certificate, maxline?: number) => PEM;

function createCaStore

createCaStore: (certs?: ReadonlyArray<Certificate | pki.PEM>) => CAStore;

function createCertificate

createCertificate: () => Certificate;

function createCertificationRequest

createCertificationRequest: () => CertificateRequest;

function decryptPrivateKeyInfo

decryptPrivateKeyInfo: (obj: asn1.Asn1, password: string) => asn1.Asn1;

function decryptRsaPrivateKey

decryptRsaPrivateKey: {
    (pem: PEM, passphrase?: string): rsa.PrivateKey;
    (pem: string, password: string): rsa.PrivateKey;
};

function encryptedPrivateKeyFromPem

encryptedPrivateKeyFromPem: (pem: PEM) => asn1.Asn1;

function encryptedPrivateKeyToPem

encryptedPrivateKeyToPem: (obj: asn1.Asn1) => PEM;

function encryptPrivateKeyInfo

encryptPrivateKeyInfo: (
    obj: asn1.Asn1,
    password: string,
    options?: EncryptionOptions
) => asn1.Asn1;

function encryptRsaPrivateKey

encryptRsaPrivateKey: (
    privateKey: PrivateKey,
    password: string,
    options?: EncryptionOptions
) => PEM;

function getPublicKeyFingerprint

getPublicKeyFingerprint: {
    (
        publicKey: PublicKey,
        options?: ByteBufferFingerprintOptions
    ): util.ByteStringBuffer;
    (publicKey: any, options: HexFingerprintOptions): string;
    (publicKey: any, options: BinaryFingerprintOptions): string;
};

function pemToDer

pemToDer: (pem: PEM) => util.ByteStringBuffer;

function privateKeyFromAsn1

privateKeyFromAsn1: (privateKey: asn1.Asn1) => PrivateKey;

function privateKeyFromPem

privateKeyFromPem: (pem: PEM) => rsa.PrivateKey;

function privateKeyInfoToPem

privateKeyInfoToPem: (key: asn1.Asn1, maxline?: number) => PEM;

function privateKeyToAsn1

privateKeyToAsn1: (privateKey: PrivateKey) => asn1.Asn1;

function privateKeyToPem

privateKeyToPem: (key: PrivateKey, maxline?: number) => PEM;

function publicKeyFromAsn1

publicKeyFromAsn1: (publicKey: asn1.Asn1) => PublicKey;

function publicKeyFromPem

publicKeyFromPem: (pem: PEM) => rsa.PublicKey;

function publicKeyToAsn1

publicKeyToAsn1: (publicKey: PublicKey) => asn1.Asn1;

function publicKeyToPem

publicKeyToPem: (key: PublicKey, maxline?: number) => PEM;

function publicKeyToRSAPublicKey

publicKeyToRSAPublicKey: (publicKey: PublicKey) => any;

function publicKeyToRSAPublicKeyPem

publicKeyToRSAPublicKeyPem: (key: PublicKey, maxline?: number) => PEM;

function verifyCertificateChain

verifyCertificateChain: (
    caStore: CAStore,
    chain: Certificate[],
    options?:
        | ((
              verified: boolean | string,
              depth: number,
              certs: Certificate[]
          ) => boolean)
        | {
              verify?: (
                  verified: boolean | string,
                  depth: number,
                  certs: Certificate[]
              ) => boolean;
              validityCheckDate?: Date | null | undefined;
          }
) => boolean;

function wrapRsaPrivateKey

wrapRsaPrivateKey: (privateKey: asn1.Asn1) => asn1.Asn1;

interface Attribute

interface Attribute {}

property extensions

extensions?: any[] | undefined;

Extensions

property name

name: string;

e.g. challengePassword

property shortName

shortName?: string | undefined;

Short name, if available (e.g. 'CN' for 'commonName')

property type

type: string;

OID, e.g. '1.2.840.113549.1.9.7'

property value

value: any;

Attribute value

property valueTagClass

valueTagClass: number;

Attribute value data type

interface BinaryFingerprintOptions

interface BinaryFingerprintOptions extends ByteBufferFingerprintOptions {}

property encoding

encoding: 'binary';

if not specified, the function will return ByteStringBuffer

interface ByteBufferFingerprintOptions

interface ByteBufferFingerprintOptions {}

property delimiter

delimiter?: string | undefined;

the delimiter to use between bytes for hex encoded output

property md

md?: md.MessageDigest | undefined;

if not specified defaults to md.md5

property type

type?: 'SubjectPublicKeyInfo' | 'RSAPublicKey' | undefined;

The type of fingerprint. If not specified, defaults to 'RSAPublicKey'

interface CAStore

interface CAStore {}

method addCertificate

addCertificate: (cert: Certificate | string) => void;

method getBySubject

getBySubject: (subject: string) => Certificate | null;

method getIssuer

getIssuer: (subject: Certificate) => Certificate | null;

method hasCertificate

hasCertificate: (cert: Certificate | string) => boolean;

method listAllCertificates

listAllCertificates: () => pki.Certificate[];

method removeCertificate

removeCertificate: (cert: Certificate | string) => Certificate | null;

interface Certificate

interface Certificate {}

property extensions

extensions: any[];

property issuer

issuer: {
    getField(sn: string | CertificateFieldOptions): any;
    addField(attr: CertificateField): void;
    attributes: CertificateField[];
    hash: any;
};

property md

md: md.MessageDigest;

property privateKey

privateKey: PrivateKey;

property publicKey

publicKey: PublicKey;

property serialNumber

serialNumber: string;

property siginfo

siginfo: {
    algorithmOid: string;
    parameters: any;
};

property signature

signature: any;

property signatureOid

signatureOid: string;

property signatureParameters

signatureParameters: any;

property subject

subject: {
    getField(sn: string | CertificateFieldOptions): any;
    addField(attr: CertificateField): void;
    attributes: CertificateField[];
    hash: any;
};

property tbsCertificate

tbsCertificate: asn1.Asn1;

property validity

validity: {
    notBefore: Date;
    notAfter: Date;
};

property version

version: number;

method generateSubjectKeyIdentifier

generateSubjectKeyIdentifier: () => util.ByteStringBuffer;

Generates the subjectKeyIdentifier for this certificate as byte buffer.
the subjectKeyIdentifier for this certificate as byte buffer.

method getExtension

getExtension: (
    options: string | { name: string } | { id: number }
) => {} | undefined;

Gets an extension by its name or id.
Parameter options
the name to use or an object with: name the name to use. id the id to use.
the extension or null if not found.

method isIssuer

isIssuer: (parent: Certificate) => boolean;

Returns true if this certificate's issuer matches the passed certificate's subject. Note that no signature check is performed.
Parameter parent
the certificate to check.
true if this certificate's issuer matches the passed certificate's subject.

method issued

issued: (child: Certificate) => boolean;

Returns true if this certificate's subject matches the issuer of the given certificate). Note that not signature check is performed.
Parameter child
the certificate to check.
true if this certificate's subject matches the passed certificate's issuer.

method setExtensions

setExtensions: (exts: any[]) => void;

Sets the extensions of this certificate.
Parameter exts
the array of extensions to use.

method setIssuer

setIssuer: (attrs: CertificateField[], uniqueId?: string) => void;

Sets the issuer of this certificate.
Parameter attrs
the array of subject attributes to use.
Parameter uniqueId
an optional a unique ID to use.

method setSubject

setSubject: (attrs: CertificateField[], uniqueId?: string) => void;

Sets the subject of this certificate.
Parameter attrs
the array of subject attributes to use.
Parameter uniqueId
an optional a unique ID to use.

method sign

sign: (key: pki.PrivateKey, md?: md.MessageDigest) => void;

Signs this certificate using the given private key.
Parameter key
the private key to sign with.
Parameter md
the message digest object to use (defaults to forge.md.sha1).

method verify

verify: (child: Certificate) => boolean;

Attempts verify the signature on the passed certificate using this certificate's public key.
Parameter child
the certificate to verify.
true if verified, false if not.

method verifySubjectKeyIdentifier

verifySubjectKeyIdentifier: () => boolean;

Verifies the subjectKeyIdentifier extension value for this certificate against its public key. If no extension is found, false will be returned.
true if verified, false if not.

interface CertificateField

interface CertificateField extends CertificateFieldOptions {}

property extensions

extensions?: any[] | undefined;

property value

value?: any[] | string | undefined;

property valueConstructed

valueConstructed?: boolean | undefined;

property valueTagClass

valueTagClass?: asn1.Class | undefined;

interface CertificateFieldOptions

interface CertificateFieldOptions {}

property name

name?: string | undefined;

property shortName

shortName?: string | undefined;

property type

type?: string | undefined;

interface CertificateRequest

interface CertificateRequest extends Certificate {}

method getAttribute

getAttribute: (opts: string | GetAttributeOpts) => Attribute | null;

Gets an issuer or subject attribute from its name, type, or short name.
Parameter opts
a short name string or an object with: shortName the short name for the attribute. name the name for the attribute. type the type for the attribute.
the attribute.

interface GetAttributeOpts

interface GetAttributeOpts {}

Attribute members to search on; any one hit will return the attribute

property name

name?: string | undefined;

Long name

property shortName

shortName?: string | undefined;

Short name

property type

type?: string | undefined;

interface HexFingerprintOptions

interface HexFingerprintOptions extends ByteBufferFingerprintOptions {}

property encoding

encoding: 'hex';

if not specified, the function will return ByteStringBuffer

interface KeyPair

interface KeyPair {}

property privateKey

privateKey: PrivateKey;

property publicKey

publicKey: PublicKey;

interface oids

interface oids {}

index signature

[key: string]: string;

type EncryptionOptions

type EncryptionOptions = {
    algorithm?: 'aes128' | 'aes192' | 'aes256' | '3des' | undefined;
    count?: number | undefined;
    saltSize?: number | undefined;
    prfAlgorithm?: 'sha1' | 'sha224' | 'sha256' | 'sha384' | 'sha512' | undefined;
    legacy?: boolean | undefined;
};

type PEM

type PEM = string;

type PrivateKey

type PrivateKey = rsa.PrivateKey | ed25519.Key;

type PublicKey

type PublicKey = rsa.PublicKey | ed25519.Key;

namespace node-forge.pki.ed25519

namespace node-forge.pki.ed25519 {}

function generateKeyPair

generateKeyPair: (options?: { seed?: NativeBuffer | string | undefined }) => {
    publicKey: NativeBuffer;
    privateKey: NativeBuffer;
};

function privateKeyFromAsn1

privateKeyFromAsn1: (obj: asn1.Asn1) => { privateKeyBytes: NativeBuffer };

function publicKeyFromAsn1

publicKeyFromAsn1: (obj: asn1.Asn1) => NativeBuffer;

function publicKeyFromPrivateKey

publicKeyFromPrivateKey: (options: { privateKey: BinaryBuffer }) => NativeBuffer;

function sign

sign: (
    options: ToNativeBufferParameters & { privateKey: BinaryBuffer }
) => NativeBuffer;

function verify

verify: (
    options: ToNativeBufferParameters & {
        signature: BinaryBuffer;
        publicKey: BinaryBuffer;
    }
) => boolean;

type BinaryBuffer

type BinaryBuffer = NativeBuffer | util.ByteBuffer | string;

type Key

type Key = NativeBuffer;

type NativeBuffer

type NativeBuffer = Buffer | Uint8Array;

type ToNativeBufferParameters

type ToNativeBufferParameters =
    | {
          md: md.MessageDigest;
      }
    | {
          message: NativeBuffer | util.ByteBuffer;
      }
    | {
          message: string;
          encoding: 'binary' | 'utf8';
      };

namespace node-forge.pki.ed25519.constants

namespace node-forge.pki.ed25519.constants {}

variable HASH_BYTE_LENGTH

const HASH_BYTE_LENGTH: number;

variable PRIVATE_KEY_BYTE_LENGTH

const PRIVATE_KEY_BYTE_LENGTH: number;

variable PUBLIC_KEY_BYTE_LENGTH

const PUBLIC_KEY_BYTE_LENGTH: number;

variable SEED_BYTE_LENGTH

const SEED_BYTE_LENGTH: number;

variable SIGN_BYTE_LENGTH

const SIGN_BYTE_LENGTH: number;

namespace node-forge.pki.rsa

namespace node-forge.pki.rsa {}

function generateKeyPair

generateKeyPair: {
    (
        bits?: number,
        e?: number,
        callback?: (err: Error, keypair: KeyPair) => void
    ): KeyPair;
    (
        options?: GenerateKeyPairOptions,
        callback?: (err: Error, keypair: KeyPair) => void
    ): KeyPair;
};

function setPrivateKey

setPrivateKey: (
    n: jsbn.BigInteger,
    e: jsbn.BigInteger,
    d: jsbn.BigInteger,
    p: jsbn.BigInteger,
    q: jsbn.BigInteger,
    dP: jsbn.BigInteger,
    dQ: jsbn.BigInteger,
    qInv: jsbn.BigInteger
) => PrivateKey;

function setPublicKey

setPublicKey: (n: jsbn.BigInteger, e: jsbn.BigInteger) => PublicKey;

interface GenerateKeyPairOptions

interface GenerateKeyPairOptions {}

property algorithm

algorithm?: string | undefined;

property bits

bits?: number | undefined;

property e

e?: number | undefined;

property prng

prng?: any;

property workers

workers?: number | undefined;

property workerScript

workerScript?: string | undefined;

property workLoad

workLoad?: number | undefined;

interface KeyPair

interface KeyPair {}

property privateKey

privateKey: PrivateKey;

property publicKey

publicKey: PublicKey;

interface PrivateKey

interface PrivateKey {}

property d

d: jsbn.BigInteger;

property dP

dP: jsbn.BigInteger;

property dQ

dQ: jsbn.BigInteger;

property e

e: jsbn.BigInteger;

property n

n: jsbn.BigInteger;

property p

p: jsbn.BigInteger;

property q

q: jsbn.BigInteger;

property qInv

qInv: jsbn.BigInteger;

method decrypt

decrypt: (data: Bytes, scheme?: EncryptionScheme, schemeOptions?: any) => Bytes;

method sign

sign: (md: md.MessageDigest | Bytes, scheme?: SignatureScheme) => Bytes;

interface PublicKey

interface PublicKey {}

property e

e: jsbn.BigInteger;

property n

n: jsbn.BigInteger;

method encrypt

encrypt: (data: Bytes, scheme?: EncryptionScheme, schemeOptions?: any) => Bytes;

method verify

verify: (digest: Bytes, signature: Bytes, scheme?: SignatureScheme) => boolean;

type EncryptionScheme

type EncryptionScheme = 'RSAES-PKCS1-V1_5' | 'RSA-OAEP' | 'RAW' | 'NONE' | null;

type SignatureScheme

type SignatureScheme = 'RSASSA-PKCS1-V1_5' | pss.PSS | 'NONE' | null;

namespace node-forge.pss

namespace node-forge.pss {}

function create

create: (any: any) => PSS;

type PSS

type PSS = any;

namespace node-forge.random

namespace node-forge.random {}

function createInstance

createInstance: () => Random;

function getBytes

getBytes: (
    count: number,
    callback?: (err: Error | null, bytes: Bytes) => any
) => void;

function getBytesSync

getBytesSync: (count: number) => Bytes;

interface Random

interface Random {}

property seedFile

seedFile: (needed: number, cb: CB) => void;

property seedFileSync

seedFileSync: (needed: number) => string;

type CB

type CB = (_: any, seed: string) => void;

namespace node-forge.rc2

namespace node-forge.rc2 {}

function createDecryptionCipher

createDecryptionCipher: (
    key: string | util.ByteBuffer,
    bits?: number
) => rc2.cipher;

function createEncryptionCipher

createEncryptionCipher: (
    key: string | util.ByteBuffer,
    bits?: number
) => rc2.cipher;

function expandKey

expandKey: (
    key: string | util.ByteBuffer,
    effKeyBits?: number
) => util.ByteBuffer;

function startDecrypting

startDecrypting: (
    key: string | util.ByteBuffer,
    iv: util.ByteBuffer | Byte[] | Bytes,
    output: util.ByteBuffer | null
) => rc2.cipher;

function startEncrypting

startEncrypting: (
    key: string | util.ByteBuffer,
    iv: util.ByteBuffer | Byte[] | Bytes,
    output: util.ByteBuffer | null
) => rc2.cipher;

interface cipher

interface cipher {}

property output

output: util.ByteBuffer;

method finish

finish: (pad?: pad_function) => boolean;

method start

start: (iv: util.ByteBuffer | string | null, output?: util.ByteBuffer) => void;

method update

update: (input: util.ByteBuffer) => void;

type pad_function

type pad_function = (
    blockSize: number,
    buffer: util.ByteBuffer,
    decrypt: boolean
) => boolean;

namespace node-forge.ssh

namespace node-forge.ssh {}

function getPublicKeyFingerprint

getPublicKeyFingerprint: (
    publicKey: pki.PublicKey,
    options?: FingerprintOptions
) => util.ByteStringBuffer | Hex | string;

Gets the SSH fingerprint for the given public key

function privateKeyToOpenSSH

privateKeyToOpenSSH: (privateKey: pki.PrivateKey, passphrase?: string) => string;

Encodes a private RSA key as an OpenSSH file

function privateKeyToPutty

privateKeyToPutty: (
    privateKey: pki.PrivateKey,
    passphrase?: string,
    comment?: string
) => string;

Encodes (and optionally encrypts) a private RSA key as a Putty PPK file

function publicKeyToOpenSSH

publicKeyToOpenSSH: (
    publicKey: pki.PublicKey,
    comment?: string
) => string | pki.PEM;

Encodes a public RSA key as an OpenSSH file

interface FingerprintOptions

interface FingerprintOptions {}

property delimiter

delimiter?: string | undefined;

the delimiter to use between bytes for hex encoded output

property encoding

encoding?: 'hex' | 'binary' | undefined;

if not specified, the function will return ByteStringBuffer

property md

md?: md.MessageDigest | undefined;

if not specified defaults to md.md5

namespace node-forge.tls

namespace node-forge.tls {}

variable CipherSuites

const CipherSuites: { [name: string]: CipherSuite };

variable MaxFragment

const MaxFragment: number;

variable SupportedVersions

const SupportedVersions: ProtocolVersion[];

variable Version

const Version: ProtocolVersion;

variable Versions

const Versions: ProtocolVersion[];

function createConnection

createConnection: (options: {
    server?: boolean | undefined;
    sessionId?: Bytes | null | undefined;
    caStore?: pki.CAStore | ReadonlyArray<pki.Certificate> | undefined;
    sessionCache?: SessionCache | { [key: string]: Session };
    cipherSuites?: CipherSuite[] | undefined;
    connected(conn: Connection): void;
    virtualHost?: string | undefined;
    verifyClient?: boolean | undefined;
    verify?(
        conn: Connection,
        verified: Verified,
        depth: number,
        certs: pki.Certificate[]
    ): Verified;
    getCertificate?(
        conn: Connection,
        hint: CertificateRequest | string[]
    ): pki.PEM | ReadonlyArray<pki.PEM>;
    getPrivateKey?(conn: Connection, certificate: pki.Certificate): pki.PEM;
    getSignature?(
        conn: Connection,
        bytes: Bytes,
        callback: (conn: Connection, bytes: Bytes) => void
    ): void;
    tlsDataReady(conn: Connection): void;
    dataReady(conn: Connection): void;
    heartbeatReceived?(conn: Connection, payload: util.ByteBuffer): void;
    closed(conn: Connection): void;
    error(conn: Connection, error: TLSError): void;
    deflate?(inBytes: Bytes): Bytes;
    inflate?(inBytes: Bytes): Bytes;
}) => Connection;

function createSessionCache

createSessionCache: (
    cache?: SessionCache | { [key: string]: Session },
    capacity?: number
) => SessionCache;

function hmac_sha1

hmac_sha1: (
    key: string | ReadonlyArray<Byte> | util.ByteBuffer,
    seqNum: [number, number],
    record: Record
) => Bytes;

function prf_tls1

prf_tls1: (
    secret: string,
    label: string,
    seed: string,
    length: number
) => util.ByteBuffer;

interface Alert

interface Alert {}

property description

description: Alert.Description;

property level

level: Alert.Level;

interface CertificateRequest

interface CertificateRequest {}

property certificate_authorities

certificate_authorities: util.ByteBuffer;

property certificate_types

certificate_types: util.ByteBuffer;

interface CipherSuite

interface CipherSuite {}

property id

id: [Byte, Byte];

property name

name: string;

interface Connection

interface Connection {}

property caStore

caStore: pki.CAStore;

property cipherSuites

cipherSuites: CipherSuite[];

property data

data: util.ByteBuffer;

property deflate

deflate: ((inBytes: Bytes) => Bytes) | null;

property entity

entity: ConnectionEnd;

property expect

expect: number;

property fail

fail: boolean;

property fragmented

fragmented: Record | null;

property getCertificate

getCertificate:
    | ((
          conn: Connection,
          hint: CertificateRequest | string[]
      ) => pki.PEM | ReadonlyArray<pki.PEM>)
    | null;

property getPrivateKey

getPrivateKey:
    | ((conn: Connection, certificate: pki.Certificate) => pki.PEM)
    | null;

property getSignature

getSignature:
    | ((
          conn: Connection,
          bytes: Bytes,
          callback: (conn: Connection, bytes: Bytes) => void
      ) => void)
    | null;

property handshakes

handshakes: number;

property handshaking

handshaking: boolean;

property heartbeatReceived

heartbeatReceived:
    | ((conn: Connection, payload: util.ByteBuffer) => void)
    | undefined;

property inflate

inflate: ((inBytes: Bytes) => Bytes) | null;

property input

input: util.ByteBuffer;

property isConnected

isConnected: boolean;

property open

open: boolean;

property peerCertificate

peerCertificate: pki.Certificate | null;

property record

record: Record | null;

property records

records: Record[];

property session

session: Session | null;

property sessionCache

sessionCache: SessionCache | null;

property sessionId

sessionId: Bytes | null;

property state

state: { pending: ConnectionState | null; current: ConnectionState };

property tlsData

tlsData: util.ByteBuffer;

property verifyClient

verifyClient: boolean;

property version

version: ProtocolVersion;

property virtualHost

virtualHost: string | null;

method close

close: (clearFail?: boolean) => Connection;

method closed

closed: (conn: Connection) => void;

method connected

connected: (conn: Connection) => void;

method dataReady

dataReady: (conn: Connection) => void;

method error

error: (conn: Connection, error: TLSError) => void;

method handshake

handshake: (sessionId?: Bytes | null) => void;

method prepare

prepare: (data: Bytes) => boolean;

method prepareHeartbeatRequest

prepareHeartbeatRequest: (
    payload: Bytes | util.ByteBuffer,
    payloadLength?: number
) => boolean;

method process

process: (data: Bytes) => number;

method reset

reset: (clearFail?: boolean) => void;

method tlsDataReady

tlsDataReady: (conn: Connection) => void;

method verify

verify: (
    conn: Connection,
    verified: Verified,
    depth: number,
    certs: pki.Certificate[]
) => Verified;

interface ProtocolVersion

interface ProtocolVersion {}

property major

major: Byte;

property minor

minor: Byte;

interface Record

interface Record {}

property fragment

fragment: util.ByteBuffer;

property length

length: number;

property ready

ready?: boolean | undefined;

property type

type: ContentType;

property version

version: ProtocolVersion;

interface Session

interface Session {}

property cipherSuite

cipherSuite: CipherSuite | null;

property clientCertificate

clientCertificate: pki.Certificate | null;

property compressionMethod

compressionMethod: CompressionMethod | null;

property extensions

extensions: { [_: string]: object };

property md5

md5: md.MessageDigest;

property serverCertificate

serverCertificate: pki.Certificate | null;

property sha1

sha1: md.MessageDigest;

property version

version: ProtocolVersion | null;

interface SessionCache

interface SessionCache {}

property cache

cache: { [key: string]: Session };

property capacity

capacity: number;

property order

order: [Hex];

method getSession

getSession: (sessionId: Bytes) => Session;

method setSession

setSession: (sessionId: Bytes, session: Session) => void;

interface TLSError

interface TLSError extends Error {}

property alert

alert: Alert;

property message

message: string;

property origin

origin: 'server' | 'client';

property send

send: boolean;

enum BulkCipherAlgorithm

enum BulkCipherAlgorithm {
    rc4 = 0,
    des3 = 1,
    aes = 2,
}

member aes

aes = 2

member des3

des3 = 1

member rc4

rc4 = 0

enum CipherType

enum CipherType {
    stream = 0,
    block = 1,
    aead = 2,
}

member aead

aead = 2

member block

block = 1

member stream

stream = 0

enum CompressionMethod

enum CompressionMethod {
    none = 0,
    deflate = 1,
}

member deflate

deflate = 1

member none

none = 0

enum ConnectionEnd

enum ConnectionEnd {
    server = 0,
    client = 1,
}

member client

client = 1

member server

server = 0

enum ContentType

enum ContentType {
    change_cipher_spec = 20,
    alert = 21,
    handshake = 22,
    application_data = 23,
    heartbeat = 24,
}

member alert

alert = 21

member application_data

application_data = 23

member change_cipher_spec

change_cipher_spec = 20

member handshake

handshake = 22

member heartbeat

heartbeat = 24

enum HandshakeType

enum HandshakeType {
    hello_request = 0,
    client_hello = 1,
    server_hello = 2,
    certificate = 11,
    server_key_exchange = 12,
    certificate_request = 13,
    server_hello_done = 14,
    certificate_verify = 15,
    client_key_exchange = 16,
    finished = 20,
}

member certificate

certificate = 11

member certificate_request

certificate_request = 13

member certificate_verify

certificate_verify = 15

member client_hello

client_hello = 1

member client_key_exchange

client_key_exchange = 16

member finished

finished = 20

member hello_request

hello_request = 0

member server_hello

server_hello = 2

member server_hello_done

server_hello_done = 14

member server_key_exchange

server_key_exchange = 12

enum HeartbeatMessageType

enum HeartbeatMessageType {
    heartbeat_request = 1,
    heartbeat_response = 2,
}

member heartbeat_request

heartbeat_request = 1

member heartbeat_response

heartbeat_response = 2

enum MACAlgorithm

enum MACAlgorithm {
    hmac_md5 = 0,
    hmac_sha1 = 1,
    hmac_sha256 = 2,
    hmac_sha384 = 3,
    hmac_sha512 = 4,
}

member hmac_md5

hmac_md5 = 0

member hmac_sha1

hmac_sha1 = 1

member hmac_sha256

hmac_sha256 = 2

member hmac_sha384

hmac_sha384 = 3

member hmac_sha512

hmac_sha512 = 4

enum PRFAlgorithm

enum PRFAlgorithm {
    tls_prf_sha256 = 0,
}

member tls_prf_sha256

tls_prf_sha256 = 0

type ConnectionState

type ConnectionState = any;

type Verified

type Verified =
    | true
    | { message?: string | undefined; alert?: Alert.Description | undefined };

namespace node-forge.tls.Alert

namespace node-forge.tls.Alert {}

enum Description

enum Description {
    close_notify = 0,
    unexpected_message = 10,
    bad_record_mac = 20,
    decryption_failed = 21,
    record_overflow = 22,
    decompression_failure <