@types/node-forge

Version 1.3.13
Published 26 days ago
63.6 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 dateToGeneralizedTime

dateToGeneralizedTime: (date: Date | string) => Bytes;

function dateToUtcTime

dateToUtcTime: (date: Date | string) => Bytes;

function derToInteger

derToInteger: (bytes: Bytes | util.ByteBuffer) => number;

function derToOid

derToOid: (bytes: Bytes | util.ByteBuffer) => OID;

Converts a DER-encoded byte buffer to an OID dot-separated string. The byte buffer should contain only the DER-encoded value, not any tag or length bytes.
Parameter bytes
the byte buffer.
the OID dot-separated string.

function fromDer

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

function generalizedTimeToDate

generalizedTimeToDate: (bytes: Bytes) => Date;

function integerToDer

integerToDer: (int: number) => util.ByteBuffer;

function oidToDer

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

Converts an OID dot-separated string to a byte buffer. The byte buffer contains only the DER-encoded value, not any tag or length bytes.
Parameter oid
the OID dot-separated string.
the byte buffer.

function toDer

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

function utcTimeToDate

utcTimeToDate: (bytes: Bytes) => Date;

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: Array<{
    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;

property recipients

recipients: Recipient[];

method addRecipient

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

Add (another) entity to list of recipients.
Parameter certificate
The certificate of the entity to add.

method decrypt

decrypt: (recipient: Recipient, privKey: pki.rsa.PrivateKey) => void;

Decrypt enveloped content
Parameter recipient
The recipient object related to the private key
Parameter privKey
The (RSA) private key object

method encrypt

encrypt: (key?: util.ByteBuffer, cipher?: OID) => void;

Encrypt enveloped content.
This function supports two optional arguments, cipher and key, which can be used to influence symmetric encryption. Unless cipher is provided, the cipher specified in encryptedContent.algorithm is used (defaults to AES-256-CBC). If no key is provided, encryptedContent.key is (re-)used. If that one's not set, a random key will be generated automatically.
Parameter key
The key to be used for symmetric encryption.
Parameter cipher
The OID of the symmetric cipher to use.

method findRecipient

findRecipient: (cert: pki.Certificate) => Recipient | null;

Find recipient by X.509 certificate's issuer and serialNumber.
Parameter cert
the certificate with the issuer to look for.
the recipient object, or null if no match.

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?:
        | Array<{ type: string; value?: string | undefined }>
        | undefined;
}) => void;

method sign

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

method toAsn1

toAsn1: () => asn1.Asn1;

interface Recipient

interface Recipient {}

property encryptedContent

encryptedContent: {
    algorithm: OID;
    parameter: Bytes;
    content: Bytes;
};

property issuer

issuer: pki.CertificateField[];

property serialNumber

serialNumber: Hex;

property version

version: number;

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
) => CertificateSigningRequest;

function certificationRequestFromPem

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

function certificationRequestToAsn1

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

function certificationRequestToPem

certificationRequestToPem: (
    csr: CertificateSigningRequest,
    maxline?: number
) => PEM;

function createCaStore

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

function createCertificate

createCertificate: () => Certificate;

function createCertificationRequest

createCertificationRequest: () => CertificateSigningRequest;

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 distinguishedNameToAsn1

distinguishedNameToAsn1: (dn: {
    attributes: ReadonlyArray<CertificateField>;
}) => asn1.Asn1;

Converts a DistinguishedName (subject or issuer) to an ASN.1 object.
Parameter dn
the DistinguishedName object containing certificate attributes.
the asn1 representation of a DistinguishedName.

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) => rsa.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) => rsa.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: (signer: MDSigner, md?: md.MessageDigest) => void;

Signs this certificate using the given private key.
Parameter signer
the signer used to sign this csr
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 CertificateSigningRequest

interface CertificateSigningRequest {}

property attributes

attributes: CertificateField[];

property certificationRequestInfo

certificationRequestInfo: asn1.Asn1 | null;

property md

md: md.MessageDigest | null;

property publicKey

publicKey: PublicKey | null;

property siginfo

siginfo: {
    algorithmOid: string | null;
};

property signature

signature: any;

property signatureOid

signatureOid: string | null;

property signatureParameters

signatureParameters: any;

property subject

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

property version

version: number;

method addAttribute

addAttribute: (attr: CertificateField) => void;

method getAttribute

getAttribute: (sn: 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.

method setAttributes

setAttributes: (attrs: CertificateField[]) => void;

method setSubject

setSubject: (attrs: CertificateField[]) => void;

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

method sign

sign: (signer: MDSigner, md?: md.MessageDigest) => void;

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

method verify

verify: () => boolean;

Attempts verify the signature on this csr using this csr's public key.
true if verified, false if not.

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 MDSigner

interface MDSigner {}

method sign

sign: (md: md.MessageDigest) => Bytes;

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 | readonly 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 | readonly 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 | readonly 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 | readonly 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 = 30,
    handshake_failure = 40,
    bad_certificate = 42,
    unsupported_certificate = 43,
    certificate_revoked = 44,
    certificate_expired = 45,
    certificate_unknown = 46,
    illegal_parameter = 47,
    unknown_ca = 48,
    access_denied = 49,
    decode_error = 50,
    decrypt_error = 51,
    export_restriction = 60,
    protocol_version = 70,
    insufficient_security = 71,
    internal_error = 80,
    user_canceled = 90,
    no_renegotiation = 100,
}

member access_denied

access_denied = 49

member bad_certificate

bad_certificate = 42

member bad_record_mac

bad_record_mac = 20

member certificate_expired

certificate_expired = 45

member certificate_revoked

certificate_revoked = 44

member certificate_unknown

certificate_unknown = 46

member close_notify

close_notify = 0

member decode_error

decode_error = 50

member decompression_failure

decompression_failure = 30

member decrypt_error

decrypt_error = 51

member decryption_failed

decryption_failed = 21

member export_restriction

export_restriction = 60

member handshake_failure

handshake_failure = 40

member illegal_parameter

illegal_parameter = 47

member insufficient_security

insufficient_security = 71

member internal_error

internal_error = 80

member no_renegotiation

no_renegotiation = 100

member protocol_version

protocol_version = 70

member record_overflow

record_overflow = 22

member unexpected_message

unexpected_message = 10

member unknown_ca

unknown_ca = 48

member unsupported_certificate

unsupported_certificate = 43

member user_canceled

user_canceled = 90

enum Level

enum Level {
    warning = 1,
    fatal = 2,
}

member fatal

fatal = 2

member warning

warning = 1

namespace node-forge.util

namespace node-forge.util {}

function bytesToHex

bytesToHex: (bytes: Bytes) => Hex;

function createBuffer

createBuffer: {
    (): ByteBuffer;
    (
        input: string | ByteStringBuffer | ArrayBuffer | ArrayBufferView,
        encoding?: Encoding
    ): ByteStringBuffer;
};

function decode64

decode64: (encoded: Base64) => Bytes;

function decodeUtf8

decodeUtf8: (encoded: Utf8) => string;

function encode64

encode64: (bytes: Bytes, maxline?: number) => Base64;

function encodeUtf8

encodeUtf8: (str: string) => Utf8;

function fillString

fillString: (char: string, count: number) => string;

function hexToBytes

hexToBytes: (hex: Hex) => Bytes;

function int32ToBytes

int32ToBytes: (int: number) => Bytes;

function isArray

isArray: (x: any) => boolean;

function isArrayBuffer

isArrayBuffer: (x: any) => boolean;

function isArrayBufferView

isArrayBufferView: (x: any) => boolean;

function xorBytes

xorBytes: (bytes1: string, bytes2: string, count: number) => string;

class ByteStringBuffer

class ByteStringBuffer {}

constructor

constructor(bytes?: string | ByteStringBuffer | ArrayBuffer | ArrayBufferView);

property data

data: string;

property read

read: number;

method at

at: (index: number) => Byte;

method bytes

bytes: (count?: number) => Bytes;

method clear

clear: () => ByteStringBuffer;

method compact

compact: () => ByteStringBuffer;

method copy

copy: () => ByteStringBuffer;

method fillWithByte

fillWithByte: (byte: Byte, n: number) => ByteStringBuffer;

method getByte

getByte: () => number;

method getBytes

getBytes: (count?: number) => Bytes;

method getInt

getInt: (numOfBits: number) => number;

method getInt16

getInt16: () => number;

method getInt16Le

getInt16Le: () => number;

method getInt24

getInt24: () => number;

method getInt24Le

getInt24Le: () => number;

method getInt32

getInt32: () => number;

method getInt32Le

getInt32Le: () => number;

method getSignedInt

getSignedInt: (numOfBits: number) => number;

method isEmpty

isEmpty: () => boolean;

method last

last: () => Byte;

method length

length: () => number;

method putBuffer

putBuffer: (buffer: ByteStringBuffer) => ByteStringBuffer;

method putByte

putByte: (byte: Byte) => ByteStringBuffer;

method putBytes

putBytes: (bytes: Bytes) => ByteStringBuffer;

method putInt

putInt: (int: number, numOfBits: number) => ByteStringBuffer;

method putInt16

putInt16: (int: number) => ByteStringBuffer;

method putInt16Le

putInt16Le: (int: number) => ByteStringBuffer;

method putInt24

putInt24: (int: number) => ByteStringBuffer;

method putInt24Le

putInt24Le: (int: number) => ByteStringBuffer;

method putInt32

putInt32: (int: number) => ByteStringBuffer;

method putInt32Le

putInt32Le: (int: number) => ByteStringBuffer;

method putSignedInt

putSignedInt: (int: number, numOfBits: number) => ByteStringBuffer;

method putString

putString: (str: string) => ByteStringBuffer;

method setAt

setAt: (index: number, byte: number) => ByteStringBuffer;

method toHex

toHex: () => Hex;

method toString

toString: () => string;

method truncate

truncate: () => ByteStringBuffer;

interface ArrayBufferView

interface ArrayBufferView {}

property buffer

buffer: ArrayBuffer;

property byteLength

byteLength: number;

type ByteBuffer

type ByteBuffer = ByteStringBuffer;

namespace node-forge.util.binary

namespace node-forge.util.binary {}

namespace node-forge.util.binary.base64

namespace node-forge.util.binary.base64 {}

function decode

decode: (input: Base64, output?: Uint8Array, offset?: number) => Uint8Array;

function encode

encode: (input: Uint8Array, maxline?: number) => Base64;

namespace node-forge.util.binary.hex

namespace node-forge.util.binary.hex {}

function decode

decode: (hex: Hex, output?: Uint8Array, offset?: number) => Uint8Array;

function encode

encode: (bytes: Bytes | ArrayBuffer | ArrayBufferView | ByteStringBuffer) => Hex;

namespace node-forge.util.binary.raw

namespace node-forge.util.binary.raw {}

function decode

decode: (str: Bytes, output?: Uint8Array, offset?: number) => Uint8Array;

function encode

encode: (x: Uint8Array) => Bytes;

namespace node-forge.util.text

namespace node-forge.util.text {}

namespace node-forge.util.text.utf16

namespace node-forge.util.text.utf16 {}

function decode

decode: (bytes: Uint8Array) => string;

function encode

encode: (str: string, output?: Uint8Array, offset?: number) => Uint8Array;

namespace node-forge.util.text.utf8

namespace node-forge.util.text.utf8 {}

function decode

decode: (bytes: Uint8Array) => Utf8;

function encode

encode: (str: string, output?: Uint8Array, offset?: number) => Uint8Array;

Package Files (1)

index.d.ts

Dependencies (1)

@types/node

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/node-forge.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/node-forge)

HTML

<a href="https://www.jsdocs.io/package/@types/node-forge"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 26 days ago.
Package analyzed in 9381 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/node-forge

Install

Overview

Index

Namespaces

Namespaces

namespace node-forge

variable md

variable md5

variable sha1

variable sha256

variable sha384

variable sha512

type Base64

type Byte

type Bytes

type Encoding

type Hex

type OID

type Utf8

namespace node-forge.asn1

function create

function dateToGeneralizedTime

function dateToUtcTime

function derToInteger

function derToOid

Parameter bytes

function fromDer

function generalizedTimeToDate

function integerToDer

function oidToDer

Parameter oid

function toDer

function utcTimeToDate

interface Asn1

property composed

property constructed

property tagClass

property type

property value

enum Class

member APPLICATION

member CONTEXT_SPECIFIC

member PRIVATE

member UNIVERSAL

enum Type

member BITSTRING

member BMPSTRING

member BOOLEAN

member EMBEDDED

member ENUMERATED

member EXTERNAL

member GENERALIZEDTIME

member IA5STRING

member INTEGER

member NONE

member NULL

member OCTETSTRING

member ODESC

member OID

member PRINTABLESTRING

member REAL

member ROID

member SEQUENCE

member SET

member UTCTIME

member UTF8

namespace node-forge.cipher

function createCipher

function createDecipher

interface BlockCipher

property finish

property mode

property output

property start

property update

interface Mode

property tag

interface StartOptions

property additionalData