@types/sshpk

  • Version 1.17.0
  • Published
  • 28.7 kB
  • 2 dependencies
  • MIT license

Install

npm i @types/sshpk
yarn add @types/sshpk
pnpm add @types/sshpk

Overview

TypeScript definitions for sshpk

Index

Functions

Classes

Interfaces

Type Aliases

Namespaces

Functions

function addRSAMissing

addRSAMissing: (key: PrivateKey) => void;

    function assertCompatible

    assertCompatible: (
    obj: object,
    klass: any,
    needVer: Version,
    name?: string
    ) => void;

      function bufferSplit

      bufferSplit: (buf: Buffer, chr: string) => Buffer[];

        function calculateDSAPublic

        calculateDSAPublic: (g: Buffer, p: Buffer, x: Buffer) => Buffer;

          function calculateED25519Public

          calculateED25519Public: (k: Buffer) => Buffer;

            function calculateX25519Public

            calculateX25519Public: (k: Buffer) => Buffer;

              function countZeros

              countZeros: (buf: Buffer) => number;

                function createCertificate

                createCertificate: (
                subjectOrSubjects: Identity | Identity[],
                key: PrivateKey | Key,
                issuer: Identity,
                issuerKey: PrivateKey,
                options?: CertificateCreateOptions
                ) => Certificate;

                  function createSelfSignedCertificate

                  createSelfSignedCertificate: (
                  subjectOrSubjects: Identity | Identity[],
                  key: PrivateKey,
                  options?: CertificateCreateOptions
                  ) => Certificate;

                    function ecNormalize

                    ecNormalize: (buf: Buffer, addZero?: boolean) => Buffer;

                      function generatePrivateKey

                      generatePrivateKey: {
                      (type: 'ecdsa', options?: { curve?: CurveType }): PrivateKey;
                      (type: 'ed25519'): PrivateKey;
                      };

                        function identityForEmail

                        identityForEmail: (email: string) => Identity;

                          function identityForHost

                          identityForHost: (hostname: string) => Identity;

                            function identityForUser

                            identityForUser: (uid: string) => Identity;

                              function identityFromArray

                              identityFromArray: (components: IdentityNameComponent[]) => Identity;

                                function identityFromDN

                                identityFromDN: (dn: string) => Identity;

                                  function isCompatible

                                  isCompatible: (obj: object, klass: any, needVer: Version) => boolean;

                                    function mpDenormalize

                                    mpDenormalize: (buf: Buffer) => Buffer;

                                      function mpNormalize

                                      mpNormalize: (buf: Buffer) => Buffer;

                                        function opensshCipherInfo

                                        opensshCipherInfo: (cipter: Format.SshPrivateCipher) => OpenSshCipherInfo;

                                          function opensslKeyDeriv

                                          opensslKeyDeriv: (
                                          cipher: 'des-ede3-cbc' | 'aes-128-cbc' | 'aes-256-cbc',
                                          salt: Buffer,
                                          passphrase: Buffer,
                                          count: number
                                          ) => OpenSslKeyDeriv;

                                            function parseCertificate

                                            parseCertificate: (
                                            data: string | Buffer,
                                            format: CertificateFormat,
                                            options?: string | KeyParseOptions
                                            ) => Certificate;

                                              function parseFingerprint

                                              parseFingerprint: (
                                              fp: string,
                                              options?: string[] | FingerprintParseOptions
                                              ) => Fingerprint;

                                                function parseKey

                                                parseKey: (
                                                data: string | Buffer,
                                                format?: KeyFormatType,
                                                options?: string | (Format.ReadOptions & { filename?: string })
                                                ) => Key;

                                                  function parsePrivateKey

                                                  parsePrivateKey: (
                                                  data: string | Buffer,
                                                  format?: PrivateKeyFormatType,
                                                  options?: string | KeyParseOptions
                                                  ) => PrivateKey;

                                                    function parseSignature

                                                    parseSignature: (
                                                    data: string | Buffer,
                                                    type: AlgorithmType,
                                                    format: SignatureFormatType
                                                    ) => Signature;

                                                      function pbkdf2

                                                      pbkdf2: (
                                                      hashAlg: string,
                                                      salt: Buffer,
                                                      iterations: number,
                                                      size: number,
                                                      passphrase: crypto.BinaryLike
                                                      ) => Buffer;

                                                        function publicFromPrivateECDSA

                                                        publicFromPrivateECDSA: (curveName: CurveType, priv: Buffer) => Key;

                                                          function readBitString

                                                          readBitString: (der: BerReader, tag?: number) => Buffer;

                                                            function writeBitString

                                                            writeBitString: (der: BerWriter, buf: Buffer, tag?: number) => void;

                                                              function zeroPadToLength

                                                              zeroPadToLength: (buf: Buffer, len: number) => Buffer;

                                                                Classes

                                                                class algInfo

                                                                class algInfo {}

                                                                  property curve25519

                                                                  curve25519: Algo;

                                                                    property dsa

                                                                    dsa: Algo;

                                                                      property ecdsa

                                                                      ecdsa: Algo;

                                                                        property ed25519

                                                                        ed25519: Algo;

                                                                          property rsa

                                                                          rsa: Algo;

                                                                            class Algo

                                                                            class Algo {}

                                                                              property normalize

                                                                              normalize?: boolean;

                                                                                property parts

                                                                                parts: string[];

                                                                                  property sizePart

                                                                                  sizePart?: string;

                                                                                    class algPrivInfo

                                                                                    class algPrivInfo {}

                                                                                      property curve25519

                                                                                      curve25519: Algo;

                                                                                        property dsa

                                                                                        dsa: Algo;

                                                                                          property ecdsa

                                                                                          ecdsa: Algo;

                                                                                            property ed25519

                                                                                            ed25519: Algo;

                                                                                              property rsa

                                                                                              rsa: Algo;

                                                                                                class algs

                                                                                                class algs {}

                                                                                                  property curves

                                                                                                  curves: curves;

                                                                                                    property hashAlgs

                                                                                                    hashAlgs: hashAlgs;

                                                                                                      property info

                                                                                                      info: algInfo;

                                                                                                        property privInfo

                                                                                                        privInfo: algPrivInfo;

                                                                                                          class Certificate

                                                                                                          class Certificate {}

                                                                                                            constructor

                                                                                                            constructor(opts: CertificateOptions);

                                                                                                              property formats

                                                                                                              static formats: { openssh: Format; pem: Format; x509: Format };

                                                                                                                property issuer

                                                                                                                issuer: Identity;

                                                                                                                  property issuerKey

                                                                                                                  issuerKey?: Key;

                                                                                                                    property purposes

                                                                                                                    purposes?: string[];

                                                                                                                      property serial

                                                                                                                      serial: Buffer;

                                                                                                                        property signatures

                                                                                                                        signatures: { x509?: Format.x509Signature; openssh?: Format.OpenSshSignature };

                                                                                                                          property subjectKey

                                                                                                                          subjectKey: Key;

                                                                                                                            property subjects

                                                                                                                            subjects: Identity[];

                                                                                                                              property validFrom

                                                                                                                              validFrom: Date;

                                                                                                                                property validUntil

                                                                                                                                validUntil: Date;

                                                                                                                                  method create

                                                                                                                                  static create: (
                                                                                                                                  subjectOrSubjects: Identity | Identity[],
                                                                                                                                  key: PrivateKey | Key,
                                                                                                                                  issuer: Identity,
                                                                                                                                  issuerKey: PrivateKey,
                                                                                                                                  options?: CertificateCreateOptions
                                                                                                                                  ) => Certificate;

                                                                                                                                    method createSelfSigned

                                                                                                                                    static createSelfSigned: (
                                                                                                                                    subjectOrSubjects: Identity | Identity[],
                                                                                                                                    key: PrivateKey,
                                                                                                                                    options?: CertificateCreateOptions
                                                                                                                                    ) => Certificate;

                                                                                                                                      method fingerprint

                                                                                                                                      fingerprint: (algo?: AlgorithmHashType) => Fingerprint;

                                                                                                                                        method getExtension

                                                                                                                                        getExtension: (
                                                                                                                                        keyOrOid: string
                                                                                                                                        ) => Format.OpenSshSignatureExt | Format.x509SignatureExt | undefined;

                                                                                                                                          method getExtensions

                                                                                                                                          getExtensions: () => Array<Format.OpenSshSignatureExt | Format.x509SignatureExt>;

                                                                                                                                            method hash

                                                                                                                                            hash: (algo: AlgorithmHashType) => string;

                                                                                                                                              method isCertificate

                                                                                                                                              static isCertificate: (data: string | Buffer, ver: Version) => boolean;

                                                                                                                                                method isExpired

                                                                                                                                                isExpired: (when?: Date) => boolean;

                                                                                                                                                  method isSignedBy

                                                                                                                                                  isSignedBy: (issuerCert: Certificate) => boolean;

                                                                                                                                                    method isSignedByKey

                                                                                                                                                    isSignedByKey: (issuerKey: Key) => boolean;

                                                                                                                                                      method parse

                                                                                                                                                      static parse: (
                                                                                                                                                      data: string | Buffer,
                                                                                                                                                      format: CertificateFormat,
                                                                                                                                                      options?: string | KeyParseOptions
                                                                                                                                                      ) => Certificate;

                                                                                                                                                        method signWith

                                                                                                                                                        signWith: (key: PrivateKey) => void;

                                                                                                                                                          method toBuffer

                                                                                                                                                          toBuffer: (format: CertificateFormat, options?: Format.WriteOptions) => Buffer;

                                                                                                                                                            method toString

                                                                                                                                                            toString: (format: CertificateFormat, options?: Format.WriteOptions) => string;

                                                                                                                                                              class CertificateParseError

                                                                                                                                                              class CertificateParseError implements Error {}

                                                                                                                                                                constructor

                                                                                                                                                                constructor(name: string, format: string, innerErr: Error);

                                                                                                                                                                  property certName

                                                                                                                                                                  certName: string;

                                                                                                                                                                    property format

                                                                                                                                                                    format: string;

                                                                                                                                                                      property innerErr

                                                                                                                                                                      innerErr: Error;

                                                                                                                                                                        property message

                                                                                                                                                                        message: string;

                                                                                                                                                                          property name

                                                                                                                                                                          name: string;

                                                                                                                                                                            class Curve

                                                                                                                                                                            class Curve {}

                                                                                                                                                                              property a

                                                                                                                                                                              a: Buffer;

                                                                                                                                                                                property b

                                                                                                                                                                                b: Buffer;

                                                                                                                                                                                  property G

                                                                                                                                                                                  G: Buffer;

                                                                                                                                                                                    property n

                                                                                                                                                                                    n: Buffer;

                                                                                                                                                                                      property p

                                                                                                                                                                                      p: Buffer;

                                                                                                                                                                                        property pkcs8oid

                                                                                                                                                                                        pkcs8oid: string;

                                                                                                                                                                                          property s

                                                                                                                                                                                          s: Buffer;

                                                                                                                                                                                            property size

                                                                                                                                                                                            size: number;

                                                                                                                                                                                              class curves

                                                                                                                                                                                              class curves {}

                                                                                                                                                                                                property nistp256

                                                                                                                                                                                                nistp256: Curve;

                                                                                                                                                                                                  property nistp384

                                                                                                                                                                                                  nistp384: Curve;

                                                                                                                                                                                                    property nistp512

                                                                                                                                                                                                    nistp512: Curve;

                                                                                                                                                                                                      class DiffieHellman

                                                                                                                                                                                                      class DiffieHellman {}

                                                                                                                                                                                                        method computeSecret

                                                                                                                                                                                                        computeSecret: (otherpk: Key) => Buffer;

                                                                                                                                                                                                          method generateKey

                                                                                                                                                                                                          generateKey: () => PrivateKey;

                                                                                                                                                                                                            method generateKeys

                                                                                                                                                                                                            generateKeys: () => PrivateKey;

                                                                                                                                                                                                              method getKey

                                                                                                                                                                                                              getKey: () => PrivateKey;

                                                                                                                                                                                                                method getPrivateKey

                                                                                                                                                                                                                getPrivateKey: () => PrivateKey;

                                                                                                                                                                                                                  method getPublicKey

                                                                                                                                                                                                                  getPublicKey: () => Key;

                                                                                                                                                                                                                    method setKey

                                                                                                                                                                                                                    setKey: (key: PrivateKey) => void;

                                                                                                                                                                                                                      method setPrivateKey

                                                                                                                                                                                                                      setPrivateKey: (key: PrivateKey) => void;

                                                                                                                                                                                                                        class Fingerprint

                                                                                                                                                                                                                        class Fingerprint {}

                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                          constructor(opts: FingerprintOptions);

                                                                                                                                                                                                                            property algorithm

                                                                                                                                                                                                                            algorithm: AlgorithmHashType;

                                                                                                                                                                                                                              property hash

                                                                                                                                                                                                                              hash: Buffer;

                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                type: FingerprintType;

                                                                                                                                                                                                                                  method isFingerprint

                                                                                                                                                                                                                                  static isFingerprint: (obj: any, ver: Version) => boolean;

                                                                                                                                                                                                                                    method matches

                                                                                                                                                                                                                                    matches: (other: Certificate | PrivateKey | Key) => boolean;

                                                                                                                                                                                                                                      method parse

                                                                                                                                                                                                                                      static parse: (
                                                                                                                                                                                                                                      fp: string,
                                                                                                                                                                                                                                      options?: string[] | FingerprintParseOptions
                                                                                                                                                                                                                                      ) => Fingerprint;

                                                                                                                                                                                                                                        method toString

                                                                                                                                                                                                                                        toString: (format?: 'hex' | 'base64') => string;

                                                                                                                                                                                                                                          class FingerprintFormatError

                                                                                                                                                                                                                                          class FingerprintFormatError implements Error {}

                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                            constructor(fp?: Fingerprint, format?: string);

                                                                                                                                                                                                                                              property fingerprint

                                                                                                                                                                                                                                              fingerprint?: Fingerprint;

                                                                                                                                                                                                                                                property format

                                                                                                                                                                                                                                                format?: string;

                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                  message: string;

                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                      class hashAlgs

                                                                                                                                                                                                                                                      class hashAlgs {}

                                                                                                                                                                                                                                                        property md5

                                                                                                                                                                                                                                                        md5: boolean;

                                                                                                                                                                                                                                                          property sha1

                                                                                                                                                                                                                                                          sha1: boolean;

                                                                                                                                                                                                                                                            property sha256

                                                                                                                                                                                                                                                            sha256: boolean;

                                                                                                                                                                                                                                                              property sha384

                                                                                                                                                                                                                                                              sha384: boolean;

                                                                                                                                                                                                                                                                property sha512

                                                                                                                                                                                                                                                                sha512: boolean;

                                                                                                                                                                                                                                                                  class Identity

                                                                                                                                                                                                                                                                  class Identity {}

                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                    constructor(opts: {
                                                                                                                                                                                                                                                                    components: IdentityComponent[];
                                                                                                                                                                                                                                                                    type?: IdentityType;
                                                                                                                                                                                                                                                                    hostname?: string;
                                                                                                                                                                                                                                                                    uid?: string;
                                                                                                                                                                                                                                                                    email?: string;
                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                      property cn

                                                                                                                                                                                                                                                                      cn?: string;

                                                                                                                                                                                                                                                                        property componentLookup

                                                                                                                                                                                                                                                                        componentLookup: {
                                                                                                                                                                                                                                                                        cn: IdentityComponent[];
                                                                                                                                                                                                                                                                        o: IdentityComponent[];
                                                                                                                                                                                                                                                                        ou: IdentityComponent[];
                                                                                                                                                                                                                                                                        l: IdentityComponent[];
                                                                                                                                                                                                                                                                        s: IdentityComponent[];
                                                                                                                                                                                                                                                                        c: IdentityComponent[];
                                                                                                                                                                                                                                                                        sn: IdentityComponent[];
                                                                                                                                                                                                                                                                        postalCode: IdentityComponent[];
                                                                                                                                                                                                                                                                        serialNumber: IdentityComponent[];
                                                                                                                                                                                                                                                                        street: IdentityComponent[];
                                                                                                                                                                                                                                                                        x500UniqueIdentifier: IdentityComponent[];
                                                                                                                                                                                                                                                                        role: IdentityComponent[];
                                                                                                                                                                                                                                                                        telephoneNumber: IdentityComponent[];
                                                                                                                                                                                                                                                                        description: IdentityComponent[];
                                                                                                                                                                                                                                                                        dc: IdentityComponent[];
                                                                                                                                                                                                                                                                        uid: IdentityComponent[];
                                                                                                                                                                                                                                                                        mail: IdentityComponent[];
                                                                                                                                                                                                                                                                        title: IdentityComponent[];
                                                                                                                                                                                                                                                                        gn: IdentityComponent[];
                                                                                                                                                                                                                                                                        initials: IdentityComponent[];
                                                                                                                                                                                                                                                                        pseudonym: IdentityComponent[];
                                                                                                                                                                                                                                                                        emailAddress: IdentityComponent[];
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          property components

                                                                                                                                                                                                                                                                          components: IdentityComponent[];

                                                                                                                                                                                                                                                                            property email

                                                                                                                                                                                                                                                                            email?: string;

                                                                                                                                                                                                                                                                              property hostname

                                                                                                                                                                                                                                                                              hostname?: string;

                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                type: IdentityTypeWithUnknown;

                                                                                                                                                                                                                                                                                  property uid

                                                                                                                                                                                                                                                                                  uid?: string;

                                                                                                                                                                                                                                                                                    method equals

                                                                                                                                                                                                                                                                                    equals: (other: Identity) => boolean;

                                                                                                                                                                                                                                                                                      method forEmail

                                                                                                                                                                                                                                                                                      static forEmail: (email: string) => Identity;

                                                                                                                                                                                                                                                                                        method forHost

                                                                                                                                                                                                                                                                                        static forHost: (hostname: string) => Identity;

                                                                                                                                                                                                                                                                                          method forUser

                                                                                                                                                                                                                                                                                          static forUser: (uid: string) => Identity;

                                                                                                                                                                                                                                                                                            method fromArray

                                                                                                                                                                                                                                                                                            static fromArray: (components: IdentityNameComponent[]) => Identity;

                                                                                                                                                                                                                                                                                              method get

                                                                                                                                                                                                                                                                                              get: {
                                                                                                                                                                                                                                                                                              (name: IndentityOidName, asArray?: false): string;
                                                                                                                                                                                                                                                                                              (name: IndentityOidName, asArray: true): string[];
                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                method isIdentity

                                                                                                                                                                                                                                                                                                static isIdentity: (obj: any, ver: Version) => boolean;

                                                                                                                                                                                                                                                                                                  method parseAsn1

                                                                                                                                                                                                                                                                                                  static parseAsn1: (dn: BerReader, top?: number) => Identity;

                                                                                                                                                                                                                                                                                                    method parseDN

                                                                                                                                                                                                                                                                                                    static parseDN: (dn: string) => Identity;

                                                                                                                                                                                                                                                                                                      method toArray

                                                                                                                                                                                                                                                                                                      toArray: () => IdentityNameComponent[];

                                                                                                                                                                                                                                                                                                        method toAsn1

                                                                                                                                                                                                                                                                                                        toAsn1: (der: BerWriter, tag?: number) => void;

                                                                                                                                                                                                                                                                                                          method toString

                                                                                                                                                                                                                                                                                                          toString: () => string;

                                                                                                                                                                                                                                                                                                            class InvalidAlgorithmError

                                                                                                                                                                                                                                                                                                            class InvalidAlgorithmError implements Error {}

                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                              constructor(algo: string);

                                                                                                                                                                                                                                                                                                                property algorithm

                                                                                                                                                                                                                                                                                                                algorithm: string;

                                                                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                                                                  message: string;

                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                      class Key

                                                                                                                                                                                                                                                                                                                      class Key {}

                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                        constructor(opts: KeyOptions);

                                                                                                                                                                                                                                                                                                                          property comment

                                                                                                                                                                                                                                                                                                                          comment?: string;

                                                                                                                                                                                                                                                                                                                            property curve

                                                                                                                                                                                                                                                                                                                            curve?: string;

                                                                                                                                                                                                                                                                                                                              property formats

                                                                                                                                                                                                                                                                                                                              static formats: {
                                                                                                                                                                                                                                                                                                                              openssh: Format;
                                                                                                                                                                                                                                                                                                                              pem: Format;
                                                                                                                                                                                                                                                                                                                              auto: Format;
                                                                                                                                                                                                                                                                                                                              pkcs1: Format;
                                                                                                                                                                                                                                                                                                                              pkcs8: Format;
                                                                                                                                                                                                                                                                                                                              rfc4253: Format;
                                                                                                                                                                                                                                                                                                                              ssh: Format;
                                                                                                                                                                                                                                                                                                                              'ssh-private': Format;
                                                                                                                                                                                                                                                                                                                              dnssec: Format;
                                                                                                                                                                                                                                                                                                                              putty: Format;
                                                                                                                                                                                                                                                                                                                              ppk: Format;
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                property part

                                                                                                                                                                                                                                                                                                                                part: { ecdsa: KeyPart; ed25519: KeyPart; dsa: KeyPart; rsa: KeyPart };

                                                                                                                                                                                                                                                                                                                                  property parts

                                                                                                                                                                                                                                                                                                                                  parts: KeyPart[];

                                                                                                                                                                                                                                                                                                                                    property size

                                                                                                                                                                                                                                                                                                                                    size: number;

                                                                                                                                                                                                                                                                                                                                      property source

                                                                                                                                                                                                                                                                                                                                      source?: string;

                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                        type: AlgorithmTypeWithCurve;

                                                                                                                                                                                                                                                                                                                                          method createDH

                                                                                                                                                                                                                                                                                                                                          createDH: () => DiffieHellman;

                                                                                                                                                                                                                                                                                                                                            method createDiffieHellman

                                                                                                                                                                                                                                                                                                                                            createDiffieHellman: () => DiffieHellman;

                                                                                                                                                                                                                                                                                                                                              method createVerify

                                                                                                                                                                                                                                                                                                                                              createVerify: (algo?: AlgorithmHashType) => Verify;

                                                                                                                                                                                                                                                                                                                                                method defaultHashAlgorithm

                                                                                                                                                                                                                                                                                                                                                defaultHashAlgorithm: () => ShaHashType;

                                                                                                                                                                                                                                                                                                                                                  method fingerprint

                                                                                                                                                                                                                                                                                                                                                  fingerprint: (
                                                                                                                                                                                                                                                                                                                                                  algo?: AlgorithmHashType,
                                                                                                                                                                                                                                                                                                                                                  type?: FingerprintHashType
                                                                                                                                                                                                                                                                                                                                                  ) => Fingerprint;

                                                                                                                                                                                                                                                                                                                                                    method hash

                                                                                                                                                                                                                                                                                                                                                    hash: (algo: AlgorithmHashType, type?: FingerprintHashType) => Buffer;

                                                                                                                                                                                                                                                                                                                                                      method isKey

                                                                                                                                                                                                                                                                                                                                                      static isKey: (obj: any, ver: Version) => boolean;

                                                                                                                                                                                                                                                                                                                                                        method parse

                                                                                                                                                                                                                                                                                                                                                        static parse: (
                                                                                                                                                                                                                                                                                                                                                        data: string | Buffer,
                                                                                                                                                                                                                                                                                                                                                        format?: KeyFormatType,
                                                                                                                                                                                                                                                                                                                                                        options?: string | KeyParseOptions
                                                                                                                                                                                                                                                                                                                                                        ) => Key;

                                                                                                                                                                                                                                                                                                                                                          method toBuffer

                                                                                                                                                                                                                                                                                                                                                          toBuffer: (format: KeyFormatType, options?: Format.WriteOptions) => Buffer;

                                                                                                                                                                                                                                                                                                                                                            method toString

                                                                                                                                                                                                                                                                                                                                                            toString: (format: KeyFormatType, options?: Format.WriteOptions) => string;

                                                                                                                                                                                                                                                                                                                                                              class KeyEncryptedError

                                                                                                                                                                                                                                                                                                                                                              class KeyEncryptedError implements Error {}

                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                constructor(name: string, format: string);

                                                                                                                                                                                                                                                                                                                                                                  property format

                                                                                                                                                                                                                                                                                                                                                                  format: string;

                                                                                                                                                                                                                                                                                                                                                                    property keyName

                                                                                                                                                                                                                                                                                                                                                                    keyName: string;

                                                                                                                                                                                                                                                                                                                                                                      property message

                                                                                                                                                                                                                                                                                                                                                                      message: string;

                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                          class KeyParseError

                                                                                                                                                                                                                                                                                                                                                                          class KeyParseError implements Error {}

                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                            constructor(name: string, format: string, innerErr: Error);

                                                                                                                                                                                                                                                                                                                                                                              property format

                                                                                                                                                                                                                                                                                                                                                                              format: string;

                                                                                                                                                                                                                                                                                                                                                                                property innerErr

                                                                                                                                                                                                                                                                                                                                                                                innerErr: Error;

                                                                                                                                                                                                                                                                                                                                                                                  property keyName

                                                                                                                                                                                                                                                                                                                                                                                  keyName: string;

                                                                                                                                                                                                                                                                                                                                                                                    property message

                                                                                                                                                                                                                                                                                                                                                                                    message: string;

                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                                                                                        class OpenSshCipherInfo

                                                                                                                                                                                                                                                                                                                                                                                        class OpenSshCipherInfo {}

                                                                                                                                                                                                                                                                                                                                                                                          property blockSize

                                                                                                                                                                                                                                                                                                                                                                                          blockSize: number;

                                                                                                                                                                                                                                                                                                                                                                                            property keySize

                                                                                                                                                                                                                                                                                                                                                                                            keySize: number;

                                                                                                                                                                                                                                                                                                                                                                                              property opensslName

                                                                                                                                                                                                                                                                                                                                                                                              opensslName: OpenSshCipherName;

                                                                                                                                                                                                                                                                                                                                                                                                class PrivateKey

                                                                                                                                                                                                                                                                                                                                                                                                class PrivateKey {}

                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                  constructor(opts: KeyOptions);

                                                                                                                                                                                                                                                                                                                                                                                                    property comment

                                                                                                                                                                                                                                                                                                                                                                                                    comment?: string;

                                                                                                                                                                                                                                                                                                                                                                                                      property curve

                                                                                                                                                                                                                                                                                                                                                                                                      curve?: string;

                                                                                                                                                                                                                                                                                                                                                                                                        property part

                                                                                                                                                                                                                                                                                                                                                                                                        part: { ecdsa: KeyPart; ed25519: KeyPart; dsa: KeyPart; rsa: KeyPart };

                                                                                                                                                                                                                                                                                                                                                                                                          property parts

                                                                                                                                                                                                                                                                                                                                                                                                          parts: KeyPart[];

                                                                                                                                                                                                                                                                                                                                                                                                            property size

                                                                                                                                                                                                                                                                                                                                                                                                            size: number;

                                                                                                                                                                                                                                                                                                                                                                                                              property source

                                                                                                                                                                                                                                                                                                                                                                                                              source?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                type: AlgorithmTypeWithCurve;

                                                                                                                                                                                                                                                                                                                                                                                                                  method createDH

                                                                                                                                                                                                                                                                                                                                                                                                                  createDH: () => DiffieHellman;

                                                                                                                                                                                                                                                                                                                                                                                                                    method createDiffieHellman

                                                                                                                                                                                                                                                                                                                                                                                                                    createDiffieHellman: () => DiffieHellman;

                                                                                                                                                                                                                                                                                                                                                                                                                      method createSign

                                                                                                                                                                                                                                                                                                                                                                                                                      createSign: (hashAlgo: AlgorithmType) => Signer;

                                                                                                                                                                                                                                                                                                                                                                                                                        method createVerify

                                                                                                                                                                                                                                                                                                                                                                                                                        createVerify: (algo?: AlgorithmHashType) => Verify;

                                                                                                                                                                                                                                                                                                                                                                                                                          method defaultHashAlgorithm

                                                                                                                                                                                                                                                                                                                                                                                                                          defaultHashAlgorithm: () => ShaHashType;

                                                                                                                                                                                                                                                                                                                                                                                                                            method derive

                                                                                                                                                                                                                                                                                                                                                                                                                            derive: (newType: 'ed25519' | 'curve25519') => PrivateKey;

                                                                                                                                                                                                                                                                                                                                                                                                                              method fingerprint

                                                                                                                                                                                                                                                                                                                                                                                                                              fingerprint: (
                                                                                                                                                                                                                                                                                                                                                                                                                              algo?: AlgorithmHashType,
                                                                                                                                                                                                                                                                                                                                                                                                                              type?: FingerprintHashType
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Fingerprint;

                                                                                                                                                                                                                                                                                                                                                                                                                                method generate

                                                                                                                                                                                                                                                                                                                                                                                                                                static generate: {
                                                                                                                                                                                                                                                                                                                                                                                                                                (type: 'ecdsa', options?: { curve?: CurveType }): PrivateKey;
                                                                                                                                                                                                                                                                                                                                                                                                                                (type: 'ed25519'): PrivateKey;
                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                  method hash

                                                                                                                                                                                                                                                                                                                                                                                                                                  hash: (algo: AlgorithmHashType, type?: FingerprintHashType) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method isPrivateKey

                                                                                                                                                                                                                                                                                                                                                                                                                                    static isPrivateKey: (data: any, ver: Version) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method parse

                                                                                                                                                                                                                                                                                                                                                                                                                                      static parse: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      data: string | Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                      format?: PrivateKeyFormatType,
                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: string | KeyParseOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => PrivateKey;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method toBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                        toBuffer: (
                                                                                                                                                                                                                                                                                                                                                                                                                                        format: PrivateKeyFormatType,
                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Format.WriteOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method toPublic

                                                                                                                                                                                                                                                                                                                                                                                                                                          toPublic: () => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                            toString: (
                                                                                                                                                                                                                                                                                                                                                                                                                                            format: PrivateKeyFormatType,
                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Format.WriteOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              class Signature

                                                                                                                                                                                                                                                                                                                                                                                                                                              class Signature {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(opts: SignatureOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property curve

                                                                                                                                                                                                                                                                                                                                                                                                                                                  curve?: CurveType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hashAlgorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                    hashAlgorithm?: AlgorithmHashType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property part

                                                                                                                                                                                                                                                                                                                                                                                                                                                      part: { s: SignaturePart; r: SignaturePart; sig: SignaturePart };

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property parts

                                                                                                                                                                                                                                                                                                                                                                                                                                                        parts: SignaturePart[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: AlgorithmType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                            static isSignature: (obj: any, ver: Version) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                              static parse: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              data: string | Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: AlgorithmType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              format: SignatureFormatType
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Signature;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method toBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                toBuffer: (format?: SignatureFormatType) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toString: (format?: SignatureFormatType) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SignatureParseError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SignatureParseError implements Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(type: string, format: string, innerErr: Error);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        format: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property innerErr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          innerErr: Error;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Signer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Signer extends Writable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sign: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    private_key:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | crypto.KeyLike
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | crypto.SignKeyObjectInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | crypto.SignPrivateKeyInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): Buffer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (private_key: any, output_format: crypto.BinaryToTextEncoding): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (): Signature;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (data: crypto.BinaryLike): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (data: string, input_encoding: crypto.Encoding): this;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SSHBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SSHBuffer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(opts: { buffer?: Buffer });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method atEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            atEnd: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method expand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              expand: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method readBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readBuffer: () => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method readChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readChar: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method readCString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readCString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method readInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readInt: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method readInt64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readInt64: () => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method readPart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readPart: () => SSHPart;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method readString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method remainder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              remainder: () => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                skip: (n: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method toBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toBuffer: () => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    write: (buf: Buffer) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method writeBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writeBuffer: (buf: Buffer) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method writeChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        writeChar: (buf: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method writeCString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          writeCString: (buf: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method writeInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            writeInt: (buf: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method writeInt64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              writeInt64: (buf: Buffer) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method writePart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                writePart: (buf: SSHPart) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method writeString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  writeString: (buf: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SSHPart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SSHPart {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      data: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SshPK

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SshPK {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Verifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Verifier extends Writable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(key: Key, hashAlgo: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              update: (chunk: string | Buffer) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                verify: (signature: Signature) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CertificateCreateOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CertificateCreateOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ca

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ca?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property lifetime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lifetime?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property purposes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        purposes?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property serial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serial?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property validFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            validFrom?: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property validUntil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              validUntil?: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CertificateOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CertificateOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property issuer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  issuer: Identity;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property issuerKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    issuerKey?: Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property purposes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      purposes?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property serial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serial: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property signatures

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          signatures: { x509: Signature; openssh: Signature };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property subjectKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            subjectKey: Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property subjects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              subjects: Identity[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property validFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                validFrom: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property validUntil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  validUntil: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FingerprintOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FingerprintOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      algorithm: AlgorithmHashType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hash: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property hashType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hashType?: FingerprintHashType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: FingerprintType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FingerprintParseOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FingerprintParseOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property algotirhms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                algotirhms?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property enAlgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enAlgs?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hashType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hashType?: FingerprintHashType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: FingerprintType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          read: (buf: string | Buffer, options?: Format.ReadOptions) => Certificate | Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            write: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keyOrCert: Certificate | PrivateKey | Key,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Format.WriteOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IdentityComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IdentityComponent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property asn1type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                asn1type?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name?: IndentityOidName;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property oid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    oid?: IdentityOidValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: Buffer | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IdentityNameComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IdentityNameComponent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: IndentityOidName;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: Buffer | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface KeyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface KeyOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property comment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                comment?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property parts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parts: KeyPart[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: AlgorithmTypeWithCurve;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface KeyParseOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface KeyParseOptions extends Format.ReadOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property filename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filename?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface KeyPart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface KeyPart {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              data: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: AlgorithmPart;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface OpenSslKeyDeriv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface OpenSslKeyDeriv {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property iv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    iv: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SignatureOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SignatureOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property curve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          curve?: CurveType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property hashAlgo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hashAlgo?: AlgorithmHashType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property parts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parts: SignaturePart[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: AlgorithmType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SignaturePart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SignaturePart {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: SignaturePartType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Verify {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • extends crypto.Verify but override 'verify' function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        update: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (data: crypto.BinaryLike): Verify;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (data: string, input_encoding: crypto.Encoding): Verify;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          verify: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (signature: Signature): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (signature: any, fmt?: crypto.BinaryToTextEncoding): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AlgorithmHashType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AlgorithmHashType = 'md5' | ShaHashType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type AlgorithmPart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type AlgorithmPart =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'p'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'q'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'g'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'y'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'x'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'n'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'e'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'd'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'iqmp'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'curve'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'Q'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'A'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'k';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AlgorithmType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AlgorithmType = 'dsa' | 'rsa' | 'ecdsa' | 'ed25519';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AlgorithmTypeWithCurve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type AlgorithmTypeWithCurve = AlgorithmType | 'curve25519';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CertificateFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CertificateFormat = 'openssh' | 'pem' | 'x509';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CurveType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CurveType = 'nistp256' | 'nistp384' | 'nistp521';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FingerprintHashType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FingerprintHashType = 'ssh' | 'spki';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FingerprintType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FingerprintType = 'key' | 'certificate';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IdentityOidValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IdentityOidValue =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.3'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.10'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.11'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.7'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.8'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.6'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.4'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.17'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.5'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.9'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.45'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.72'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.20'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.13'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '0.9.2342.19200300.100.1.25'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '0.9.2342.19200300.100.1.1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '0.9.2342.19200300.100.1.3'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.12'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.42'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.43'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '2.5.4.65'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | '1.2.840.113549.1.9.1';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IdentityType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IdentityType = 'host' | 'user' | 'email';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IdentityTypeWithUnknown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IdentityTypeWithUnknown = IdentityType | 'unknown';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IndentityOidName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IndentityOidName =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'cn'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'o'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'ou'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'l'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 's'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'c'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'sn'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'postalCode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'serialNumber'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'street'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'x500UniqueIdentifier'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'role'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'telephoneNumber'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'description'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'dc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'uid'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'mail'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'title'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'gn'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'initials'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'pseudonym'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'emailAddress';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type KeyFormatType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type KeyFormatType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'auto'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'pem'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'pkcs1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'pkcs8'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'rfc4253'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'ssh'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'ssh-private'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'openssh'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'dnssec'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'putty'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'ppk';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type KeyType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type KeyType = 'public' | 'private';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type OpenSshCipherName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type OpenSshCipherName =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'des-ede3-cbc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'bf-cbc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'aes-128-cbc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'aes-128-ctr'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'aes-128-gcm'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'aes-192-cbc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'aes-192-ctr'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'aes-192-gcm'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'aes-256-cbc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'aes-256-ctr'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'aes-256-gcm';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PrivateKeyFormatType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PrivateKeyFormatType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'auto'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'pem'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'pkcs1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'pkcs8'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'rfc4253'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'ssh'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'ssh-private'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'openssh'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'dnssec';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ShaHashType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ShaHashType = 'sha1' | 'sha256' | 'sha384' | 'sha512';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SignatureFormatType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SignatureFormatType = 'asn1' | 'ssh' | 'raw';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SignaturePartType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SignaturePartType = 'r' | 's' | 'sig';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Version = [number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace Format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Auto

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Auto extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        read: (buf: string | Buffer, options?: ReadOptions) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          write: (key: Key) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DnsSec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DnsSec extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              read: (buf: string | Buffer) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                write: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                key: PrivateKey,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: { hashAlgo?: 'sha1' | 'sha256' | 'sha512' }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface OpenSshCert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface OpenSshCert extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    read: (buf: string | Buffer) => Certificate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sign: (cert: Certificate, key: PrivateKey) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method signAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        signAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cert: Certificate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        signer: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        blob: Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        done: (err: Error | undefined, signature: Signature) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        done: (err?: Error) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          verify: () => false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            write: (cert: Certificate, options?: { comment?: string }) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface OpenSshSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface OpenSshSignature {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property exts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                exts: OpenSshSignatureExt[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property keyId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  keyId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property nonce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nonce: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signature: Signature;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface OpenSshSignatureExt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface OpenSshSignatureExt {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property critical

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          critical: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Pem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Pem extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  read: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  buf: string | Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: ReadOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  forceType?: 'pkcs1' | 'pkcs8'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    write: (key: Key, options?: any, type?: 'pkcs1' | 'pkcs8') => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Pkcs1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Pkcs1 extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        read: (buf: string | Buffer, options?: ReadOptions) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method readPkcs1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readPkcs1: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (alg: 'RSA' | 'DSA' | 'EC' | 'ECDSA', type: 'public', der: BerReader): Key;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          alg: 'RSA' | 'DSA' | 'EC' | 'ECDSA' | 'EDDSA' | 'EdDSA',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'private',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          der: BerReader
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): PrivateKey;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            write: (key: Key) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method writePkcs1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              writePkcs1: (der: BerWriter, key: Key) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Pkcs8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Pkcs8 extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method pkcs8ToBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pkcs8ToBuffer: (key: Key) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    read: (buf: string | Buffer, options?: ReadOptions) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method readECDSACurve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readECDSACurve: (der: BerReader) => CurveType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method readPkcs8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readPkcs8: (alg: any, type: KeyType, der: BerReader) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          write: (key: Key) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method writeECDSACurve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            writeECDSACurve: (key: Key, der: BerWriter) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method writePkcs8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              writePkcs8: (der: BerWriter, key: Key) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Putty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Putty extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  read: (buf: string | Buffer) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    write: (key: Key) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ReadOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ReadOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cipher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cipher?: SshPrivateCipher;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property passphrase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          passphrase?: string | Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Rfc4253

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Rfc4253 extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method algToKeyType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              algToKeyType: (alg: Rfc4253Algorithm) => AlgorithmTypeWithCurve;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method keyTypeToAlg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                keyTypeToAlg: (key: Key) => Rfc4253Algorithm;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  read: (buf: string | Buffer) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method readInternal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readInternal: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    partial: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: KeyType | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    buf: string | Buffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method readPartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readPartial: (type: KeyType | undefined, buf: string | Buffer) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method readType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readType: (type: KeyType | undefined, buf: string | Buffer) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          write: (key: Key) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Ssh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Ssh extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              read: (buf: string | Buffer) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                write: (key: Key) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SshPrivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SshPrivate extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    read: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    buf: string | Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: ReadOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forceType?: 'pkcs1' | 'pkcs8'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method readSSHPrivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readSSHPrivate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      buf: Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: { passphrase: string | Buffer }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        write: (key: Key, options?: ReadOptions) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface WriteOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface WriteOptions extends ReadOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property comment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            comment?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hashAlgo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hashAlgo?: 'sha1' | 'sha256' | 'sha512';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface x509

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface x509 extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  read: (buf: string | Buffer) => Certificate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sign: (cert: Certificate, key: PrivateKey) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method signAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cert: Certificate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      signer: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      blob: Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      done: (err: Error | undefined, signature: Signature) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      done: (err?: Error) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        verify: (cert: Certificate, key: Key) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          write: (cert: Certificate) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface x509Pem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface x509Pem extends Format {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              read: (buf: string | Buffer) => Certificate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sign: (cert: Certificate, key: PrivateKey) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  verify: (cert: Certificate, key: Key) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    write: (cert: Certificate) => Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface x509Signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface x509Signature {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property algo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        algo: x509SignAlgorithm;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cache: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property extras

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extras: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            issuerUniqueID: Buffer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            subjectUniqueID: Buffer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            exts: x509SignatureExt[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              signature: Signature;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface x509SignatureExt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface x509SignatureExt {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bits?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property critical

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    critical: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      data?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property oid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        oid: x509ExtsOid;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property pathLen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pathLen?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Rfc4253Algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Rfc4253Algorithm =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'ssh-dss'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'ssh-rsa'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'ssh-ed25519'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'ssh-curve25519'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'ecdsa-sha2-nistp256'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'ecdsa-sha2-nistp384'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'ecdsa-sha2-nistp521';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SshPrivateCipher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SshPrivateCipher =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '3des-cbc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'blowfish-cbc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'aes128-cbc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'aes128-ctr'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'aes128-gcm@openssh.com'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'aes192-cbc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'aes192-ctr'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'aes192-gcm@openssh.com'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'aes256-cbc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'aes256-ctr'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'aes256-gcm@openssh.com';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type x509ExtsOid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type x509ExtsOid =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | '2.5.29.35'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | '2.5.29.17'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | '2.5.29.19'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | '2.5.29.15'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | '2.5.29.37';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type x509SignAlgorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type x509SignAlgorithm =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'rsa-md5'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'rsa-sha1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'rsa-sha256'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'rsa-sha384'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'rsa-sha512'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'dsa-sha1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'dsa-sha256'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'ecdsa-sha1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'ecdsa-sha256'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'ecdsa-sha384'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'ecdsa-sha512'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'ed25519-sha512';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace PrivateKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace PrivateKey {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable formats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      let formats: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      openssh: Format;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pem: Format;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      auto: Format;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pkcs1: Format;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pkcs8: Format;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rfc4253: Format;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ssh: Format;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'ssh-private': Format;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dnssec: Format;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto 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/sshpk.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/sshpk)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/@types/sshpk"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>