@types/sshpk

  • Version 1.10.7
  • Published
  • 14.6 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: Identity | Identity[],
            key: Key,
            issuer: Identity,
            issuerKey: PrivateKey,
            options?: {
            validFrom?: Date;
            validUntil?: Date;
            lifetime?: number;
            serial?: Buffer;
            purposes?: string[];
            }
            ) => Certificate;

              function createSelfSignedCertificate

              createSelfSignedCertificate: (
              subjectOrSubjects: Identity | Identity[],
              key: Key,
              options?: {
              validFrom?: Date;
              validUntil?: Date;
              lifetime?: number;
              serial?: Buffer;
              purposes?: string[];
              }
              ) => 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: Identity;

                                                                                              property issuerKey

                                                                                              issuerKey: Key;

                                                                                                property serial

                                                                                                serial: any;

                                                                                                  property signatures

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

                                                                                                    property subjectKey

                                                                                                    subjectKey: Key;

                                                                                                      property subjects

                                                                                                      subjects: Identity[];

                                                                                                        property validFrom

                                                                                                        validFrom: Date;

                                                                                                          property validUntil

                                                                                                          validUntil: Date;

                                                                                                            method create

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

                                                                                                              method createSelfSigned

                                                                                                              static createSelfSigned: (
                                                                                                              subjectOrSubjects: Identity[],
                                                                                                              key: Key,
                                                                                                              options: {
                                                                                                              validFrom?: Date;
                                                                                                              validUntil?: Date;
                                                                                                              lifetime?: number;
                                                                                                              serial?: Buffer;
                                                                                                              purposes?: string[];
                                                                                                              }
                                                                                                              ) => Certificate;

                                                                                                                method fingerprint

                                                                                                                fingerprint: (algo: string) => Fingerprint;

                                                                                                                  method getExtension

                                                                                                                  getExtension: (
                                                                                                                  keyOrOid: string
                                                                                                                  ) =>
                                                                                                                  | { format: 'x509'; oid: string; critical: boolean; pathLen: number }
                                                                                                                  | { format: 'openssh'; name: string; critical: boolean; data: Buffer }
                                                                                                                  | undefined;

                                                                                                                    method getExtensions

                                                                                                                    getExtensions: () =>
                                                                                                                    | Array<{ format: 'x509'; oid: string; critical: boolean; pathLen: number }>
                                                                                                                    | Array<{
                                                                                                                    format: 'openssh';
                                                                                                                    name: string;
                                                                                                                    critical: boolean;
                                                                                                                    data: Buffer;
                                                                                                                    }>;

                                                                                                                      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: {
                                                                                                                                validFrom?: Date;
                                                                                                                                validUntil?: Date;
                                                                                                                                lifetime?: number;
                                                                                                                                serial?: Buffer;
                                                                                                                                purposes?: string[];
                                                                                                                                }
                                                                                                                                ) => Certificate;

                                                                                                                                  method signWith

                                                                                                                                  signWith: (key: PrivateKey) => 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);

                                                                                                                                                                                                                                                                                                                                                                                                                          property extras

                                                                                                                                                                                                                                                                                                                                                                                                                          extras?: { exts?: { oid: string; critical: boolean; pathLen: number } }[];

                                                                                                                                                                                                                                                                                                                                                                                                                            property exts

                                                                                                                                                                                                                                                                                                                                                                                                                            exts?: { name: string; critical: boolean; data: 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 extends Stream.Writable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                method sign

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                  update: { (data: any): this; (data: string, input_encoding: any): this };

                                                                                                                                                                                                                                                                                                                                                                                                                                                    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>