@types/sshpk

  • Version 1.10.5
  • Published
  • 11.5 kB
  • 1 dependency
  • MIT license

Install

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

Overview

TypeScript definitions for sshpk

Index

Functions

Classes

Functions

function addRSAMissing

addRSAMissing: (key: PrivateKey) => void;

    function assertCompatible

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

      function bufferSplit

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

        function calculateDSAPublic

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

          function countZeros

          countZeros: (buf: any) => number;

            function createCertificate

            createCertificate: (
            subjectOrSubjects: string,
            key: Key,
            issuer: string,
            issuerKey: PrivateKey,
            options?: any
            ) => Certificate;

              function createSelfSignedCertificate

              createSelfSignedCertificate: (
              subjectOrSubjects: string,
              key: Key,
              options?: any
              ) => Certificate;

                function ecNormalize

                ecNormalize: (buf: any, addZero: boolean) => any;

                  function identityForEmail

                  identityForEmail: (email: string) => Identity;

                    function identityForHost

                    identityForHost: (hostname: string) => Identity;

                      function identityForUser

                      identityForUser: (uid: string) => Identity;

                        function identityFromDN

                        identityFromDN: (dn: string) => Identity;

                          function isCompatible

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

                            function mpNormalize

                            mpNormalize: (buf: any) => any;

                              function opensshCipherInfo

                              opensshCipherInfo: (cipber: string) => OpensshCipherInfo;

                                function opensslKeyDeriv

                                opensslKeyDeriv: (
                                cipher: string,
                                salt: string,
                                passphrase: string,
                                count: number
                                ) => OpenSllKeyDeriv;

                                  function parseCertificate

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

                                    function parseFingerprint

                                    parseFingerprint: (fp: string, options?: any) => Fingerprint;

                                      function parseKey

                                      parseKey: (data: string | Buffer, format: string, options?: any) => Key;

                                        function parsePrivateKey

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

                                          function parseSignature

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

                                            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: any);

                                                                                          property formats

                                                                                          static formats: Formats;

                                                                                            property issuer

                                                                                            issuer: string;

                                                                                              property issuerKey

                                                                                              issuerKey: string;

                                                                                                property serial

                                                                                                serial: string;

                                                                                                  property signatures

                                                                                                  signatures: string;

                                                                                                    property subjectKey

                                                                                                    subjectKey: string;

                                                                                                      property subjects

                                                                                                      subjects: Identity[];

                                                                                                        property validFrom

                                                                                                        validFrom: string;

                                                                                                          property validUntil

                                                                                                          validUntil: string;

                                                                                                            method create

                                                                                                            static create: (
                                                                                                            subjectOrSubjects: string,
                                                                                                            key: Key,
                                                                                                            issuer: string,
                                                                                                            issuerKey: PrivateKey,
                                                                                                            options: any
                                                                                                            ) => Certificate;

                                                                                                              method createSelfSigned

                                                                                                              static createSelfSigned: (
                                                                                                              subjectOrSubjects: string,
                                                                                                              key: Key,
                                                                                                              options: any
                                                                                                              ) => Certificate;

                                                                                                                method fingerprint

                                                                                                                fingerprint: (algo: string) => Fingerprint;

                                                                                                                  method hash

                                                                                                                  hash: (algo: string) => string;

                                                                                                                    method isCertificate

                                                                                                                    static isCertificate: (data: string | Buffer, ver: string) => 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: string,
                                                                                                                            options: any
                                                                                                                            ) => Certificate;

                                                                                                                              method signWith

                                                                                                                              signWith: (key: Key) => void;

                                                                                                                                method toBuffer

                                                                                                                                toBuffer: (format: string, options?: any) => any;

                                                                                                                                  method toString

                                                                                                                                  toString: (format: string, options?: any) => string;

                                                                                                                                    class CertificateParseError

                                                                                                                                    class CertificateParseError implements Error {}

                                                                                                                                      constructor

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

                                                                                                                                        property message

                                                                                                                                        message: string;

                                                                                                                                          property name

                                                                                                                                          name: string;

                                                                                                                                            class Curve

                                                                                                                                            class Curve {}

                                                                                                                                              property a

                                                                                                                                              a: any;

                                                                                                                                                property b

                                                                                                                                                b: any;

                                                                                                                                                  property G

                                                                                                                                                  G: any;

                                                                                                                                                    property n

                                                                                                                                                    n: any;

                                                                                                                                                      property p

                                                                                                                                                      p: any;

                                                                                                                                                        property pkcs8oid

                                                                                                                                                        pkcs8oid: string;

                                                                                                                                                          property s

                                                                                                                                                          s: any;

                                                                                                                                                            property size

                                                                                                                                                            size: number;

                                                                                                                                                              class curves

                                                                                                                                                              class curves {}

                                                                                                                                                                property nistp256

                                                                                                                                                                nistp256: Curve;

                                                                                                                                                                  property nistp384

                                                                                                                                                                  nistp384: Curve;

                                                                                                                                                                    property nistp512

                                                                                                                                                                    nistp512: Curve;

                                                                                                                                                                      class DiffieHellman

                                                                                                                                                                      class DiffieHellman {}

                                                                                                                                                                        constructor

                                                                                                                                                                        constructor(key: Key);

                                                                                                                                                                          method computeSecret

                                                                                                                                                                          computeSecret: (otherpk: PrivateKey) => any;

                                                                                                                                                                            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 ECPrivate

                                                                                                                                                                                          class ECPrivate {}

                                                                                                                                                                                            constructor

                                                                                                                                                                                            constructor(params: X9ECParameters, buffer: any);

                                                                                                                                                                                              method deriveSharedSecret

                                                                                                                                                                                              deriveSharedSecret: (pk: Key) => any;

                                                                                                                                                                                                class ECPublic

                                                                                                                                                                                                class ECPublic {}

                                                                                                                                                                                                  constructor

                                                                                                                                                                                                  constructor(params: X9ECParameters, buffer: any);

                                                                                                                                                                                                    class Fingerprint

                                                                                                                                                                                                    class Fingerprint {}

                                                                                                                                                                                                      constructor

                                                                                                                                                                                                      constructor(opts: any);

                                                                                                                                                                                                        property algorithm

                                                                                                                                                                                                        algorithm: string;

                                                                                                                                                                                                          property hash

                                                                                                                                                                                                          hash: string;

                                                                                                                                                                                                            property type

                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                              method addColons

                                                                                                                                                                                                              addColons: (fp: string) => string;

                                                                                                                                                                                                                method base64Strip

                                                                                                                                                                                                                base64Strip: (fp: string) => string;

                                                                                                                                                                                                                  method isFingerprint

                                                                                                                                                                                                                  isFingerprint: (obj: string | Buffer, ver: string) => boolean;

                                                                                                                                                                                                                    method matches

                                                                                                                                                                                                                    matches: (other: Fingerprint) => boolean;

                                                                                                                                                                                                                      method parse

                                                                                                                                                                                                                      static parse: (fp: string, options: any) => Fingerprint;

                                                                                                                                                                                                                        method sshBase64Format

                                                                                                                                                                                                                        sshBase64Format: (alg: string, h: string) => string;

                                                                                                                                                                                                                          method toString

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

                                                                                                                                                                                                                            class FingerprintFormatError

                                                                                                                                                                                                                            class FingerprintFormatError implements Error {}

                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                              constructor(fp: Fingerprint, format: string);

                                                                                                                                                                                                                                property message

                                                                                                                                                                                                                                message: string;

                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                    class Format

                                                                                                                                                                                                                                    class Format {}

                                                                                                                                                                                                                                      property read

                                                                                                                                                                                                                                      read: (buf: any, options?: any) => any;

                                                                                                                                                                                                                                        property write

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

                                                                                                                                                                                                                                          class Formats

                                                                                                                                                                                                                                          class Formats {}

                                                                                                                                                                                                                                            property "ssh-private"

                                                                                                                                                                                                                                            'ssh-private': Format;

                                                                                                                                                                                                                                              property auto

                                                                                                                                                                                                                                              auto: Format;

                                                                                                                                                                                                                                                property openssh

                                                                                                                                                                                                                                                openssh: Format;

                                                                                                                                                                                                                                                  property pem

                                                                                                                                                                                                                                                  pem: Format;

                                                                                                                                                                                                                                                    property pkcs1

                                                                                                                                                                                                                                                    pkcs1: Format;

                                                                                                                                                                                                                                                      property pkcs8

                                                                                                                                                                                                                                                      pkcs8: Format;

                                                                                                                                                                                                                                                        property rfc4253

                                                                                                                                                                                                                                                        rfc4253: Format;

                                                                                                                                                                                                                                                          property ssh

                                                                                                                                                                                                                                                          ssh: Format;

                                                                                                                                                                                                                                                            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: any);

                                                                                                                                                                                                                                                                            property cn

                                                                                                                                                                                                                                                                            cn: string;

                                                                                                                                                                                                                                                                              property componentLookup

                                                                                                                                                                                                                                                                              componentLookup: any;

                                                                                                                                                                                                                                                                                property components

                                                                                                                                                                                                                                                                                components: string[];

                                                                                                                                                                                                                                                                                  property email

                                                                                                                                                                                                                                                                                  email: string;

                                                                                                                                                                                                                                                                                    property hostname

                                                                                                                                                                                                                                                                                    hostname: string;

                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                        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 isIdentity

                                                                                                                                                                                                                                                                                                  static isIdentity: (dn: Buffer | string, ver: string) => boolean;

                                                                                                                                                                                                                                                                                                    method parseAsn1

                                                                                                                                                                                                                                                                                                    static parseAsn1: (dn: Buffer | string, top: string) => Identity;

                                                                                                                                                                                                                                                                                                      method parseDN

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

                                                                                                                                                                                                                                                                                                        method toAsn1

                                                                                                                                                                                                                                                                                                        toAsn1: (der: Buffer | string, tag: string) => void;

                                                                                                                                                                                                                                                                                                          method toString

                                                                                                                                                                                                                                                                                                          toString: () => string;

                                                                                                                                                                                                                                                                                                            class InvalidAlgorithmError

                                                                                                                                                                                                                                                                                                            class InvalidAlgorithmError implements Error {}

                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                              constructor(algo: string);

                                                                                                                                                                                                                                                                                                                property message

                                                                                                                                                                                                                                                                                                                message: string;

                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                    class Key

                                                                                                                                                                                                                                                                                                                    class Key {}

                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                      constructor(opts: any);

                                                                                                                                                                                                                                                                                                                        property comment

                                                                                                                                                                                                                                                                                                                        comment?: string;

                                                                                                                                                                                                                                                                                                                          property curve

                                                                                                                                                                                                                                                                                                                          curve?: string;

                                                                                                                                                                                                                                                                                                                            property formats

                                                                                                                                                                                                                                                                                                                            static formats: Formats;

                                                                                                                                                                                                                                                                                                                              property part

                                                                                                                                                                                                                                                                                                                              part: string;

                                                                                                                                                                                                                                                                                                                                property parts

                                                                                                                                                                                                                                                                                                                                parts: string;

                                                                                                                                                                                                                                                                                                                                  property size

                                                                                                                                                                                                                                                                                                                                  size: number;

                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                    source?: string;

                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                      type: string;

                                                                                                                                                                                                                                                                                                                                        method createDH

                                                                                                                                                                                                                                                                                                                                        createDH: () => DiffieHellman;

                                                                                                                                                                                                                                                                                                                                          method createDiffieHellman

                                                                                                                                                                                                                                                                                                                                          createDiffieHellman: () => DiffieHellman;

                                                                                                                                                                                                                                                                                                                                            method createVerify

                                                                                                                                                                                                                                                                                                                                            createVerify: (algo: string) => Verify;

                                                                                                                                                                                                                                                                                                                                              method defaultHashAlgorithm

                                                                                                                                                                                                                                                                                                                                              defaultHashAlgorithm: () => string;

                                                                                                                                                                                                                                                                                                                                                method fingerprint

                                                                                                                                                                                                                                                                                                                                                fingerprint: (algo: string) => Fingerprint;

                                                                                                                                                                                                                                                                                                                                                  method hash

                                                                                                                                                                                                                                                                                                                                                  hash: (algo: string) => any;

                                                                                                                                                                                                                                                                                                                                                    method isKey

                                                                                                                                                                                                                                                                                                                                                    static isKey: (obj: string | Buffer, ver: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                      method parse

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

                                                                                                                                                                                                                                                                                                                                                        method toBuffer

                                                                                                                                                                                                                                                                                                                                                        toBuffer: (format: string, options?: any) => any;

                                                                                                                                                                                                                                                                                                                                                          method toString

                                                                                                                                                                                                                                                                                                                                                          toString: (format: string, options?: any) => string;

                                                                                                                                                                                                                                                                                                                                                            class KeyEncryptedError

                                                                                                                                                                                                                                                                                                                                                            class KeyEncryptedError implements Error {}

                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                              constructor(name: string, format: string);

                                                                                                                                                                                                                                                                                                                                                                property message

                                                                                                                                                                                                                                                                                                                                                                message: string;

                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                    class KeyParseError

                                                                                                                                                                                                                                                                                                                                                                    class KeyParseError implements Error {}

                                                                                                                                                                                                                                                                                                                                                                      constructor

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

                                                                                                                                                                                                                                                                                                                                                                        property message

                                                                                                                                                                                                                                                                                                                                                                        message: string;

                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                            class OpenSllKeyDeriv

                                                                                                                                                                                                                                                                                                                                                                            class OpenSllKeyDeriv {}

                                                                                                                                                                                                                                                                                                                                                                              property iv

                                                                                                                                                                                                                                                                                                                                                                              iv: any;

                                                                                                                                                                                                                                                                                                                                                                                property key

                                                                                                                                                                                                                                                                                                                                                                                key: any;

                                                                                                                                                                                                                                                                                                                                                                                  class OpensshCipherInfo

                                                                                                                                                                                                                                                                                                                                                                                  class OpensshCipherInfo {}

                                                                                                                                                                                                                                                                                                                                                                                    property blockSize

                                                                                                                                                                                                                                                                                                                                                                                    blockSize: number;

                                                                                                                                                                                                                                                                                                                                                                                      property keySize

                                                                                                                                                                                                                                                                                                                                                                                      keySize: number;

                                                                                                                                                                                                                                                                                                                                                                                        property opensslName

                                                                                                                                                                                                                                                                                                                                                                                        opensslName: string;

                                                                                                                                                                                                                                                                                                                                                                                          class PrivateKey

                                                                                                                                                                                                                                                                                                                                                                                          class PrivateKey {}

                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                            constructor(opts: any);

                                                                                                                                                                                                                                                                                                                                                                                              property comment

                                                                                                                                                                                                                                                                                                                                                                                              comment?: string;

                                                                                                                                                                                                                                                                                                                                                                                                property formats

                                                                                                                                                                                                                                                                                                                                                                                                static formats: Formats;

                                                                                                                                                                                                                                                                                                                                                                                                  method createSign

                                                                                                                                                                                                                                                                                                                                                                                                  createSign: (hashAlgo: string) => Signer;

                                                                                                                                                                                                                                                                                                                                                                                                    method createVerify

                                                                                                                                                                                                                                                                                                                                                                                                    createVerify: (hashAlgo: string) => Key;

                                                                                                                                                                                                                                                                                                                                                                                                      method derive

                                                                                                                                                                                                                                                                                                                                                                                                      derive: (newType: string, newSize: number) => PrivateKey;

                                                                                                                                                                                                                                                                                                                                                                                                        method hash

                                                                                                                                                                                                                                                                                                                                                                                                        hash: (algo: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                          method isPrivateKey

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

                                                                                                                                                                                                                                                                                                                                                                                                            method parse

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

                                                                                                                                                                                                                                                                                                                                                                                                              method toBuffer

                                                                                                                                                                                                                                                                                                                                                                                                              toBuffer: (format: string, options: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                method toPublic

                                                                                                                                                                                                                                                                                                                                                                                                                toPublic: () => Key;

                                                                                                                                                                                                                                                                                                                                                                                                                  class Signature

                                                                                                                                                                                                                                                                                                                                                                                                                  class Signature {}

                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(opts: any);

                                                                                                                                                                                                                                                                                                                                                                                                                      method isSignature

                                                                                                                                                                                                                                                                                                                                                                                                                      static isSignature: (obj: string | Buffer, ver: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                        method parse

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

                                                                                                                                                                                                                                                                                                                                                                                                                          method toBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                          toBuffer: (format: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                            method toString

                                                                                                                                                                                                                                                                                                                                                                                                                            toString: (format: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                              class SignatureParseError

                                                                                                                                                                                                                                                                                                                                                                                                                              class SignatureParseError implements Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                                                                                                                                                                                  message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      class Signer

                                                                                                                                                                                                                                                                                                                                                                                                                                      class Signer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(key: Key, hashAlgo: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                          method sign

                                                                                                                                                                                                                                                                                                                                                                                                                                          sign: () => Signature;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method update

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

                                                                                                                                                                                                                                                                                                                                                                                                                                              class SSHBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                              class SSHBuffer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(opts: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method atEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                  atEnd: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method expand

                                                                                                                                                                                                                                                                                                                                                                                                                                                    expand: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method readBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                      readBuffer: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method readChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                        readChar: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method readInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                          readInt: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method readInt64

                                                                                                                                                                                                                                                                                                                                                                                                                                                            readInt64: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method readPart

                                                                                                                                                                                                                                                                                                                                                                                                                                                              readPart: () => SSHPart;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method readString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                readString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method remainder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  remainder: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skip: (n: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toBuffer: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        write: (buf: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method writeBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          writeBuffer: (buf: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method writeChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            writeChar: (buf: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method writeCString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              writeCString: (buf: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method writeInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                writeInt: (buf: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method writeInt64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  writeInt64: (buf: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method writePart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    writePart: (buf: SSHPart) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method writeString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writeString: (buf: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SSHPart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SSHPart {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class SshPK

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class SshPK {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Verifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Verifier {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(key: Key, hashAlgo: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method update

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    verify: (signature: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Verify {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        verify: (data: string, fmt: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class X9ECParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class X9ECParameters {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property g

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            g: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property G

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              G: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property h

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                h: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property n

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  n: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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>