sshpk
Parse, convert, fingerprint and use SSH keys (both public and private) in pure node -- no ssh-keygen
or other external dependencies.
Supports RSA, DSA, ECDSA (nistp-*) and ED25519 key types, in PEM (PKCS#1, PKCS#8) and OpenSSH formats.
This library has been extracted from node-http-signature
(work by Mark Cavage and Dave Eddy) and node-ssh-fingerprint
(work by Dave Eddy), with additions (including ECDSA support) by Alex Wilson.
Install
Examples
Example output:
More examples: converting between formats:
Signing and verifying:
Matching fingerprints with keys:
Usage
Public keys
parseKey(data[, format = 'auto'[, options]])
parseKey(data[, format = 'auto'[, options]])
Parses a key from a given data format and returns a new Key
object.
Parameters
data
-- Either a Buffer or String, containing the keyformat
-- String name of format to use, valid options are:auto
: choose automatically from all belowpem
: supports both PKCS#1 and PKCS#8ssh
: standard OpenSSH format,pkcs1
,pkcs8
: variants ofpem
rfc4253
: raw OpenSSH wire formatopenssh
: new post-OpenSSH 6.5 internal format, produced byssh-keygen -o
dnssec
:.key
file format output bydnssec-keygen
etcputty
: the PuTTY.ppk
file format (supports truncated variant without all the lines fromPrivate-Lines:
onwards)
options
-- Optional Object, extra options, with keys:filename
-- Optional String, name for the key being parsed (eg. the filename that was opened). Used to generate Error messagespassphrase
-- Optional String, encryption passphrase used to decrypt an encrypted PEM file
Key.isKey(obj)
Key.isKey(obj)
Returns true
if the given object is a valid Key
object created by a version of sshpk
compatible with this one.
Parameters
obj
-- Object to identify
Key#type
Key#type
String, the type of key. Valid options are rsa
, dsa
, ecdsa
.
Key#size
Key#size
Integer, "size" of the key in bits. For RSA/DSA this is the size of the modulus; for ECDSA this is the bit size of the curve in use.
Key#comment
Key#comment
Optional string, a key comment used by some formats (eg the ssh
format).
Key#curve
Key#curve
Only present if this.type === 'ecdsa'
, string containing the name of the named curve used with this key. Possible values include nistp256
, nistp384
and nistp521
.
Key#toBuffer([format = 'ssh'])
Key#toBuffer([format = 'ssh'])
Convert the key into a given data format and return the serialized key as a Buffer.
Parameters
format
-- String name of format to use, for valid options seeparseKey()
Key#toString([format = 'ssh])
Key#toString([format = 'ssh])
Same as this.toBuffer(format).toString()
.
Key#fingerprint([algorithm = 'sha256'[, hashType = 'ssh']])
Key#fingerprint([algorithm = 'sha256'[, hashType = 'ssh']])
Creates a new Fingerprint
object representing this Key's fingerprint.
Parameters
algorithm
-- String name of hash algorithm to use, valid options aremd5
,sha1
,sha256
,sha384
,sha512
hashType
-- String name of fingerprint hash type to use, valid options aressh
(the type of fingerprint used by OpenSSH, e.g. inssh-keygen
),spki
(used by HPKP, some OpenSSL applications)
Key#createVerify([hashAlgorithm])
Key#createVerify([hashAlgorithm])
Creates a crypto.Verifier
specialized to use this Key (and the correct public key algorithm to match it). The returned Verifier has the same API as a regular one, except that the verify()
function takes only the target signature as an argument.
Parameters
hashAlgorithm
-- optional String name of hash algorithm to use, any supported by OpenSSL are valid, usually includingsha1
,sha256
.
v.verify(signature[, format])
Parameters
signature
-- either a Signature object, or a Buffer or Stringformat
-- optional String, name of format to interpret given String with. Not valid ifsignature
is a Signature or Buffer.
Key#createDiffieHellman()
Key#createDiffieHellman()
Key#createDH()
Key#createDH()
Creates a Diffie-Hellman key exchange object initialized with this key and all necessary parameters. This has the same API as a crypto.DiffieHellman
instance, except that functions take Key
and PrivateKey
objects as arguments, and return them where indicated for.
This is only valid for keys belonging to a cryptosystem that supports DHE or a close analogue (i.e. dsa
, ecdsa
and curve25519
keys). An attempt to call this function on other keys will yield an Error
.
Private keys
parsePrivateKey(data[, format = 'auto'[, options]])
parsePrivateKey(data[, format = 'auto'[, options]])
Parses a private key from a given data format and returns a new PrivateKey
object.
Parameters
data
-- Either a Buffer or String, containing the keyformat
-- String name of format to use, valid options are:auto
: choose automatically from all belowpem
: supports both PKCS#1 and PKCS#8ssh
,openssh
: new post-OpenSSH 6.5 internal format, produced byssh-keygen -o
pkcs1
,pkcs8
: variants ofpem
rfc4253
: raw OpenSSH wire formatdnssec
:.private
format output bydnssec-keygen
etc.
options
-- Optional Object, extra options, with keys:filename
-- Optional String, name for the key being parsed (eg. the filename that was opened). Used to generate Error messagespassphrase
-- Optional String, encryption passphrase used to decrypt an encrypted PEM file
generatePrivateKey(type[, options])
generatePrivateKey(type[, options])
Generates a new private key of a certain key type, from random data.
Parameters
type
-- String, type of key to generate. Currently supported are'ecdsa'
and'ed25519'
options
-- optional Object, with keys:curve
-- optional String, for'ecdsa'
keys, specifies the curve to use. If ECDSA is specified and this option is not given, defaults to using'nistp256'
.
PrivateKey.isPrivateKey(obj)
PrivateKey.isPrivateKey(obj)
Returns true
if the given object is a valid PrivateKey
object created by a version of sshpk
compatible with this one.
Parameters
obj
-- Object to identify
PrivateKey#type
PrivateKey#type
String, the type of key. Valid options are rsa
, dsa
, ecdsa
.
PrivateKey#size
PrivateKey#size
Integer, "size" of the key in bits. For RSA/DSA this is the size of the modulus; for ECDSA this is the bit size of the curve in use.
PrivateKey#curve
PrivateKey#curve
Only present if this.type === 'ecdsa'
, string containing the name of the named curve used with this key. Possible values include nistp256
, nistp384
and nistp521
.
PrivateKey#toBuffer([format = 'pkcs1'])
PrivateKey#toBuffer([format = 'pkcs1'])
Convert the key into a given data format and return the serialized key as a Buffer.
Parameters
format
-- String name of format to use, valid options are listed underparsePrivateKey
. Note that ED25519 keys default toopenssh
format instead (as they have nopkcs1
representation).
PrivateKey#toString([format = 'pkcs1'])
PrivateKey#toString([format = 'pkcs1'])
Same as this.toBuffer(format).toString()
.
PrivateKey#toPublic()
PrivateKey#toPublic()
Extract just the public part of this private key, and return it as a Key
object.
PrivateKey#fingerprint([algorithm = 'sha256'])
PrivateKey#fingerprint([algorithm = 'sha256'])
Same as this.toPublic().fingerprint()
.
PrivateKey#createVerify([hashAlgorithm])
PrivateKey#createVerify([hashAlgorithm])
Same as this.toPublic().createVerify()
.
PrivateKey#createSign([hashAlgorithm])
PrivateKey#createSign([hashAlgorithm])
Creates a crypto.Sign
specialized to use this PrivateKey (and the correct key algorithm to match it). The returned Signer has the same API as a regular one, except that the sign()
function takes no arguments, and returns a Signature
object.
Parameters
hashAlgorithm
-- optional String name of hash algorithm to use, any supported by OpenSSL are valid, usually includingsha1
,sha256
.
v.sign()
Parameters
none
PrivateKey#derive(newType)
PrivateKey#derive(newType)
Derives a related key of type newType
from this key. Currently this is only supported to change between ed25519
and curve25519
keys which are stored with the same private key (but usually distinct public keys in order to avoid degenerate keys that lead to a weak Diffie-Hellman exchange).
Parameters
newType
-- String, type of key to derive, eithered25519
orcurve25519
Fingerprints
parseFingerprint(fingerprint[, options])
parseFingerprint(fingerprint[, options])
Pre-parses a fingerprint, creating a Fingerprint
object that can be used to quickly locate a key by using the Fingerprint#matches
function.
Parameters
fingerprint
-- String, the fingerprint value, in any supported formatoptions
-- Optional Object, with properties:algorithms
-- Array of strings, names of hash algorithms to limit support to. Iffingerprint
uses a hash algorithm not on this list, throwsInvalidAlgorithmError
.hashType
-- String, the type of hash the fingerprint uses, eitherssh
orspki
(normally auto-detected based on the format, but can be overridden)type
-- String, the entity this fingerprint identifies, eitherkey
orcertificate
Fingerprint.isFingerprint(obj)
Fingerprint.isFingerprint(obj)
Returns true
if the given object is a valid Fingerprint
object created by a version of sshpk
compatible with this one.
Parameters
obj
-- Object to identify
Fingerprint#toString([format])
Fingerprint#toString([format])
Returns a fingerprint as a string, in the given format.
Parameters
format
-- Optional String, format to use, valid options arehex
andbase64
. If thisFingerprint
uses themd5
algorithm, the default format ishex
. Otherwise, the default isbase64
.
Fingerprint#matches(keyOrCertificate)
Fingerprint#matches(keyOrCertificate)
Verifies whether or not this Fingerprint
matches a given Key
or Certificate
. This function uses double-hashing to avoid leaking timing information. Returns a boolean.
Note that a Key
-type Fingerprint will always return false
if asked to match a Certificate
and vice versa.
Parameters
keyOrCertificate
-- aKey
object orCertificate
object, the entity to match this fingerprint against
Signatures
parseSignature(signature, algorithm, format)
parseSignature(signature, algorithm, format)
Parses a signature in a given format, creating a Signature
object. Useful for converting between the SSH and ASN.1 (PKCS/OpenSSL) signature formats, and also returned as output from PrivateKey#createSign().sign()
.
A Signature object can also be passed to a verifier produced by Key#createVerify()
and it will automatically be converted internally into the correct format for verification.
Parameters
signature
-- a Buffer (binary) or String (base64), data of the actual signature in the given formatalgorithm
-- a String, name of the algorithm to be used, possible values arersa
,dsa
,ecdsa
format
-- a String, eitherasn1
orssh
Signature.isSignature(obj)
Signature.isSignature(obj)
Returns true
if the given object is a valid Signature
object created by a version of sshpk
compatible with this one.
Parameters
obj
-- Object to identify
Signature#toBuffer([format = 'asn1'])
Signature#toBuffer([format = 'asn1'])
Converts a Signature to the given format and returns it as a Buffer.
Parameters
format
-- a String, eitherasn1
orssh
Signature#toString([format = 'asn1'])
Signature#toString([format = 'asn1'])
Same as this.toBuffer(format).toString('base64')
.
Certificates
sshpk
includes basic support for parsing certificates in X.509 (PEM) format and the OpenSSH certificate format. This feature is intended to be used mainly to access basic metadata about certificates, extract public keys from them, and also to generate simple self-signed certificates from an existing key.
Notably, there is no implementation of CA chain-of-trust verification, and only very minimal support for key usage restrictions. Please do the security world a favour, and DO NOT use this code for certificate verification in the traditional X.509 CA chain style.
parseCertificate(data, format)
parseCertificate(data, format)
Parameters
data
-- a Buffer or Stringformat
-- a String, format to use, one of'openssh'
,'pem'
(X.509 in a PEM wrapper), or'x509'
(raw DER encoded)
createSelfSignedCertificate(subject, privateKey[, options])
createSelfSignedCertificate(subject, privateKey[, options])
Parameters
subject
-- an Identity, the subject of the certificateprivateKey
-- a PrivateKey, the key of the subject: will be used both to be placed in the certificate and also to sign it (since this is a self-signed certificate)options
-- optional Object, with keys:lifetime
-- optional Number, lifetime of the certificate from now in secondsvalidFrom
,validUntil
-- optional Dates, beginning and end of certificate validity period. If givenlifetime
will be ignoredserial
-- optional Buffer, the serial number of the certificatepurposes
-- optional Array of String, X.509 key usage restrictions
createCertificate(subject, key, issuer, issuerKey[, options])
createCertificate(subject, key, issuer, issuerKey[, options])
Parameters
subject
-- an Identity, the subject of the certificatekey
-- a Key, the public key of the subjectissuer
-- an Identity, the issuer of the certificate who will sign itissuerKey
-- a PrivateKey, the issuer's private key for signingoptions
-- optional Object, with keys:lifetime
-- optional Number, lifetime of the certificate from now in secondsvalidFrom
,validUntil
-- optional Dates, beginning and end of certificate validity period. If givenlifetime
will be ignoredserial
-- optional Buffer, the serial number of the certificatepurposes
-- optional Array of String, X.509 key usage restrictions
Certificate#subjects
Certificate#subjects
Array of Identity
instances describing the subject of this certificate.
Certificate#issuer
Certificate#issuer
The Identity
of the Certificate's issuer (signer).
Certificate#subjectKey
Certificate#subjectKey
The public key of the subject of the certificate, as a Key
instance.
Certificate#issuerKey
Certificate#issuerKey
The public key of the signing issuer of this certificate, as a Key
instance. May be undefined
if the issuer's key is unknown (e.g. on an X509 certificate).
Certificate#serial
Certificate#serial
The serial number of the certificate. As this is normally a 64-bit or wider integer, it is returned as a Buffer.
Certificate#purposes
Certificate#purposes
Array of Strings indicating the X.509 key usage purposes that this certificate is valid for. The possible strings at the moment are:
'signature'
-- key can be used for digital signatures'identity'
-- key can be used to attest about the identity of the signer (X.509 calls thisnonRepudiation
)'codeSigning'
-- key can be used to sign executable code'keyEncryption'
-- key can be used to encrypt other keys'encryption'
-- key can be used to encrypt data (only applies for RSA)'keyAgreement'
-- key can be used for key exchange protocols such as Diffie-Hellman'ca'
-- key can be used to sign other certificates (is a Certificate Authority)'crl'
-- key can be used to sign Certificate Revocation Lists (CRLs)
Certificate#getExtension(nameOrOid)
Certificate#getExtension(nameOrOid)
Retrieves information about a certificate extension, if present, or returns undefined
if not. The string argument nameOrOid
should be either the OID (for X509 extensions) or the name (for OpenSSH extensions) of the extension to retrieve.
The object returned will have the following properties:
format
-- String, set to either'x509'
or'openssh'
name
oroid
-- String, only one set based on value offormat
data
-- Buffer, the raw data inside the extension
Certificate#getExtensions()
Certificate#getExtensions()
Returns an Array of all present certificate extensions, in the same manner and format as getExtension()
.
Certificate#isExpired([when])
Certificate#isExpired([when])
Tests whether the Certificate is currently expired (i.e. the validFrom
and validUntil
dates specify a range of time that does not include the current time).
Parameters
when
-- optional Date, if specified, tests whether the Certificate was or will be expired at the specified time instead of now
Returns a Boolean.
Certificate#isSignedByKey(key)
Certificate#isSignedByKey(key)
Tests whether the Certificate was validly signed by the given (public) Key.
Parameters
key
-- a Key instance
Returns a Boolean.
Certificate#isSignedBy(certificate)
Certificate#isSignedBy(certificate)
Tests whether this Certificate was validly signed by the subject of the given certificate. Also tests that the issuer Identity of this Certificate and the subject Identity of the other Certificate are equivalent.
Parameters
certificate
-- another Certificate instance
Returns a Boolean.
Certificate#fingerprint([hashAlgo])
Certificate#fingerprint([hashAlgo])
Returns the X509-style fingerprint of the entire certificate (as a Fingerprint instance). This matches what a web-browser or similar would display as the certificate fingerprint and should not be confused with the fingerprint of the subject's public key.
Parameters
hashAlgo
-- an optional String, any hash function name
Certificate#toBuffer([format])
Certificate#toBuffer([format])
Serializes the Certificate to a Buffer and returns it.
Parameters
format
-- an optional String, output format, one of'openssh'
,'pem'
or'x509'
. Defaults to'x509'
.
Returns a Buffer.
Certificate#toString([format])
Certificate#toString([format])
format
-- an optional String, output format, one of'openssh'
,'pem'
or'x509'
. Defaults to'pem'
.
Returns a String.
Certificate identities
identityForHost(hostname)
identityForHost(hostname)
Constructs a host-type Identity for a given hostname.
Parameters
hostname
-- the fully qualified DNS name of the host
Returns an Identity instance.
identityForUser(uid)
identityForUser(uid)
Constructs a user-type Identity for a given UID.
Parameters
uid
-- a String, user identifier (login name)
Returns an Identity instance.
identityForEmail(email)
identityForEmail(email)
Constructs an email-type Identity for a given email address.
Parameters
email
-- a String, email address
Returns an Identity instance.
identityFromDN(dn)
identityFromDN(dn)
Parses an LDAP-style DN string (e.g. 'CN=foo, C=US'
) and turns it into an Identity instance.
Parameters
dn
-- a String
Returns an Identity instance.
identityFromArray(arr)
identityFromArray(arr)
Constructs an Identity from an array of DN components (see Identity#toArray()
for the format).
Parameters
arr
-- an Array of Objects, DN components withname
andvalue
Returns an Identity instance.
Supported attributes in DNs:
Attribute name | OID |
---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Identity#toString()
Identity#toString()
Returns the identity as an LDAP-style DN string. e.g. 'CN=foo, O=bar corp, C=us'
Identity#type
Identity#type
The type of identity. One of 'host'
, 'user'
, 'email'
or 'unknown'
Identity#hostname
Identity#hostname
Identity#uid
Identity#uid
Identity#email
Identity#email
Set when type
is 'host'
, 'user'
, or 'email'
, respectively. Strings.
Identity#cn
Identity#cn
The value of the first CN=
in the DN, if any. It's probably better to use the #get()
method instead of this property.
Identity#get(name[, asArray])
Identity#get(name[, asArray])
Returns the value of a named attribute in the Identity DN. If there is no attribute of the given name, returns undefined
. If multiple components of the DN contain an attribute of this name, an exception is thrown unless the asArray
argument is given as true
-- then they will be returned as an Array in the same order they appear in the DN.
Parameters
name
-- a StringasArray
-- an optional Boolean
Identity#toArray()
Identity#toArray()
Returns the Identity as an Array of DN component objects. This looks like:
Each object has a name
and a value
property. The returned objects may be safely modified.
Errors
InvalidAlgorithmError
InvalidAlgorithmError
The specified algorithm is not valid, either because it is not supported, or because it was not included on a list of allowed algorithms.
Thrown by Fingerprint.parse
, Key#fingerprint
.
Properties
algorithm
-- the algorithm that could not be validated
FingerprintFormatError
FingerprintFormatError
The fingerprint string given could not be parsed as a supported fingerprint format, or the specified fingerprint format is invalid.
Thrown by Fingerprint.parse
, Fingerprint#toString
.
Properties
fingerprint
-- if caused by a fingerprint, the string value givenformat
-- if caused by an invalid format specification, the string value given
KeyParseError
KeyParseError
The key data given could not be parsed as a valid key.
Properties
keyName
--filename
that was given toparseKey
format
-- theformat
that was trying to parse the key (seeparseKey
)innerErr
-- the inner Error thrown by the format parser
KeyEncryptedError
KeyEncryptedError
The key is encrypted with a symmetric key (ie, it is password protected). The parsing operation would succeed if it was given the passphrase
option.
Properties
keyName
--filename
that was given toparseKey
format
-- theformat
that was trying to parse the key (currently can only be"pem"
)
CertificateParseError
CertificateParseError
The certificate data given could not be parsed as a valid certificate.
Properties
certName
--filename
that was given toparseCertificate
format
-- theformat
that was trying to parse the key (seeparseCertificate
)innerErr
-- the inner Error thrown by the format parser
Friends of sshpk
sshpk-agent
is a library for speaking thessh-agent
protocol from node.js, which usessshpk
Last updated