@types/sshpk

Version 1.17.4
Published 1 year ago
28.3 kB
2 dependencies
MIT license

Install

npm i @types/sshpk

yarn add @types/sshpk

pnpm add @types/sshpk

Overview

TypeScript definitions for sshpk

Index

Classes

algInfo
Algo
algPrivInfo
algs
Certificate
CertificateParseError
Curve
- a
- b
- G
- n
- p
- pkcs8oid
- s
- size
curves
DiffieHellman
Fingerprint
FingerprintFormatError
hashAlgs
Identity
InvalidAlgorithmError
Key
KeyEncryptedError
KeyParseError
OpenSshCipherInfo
PrivateKey
Signature
SignatureParseError
Signer
- sign()
- update()
SSHBuffer
SSHPart
- data
SshPK
Verifier
- update()
- verify()

Functions

function addRSAMissing

addRSAMissing: (key: PrivateKey) => void;

function assertCompatible

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

function bufferSplit

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

function calculateDSAPublic

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

function calculateED25519Public

calculateED25519Public: (k: Buffer) => Buffer;

function calculateX25519Public

calculateX25519Public: (k: Buffer) => Buffer;

function countZeros

countZeros: (buf: Buffer) => number;

function createCertificate

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

function createSelfSignedCertificate

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

function ecNormalize

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

function generatePrivateKey

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

function identityForEmail

identityForEmail: (email: string) => Identity;

function identityForHost

identityForHost: (hostname: string) => Identity;

function identityForUser

identityForUser: (uid: string) => Identity;

function identityFromArray

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

function identityFromDN

identityFromDN: (dn: string) => Identity;

function isCompatible

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

function mpDenormalize

mpDenormalize: (buf: Buffer) => Buffer;

function mpNormalize

mpNormalize: (buf: Buffer) => Buffer;

function opensshCipherInfo

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

function opensslKeyDeriv

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

function parseCertificate

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

function parseFingerprint

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

function parseKey

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

function parsePrivateKey

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

function parseSignature

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

function pbkdf2

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

function publicFromPrivateECDSA

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

function readBitString

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

function writeBitString

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

function zeroPadToLength

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

Classes

class algInfo

class algInfo {}

property curve25519

curve25519: Algo;

property dsa

dsa: Algo;

property ecdsa

ecdsa: Algo;

property ed25519

ed25519: Algo;

property rsa

rsa: Algo;

class Algo

class Algo {}

property normalize

normalize?: boolean;

property parts

parts: string[];

property sizePart

sizePart?: string;

class algPrivInfo

class algPrivInfo {}

property curve25519

curve25519: Algo;

property dsa

dsa: Algo;

property ecdsa

ecdsa: Algo;

property ed25519

ed25519: Algo;

property rsa

rsa: Algo;

class algs

class algs {}

property curves

curves: curves;

property hashAlgs

hashAlgs: hashAlgs;

property info

info: algInfo;

property privInfo

privInfo: algPrivInfo;

class Certificate

class Certificate {}

constructor

constructor(opts: CertificateOptions);

property formats

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

property issuer

issuer: Identity;

property issuerKey

issuerKey?: Key;

property purposes

purposes?: string[];

property serial

serial: Buffer;

property signatures

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

property subjectKey

subjectKey: Key;

property subjects

subjects: Identity[];

property validFrom

validFrom: Date;

property validUntil

validUntil: Date;

method create

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

method createSelfSigned

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

method fingerprint

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

method getExtension

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

method getExtensions

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

method hash

hash: (algo: AlgorithmHashType) => string;

method isCertificate

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

method isExpired

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

method isSignedBy

isSignedBy: (issuerCert: Certificate) => boolean;

method isSignedByKey

isSignedByKey: (issuerKey: Key) => boolean;

method parse

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

method signWith

signWith: (key: PrivateKey) => void;

method toBuffer

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

method toString

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

class CertificateParseError

class CertificateParseError implements Error {}

constructor

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

property certName

certName: string;

property format

format: string;

property innerErr

innerErr: Error;

property message

message: string;

property name

name: string;

class Curve

class Curve {}

property a

a: Buffer;

property b

b: Buffer;

property G

G: Buffer;

property n

n: Buffer;

property p

p: Buffer;

property pkcs8oid

pkcs8oid: string;

property s

s: Buffer;

property size

size: number;

class curves

class curves {}

property nistp256

nistp256: Curve;

property nistp384

nistp384: Curve;

property nistp512

nistp512: Curve;

class DiffieHellman

class DiffieHellman {}

method computeSecret

computeSecret: (otherpk: Key) => Buffer;

method generateKey

generateKey: () => PrivateKey;

method generateKeys

generateKeys: () => PrivateKey;

method getKey

getKey: () => PrivateKey;

method getPrivateKey

getPrivateKey: () => PrivateKey;

method getPublicKey

getPublicKey: () => Key;

method setKey

setKey: (key: PrivateKey) => void;

method setPrivateKey

setPrivateKey: (key: PrivateKey) => void;

class Fingerprint

class Fingerprint {}

constructor

constructor(opts: FingerprintOptions);

property algorithm

algorithm: AlgorithmHashType;

property hash

hash: Buffer;

property type

type: FingerprintType;

method isFingerprint

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

method matches

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

method parse

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

method toString

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

class FingerprintFormatError

class FingerprintFormatError implements Error {}

constructor

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

property fingerprint

fingerprint?: Fingerprint;

property format

format?: string;

property message

message: string;

property name

name: string;

class hashAlgs

class hashAlgs {}

property md5

md5: boolean;

property sha1

sha1: boolean;

property sha256

sha256: boolean;

property sha384

sha384: boolean;

property sha512

sha512: boolean;

class Identity

class Identity {}

constructor

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

property cn

cn?: string;

property componentLookup

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

property components

components: IdentityComponent[];

property email

email?: string;

property hostname

hostname?: string;

property type

type: IdentityTypeWithUnknown;

property uid

uid?: string;

method equals

equals: (other: Identity) => boolean;

method forEmail

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

method forHost

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

method forUser

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

method fromArray

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

method get

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

method isIdentity

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

method parseAsn1

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

method parseDN

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

method toArray

toArray: () => IdentityNameComponent[];

method toAsn1

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

method toString

toString: () => string;

class InvalidAlgorithmError

class InvalidAlgorithmError implements Error {}

constructor

constructor(algo: string);

property algorithm

algorithm: string;

property message

message: string;

property name

name: string;

class Key

class Key {}

constructor

constructor(opts: KeyOptions);

property comment

comment?: string;

property curve

curve?: string;

property formats

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

property part

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

property parts

parts: KeyPart[];

property size

size: number;

property source

source?: string;

property type

type: AlgorithmTypeWithCurve;

method createDH

createDH: () => DiffieHellman;

method createDiffieHellman

createDiffieHellman: () => DiffieHellman;

method createVerify

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

method defaultHashAlgorithm

defaultHashAlgorithm: () => ShaHashType;

method fingerprint

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

method hash

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

method isKey

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

method parse

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

method toBuffer

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

method toString

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

class KeyEncryptedError

class KeyEncryptedError implements Error {}

constructor

constructor(name: string, format: string);

property format

format: string;

property keyName

keyName: string;

property message

message: string;

property name

name: string;

class KeyParseError

class KeyParseError implements Error {}

constructor

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

property format

format: string;

property innerErr

innerErr: Error;

property keyName

keyName: string;

property message

message: string;

property name

name: string;

class OpenSshCipherInfo

class OpenSshCipherInfo {}

property blockSize

blockSize: number;

property keySize

keySize: number;

property opensslName

opensslName: OpenSshCipherName;

class PrivateKey

class PrivateKey {}

constructor

constructor(opts: KeyOptions);

property comment

comment?: string;

property curve

curve?: string;

property part

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

property parts

parts: KeyPart[];

property size

size: number;

property source

source?: string;

property type

type: AlgorithmTypeWithCurve;

method createDH

createDH: () => DiffieHellman;

method createDiffieHellman

createDiffieHellman: () => DiffieHellman;

method createSign

createSign: (hashAlgo: AlgorithmHashType) => Signer;

method createVerify

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

method defaultHashAlgorithm

defaultHashAlgorithm: () => ShaHashType;

method derive

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

method fingerprint

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

method generate

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

method hash

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

method isPrivateKey

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

method parse

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

method toBuffer

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

method toPublic

toPublic: () => Key;

method toString

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

class Signature

class Signature {}

constructor

constructor(opts: SignatureOptions);

property curve

curve?: CurveType;

property hashAlgorithm

hashAlgorithm?: AlgorithmHashType;

property part

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

property parts

parts: SignaturePart[];

property type

type: AlgorithmType;

method isSignature

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

method parse

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

method toBuffer

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

method toString

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

class SignatureParseError

class SignatureParseError implements Error {}

constructor

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

property format

format: string;

property innerErr

innerErr: Error;

property message

message: string;

property name

name: string;

property type

type: string;

class Signer

class Signer extends Writable {}

method sign

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

method update

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

class SSHBuffer

class SSHBuffer {}

constructor

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

method atEnd

atEnd: () => boolean;

method expand

expand: () => void;

method readBuffer

readBuffer: () => Buffer;

method readChar

readChar: () => string;

method readCString

readCString: () => string;

method readInt

readInt: () => number;

method readInt64

readInt64: () => Buffer;

method readPart

readPart: () => SSHPart;

method readString

readString: () => string;

method remainder

remainder: () => Buffer;

method skip

skip: (n: number) => void;

method toBuffer

toBuffer: () => Buffer;

method write

write: (buf: Buffer) => void;

method writeBuffer

writeBuffer: (buf: Buffer) => void;

method writeChar

writeChar: (buf: string) => void;

method writeCString

writeCString: (buf: string) => void;

method writeInt

writeInt: (buf: number) => void;

method writeInt64

writeInt64: (buf: Buffer) => void;

method writePart

writePart: (buf: SSHPart) => void;

method writeString

writeString: (buf: string) => void;

class SSHPart

class SSHPart {}

property data

data: Buffer;

class SshPK

class SshPK {}

class Verifier

class Verifier extends Writable {}

constructor

constructor(key: Key, hashAlgo: string);

method update

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

method verify

verify: (signature: Signature) => boolean;

Interfaces

interface CertificateCreateOptions

interface CertificateCreateOptions {}

property ca

ca?: boolean;

property lifetime

lifetime?: number;

property purposes

purposes?: string[];

property serial

serial?: Buffer;

property validFrom

validFrom?: Date;

property validUntil

validUntil?: Date;

interface CertificateOptions

interface CertificateOptions {}

property issuer

issuer: Identity;

property issuerKey

issuerKey?: Key;

property purposes

purposes?: string[];

property serial

serial: Buffer;

property signatures

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

property subjectKey

subjectKey: Key;

property subjects

subjects: Identity[];

property validFrom

validFrom: Date;

property validUntil

validUntil: Date;

interface FingerprintOptions

interface FingerprintOptions {}

property algorithm

algorithm: AlgorithmHashType;

property hash

hash: Buffer;

property hashType

hashType?: FingerprintHashType;

property type

type: FingerprintType;

interface FingerprintParseOptions

interface FingerprintParseOptions {}

property algotirhms

algotirhms?: string[];

property enAlgs

enAlgs?: string[];

property hashType

hashType?: FingerprintHashType;

property type

type?: FingerprintType;

interface Format

interface Format {}

method read

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

method write

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

interface IdentityComponent

interface IdentityComponent {}

property asn1type

asn1type?: number;

property name

name?: IndentityOidName;

property oid

oid?: IdentityOidValue;

property value

value: Buffer | string;

interface IdentityNameComponent

interface IdentityNameComponent {}

property name

name: IndentityOidName;

property value

value: Buffer | string;

interface KeyOptions

interface KeyOptions {}

property comment

comment?: string;

property parts

parts: KeyPart[];

property source

source?: string;

property type

type: AlgorithmTypeWithCurve;

interface KeyParseOptions

interface KeyParseOptions extends Format.ReadOptions {}

property filename

filename?: string;

interface KeyPart

interface KeyPart {}

property data

data: Buffer;

property name

name: AlgorithmPart;

interface OpenSslKeyDeriv

interface OpenSslKeyDeriv {}

property iv

iv: Buffer;

property key

key: Buffer;

interface SignatureOptions

interface SignatureOptions {}

property curve

curve?: CurveType;

property hashAlgo

hashAlgo?: AlgorithmHashType;

property parts

parts: SignaturePart[];

property type

type: AlgorithmType;

interface SignaturePart

interface SignaturePart {}

property data

data: Buffer;

property name

name: SignaturePartType;

interface Verify

interface Verify {}

extends crypto.Verify but override 'verify' function

method update

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

method verify

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

Type Aliases

type AlgorithmHashType

type AlgorithmHashType = 'md5' | ShaHashType;

type AlgorithmPart

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

type AlgorithmType

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

type AlgorithmTypeWithCurve

type AlgorithmTypeWithCurve = AlgorithmType | 'curve25519';

type CertificateFormat

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

type CurveType

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

type FingerprintHashType

type FingerprintHashType = 'ssh' | 'spki';

type FingerprintType

type FingerprintType = 'key' | 'certificate';

type IdentityOidValue

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

type IdentityType

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

type IdentityTypeWithUnknown

type IdentityTypeWithUnknown = IdentityType | 'unknown';

type IndentityOidName

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

type KeyFormatType

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

type KeyType

type KeyType = 'public' | 'private';

type OpenSshCipherName

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

type PrivateKeyFormatType

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

type ShaHashType

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

type SignatureFormatType

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

type SignaturePartType

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

type Version

type Version = [number, number];

Namespaces

namespace Format

namespace Format {}

interface Auto

interface Auto extends Format {}

method read

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

method write

write: (key: Key) => Buffer;

interface DnsSec

interface DnsSec extends Format {}

method read

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

method write

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

interface OpenSshCert

interface OpenSshCert extends Format {}

method read

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

method sign

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

method signAsync

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

method verify

verify: () => false;

method write

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

interface OpenSshSignature

interface OpenSshSignature {}

property exts

exts: OpenSshSignatureExt[];

property keyId

keyId: string;

property nonce

nonce: Buffer;

property signature

signature: Signature;

interface OpenSshSignatureExt

interface OpenSshSignatureExt {}

property critical

critical: boolean;

property data

data: Buffer;

property name

name: string;

interface Pem

interface Pem extends Format {}

method read

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

method write

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

interface Pkcs1

interface Pkcs1 extends Format {}

method read

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

method readPkcs1

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

method write

write: (key: Key) => Buffer;

method writePkcs1

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

interface Pkcs8

interface Pkcs8 extends Format {}

method pkcs8ToBuffer

pkcs8ToBuffer: (key: Key) => Buffer;

method read

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

method readECDSACurve

readECDSACurve: (der: BerReader) => CurveType;

method readPkcs8

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

method write

write: (key: Key) => Buffer;

method writeECDSACurve

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

method writePkcs8

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

interface Putty

interface Putty extends Format {}

method read

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

method write

write: (key: Key) => Buffer;

interface ReadOptions

interface ReadOptions {}

property cipher

cipher?: SshPrivateCipher;

property passphrase

passphrase?: string | Buffer;

interface Rfc4253

interface Rfc4253 extends Format {}

method algToKeyType

algToKeyType: (alg: Rfc4253Algorithm) => AlgorithmTypeWithCurve;

method keyTypeToAlg

keyTypeToAlg: (key: Key) => Rfc4253Algorithm;

method read

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

method readInternal

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

method readPartial

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

method readType

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

method write

write: (key: Key) => Buffer;

interface Ssh

interface Ssh extends Format {}

method read

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

method write

write: (key: Key) => Buffer;

interface SshPrivate

interface SshPrivate extends Format {}

method read

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

method readSSHPrivate

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

method write

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

interface WriteOptions

interface WriteOptions extends ReadOptions {}

property comment

comment?: string;

property hashAlgo

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

interface x509

interface x509 extends Format {}

method read

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

method sign

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

method signAsync

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

method verify

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

method write

write: (cert: Certificate) => Buffer;

interface x509Pem

interface x509Pem extends Format {}

method read

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

method sign

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

method verify

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

method write

write: (cert: Certificate) => Buffer;

interface x509Signature

interface x509Signature {}

property algo

algo: x509SignAlgorithm;

property cache

cache: Buffer;

property extras

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

property signature

signature: Signature;

interface x509SignatureExt

interface x509SignatureExt {}

property bits

bits?: string;

property critical

critical: boolean;

property data

data?: string;

property oid

oid: x509ExtsOid;

property pathLen

pathLen?: number;

type Rfc4253Algorithm

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

type SshPrivateCipher

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

type x509ExtsOid

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

type x509SignAlgorithm

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

namespace PrivateKey

namespace PrivateKey {}

variable formats

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

Package Files (1)

index.d.ts

Dependencies (2)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

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

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/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>

Updated 1 year ago.
Package analyzed in 5800 ms.
Missing or incorrect documentation? Open an issue for this package.