{"version":3,"sources":["webpack:///./node_modules/sshpk/lib/formats/x509-pem.js","webpack:///./node_modules/sha.js/sha.js","webpack:///./node_modules/sshpk/lib/errors.js","webpack:///./node_modules/sshpk/lib/formats/x509.js","webpack:///./node_modules/sha.js/sha512.js","webpack:///./node_modules/sshpk/lib/private-key.js","webpack:///./node_modules/sshpk/lib/formats/pem.js","webpack:///./node_modules/sshpk/lib/ed-compat.js","webpack:///./node_modules/sshpk/lib/formats/dnssec.js","webpack:///./node_modules/sshpk/lib/formats/pkcs8.js","webpack:///./node_modules/sshpk/lib/signature.js","webpack:///./node_modules/sha.js/index.js","webpack:///./node_modules/sshpk/lib/ssh-buffer.js","webpack:///./node_modules/sha.js/sha224.js","webpack:///./node_modules/sshpk/lib/formats/putty.js","webpack:///./node_modules/sha.js/sha1.js","webpack:///./node_modules/sshpk/lib/formats/ssh.js","webpack:///./node_modules/sshpk/lib/formats/rfc4253.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/sshpk/lib/certificate.js","webpack:///./node_modules/sha.js/sha256.js","webpack:///./node_modules/sshpk/lib/key.js","webpack:///./node_modules/sshpk/lib/algs.js","webpack:///./node_modules/sshpk/lib/fingerprint.js","webpack:///./node_modules/sshpk/lib/dhe.js","webpack:///./node_modules/sha.js/hash.js","webpack:///./node_modules/sha.js/sha384.js","webpack:///./node_modules/sshpk/lib/identity.js","webpack:///./node_modules/safer-buffer/safer.js","webpack:///./node_modules/sshpk/lib/formats/openssh-cert.js","webpack:///./node_modules/sshpk/lib/formats/ssh-private.js","webpack:///./node_modules/sshpk/lib/formats/auto.js","webpack:///./node_modules/sshpk/lib/utils.js","webpack:///./node_modules/sshpk/lib/index.js","webpack:///./node_modules/sshpk/lib/formats/pkcs1.js"],"names":["x509","module","exports","read","verify","sign","write","assert","Buffer","buf","options","buffer","toString","m","m2","lines","trim","split","si","length","match","ok","ei","slice","headers","toLowerCase","join","from","cert","dbuf","header","tmp","len","alloc","o","i","limit","inherits","Hash","K","W","Array","Sha","this","init","_w","call","rotl5","num","rotl30","ft","s","b","c","d","prototype","_a","_b","_c","_d","_e","_update","M","a","e","readInt32BE","j","t","_hash","H","allocUnsafe","writeInt32BE","util","FingerprintFormatError","fp","format","Error","captureStackTrace","name","fingerprint","message","undefined","InvalidAlgorithmError","alg","algorithm","KeyParseError","innerErr","keyName","SignatureParseError","type","CertificateParseError","certName","KeyEncryptedError","signAsync","asn1","utils","Identity","Signature","Certificate","pkcs8","readMPInt","der","nm","strictEqual","peek","Ber","Integer","mpNormalize","readString","key","sig","signatures","object","algParts","algo","blob","cache","BerWriter","writeTBSCert","verifier","createVerify","signature","Local","Context","Constructor","SIGN_ALGS","Object","keys","forEach","k","EXTS","BerReader","readSequence","Math","abs","remain","tbsStart","offset","sigOffset","tbsEnd","version","readInt","extras","serial","after","certAlgOid","readOID","certAlg","_offset","issuer","parseAsn1","validFrom","readDate","validUntil","subjects","subjectKey","readPkcs8","issuerUniqueID","subjectUniqueID","extEnd","readExtension","sigAlgOid","sigAlg","sigData","BitString","parse","hashAlgorithm","UTCTime","utcTimeToDate","GeneralizedTime","gTimeToDate","writeDate","date","getUTCFullYear","writeString","dateToGTime","dateToUTCTime","ALTNAME","OtherName","RFC822Name","DNSName","X400Address","DirectoryName","EDIPartyName","URI","IPAddress","OID","EXTPURPOSE","EXTPURPOSE_REV","KEYUSEBITS","id","critical","extId","exts","Boolean","readBoolean","OctetString","bcEnd","ca","purposes","push","bc","oid","pathLen","ekEnd","indexOf","ide","hostname","uid","email","components","value","bits","setBits","readBitField","bit","aeEnd","forEmail","equals","host","forHost","data","UTCTIME_RE","Date","thisYear","century","floor","year","parseInt","setUTCFullYear","setUTCHours","setUTCSeconds","GTIME_RE","zeroPad","n","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","defaultHashAlgorithm","signer","createSign","done","err","startSequence","_ensure","copy","_buf","writeOID","writeNull","endSequence","toBuffer","writeBuffer","writeInt","toAsn1","subject","altNames","writePkcs8","basicConstraints","keyUsage","extKeyUsage","altName","writeBoolean","purpose","writeBitField","bitIndex","bitLen","byteN","mask","bitVal","blen","ceil","unused","Sha512","Ch","x","y","z","maj","sigma0","xl","sigma1","Gamma0","Gamma0l","Gamma1","Gamma1l","getCarry","_ah","_bh","_ch","_dh","_eh","_fh","_gh","_hh","_al","_bl","_cl","_dl","_el","_fl","_gl","_hl","ah","bh","ch","dh","eh","fh","gh","hh","al","bl","cl","dl","el","fl","gl","hl","xh","gamma0","gamma0l","gamma1","gamma1l","Wi7h","Wi7l","Wi16h","Wi16l","Wil","Wih","majh","majl","sigma0h","sigma0l","sigma1h","sigma1l","Kih","Kil","chh","chl","t1l","t1h","t2l","t2h","writeInt64BE","h","l","PrivateKey","algs","crypto","errs","dhe","generateECDSA","generateED25519","edCompat","nacl","Key","formats","opts","_pubCache","string","optionalObject","hash","toPublic","algInfo","info","pubParts","parts","p","part","source","comment","derive","newType","priv","pub","pair","box","keyPair","fromSecretKey","Uint8Array","publicKey","fromSeed","hashAlgo","Signer","v","toUpperCase","oldSign","bind","curve","filename","optionalString","isPrivateKey","obj","ver","isCompatible","generate","_sshpkApiVersion","_oldVersionDetect","func","pkcs1","sshpriv","rfc4253","errors","OID_PBES2","OID_PBKDF2","OID_TO_CIPHER","CIPHER_TO_OID","OID_TO_HASH","HASH_TO_OID","forceType","input","equal","cipher","iv","passphrase","isBuffer","opensslKeyDeriv","pbesEnd","eder","method","kdfEnd","kdfOid","salt","iterations","hashAlg","hashAlgOid","cipherOid","cinfo","opensshCipherInfo","opensslName","pbkdf2","keySize","chunk","cipherStream","createDecipheriv","chunks","once","end","concat","readSSHPrivate","readType","originalInput","readPkcs1","writePkcs1","isKey","Verifier","stream","Writable","_write","enc","cb","update","fmt","isSignature","detached","A","sigBuf","sigObj","supportedAlgos","supportedAlgosById","algElems","algoNum","algoName","readDNSSECPrivateKey","line","readRFC3110","keyString","elems","base64key","keyBuffer","publicExponentLen","readUInt8","publicExponent","modulus","rsaKey","size","ecdsaKey","ecNormalize","elementToBuf","readDNSSECRSAPrivateKey","elements","rsaParams","element","publicFromPrivateECDSA","Q","dnssecTimestamp","getFullYear","month","getMonth","timestampStr","rsaAlgFromOptions","writeRSA","dmodp","dmodq","addRSAMissing","out","mpDenormalize","q","iqmp","timestamp","writeECDSA","base64Key","pkcs8ToBuffer","readECDSACurve","writeECDSACurve","pem","next","readPkcs8RSAPublic","readPkcs8RSAPrivate","readPkcs8DSAPublic","readPkcs8DSAPrivate","readPkcs8ECDSAPublic","readPkcs8ECDSAPrivate","readPkcs8EdDSAPublic","readPkcs8EdDSAPrivate","readPkcs8X25519Public","readPkcs8X25519Private","readByte","g","calculateDSAPublic","curveName","curveNames","cd","curves","pkcs8oid","fieldTypeOid","countZeros","G","ks","readBitString","zeroPadToLength","calculateED25519Public","calculateX25519Public","sillyInt","writePkcs8RSAPrivate","writePkcs8RSAPublic","writePkcs8DSAPrivate","writePkcs8DSAPublic","writePkcs8ECDSAPrivate","writePkcs8ECDSAPublic","writePkcs8EdDSAPublic","writeByte","writeBitString","SSHBuffer","arrayOfObject","partLookup","parseOneNum","head","msg","readPart","atEnd","parseDSAasn1","r","parseDSA","readBuffer","parseECDSA","inner","stype","writePart","sz","hasOwnProperty","Algorithm","sha","sha1","sha224","sha256","sha384","sha512","_size","_buffer","remainder","skip","expand","readUInt32BE","readCString","str","readInt64","readChar","writeUInt32BE","writeCString","writeInt64","lead","writeChar","Sha256","Sha224","_f","_g","_h","formatVersion","found","splitHeader","encryption","publicLines","isFinite","publicBuf","keyType","algToKeyType","privateLines","privateBuf","decipher","derivePPK2EncryptionKey","setAutoPadding","final","privateKeyParts","sshbuf","hash1","createHash","digest","hash2","idx","rest","keyTypeToAlg","b64","wrap","unshift","txt","pos","Sha1","rotl1","SSHKEY_RE","SSHKEY_RE2","trimmed","replace","kbuf","ret","readInternal","consumed","realOffset","padding","trailer","readPartial","partial","partCount","privInfo","res","exec","normalized","nd","normalize","_rfc4253Cache","copyProps","src","dst","SafeBuffer","arg","encodingOrOffset","allocUnsafeSlow","TypeError","fill","encoding","SlowBuffer","Fingerprint","assertCompatible","issuerKey","optionalArrayOfString","_hashCache","hashAlgs","isExpired","when","getTime","isSignedBy","issuerCert","isSignedByKey","getExtension","keyOrOid","ext","getExtensions","filter","maybeExt","openssh","matches","valid","signWith","fmts","didOne","createSelfSigned","subjectOrSubjects","isArray","optionalNumber","lifetime","setTime","optionalBuffer","hostSubjects","userSubjects","create","isCertificate","f","T1","T2","DiffieHellman","szPart","sizePart","cacheKey","hashType","oldVerify","self","createDiffieHellman","createDH","algPrivInfo","addColons","sshBase64Format","other","theirHash","theirHash2","base64RE","hexRE","base64Strip","enAlgs","algorithms","test","map","isFingerprint","CRYPTO_HAVE_ECDH","createECDH","ec","jsbn","BigInteger","_isPriv","_algo","_curve","_key","_p","setPrivateKey","setPublicKey","_ecParams","X9ECParameters","_priv","ECPrivate","params","ONE","ECCurveFp","decodePointHex","ECPublic","_params","_pub","getCurve","secretKey","osCurve","generateKeys","getPublicKey","getPrivateKey","ecParams","getN","cByteLen","bitLength","randomBytes","n1","subtract","mod","add","getG","multiply","toByteArray","encodePointHex","getKey","_keyCheck","pk","isPub","deepEqual","setKey","computeSecret","otherpk","deriveSharedSecret","secret","before","generateKey","getH","pubKey","S","getX","toBigInteger","blockSize","finalSize","_block","_finalSize","_blockSize","_len","block","accum","assigned","min","rem","lowBits","highBits","SHA512","Sha384","DNS_NAME_RE","oids","unoids","componentLookup","cn","dc","mail","get","asArray","arr","toArray","NOT_PRINTABLE","NOT_IA5","globMatch","aParts","bParts","tag","Set","asn1type","Utf8String","IA5String","PrintableString","isIdentity","forUser","parseDN","dn","cmps","eqPos","charAt","fromArray","cmp","top","T61String","CharacterString","BMPString","safer","Safer","RangeError","kStringMaxLength","process","binding","constants","MAX_LENGTH","kMaxLength","MAX_STRING_LENGTH","fromBuffer","TYPES","ECDSA_ALGO","innerAlgo","nonce","getAlg","keyId","principals","pbuf","psshbuf","pr","int64ToDate","extbuf","signingKeyBuf","sourceInt64","dateToInt64","round","upper","lower","getCertType","noSig","notStrictEqual","sub","user","certType","bcrypt","MAGIC","magic","kdf","kdfOpts","nkeys","privKeyBlob","kdfOptsBuf","rounds","cinf","pass","salti","pbkdf","ckey","checkInt1","checkInt2","privBuf","kdfopts","checkInt","kdfssh","createCipheriv","ssh","dnssec","putty","DNSSEC_PRIVKEY_HEADER_PREFIX","findDNSSECHeader","findPEMHeader","findSSHHeader","findPuTTYHeader","headerCheck","bufferSplit","MAX_CLASS_DEPTH","klass","needVer","proto","getPrototypeOf","depth","constructor","CIPHER_LEN","PKCS5_SALT_LEN","count","number","D","D_prev","bufs","clen","material","hkey","gen","ts","T","I","hmac","createHmac","Ti","Uc","obit","chr","lastPart","charCodeAt","newPart","addZero","bigintToMpBuf","bigint","modPow","ybuf","kp","inf","parseKey","parseFingerprint","parseSignature","parsePrivateKey","generatePrivateKey","parseCertificate","createSelfSignedCertificate","createCertificate","identityFromDN","identityForHost","identityForUser","identityForEmail","identityFromArray","readPkcs1RSAPublic","readPkcs1RSAPrivate","readPkcs1DSAPublic","readPkcs1DSAPrivate","readPkcs1ECDSAPrivate","readPkcs1ECDSAPublic","readPkcs1EdDSAPrivate","curveOid","writePkcs1RSAPrivate","writePkcs1RSAPublic","writePkcs1DSAPrivate","writePkcs1DSAPublic","writePkcs1ECDSAPrivate","writePkcs1ECDSAPublic","writePkcs1EdDSAPrivate","writePkcs1EdDSAPublic"],"mappings":"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","file":"js/account~c8728516.5a885bad.js","sourcesContent":["// Copyright 2016 Joyent, Inc.\n\nvar x509 = require('./x509');\n\nmodule.exports = {\n\tread: read,\n\tverify: x509.verify,\n\tsign: x509.sign,\n\twrite: write\n};\n\nvar assert = require('assert-plus');\nvar asn1 = require('asn1');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('../algs');\nvar utils = require('../utils');\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\nvar pem = require('./pem');\nvar Identity = require('../identity');\nvar Signature = require('../signature');\nvar Certificate = require('../certificate');\n\nfunction read(buf, options) {\n\tif (typeof (buf) !== 'string') {\n\t\tassert.buffer(buf, 'buf');\n\t\tbuf = buf.toString('ascii');\n\t}\n\n\tvar lines = buf.trim().split(/[\\r\\n]+/g);\n\n\tvar m;\n\tvar si = -1;\n\twhile (!m && si < lines.length) {\n\t\tm = lines[++si].match(/*JSSTYLED*/\n\t\t    /[-]+[ ]*BEGIN CERTIFICATE[ ]*[-]+/);\n\t}\n\tassert.ok(m, 'invalid PEM header');\n\n\tvar m2;\n\tvar ei = lines.length;\n\twhile (!m2 && ei > 0) {\n\t\tm2 = lines[--ei].match(/*JSSTYLED*/\n\t\t    /[-]+[ ]*END CERTIFICATE[ ]*[-]+/);\n\t}\n\tassert.ok(m2, 'invalid PEM footer');\n\n\tlines = lines.slice(si, ei + 1);\n\n\tvar headers = {};\n\twhile (true) {\n\t\tlines = lines.slice(1);\n\t\tm = lines[0].match(/*JSSTYLED*/\n\t\t    /^([A-Za-z0-9-]+): (.+)$/);\n\t\tif (!m)\n\t\t\tbreak;\n\t\theaders[m[1].toLowerCase()] = m[2];\n\t}\n\n\t/* Chop off the first and last lines */\n\tlines = lines.slice(0, -1).join('');\n\tbuf = Buffer.from(lines, 'base64');\n\n\treturn (x509.read(buf, options));\n}\n\nfunction write(cert, options) {\n\tvar dbuf = x509.write(cert, options);\n\n\tvar header = 'CERTIFICATE';\n\tvar tmp = dbuf.toString('base64');\n\tvar len = tmp.length + (tmp.length / 64) +\n\t    18 + 16 + header.length*2 + 10;\n\tvar buf = Buffer.alloc(len);\n\tvar o = 0;\n\to += buf.write('-----BEGIN ' + header + '-----\\n', o);\n\tfor (var i = 0; i < tmp.length; ) {\n\t\tvar limit = i + 64;\n\t\tif (limit > tmp.length)\n\t\t\tlimit = tmp.length;\n\t\to += buf.write(tmp.slice(i, limit), o);\n\t\tbuf[o++] = 10;\n\t\ti = limit;\n\t}\n\to += buf.write('-----END ' + header + '-----\\n', o);\n\n\treturn (buf.slice(0, o));\n}\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined\n * in FIPS PUB 180-1\n * This source code is derived from sha1.js of the same repository.\n * The difference between SHA-0 and SHA-1 is just a bitwise rotate left\n * operation was added.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha, Hash)\n\nSha.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha\n","// Copyright 2015 Joyent, Inc.\n\nvar assert = require('assert-plus');\nvar util = require('util');\n\nfunction FingerprintFormatError(fp, format) {\n\tif (Error.captureStackTrace)\n\t\tError.captureStackTrace(this, FingerprintFormatError);\n\tthis.name = 'FingerprintFormatError';\n\tthis.fingerprint = fp;\n\tthis.format = format;\n\tthis.message = 'Fingerprint format is not supported, or is invalid: ';\n\tif (fp !== undefined)\n\t\tthis.message += ' fingerprint = ' + fp;\n\tif (format !== undefined)\n\t\tthis.message += ' format = ' + format;\n}\nutil.inherits(FingerprintFormatError, Error);\n\nfunction InvalidAlgorithmError(alg) {\n\tif (Error.captureStackTrace)\n\t\tError.captureStackTrace(this, InvalidAlgorithmError);\n\tthis.name = 'InvalidAlgorithmError';\n\tthis.algorithm = alg;\n\tthis.message = 'Algorithm \"' + alg + '\" is not supported';\n}\nutil.inherits(InvalidAlgorithmError, Error);\n\nfunction KeyParseError(name, format, innerErr) {\n\tif (Error.captureStackTrace)\n\t\tError.captureStackTrace(this, KeyParseError);\n\tthis.name = 'KeyParseError';\n\tthis.format = format;\n\tthis.keyName = name;\n\tthis.innerErr = innerErr;\n\tthis.message = 'Failed to parse ' + name + ' as a valid ' + format +\n\t    ' format key: ' + innerErr.message;\n}\nutil.inherits(KeyParseError, Error);\n\nfunction SignatureParseError(type, format, innerErr) {\n\tif (Error.captureStackTrace)\n\t\tError.captureStackTrace(this, SignatureParseError);\n\tthis.name = 'SignatureParseError';\n\tthis.type = type;\n\tthis.format = format;\n\tthis.innerErr = innerErr;\n\tthis.message = 'Failed to parse the given data as a ' + type +\n\t    ' signature in ' + format + ' format: ' + innerErr.message;\n}\nutil.inherits(SignatureParseError, Error);\n\nfunction CertificateParseError(name, format, innerErr) {\n\tif (Error.captureStackTrace)\n\t\tError.captureStackTrace(this, CertificateParseError);\n\tthis.name = 'CertificateParseError';\n\tthis.format = format;\n\tthis.certName = name;\n\tthis.innerErr = innerErr;\n\tthis.message = 'Failed to parse ' + name + ' as a valid ' + format +\n\t    ' format certificate: ' + innerErr.message;\n}\nutil.inherits(CertificateParseError, Error);\n\nfunction KeyEncryptedError(name, format) {\n\tif (Error.captureStackTrace)\n\t\tError.captureStackTrace(this, KeyEncryptedError);\n\tthis.name = 'KeyEncryptedError';\n\tthis.format = format;\n\tthis.keyName = name;\n\tthis.message = 'The ' + format + ' format key ' + name + ' is ' +\n\t    'encrypted (password-protected), and no passphrase was ' +\n\t    'provided in `options`';\n}\nutil.inherits(KeyEncryptedError, Error);\n\nmodule.exports = {\n\tFingerprintFormatError: FingerprintFormatError,\n\tInvalidAlgorithmError: InvalidAlgorithmError,\n\tKeyParseError: KeyParseError,\n\tSignatureParseError: SignatureParseError,\n\tKeyEncryptedError: KeyEncryptedError,\n\tCertificateParseError: CertificateParseError\n};\n","// Copyright 2017 Joyent, Inc.\n\nmodule.exports = {\n\tread: read,\n\tverify: verify,\n\tsign: sign,\n\tsignAsync: signAsync,\n\twrite: write\n};\n\nvar assert = require('assert-plus');\nvar asn1 = require('asn1');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('../algs');\nvar utils = require('../utils');\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\nvar pem = require('./pem');\nvar Identity = require('../identity');\nvar Signature = require('../signature');\nvar Certificate = require('../certificate');\nvar pkcs8 = require('./pkcs8');\n\n/*\n * This file is based on RFC5280 (X.509).\n */\n\n/* Helper to read in a single mpint */\nfunction readMPInt(der, nm) {\n\tassert.strictEqual(der.peek(), asn1.Ber.Integer,\n\t    nm + ' is not an Integer');\n\treturn (utils.mpNormalize(der.readString(asn1.Ber.Integer, true)));\n}\n\nfunction verify(cert, key) {\n\tvar sig = cert.signatures.x509;\n\tassert.object(sig, 'x509 signature');\n\n\tvar algParts = sig.algo.split('-');\n\tif (algParts[0] !== key.type)\n\t\treturn (false);\n\n\tvar blob = sig.cache;\n\tif (blob === undefined) {\n\t\tvar der = new asn1.BerWriter();\n\t\twriteTBSCert(cert, der);\n\t\tblob = der.buffer;\n\t}\n\n\tvar verifier = key.createVerify(algParts[1]);\n\tverifier.write(blob);\n\treturn (verifier.verify(sig.signature));\n}\n\nfunction Local(i) {\n\treturn (asn1.Ber.Context | asn1.Ber.Constructor | i);\n}\n\nfunction Context(i) {\n\treturn (asn1.Ber.Context | i);\n}\n\nvar SIGN_ALGS = {\n\t'rsa-md5': '1.2.840.113549.1.1.4',\n\t'rsa-sha1': '1.2.840.113549.1.1.5',\n\t'rsa-sha256': '1.2.840.113549.1.1.11',\n\t'rsa-sha384': '1.2.840.113549.1.1.12',\n\t'rsa-sha512': '1.2.840.113549.1.1.13',\n\t'dsa-sha1': '1.2.840.10040.4.3',\n\t'dsa-sha256': '2.16.840.1.101.3.4.3.2',\n\t'ecdsa-sha1': '1.2.840.10045.4.1',\n\t'ecdsa-sha256': '1.2.840.10045.4.3.2',\n\t'ecdsa-sha384': '1.2.840.10045.4.3.3',\n\t'ecdsa-sha512': '1.2.840.10045.4.3.4',\n\t'ed25519-sha512': '1.3.101.112'\n};\nObject.keys(SIGN_ALGS).forEach(function (k) {\n\tSIGN_ALGS[SIGN_ALGS[k]] = k;\n});\nSIGN_ALGS['1.3.14.3.2.3'] = 'rsa-md5';\nSIGN_ALGS['1.3.14.3.2.29'] = 'rsa-sha1';\n\nvar EXTS = {\n\t'issuerKeyId': '2.5.29.35',\n\t'altName': '2.5.29.17',\n\t'basicConstraints': '2.5.29.19',\n\t'keyUsage': '2.5.29.15',\n\t'extKeyUsage': '2.5.29.37'\n};\n\nfunction read(buf, options) {\n\tif (typeof (buf) === 'string') {\n\t\tbuf = Buffer.from(buf, 'binary');\n\t}\n\tassert.buffer(buf, 'buf');\n\n\tvar der = new asn1.BerReader(buf);\n\n\tder.readSequence();\n\tif (Math.abs(der.length - der.remain) > 1) {\n\t\tthrow (new Error('DER sequence does not contain whole byte ' +\n\t\t    'stream'));\n\t}\n\n\tvar tbsStart = der.offset;\n\tder.readSequence();\n\tvar sigOffset = der.offset + der.length;\n\tvar tbsEnd = sigOffset;\n\n\tif (der.peek() === Local(0)) {\n\t\tder.readSequence(Local(0));\n\t\tvar version = der.readInt();\n\t\tassert.ok(version <= 3,\n\t\t    'only x.509 versions up to v3 supported');\n\t}\n\n\tvar cert = {};\n\tcert.signatures = {};\n\tvar sig = (cert.signatures.x509 = {});\n\tsig.extras = {};\n\n\tcert.serial = readMPInt(der, 'serial');\n\n\tder.readSequence();\n\tvar after = der.offset + der.length;\n\tvar certAlgOid = der.readOID();\n\tvar certAlg = SIGN_ALGS[certAlgOid];\n\tif (certAlg === undefined)\n\t\tthrow (new Error('unknown signature algorithm ' + certAlgOid));\n\n\tder._offset = after;\n\tcert.issuer = Identity.parseAsn1(der);\n\n\tder.readSequence();\n\tcert.validFrom = readDate(der);\n\tcert.validUntil = readDate(der);\n\n\tcert.subjects = [Identity.parseAsn1(der)];\n\n\tder.readSequence();\n\tafter = der.offset + der.length;\n\tcert.subjectKey = pkcs8.readPkcs8(undefined, 'public', der);\n\tder._offset = after;\n\n\t/* issuerUniqueID */\n\tif (der.peek() === Local(1)) {\n\t\tder.readSequence(Local(1));\n\t\tsig.extras.issuerUniqueID =\n\t\t    buf.slice(der.offset, der.offset + der.length);\n\t\tder._offset += der.length;\n\t}\n\n\t/* subjectUniqueID */\n\tif (der.peek() === Local(2)) {\n\t\tder.readSequence(Local(2));\n\t\tsig.extras.subjectUniqueID =\n\t\t    buf.slice(der.offset, der.offset + der.length);\n\t\tder._offset += der.length;\n\t}\n\n\t/* extensions */\n\tif (der.peek() === Local(3)) {\n\t\tder.readSequence(Local(3));\n\t\tvar extEnd = der.offset + der.length;\n\t\tder.readSequence();\n\n\t\twhile (der.offset < extEnd)\n\t\t\treadExtension(cert, buf, der);\n\n\t\tassert.strictEqual(der.offset, extEnd);\n\t}\n\n\tassert.strictEqual(der.offset, sigOffset);\n\n\tder.readSequence();\n\tafter = der.offset + der.length;\n\tvar sigAlgOid = der.readOID();\n\tvar sigAlg = SIGN_ALGS[sigAlgOid];\n\tif (sigAlg === undefined)\n\t\tthrow (new Error('unknown signature algorithm ' + sigAlgOid));\n\tder._offset = after;\n\n\tvar sigData = der.readString(asn1.Ber.BitString, true);\n\tif (sigData[0] === 0)\n\t\tsigData = sigData.slice(1);\n\tvar algParts = sigAlg.split('-');\n\n\tsig.signature = Signature.parse(sigData, algParts[0], 'asn1');\n\tsig.signature.hashAlgorithm = algParts[1];\n\tsig.algo = sigAlg;\n\tsig.cache = buf.slice(tbsStart, tbsEnd);\n\n\treturn (new Certificate(cert));\n}\n\nfunction readDate(der) {\n\tif (der.peek() === asn1.Ber.UTCTime) {\n\t\treturn (utcTimeToDate(der.readString(asn1.Ber.UTCTime)));\n\t} else if (der.peek() === asn1.Ber.GeneralizedTime) {\n\t\treturn (gTimeToDate(der.readString(asn1.Ber.GeneralizedTime)));\n\t} else {\n\t\tthrow (new Error('Unsupported date format'));\n\t}\n}\n\nfunction writeDate(der, date) {\n\tif (date.getUTCFullYear() >= 2050 || date.getUTCFullYear() < 1950) {\n\t\tder.writeString(dateToGTime(date), asn1.Ber.GeneralizedTime);\n\t} else {\n\t\tder.writeString(dateToUTCTime(date), asn1.Ber.UTCTime);\n\t}\n}\n\n/* RFC5280, section 4.2.1.6 (GeneralName type) */\nvar ALTNAME = {\n\tOtherName: Local(0),\n\tRFC822Name: Context(1),\n\tDNSName: Context(2),\n\tX400Address: Local(3),\n\tDirectoryName: Local(4),\n\tEDIPartyName: Local(5),\n\tURI: Context(6),\n\tIPAddress: Context(7),\n\tOID: Context(8)\n};\n\n/* RFC5280, section 4.2.1.12 (KeyPurposeId) */\nvar EXTPURPOSE = {\n\t'serverAuth': '1.3.6.1.5.5.7.3.1',\n\t'clientAuth': '1.3.6.1.5.5.7.3.2',\n\t'codeSigning': '1.3.6.1.5.5.7.3.3',\n\n\t/* See https://github.com/joyent/oid-docs/blob/master/root.md */\n\t'joyentDocker': '1.3.6.1.4.1.38678.1.4.1',\n\t'joyentCmon': '1.3.6.1.4.1.38678.1.4.2'\n};\nvar EXTPURPOSE_REV = {};\nObject.keys(EXTPURPOSE).forEach(function (k) {\n\tEXTPURPOSE_REV[EXTPURPOSE[k]] = k;\n});\n\nvar KEYUSEBITS = [\n\t'signature', 'identity', 'keyEncryption',\n\t'encryption', 'keyAgreement', 'ca', 'crl'\n];\n\nfunction readExtension(cert, buf, der) {\n\tder.readSequence();\n\tvar after = der.offset + der.length;\n\tvar extId = der.readOID();\n\tvar id;\n\tvar sig = cert.signatures.x509;\n\tif (!sig.extras.exts)\n\t\tsig.extras.exts = [];\n\n\tvar critical;\n\tif (der.peek() === asn1.Ber.Boolean)\n\t\tcritical = der.readBoolean();\n\n\tswitch (extId) {\n\tcase (EXTS.basicConstraints):\n\t\tder.readSequence(asn1.Ber.OctetString);\n\t\tder.readSequence();\n\t\tvar bcEnd = der.offset + der.length;\n\t\tvar ca = false;\n\t\tif (der.peek() === asn1.Ber.Boolean)\n\t\t\tca = der.readBoolean();\n\t\tif (cert.purposes === undefined)\n\t\t\tcert.purposes = [];\n\t\tif (ca === true)\n\t\t\tcert.purposes.push('ca');\n\t\tvar bc = { oid: extId, critical: critical };\n\t\tif (der.offset < bcEnd && der.peek() === asn1.Ber.Integer)\n\t\t\tbc.pathLen = der.readInt();\n\t\tsig.extras.exts.push(bc);\n\t\tbreak;\n\tcase (EXTS.extKeyUsage):\n\t\tder.readSequence(asn1.Ber.OctetString);\n\t\tder.readSequence();\n\t\tif (cert.purposes === undefined)\n\t\t\tcert.purposes = [];\n\t\tvar ekEnd = der.offset + der.length;\n\t\twhile (der.offset < ekEnd) {\n\t\t\tvar oid = der.readOID();\n\t\t\tcert.purposes.push(EXTPURPOSE_REV[oid] || oid);\n\t\t}\n\t\t/*\n\t\t * This is a bit of a hack: in the case where we have a cert\n\t\t * that's only allowed to do serverAuth or clientAuth (and not\n\t\t * the other), we want to make sure all our Subjects are of\n\t\t * the right type. But we already parsed our Subjects and\n\t\t * decided if they were hosts or users earlier (since it appears\n\t\t * first in the cert).\n\t\t *\n\t\t * So we go through and mutate them into the right kind here if\n\t\t * it doesn't match. This might not be hugely beneficial, as it\n\t\t * seems that single-purpose certs are not often seen in the\n\t\t * wild.\n\t\t */\n\t\tif (cert.purposes.indexOf('serverAuth') !== -1 &&\n\t\t    cert.purposes.indexOf('clientAuth') === -1) {\n\t\t\tcert.subjects.forEach(function (ide) {\n\t\t\t\tif (ide.type !== 'host') {\n\t\t\t\t\tide.type = 'host';\n\t\t\t\t\tide.hostname = ide.uid ||\n\t\t\t\t\t    ide.email ||\n\t\t\t\t\t    ide.components[0].value;\n\t\t\t\t}\n\t\t\t});\n\t\t} else if (cert.purposes.indexOf('clientAuth') !== -1 &&\n\t\t    cert.purposes.indexOf('serverAuth') === -1) {\n\t\t\tcert.subjects.forEach(function (ide) {\n\t\t\t\tif (ide.type !== 'user') {\n\t\t\t\t\tide.type = 'user';\n\t\t\t\t\tide.uid = ide.hostname ||\n\t\t\t\t\t    ide.email ||\n\t\t\t\t\t    ide.components[0].value;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\tsig.extras.exts.push({ oid: extId, critical: critical });\n\t\tbreak;\n\tcase (EXTS.keyUsage):\n\t\tder.readSequence(asn1.Ber.OctetString);\n\t\tvar bits = der.readString(asn1.Ber.BitString, true);\n\t\tvar setBits = readBitField(bits, KEYUSEBITS);\n\t\tsetBits.forEach(function (bit) {\n\t\t\tif (cert.purposes === undefined)\n\t\t\t\tcert.purposes = [];\n\t\t\tif (cert.purposes.indexOf(bit) === -1)\n\t\t\t\tcert.purposes.push(bit);\n\t\t});\n\t\tsig.extras.exts.push({ oid: extId, critical: critical,\n\t\t    bits: bits });\n\t\tbreak;\n\tcase (EXTS.altName):\n\t\tder.readSequence(asn1.Ber.OctetString);\n\t\tder.readSequence();\n\t\tvar aeEnd = der.offset + der.length;\n\t\twhile (der.offset < aeEnd) {\n\t\t\tswitch (der.peek()) {\n\t\t\tcase ALTNAME.OtherName:\n\t\t\tcase ALTNAME.EDIPartyName:\n\t\t\t\tder.readSequence();\n\t\t\t\tder._offset += der.length;\n\t\t\t\tbreak;\n\t\t\tcase ALTNAME.OID:\n\t\t\t\tder.readOID(ALTNAME.OID);\n\t\t\t\tbreak;\n\t\t\tcase ALTNAME.RFC822Name:\n\t\t\t\t/* RFC822 specifies email addresses */\n\t\t\t\tvar email = der.readString(ALTNAME.RFC822Name);\n\t\t\t\tid = Identity.forEmail(email);\n\t\t\t\tif (!cert.subjects[0].equals(id))\n\t\t\t\t\tcert.subjects.push(id);\n\t\t\t\tbreak;\n\t\t\tcase ALTNAME.DirectoryName:\n\t\t\t\tder.readSequence(ALTNAME.DirectoryName);\n\t\t\t\tid = Identity.parseAsn1(der);\n\t\t\t\tif (!cert.subjects[0].equals(id))\n\t\t\t\t\tcert.subjects.push(id);\n\t\t\t\tbreak;\n\t\t\tcase ALTNAME.DNSName:\n\t\t\t\tvar host = der.readString(\n\t\t\t\t    ALTNAME.DNSName);\n\t\t\t\tid = Identity.forHost(host);\n\t\t\t\tif (!cert.subjects[0].equals(id))\n\t\t\t\t\tcert.subjects.push(id);\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tder.readString(der.peek());\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tsig.extras.exts.push({ oid: extId, critical: critical });\n\t\tbreak;\n\tdefault:\n\t\tsig.extras.exts.push({\n\t\t\toid: extId,\n\t\t\tcritical: critical,\n\t\t\tdata: der.readString(asn1.Ber.OctetString, true)\n\t\t});\n\t\tbreak;\n\t}\n\n\tder._offset = after;\n}\n\nvar UTCTIME_RE =\n    /^([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})?Z$/;\nfunction utcTimeToDate(t) {\n\tvar m = t.match(UTCTIME_RE);\n\tassert.ok(m, 'timestamps must be in UTC');\n\tvar d = new Date();\n\n\tvar thisYear = d.getUTCFullYear();\n\tvar century = Math.floor(thisYear / 100) * 100;\n\n\tvar year = parseInt(m[1], 10);\n\tif (thisYear % 100 < 50 && year >= 60)\n\t\tyear += (century - 1);\n\telse\n\t\tyear += century;\n\td.setUTCFullYear(year, parseInt(m[2], 10) - 1, parseInt(m[3], 10));\n\td.setUTCHours(parseInt(m[4], 10), parseInt(m[5], 10));\n\tif (m[6] && m[6].length > 0)\n\t\td.setUTCSeconds(parseInt(m[6], 10));\n\treturn (d);\n}\n\nvar GTIME_RE =\n    /^([0-9]{4})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})?Z$/;\nfunction gTimeToDate(t) {\n\tvar m = t.match(GTIME_RE);\n\tassert.ok(m);\n\tvar d = new Date();\n\n\td.setUTCFullYear(parseInt(m[1], 10), parseInt(m[2], 10) - 1,\n\t    parseInt(m[3], 10));\n\td.setUTCHours(parseInt(m[4], 10), parseInt(m[5], 10));\n\tif (m[6] && m[6].length > 0)\n\t\td.setUTCSeconds(parseInt(m[6], 10));\n\treturn (d);\n}\n\nfunction zeroPad(n, m) {\n\tif (m === undefined)\n\t\tm = 2;\n\tvar s = '' + n;\n\twhile (s.length < m)\n\t\ts = '0' + s;\n\treturn (s);\n}\n\nfunction dateToUTCTime(d) {\n\tvar s = '';\n\ts += zeroPad(d.getUTCFullYear() % 100);\n\ts += zeroPad(d.getUTCMonth() + 1);\n\ts += zeroPad(d.getUTCDate());\n\ts += zeroPad(d.getUTCHours());\n\ts += zeroPad(d.getUTCMinutes());\n\ts += zeroPad(d.getUTCSeconds());\n\ts += 'Z';\n\treturn (s);\n}\n\nfunction dateToGTime(d) {\n\tvar s = '';\n\ts += zeroPad(d.getUTCFullYear(), 4);\n\ts += zeroPad(d.getUTCMonth() + 1);\n\ts += zeroPad(d.getUTCDate());\n\ts += zeroPad(d.getUTCHours());\n\ts += zeroPad(d.getUTCMinutes());\n\ts += zeroPad(d.getUTCSeconds());\n\ts += 'Z';\n\treturn (s);\n}\n\nfunction sign(cert, key) {\n\tif (cert.signatures.x509 === undefined)\n\t\tcert.signatures.x509 = {};\n\tvar sig = cert.signatures.x509;\n\n\tsig.algo = key.type + '-' + key.defaultHashAlgorithm();\n\tif (SIGN_ALGS[sig.algo] === undefined)\n\t\treturn (false);\n\n\tvar der = new asn1.BerWriter();\n\twriteTBSCert(cert, der);\n\tvar blob = der.buffer;\n\tsig.cache = blob;\n\n\tvar signer = key.createSign();\n\tsigner.write(blob);\n\tcert.signatures.x509.signature = signer.sign();\n\n\treturn (true);\n}\n\nfunction signAsync(cert, signer, done) {\n\tif (cert.signatures.x509 === undefined)\n\t\tcert.signatures.x509 = {};\n\tvar sig = cert.signatures.x509;\n\n\tvar der = new asn1.BerWriter();\n\twriteTBSCert(cert, der);\n\tvar blob = der.buffer;\n\tsig.cache = blob;\n\n\tsigner(blob, function (err, signature) {\n\t\tif (err) {\n\t\t\tdone(err);\n\t\t\treturn;\n\t\t}\n\t\tsig.algo = signature.type + '-' + signature.hashAlgorithm;\n\t\tif (SIGN_ALGS[sig.algo] === undefined) {\n\t\t\tdone(new Error('Invalid signing algorithm \"' +\n\t\t\t    sig.algo + '\"'));\n\t\t\treturn;\n\t\t}\n\t\tsig.signature = signature;\n\t\tdone();\n\t});\n}\n\nfunction write(cert, options) {\n\tvar sig = cert.signatures.x509;\n\tassert.object(sig, 'x509 signature');\n\n\tvar der = new asn1.BerWriter();\n\tder.startSequence();\n\tif (sig.cache) {\n\t\tder._ensure(sig.cache.length);\n\t\tsig.cache.copy(der._buf, der._offset);\n\t\tder._offset += sig.cache.length;\n\t} else {\n\t\twriteTBSCert(cert, der);\n\t}\n\n\tder.startSequence();\n\tder.writeOID(SIGN_ALGS[sig.algo]);\n\tif (sig.algo.match(/^rsa-/))\n\t\tder.writeNull();\n\tder.endSequence();\n\n\tvar sigData = sig.signature.toBuffer('asn1');\n\tvar data = Buffer.alloc(sigData.length + 1);\n\tdata[0] = 0;\n\tsigData.copy(data, 1);\n\tder.writeBuffer(data, asn1.Ber.BitString);\n\tder.endSequence();\n\n\treturn (der.buffer);\n}\n\nfunction writeTBSCert(cert, der) {\n\tvar sig = cert.signatures.x509;\n\tassert.object(sig, 'x509 signature');\n\n\tder.startSequence();\n\n\tder.startSequence(Local(0));\n\tder.writeInt(2);\n\tder.endSequence();\n\n\tder.writeBuffer(utils.mpNormalize(cert.serial), asn1.Ber.Integer);\n\n\tder.startSequence();\n\tder.writeOID(SIGN_ALGS[sig.algo]);\n\tif (sig.algo.match(/^rsa-/))\n\t\tder.writeNull();\n\tder.endSequence();\n\n\tcert.issuer.toAsn1(der);\n\n\tder.startSequence();\n\twriteDate(der, cert.validFrom);\n\twriteDate(der, cert.validUntil);\n\tder.endSequence();\n\n\tvar subject = cert.subjects[0];\n\tvar altNames = cert.subjects.slice(1);\n\tsubject.toAsn1(der);\n\n\tpkcs8.writePkcs8(der, cert.subjectKey);\n\n\tif (sig.extras && sig.extras.issuerUniqueID) {\n\t\tder.writeBuffer(sig.extras.issuerUniqueID, Local(1));\n\t}\n\n\tif (sig.extras && sig.extras.subjectUniqueID) {\n\t\tder.writeBuffer(sig.extras.subjectUniqueID, Local(2));\n\t}\n\n\tif (altNames.length > 0 || subject.type === 'host' ||\n\t    (cert.purposes !== undefined && cert.purposes.length > 0) ||\n\t    (sig.extras && sig.extras.exts)) {\n\t\tder.startSequence(Local(3));\n\t\tder.startSequence();\n\n\t\tvar exts = [];\n\t\tif (cert.purposes !== undefined && cert.purposes.length > 0) {\n\t\t\texts.push({\n\t\t\t\toid: EXTS.basicConstraints,\n\t\t\t\tcritical: true\n\t\t\t});\n\t\t\texts.push({\n\t\t\t\toid: EXTS.keyUsage,\n\t\t\t\tcritical: true\n\t\t\t});\n\t\t\texts.push({\n\t\t\t\toid: EXTS.extKeyUsage,\n\t\t\t\tcritical: true\n\t\t\t});\n\t\t}\n\t\texts.push({ oid: EXTS.altName });\n\t\tif (sig.extras && sig.extras.exts)\n\t\t\texts = sig.extras.exts;\n\n\t\tfor (var i = 0; i < exts.length; ++i) {\n\t\t\tder.startSequence();\n\t\t\tder.writeOID(exts[i].oid);\n\n\t\t\tif (exts[i].critical !== undefined)\n\t\t\t\tder.writeBoolean(exts[i].critical);\n\n\t\t\tif (exts[i].oid === EXTS.altName) {\n\t\t\t\tder.startSequence(asn1.Ber.OctetString);\n\t\t\t\tder.startSequence();\n\t\t\t\tif (subject.type === 'host') {\n\t\t\t\t\tder.writeString(subject.hostname,\n\t\t\t\t\t    Context(2));\n\t\t\t\t}\n\t\t\t\tfor (var j = 0; j < altNames.length; ++j) {\n\t\t\t\t\tif (altNames[j].type === 'host') {\n\t\t\t\t\t\tder.writeString(\n\t\t\t\t\t\t    altNames[j].hostname,\n\t\t\t\t\t\t    ALTNAME.DNSName);\n\t\t\t\t\t} else if (altNames[j].type ===\n\t\t\t\t\t    'email') {\n\t\t\t\t\t\tder.writeString(\n\t\t\t\t\t\t    altNames[j].email,\n\t\t\t\t\t\t    ALTNAME.RFC822Name);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t/*\n\t\t\t\t\t\t * Encode anything else as a\n\t\t\t\t\t\t * DN style name for now.\n\t\t\t\t\t\t */\n\t\t\t\t\t\tder.startSequence(\n\t\t\t\t\t\t    ALTNAME.DirectoryName);\n\t\t\t\t\t\taltNames[j].toAsn1(der);\n\t\t\t\t\t\tder.endSequence();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tder.endSequence();\n\t\t\t\tder.endSequence();\n\t\t\t} else if (exts[i].oid === EXTS.basicConstraints) {\n\t\t\t\tder.startSequence(asn1.Ber.OctetString);\n\t\t\t\tder.startSequence();\n\t\t\t\tvar ca = (cert.purposes.indexOf('ca') !== -1);\n\t\t\t\tvar pathLen = exts[i].pathLen;\n\t\t\t\tder.writeBoolean(ca);\n\t\t\t\tif (pathLen !== undefined)\n\t\t\t\t\tder.writeInt(pathLen);\n\t\t\t\tder.endSequence();\n\t\t\t\tder.endSequence();\n\t\t\t} else if (exts[i].oid === EXTS.extKeyUsage) {\n\t\t\t\tder.startSequence(asn1.Ber.OctetString);\n\t\t\t\tder.startSequence();\n\t\t\t\tcert.purposes.forEach(function (purpose) {\n\t\t\t\t\tif (purpose === 'ca')\n\t\t\t\t\t\treturn;\n\t\t\t\t\tif (KEYUSEBITS.indexOf(purpose) !== -1)\n\t\t\t\t\t\treturn;\n\t\t\t\t\tvar oid = purpose;\n\t\t\t\t\tif (EXTPURPOSE[purpose] !== undefined)\n\t\t\t\t\t\toid = EXTPURPOSE[purpose];\n\t\t\t\t\tder.writeOID(oid);\n\t\t\t\t});\n\t\t\t\tder.endSequence();\n\t\t\t\tder.endSequence();\n\t\t\t} else if (exts[i].oid === EXTS.keyUsage) {\n\t\t\t\tder.startSequence(asn1.Ber.OctetString);\n\t\t\t\t/*\n\t\t\t\t * If we parsed this certificate from a byte\n\t\t\t\t * stream (i.e. we didn't generate it in sshpk)\n\t\t\t\t * then we'll have a \".bits\" property on the\n\t\t\t\t * ext with the original raw byte contents.\n\t\t\t\t *\n\t\t\t\t * If we have this, use it here instead of\n\t\t\t\t * regenerating it. This guarantees we output\n\t\t\t\t * the same data we parsed, so signatures still\n\t\t\t\t * validate.\n\t\t\t\t */\n\t\t\t\tif (exts[i].bits !== undefined) {\n\t\t\t\t\tder.writeBuffer(exts[i].bits,\n\t\t\t\t\t    asn1.Ber.BitString);\n\t\t\t\t} else {\n\t\t\t\t\tvar bits = writeBitField(cert.purposes,\n\t\t\t\t\t    KEYUSEBITS);\n\t\t\t\t\tder.writeBuffer(bits,\n\t\t\t\t\t    asn1.Ber.BitString);\n\t\t\t\t}\n\t\t\t\tder.endSequence();\n\t\t\t} else {\n\t\t\t\tder.writeBuffer(exts[i].data,\n\t\t\t\t    asn1.Ber.OctetString);\n\t\t\t}\n\n\t\t\tder.endSequence();\n\t\t}\n\n\t\tder.endSequence();\n\t\tder.endSequence();\n\t}\n\n\tder.endSequence();\n}\n\n/*\n * Reads an ASN.1 BER bitfield out of the Buffer produced by doing\n * `BerReader#readString(asn1.Ber.BitString)`. That function gives us the raw\n * contents of the BitString tag, which is a count of unused bits followed by\n * the bits as a right-padded byte string.\n *\n * `bits` is the Buffer, `bitIndex` should contain an array of string names\n * for the bits in the string, ordered starting with bit #0 in the ASN.1 spec.\n *\n * Returns an array of Strings, the names of the bits that were set to 1.\n */\nfunction readBitField(bits, bitIndex) {\n\tvar bitLen = 8 * (bits.length - 1) - bits[0];\n\tvar setBits = {};\n\tfor (var i = 0; i < bitLen; ++i) {\n\t\tvar byteN = 1 + Math.floor(i / 8);\n\t\tvar bit = 7 - (i % 8);\n\t\tvar mask = 1 << bit;\n\t\tvar bitVal = ((bits[byteN] & mask) !== 0);\n\t\tvar name = bitIndex[i];\n\t\tif (bitVal && typeof (name) === 'string') {\n\t\t\tsetBits[name] = true;\n\t\t}\n\t}\n\treturn (Object.keys(setBits));\n}\n\n/*\n * `setBits` is an array of strings, containing the names for each bit that\n * sould be set to 1. `bitIndex` is same as in `readBitField()`.\n *\n * Returns a Buffer, ready to be written out with `BerWriter#writeString()`.\n */\nfunction writeBitField(setBits, bitIndex) {\n\tvar bitLen = bitIndex.length;\n\tvar blen = Math.ceil(bitLen / 8);\n\tvar unused = blen * 8 - bitLen;\n\tvar bits = Buffer.alloc(1 + blen); // zero-filled\n\tbits[0] = unused;\n\tfor (var i = 0; i < bitLen; ++i) {\n\t\tvar byteN = 1 + Math.floor(i / 8);\n\t\tvar bit = 7 - (i % 8);\n\t\tvar mask = 1 << bit;\n\t\tvar name = bitIndex[i];\n\t\tif (name === undefined)\n\t\t\tcontinue;\n\t\tvar bitVal = (setBits.indexOf(name) !== -1);\n\t\tif (bitVal) {\n\t\t\tbits[byteN] |= mask;\n\t\t}\n\t}\n\treturn (bits);\n}\n","var inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n]\n\nvar W = new Array(160)\n\nfunction Sha512 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha512, Hash)\n\nSha512.prototype.init = function () {\n  this._ah = 0x6a09e667\n  this._bh = 0xbb67ae85\n  this._ch = 0x3c6ef372\n  this._dh = 0xa54ff53a\n  this._eh = 0x510e527f\n  this._fh = 0x9b05688c\n  this._gh = 0x1f83d9ab\n  this._hh = 0x5be0cd19\n\n  this._al = 0xf3bcc908\n  this._bl = 0x84caa73b\n  this._cl = 0xfe94f82b\n  this._dl = 0x5f1d36f1\n  this._el = 0xade682d1\n  this._fl = 0x2b3e6c1f\n  this._gl = 0xfb41bd6b\n  this._hl = 0x137e2179\n\n  return this\n}\n\nfunction Ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x, xl) {\n  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)\n}\n\nfunction sigma1 (x, xl) {\n  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)\n}\n\nfunction Gamma0 (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)\n}\n\nfunction Gamma0l (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)\n}\n\nfunction Gamma1 (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)\n}\n\nfunction Gamma1l (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)\n}\n\nfunction getCarry (a, b) {\n  return (a >>> 0) < (b >>> 0) ? 1 : 0\n}\n\nSha512.prototype._update = function (M) {\n  var W = this._w\n\n  var ah = this._ah | 0\n  var bh = this._bh | 0\n  var ch = this._ch | 0\n  var dh = this._dh | 0\n  var eh = this._eh | 0\n  var fh = this._fh | 0\n  var gh = this._gh | 0\n  var hh = this._hh | 0\n\n  var al = this._al | 0\n  var bl = this._bl | 0\n  var cl = this._cl | 0\n  var dl = this._dl | 0\n  var el = this._el | 0\n  var fl = this._fl | 0\n  var gl = this._gl | 0\n  var hl = this._hl | 0\n\n  for (var i = 0; i < 32; i += 2) {\n    W[i] = M.readInt32BE(i * 4)\n    W[i + 1] = M.readInt32BE(i * 4 + 4)\n  }\n  for (; i < 160; i += 2) {\n    var xh = W[i - 15 * 2]\n    var xl = W[i - 15 * 2 + 1]\n    var gamma0 = Gamma0(xh, xl)\n    var gamma0l = Gamma0l(xl, xh)\n\n    xh = W[i - 2 * 2]\n    xl = W[i - 2 * 2 + 1]\n    var gamma1 = Gamma1(xh, xl)\n    var gamma1l = Gamma1l(xl, xh)\n\n    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]\n    var Wi7h = W[i - 7 * 2]\n    var Wi7l = W[i - 7 * 2 + 1]\n\n    var Wi16h = W[i - 16 * 2]\n    var Wi16l = W[i - 16 * 2 + 1]\n\n    var Wil = (gamma0l + Wi7l) | 0\n    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0\n    Wil = (Wil + gamma1l) | 0\n    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0\n    Wil = (Wil + Wi16l) | 0\n    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0\n\n    W[i] = Wih\n    W[i + 1] = Wil\n  }\n\n  for (var j = 0; j < 160; j += 2) {\n    Wih = W[j]\n    Wil = W[j + 1]\n\n    var majh = maj(ah, bh, ch)\n    var majl = maj(al, bl, cl)\n\n    var sigma0h = sigma0(ah, al)\n    var sigma0l = sigma0(al, ah)\n    var sigma1h = sigma1(eh, el)\n    var sigma1l = sigma1(el, eh)\n\n    // t1 = h + sigma1 + ch + K[j] + W[j]\n    var Kih = K[j]\n    var Kil = K[j + 1]\n\n    var chh = Ch(eh, fh, gh)\n    var chl = Ch(el, fl, gl)\n\n    var t1l = (hl + sigma1l) | 0\n    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0\n    t1l = (t1l + chl) | 0\n    t1h = (t1h + chh + getCarry(t1l, chl)) | 0\n    t1l = (t1l + Kil) | 0\n    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0\n    t1l = (t1l + Wil) | 0\n    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0\n\n    // t2 = sigma0 + maj\n    var t2l = (sigma0l + majl) | 0\n    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0\n\n    hh = gh\n    hl = gl\n    gh = fh\n    gl = fl\n    fh = eh\n    fl = el\n    el = (dl + t1l) | 0\n    eh = (dh + t1h + getCarry(el, dl)) | 0\n    dh = ch\n    dl = cl\n    ch = bh\n    cl = bl\n    bh = ah\n    bl = al\n    al = (t1l + t2l) | 0\n    ah = (t1h + t2h + getCarry(al, t1l)) | 0\n  }\n\n  this._al = (this._al + al) | 0\n  this._bl = (this._bl + bl) | 0\n  this._cl = (this._cl + cl) | 0\n  this._dl = (this._dl + dl) | 0\n  this._el = (this._el + el) | 0\n  this._fl = (this._fl + fl) | 0\n  this._gl = (this._gl + gl) | 0\n  this._hl = (this._hl + hl) | 0\n\n  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0\n  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0\n  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0\n  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0\n  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0\n  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0\n  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0\n  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0\n}\n\nSha512.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(64)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n  writeInt64BE(this._gh, this._gl, 48)\n  writeInt64BE(this._hh, this._hl, 56)\n\n  return H\n}\n\nmodule.exports = Sha512\n","// Copyright 2017 Joyent, Inc.\n\nmodule.exports = PrivateKey;\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('./algs');\nvar crypto = require('crypto');\nvar Fingerprint = require('./fingerprint');\nvar Signature = require('./signature');\nvar errs = require('./errors');\nvar util = require('util');\nvar utils = require('./utils');\nvar dhe = require('./dhe');\nvar generateECDSA = dhe.generateECDSA;\nvar generateED25519 = dhe.generateED25519;\nvar edCompat = require('./ed-compat');\nvar nacl = require('tweetnacl');\n\nvar Key = require('./key');\n\nvar InvalidAlgorithmError = errs.InvalidAlgorithmError;\nvar KeyParseError = errs.KeyParseError;\nvar KeyEncryptedError = errs.KeyEncryptedError;\n\nvar formats = {};\nformats['auto'] = require('./formats/auto');\nformats['pem'] = require('./formats/pem');\nformats['pkcs1'] = require('./formats/pkcs1');\nformats['pkcs8'] = require('./formats/pkcs8');\nformats['rfc4253'] = require('./formats/rfc4253');\nformats['ssh-private'] = require('./formats/ssh-private');\nformats['openssh'] = formats['ssh-private'];\nformats['ssh'] = formats['ssh-private'];\nformats['dnssec'] = require('./formats/dnssec');\nformats['putty'] = require('./formats/putty');\n\nfunction PrivateKey(opts) {\n\tassert.object(opts, 'options');\n\tKey.call(this, opts);\n\n\tthis._pubCache = undefined;\n}\nutil.inherits(PrivateKey, Key);\n\nPrivateKey.formats = formats;\n\nPrivateKey.prototype.toBuffer = function (format, options) {\n\tif (format === undefined)\n\t\tformat = 'pkcs1';\n\tassert.string(format, 'format');\n\tassert.object(formats[format], 'formats[format]');\n\tassert.optionalObject(options, 'options');\n\n\treturn (formats[format].write(this, options));\n};\n\nPrivateKey.prototype.hash = function (algo, type) {\n\treturn (this.toPublic().hash(algo, type));\n};\n\nPrivateKey.prototype.fingerprint = function (algo, type) {\n\treturn (this.toPublic().fingerprint(algo, type));\n};\n\nPrivateKey.prototype.toPublic = function () {\n\tif (this._pubCache)\n\t\treturn (this._pubCache);\n\n\tvar algInfo = algs.info[this.type];\n\tvar pubParts = [];\n\tfor (var i = 0; i < algInfo.parts.length; ++i) {\n\t\tvar p = algInfo.parts[i];\n\t\tpubParts.push(this.part[p]);\n\t}\n\n\tthis._pubCache = new Key({\n\t\ttype: this.type,\n\t\tsource: this,\n\t\tparts: pubParts\n\t});\n\tif (this.comment)\n\t\tthis._pubCache.comment = this.comment;\n\treturn (this._pubCache);\n};\n\nPrivateKey.prototype.derive = function (newType) {\n\tassert.string(newType, 'type');\n\tvar priv, pub, pair;\n\n\tif (this.type === 'ed25519' && newType === 'curve25519') {\n\t\tpriv = this.part.k.data;\n\t\tif (priv[0] === 0x00)\n\t\t\tpriv = priv.slice(1);\n\n\t\tpair = nacl.box.keyPair.fromSecretKey(new Uint8Array(priv));\n\t\tpub = Buffer.from(pair.publicKey);\n\n\t\treturn (new PrivateKey({\n\t\t\ttype: 'curve25519',\n\t\t\tparts: [\n\t\t\t\t{ name: 'A', data: utils.mpNormalize(pub) },\n\t\t\t\t{ name: 'k', data: utils.mpNormalize(priv) }\n\t\t\t]\n\t\t}));\n\t} else if (this.type === 'curve25519' && newType === 'ed25519') {\n\t\tpriv = this.part.k.data;\n\t\tif (priv[0] === 0x00)\n\t\t\tpriv = priv.slice(1);\n\n\t\tpair = nacl.sign.keyPair.fromSeed(new Uint8Array(priv));\n\t\tpub = Buffer.from(pair.publicKey);\n\n\t\treturn (new PrivateKey({\n\t\t\ttype: 'ed25519',\n\t\t\tparts: [\n\t\t\t\t{ name: 'A', data: utils.mpNormalize(pub) },\n\t\t\t\t{ name: 'k', data: utils.mpNormalize(priv) }\n\t\t\t]\n\t\t}));\n\t}\n\tthrow (new Error('Key derivation not supported from ' + this.type +\n\t    ' to ' + newType));\n};\n\nPrivateKey.prototype.createVerify = function (hashAlgo) {\n\treturn (this.toPublic().createVerify(hashAlgo));\n};\n\nPrivateKey.prototype.createSign = function (hashAlgo) {\n\tif (hashAlgo === undefined)\n\t\thashAlgo = this.defaultHashAlgorithm();\n\tassert.string(hashAlgo, 'hash algorithm');\n\n\t/* ED25519 is not supported by OpenSSL, use a javascript impl. */\n\tif (this.type === 'ed25519' && edCompat !== undefined)\n\t\treturn (new edCompat.Signer(this, hashAlgo));\n\tif (this.type === 'curve25519')\n\t\tthrow (new Error('Curve25519 keys are not suitable for ' +\n\t\t    'signing or verification'));\n\n\tvar v, nm, err;\n\ttry {\n\t\tnm = hashAlgo.toUpperCase();\n\t\tv = crypto.createSign(nm);\n\t} catch (e) {\n\t\terr = e;\n\t}\n\tif (v === undefined || (err instanceof Error &&\n\t    err.message.match(/Unknown message digest/))) {\n\t\tnm = 'RSA-';\n\t\tnm += hashAlgo.toUpperCase();\n\t\tv = crypto.createSign(nm);\n\t}\n\tassert.ok(v, 'failed to create verifier');\n\tvar oldSign = v.sign.bind(v);\n\tvar key = this.toBuffer('pkcs1');\n\tvar type = this.type;\n\tvar curve = this.curve;\n\tv.sign = function () {\n\t\tvar sig = oldSign(key);\n\t\tif (typeof (sig) === 'string')\n\t\t\tsig = Buffer.from(sig, 'binary');\n\t\tsig = Signature.parse(sig, type, 'asn1');\n\t\tsig.hashAlgorithm = hashAlgo;\n\t\tsig.curve = curve;\n\t\treturn (sig);\n\t};\n\treturn (v);\n};\n\nPrivateKey.parse = function (data, format, options) {\n\tif (typeof (data) !== 'string')\n\t\tassert.buffer(data, 'data');\n\tif (format === undefined)\n\t\tformat = 'auto';\n\tassert.string(format, 'format');\n\tif (typeof (options) === 'string')\n\t\toptions = { filename: options };\n\tassert.optionalObject(options, 'options');\n\tif (options === undefined)\n\t\toptions = {};\n\tassert.optionalString(options.filename, 'options.filename');\n\tif (options.filename === undefined)\n\t\toptions.filename = '(unnamed)';\n\n\tassert.object(formats[format], 'formats[format]');\n\n\ttry {\n\t\tvar k = formats[format].read(data, options);\n\t\tassert.ok(k instanceof PrivateKey, 'key is not a private key');\n\t\tif (!k.comment)\n\t\t\tk.comment = options.filename;\n\t\treturn (k);\n\t} catch (e) {\n\t\tif (e.name === 'KeyEncryptedError')\n\t\t\tthrow (e);\n\t\tthrow (new KeyParseError(options.filename, format, e));\n\t}\n};\n\nPrivateKey.isPrivateKey = function (obj, ver) {\n\treturn (utils.isCompatible(obj, PrivateKey, ver));\n};\n\nPrivateKey.generate = function (type, options) {\n\tif (options === undefined)\n\t\toptions = {};\n\tassert.object(options, 'options');\n\n\tswitch (type) {\n\tcase 'ecdsa':\n\t\tif (options.curve === undefined)\n\t\t\toptions.curve = 'nistp256';\n\t\tassert.string(options.curve, 'options.curve');\n\t\treturn (generateECDSA(options.curve));\n\tcase 'ed25519':\n\t\treturn (generateED25519());\n\tdefault:\n\t\tthrow (new Error('Key generation not supported with key ' +\n\t\t    'type \"' + type + '\"'));\n\t}\n};\n\n/*\n * API versions for PrivateKey:\n * [1,0] -- initial ver\n * [1,1] -- added auto, pkcs[18], openssh/ssh-private formats\n * [1,2] -- added defaultHashAlgorithm\n * [1,3] -- added derive, ed, createDH\n * [1,4] -- first tagged version\n * [1,5] -- changed ed25519 part names and format\n * [1,6] -- type arguments for hash() and fingerprint()\n */\nPrivateKey.prototype._sshpkApiVersion = [1, 6];\n\nPrivateKey._oldVersionDetect = function (obj) {\n\tassert.func(obj.toPublic);\n\tassert.func(obj.createSign);\n\tif (obj.derive)\n\t\treturn ([1, 3]);\n\tif (obj.defaultHashAlgorithm)\n\t\treturn ([1, 2]);\n\tif (obj.formats['auto'])\n\t\treturn ([1, 1]);\n\treturn ([1, 0]);\n};\n","// Copyright 2018 Joyent, Inc.\n\nmodule.exports = {\n\tread: read,\n\twrite: write\n};\n\nvar assert = require('assert-plus');\nvar asn1 = require('asn1');\nvar crypto = require('crypto');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('../algs');\nvar utils = require('../utils');\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\n\nvar pkcs1 = require('./pkcs1');\nvar pkcs8 = require('./pkcs8');\nvar sshpriv = require('./ssh-private');\nvar rfc4253 = require('./rfc4253');\n\nvar errors = require('../errors');\n\nvar OID_PBES2 = '1.2.840.113549.1.5.13';\nvar OID_PBKDF2 = '1.2.840.113549.1.5.12';\n\nvar OID_TO_CIPHER = {\n\t'1.2.840.113549.3.7': '3des-cbc',\n\t'2.16.840.1.101.3.4.1.2': 'aes128-cbc',\n\t'2.16.840.1.101.3.4.1.42': 'aes256-cbc'\n};\nvar CIPHER_TO_OID = {};\nObject.keys(OID_TO_CIPHER).forEach(function (k) {\n\tCIPHER_TO_OID[OID_TO_CIPHER[k]] = k;\n});\n\nvar OID_TO_HASH = {\n\t'1.2.840.113549.2.7': 'sha1',\n\t'1.2.840.113549.2.9': 'sha256',\n\t'1.2.840.113549.2.11': 'sha512'\n};\nvar HASH_TO_OID = {};\nObject.keys(OID_TO_HASH).forEach(function (k) {\n\tHASH_TO_OID[OID_TO_HASH[k]] = k;\n});\n\n/*\n * For reading we support both PKCS#1 and PKCS#8. If we find a private key,\n * we just take the public component of it and use that.\n */\nfunction read(buf, options, forceType) {\n\tvar input = buf;\n\tif (typeof (buf) !== 'string') {\n\t\tassert.buffer(buf, 'buf');\n\t\tbuf = buf.toString('ascii');\n\t}\n\n\tvar lines = buf.trim().split(/[\\r\\n]+/g);\n\n\tvar m;\n\tvar si = -1;\n\twhile (!m && si < lines.length) {\n\t\tm = lines[++si].match(/*JSSTYLED*/\n\t\t    /[-]+[ ]*BEGIN ([A-Z0-9][A-Za-z0-9]+ )?(PUBLIC|PRIVATE) KEY[ ]*[-]+/);\n\t}\n\tassert.ok(m, 'invalid PEM header');\n\n\tvar m2;\n\tvar ei = lines.length;\n\twhile (!m2 && ei > 0) {\n\t\tm2 = lines[--ei].match(/*JSSTYLED*/\n\t\t    /[-]+[ ]*END ([A-Z0-9][A-Za-z0-9]+ )?(PUBLIC|PRIVATE) KEY[ ]*[-]+/);\n\t}\n\tassert.ok(m2, 'invalid PEM footer');\n\n\t/* Begin and end banners must match key type */\n\tassert.equal(m[2], m2[2]);\n\tvar type = m[2].toLowerCase();\n\n\tvar alg;\n\tif (m[1]) {\n\t\t/* They also must match algorithms, if given */\n\t\tassert.equal(m[1], m2[1], 'PEM header and footer mismatch');\n\t\talg = m[1].trim();\n\t}\n\n\tlines = lines.slice(si, ei + 1);\n\n\tvar headers = {};\n\twhile (true) {\n\t\tlines = lines.slice(1);\n\t\tm = lines[0].match(/*JSSTYLED*/\n\t\t    /^([A-Za-z0-9-]+): (.+)$/);\n\t\tif (!m)\n\t\t\tbreak;\n\t\theaders[m[1].toLowerCase()] = m[2];\n\t}\n\n\t/* Chop off the first and last lines */\n\tlines = lines.slice(0, -1).join('');\n\tbuf = Buffer.from(lines, 'base64');\n\n\tvar cipher, key, iv;\n\tif (headers['proc-type']) {\n\t\tvar parts = headers['proc-type'].split(',');\n\t\tif (parts[0] === '4' && parts[1] === 'ENCRYPTED') {\n\t\t\tif (typeof (options.passphrase) === 'string') {\n\t\t\t\toptions.passphrase = Buffer.from(\n\t\t\t\t    options.passphrase, 'utf-8');\n\t\t\t}\n\t\t\tif (!Buffer.isBuffer(options.passphrase)) {\n\t\t\t\tthrow (new errors.KeyEncryptedError(\n\t\t\t\t    options.filename, 'PEM'));\n\t\t\t} else {\n\t\t\t\tparts = headers['dek-info'].split(',');\n\t\t\t\tassert.ok(parts.length === 2);\n\t\t\t\tcipher = parts[0].toLowerCase();\n\t\t\t\tiv = Buffer.from(parts[1], 'hex');\n\t\t\t\tkey = utils.opensslKeyDeriv(cipher, iv,\n\t\t\t\t    options.passphrase, 1).key;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (alg && alg.toLowerCase() === 'encrypted') {\n\t\tvar eder = new asn1.BerReader(buf);\n\t\tvar pbesEnd;\n\t\teder.readSequence();\n\n\t\teder.readSequence();\n\t\tpbesEnd = eder.offset + eder.length;\n\n\t\tvar method = eder.readOID();\n\t\tif (method !== OID_PBES2) {\n\t\t\tthrow (new Error('Unsupported PEM/PKCS8 encryption ' +\n\t\t\t    'scheme: ' + method));\n\t\t}\n\n\t\teder.readSequence();\t/* PBES2-params */\n\n\t\teder.readSequence();\t/* keyDerivationFunc */\n\t\tvar kdfEnd = eder.offset + eder.length;\n\t\tvar kdfOid = eder.readOID();\n\t\tif (kdfOid !== OID_PBKDF2)\n\t\t\tthrow (new Error('Unsupported PBES2 KDF: ' + kdfOid));\n\t\teder.readSequence();\n\t\tvar salt = eder.readString(asn1.Ber.OctetString, true);\n\t\tvar iterations = eder.readInt();\n\t\tvar hashAlg = 'sha1';\n\t\tif (eder.offset < kdfEnd) {\n\t\t\teder.readSequence();\n\t\t\tvar hashAlgOid = eder.readOID();\n\t\t\thashAlg = OID_TO_HASH[hashAlgOid];\n\t\t\tif (hashAlg === undefined) {\n\t\t\t\tthrow (new Error('Unsupported PBKDF2 hash: ' +\n\t\t\t\t    hashAlgOid));\n\t\t\t}\n\t\t}\n\t\teder._offset = kdfEnd;\n\n\t\teder.readSequence();\t/* encryptionScheme */\n\t\tvar cipherOid = eder.readOID();\n\t\tcipher = OID_TO_CIPHER[cipherOid];\n\t\tif (cipher === undefined) {\n\t\t\tthrow (new Error('Unsupported PBES2 cipher: ' +\n\t\t\t    cipherOid));\n\t\t}\n\t\tiv = eder.readString(asn1.Ber.OctetString, true);\n\n\t\teder._offset = pbesEnd;\n\t\tbuf = eder.readString(asn1.Ber.OctetString, true);\n\n\t\tif (typeof (options.passphrase) === 'string') {\n\t\t\toptions.passphrase = Buffer.from(\n\t\t\t    options.passphrase, 'utf-8');\n\t\t}\n\t\tif (!Buffer.isBuffer(options.passphrase)) {\n\t\t\tthrow (new errors.KeyEncryptedError(\n\t\t\t    options.filename, 'PEM'));\n\t\t}\n\n\t\tvar cinfo = utils.opensshCipherInfo(cipher);\n\n\t\tcipher = cinfo.opensslName;\n\t\tkey = utils.pbkdf2(hashAlg, salt, iterations, cinfo.keySize,\n\t\t    options.passphrase);\n\t\talg = undefined;\n\t}\n\n\tif (cipher && key && iv) {\n\t\tvar cipherStream = crypto.createDecipheriv(cipher, key, iv);\n\t\tvar chunk, chunks = [];\n\t\tcipherStream.once('error', function (e) {\n\t\t\tif (e.toString().indexOf('bad decrypt') !== -1) {\n\t\t\t\tthrow (new Error('Incorrect passphrase ' +\n\t\t\t\t    'supplied, could not decrypt key'));\n\t\t\t}\n\t\t\tthrow (e);\n\t\t});\n\t\tcipherStream.write(buf);\n\t\tcipherStream.end();\n\t\twhile ((chunk = cipherStream.read()) !== null)\n\t\t\tchunks.push(chunk);\n\t\tbuf = Buffer.concat(chunks);\n\t}\n\n\t/* The new OpenSSH internal format abuses PEM headers */\n\tif (alg && alg.toLowerCase() === 'openssh')\n\t\treturn (sshpriv.readSSHPrivate(type, buf, options));\n\tif (alg && alg.toLowerCase() === 'ssh2')\n\t\treturn (rfc4253.readType(type, buf, options));\n\n\tvar der = new asn1.BerReader(buf);\n\tder.originalInput = input;\n\n\t/*\n\t * All of the PEM file types start with a sequence tag, so chop it\n\t * off here\n\t */\n\tder.readSequence();\n\n\t/* PKCS#1 type keys name an algorithm in the banner explicitly */\n\tif (alg) {\n\t\tif (forceType)\n\t\t\tassert.strictEqual(forceType, 'pkcs1');\n\t\treturn (pkcs1.readPkcs1(alg, type, der));\n\t} else {\n\t\tif (forceType)\n\t\t\tassert.strictEqual(forceType, 'pkcs8');\n\t\treturn (pkcs8.readPkcs8(alg, type, der));\n\t}\n}\n\nfunction write(key, options, type) {\n\tassert.object(key);\n\n\tvar alg = {\n\t    'ecdsa': 'EC',\n\t    'rsa': 'RSA',\n\t    'dsa': 'DSA',\n\t    'ed25519': 'EdDSA'\n\t}[key.type];\n\tvar header;\n\n\tvar der = new asn1.BerWriter();\n\n\tif (PrivateKey.isPrivateKey(key)) {\n\t\tif (type && type === 'pkcs8') {\n\t\t\theader = 'PRIVATE KEY';\n\t\t\tpkcs8.writePkcs8(der, key);\n\t\t} else {\n\t\t\tif (type)\n\t\t\t\tassert.strictEqual(type, 'pkcs1');\n\t\t\theader = alg + ' PRIVATE KEY';\n\t\t\tpkcs1.writePkcs1(der, key);\n\t\t}\n\n\t} else if (Key.isKey(key)) {\n\t\tif (type && type === 'pkcs1') {\n\t\t\theader = alg + ' PUBLIC KEY';\n\t\t\tpkcs1.writePkcs1(der, key);\n\t\t} else {\n\t\t\tif (type)\n\t\t\t\tassert.strictEqual(type, 'pkcs8');\n\t\t\theader = 'PUBLIC KEY';\n\t\t\tpkcs8.writePkcs8(der, key);\n\t\t}\n\n\t} else {\n\t\tthrow (new Error('key is not a Key or PrivateKey'));\n\t}\n\n\tvar tmp = der.buffer.toString('base64');\n\tvar len = tmp.length + (tmp.length / 64) +\n\t    18 + 16 + header.length*2 + 10;\n\tvar buf = Buffer.alloc(len);\n\tvar o = 0;\n\to += buf.write('-----BEGIN ' + header + '-----\\n', o);\n\tfor (var i = 0; i < tmp.length; ) {\n\t\tvar limit = i + 64;\n\t\tif (limit > tmp.length)\n\t\t\tlimit = tmp.length;\n\t\to += buf.write(tmp.slice(i, limit), o);\n\t\tbuf[o++] = 10;\n\t\ti = limit;\n\t}\n\to += buf.write('-----END ' + header + '-----\\n', o);\n\n\treturn (buf.slice(0, o));\n}\n","// Copyright 2015 Joyent, Inc.\n\nmodule.exports = {\n\tVerifier: Verifier,\n\tSigner: Signer\n};\n\nvar nacl = require('tweetnacl');\nvar stream = require('stream');\nvar util = require('util');\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar Signature = require('./signature');\n\nfunction Verifier(key, hashAlgo) {\n\tif (hashAlgo.toLowerCase() !== 'sha512')\n\t\tthrow (new Error('ED25519 only supports the use of ' +\n\t\t    'SHA-512 hashes'));\n\n\tthis.key = key;\n\tthis.chunks = [];\n\n\tstream.Writable.call(this, {});\n}\nutil.inherits(Verifier, stream.Writable);\n\nVerifier.prototype._write = function (chunk, enc, cb) {\n\tthis.chunks.push(chunk);\n\tcb();\n};\n\nVerifier.prototype.update = function (chunk) {\n\tif (typeof (chunk) === 'string')\n\t\tchunk = Buffer.from(chunk, 'binary');\n\tthis.chunks.push(chunk);\n};\n\nVerifier.prototype.verify = function (signature, fmt) {\n\tvar sig;\n\tif (Signature.isSignature(signature, [2, 0])) {\n\t\tif (signature.type !== 'ed25519')\n\t\t\treturn (false);\n\t\tsig = signature.toBuffer('raw');\n\n\t} else if (typeof (signature) === 'string') {\n\t\tsig = Buffer.from(signature, 'base64');\n\n\t} else if (Signature.isSignature(signature, [1, 0])) {\n\t\tthrow (new Error('signature was created by too old ' +\n\t\t    'a version of sshpk and cannot be verified'));\n\t}\n\n\tassert.buffer(sig);\n\treturn (nacl.sign.detached.verify(\n\t    new Uint8Array(Buffer.concat(this.chunks)),\n\t    new Uint8Array(sig),\n\t    new Uint8Array(this.key.part.A.data)));\n};\n\nfunction Signer(key, hashAlgo) {\n\tif (hashAlgo.toLowerCase() !== 'sha512')\n\t\tthrow (new Error('ED25519 only supports the use of ' +\n\t\t    'SHA-512 hashes'));\n\n\tthis.key = key;\n\tthis.chunks = [];\n\n\tstream.Writable.call(this, {});\n}\nutil.inherits(Signer, stream.Writable);\n\nSigner.prototype._write = function (chunk, enc, cb) {\n\tthis.chunks.push(chunk);\n\tcb();\n};\n\nSigner.prototype.update = function (chunk) {\n\tif (typeof (chunk) === 'string')\n\t\tchunk = Buffer.from(chunk, 'binary');\n\tthis.chunks.push(chunk);\n};\n\nSigner.prototype.sign = function () {\n\tvar sig = nacl.sign.detached(\n\t    new Uint8Array(Buffer.concat(this.chunks)),\n\t    new Uint8Array(Buffer.concat([\n\t\tthis.key.part.k.data, this.key.part.A.data])));\n\tvar sigBuf = Buffer.from(sig);\n\tvar sigObj = Signature.parse(sigBuf, 'ed25519', 'raw');\n\tsigObj.hashAlgorithm = 'sha512';\n\treturn (sigObj);\n};\n","// Copyright 2017 Joyent, Inc.\n\nmodule.exports = {\n\tread: read,\n\twrite: write\n};\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\nvar utils = require('../utils');\nvar SSHBuffer = require('../ssh-buffer');\nvar Dhe = require('../dhe');\n\nvar supportedAlgos = {\n\t'rsa-sha1' : 5,\n\t'rsa-sha256' : 8,\n\t'rsa-sha512' : 10,\n\t'ecdsa-p256-sha256' : 13,\n\t'ecdsa-p384-sha384' : 14\n\t/*\n\t * ed25519 is hypothetically supported with id 15\n\t * but the common tools available don't appear to be\n\t * capable of generating/using ed25519 keys\n\t */\n};\n\nvar supportedAlgosById = {};\nObject.keys(supportedAlgos).forEach(function (k) {\n\tsupportedAlgosById[supportedAlgos[k]] = k.toUpperCase();\n});\n\nfunction read(buf, options) {\n\tif (typeof (buf) !== 'string') {\n\t\tassert.buffer(buf, 'buf');\n\t\tbuf = buf.toString('ascii');\n\t}\n\tvar lines = buf.split('\\n');\n\tif (lines[0].match(/^Private-key-format\\: v1/)) {\n\t\tvar algElems = lines[1].split(' ');\n\t\tvar algoNum = parseInt(algElems[1], 10);\n\t\tvar algoName = algElems[2];\n\t\tif (!supportedAlgosById[algoNum])\n\t\t\tthrow (new Error('Unsupported algorithm: ' + algoName));\n\t\treturn (readDNSSECPrivateKey(algoNum, lines.slice(2)));\n\t}\n\n\t// skip any comment-lines\n\tvar line = 0;\n\t/* JSSTYLED */\n\twhile (lines[line].match(/^\\;/))\n\t\tline++;\n\t// we should now have *one single* line left with our KEY on it.\n\tif ((lines[line].match(/\\. IN KEY /) ||\n\t    lines[line].match(/\\. IN DNSKEY /)) && lines[line+1].length === 0) {\n\t\treturn (readRFC3110(lines[line]));\n\t}\n\tthrow (new Error('Cannot parse dnssec key'));\n}\n\nfunction readRFC3110(keyString) {\n\tvar elems = keyString.split(' ');\n\t//unused var flags = parseInt(elems[3], 10);\n\t//unused var protocol = parseInt(elems[4], 10);\n\tvar algorithm = parseInt(elems[5], 10);\n\tif (!supportedAlgosById[algorithm])\n\t\tthrow (new Error('Unsupported algorithm: ' + algorithm));\n\tvar base64key = elems.slice(6, elems.length).join();\n\tvar keyBuffer = Buffer.from(base64key, 'base64');\n\tif (supportedAlgosById[algorithm].match(/^RSA-/)) {\n\t\t// join the rest of the body into a single base64-blob\n\t\tvar publicExponentLen = keyBuffer.readUInt8(0);\n\t\tif (publicExponentLen != 3 && publicExponentLen != 1)\n\t\t\tthrow (new Error('Cannot parse dnssec key: ' +\n\t\t\t    'unsupported exponent length'));\n\n\t\tvar publicExponent = keyBuffer.slice(1, publicExponentLen+1);\n\t\tpublicExponent = utils.mpNormalize(publicExponent);\n\t\tvar modulus = keyBuffer.slice(1+publicExponentLen);\n\t\tmodulus = utils.mpNormalize(modulus);\n\t\t// now, make the key\n\t\tvar rsaKey = {\n\t\t\ttype: 'rsa',\n\t\t\tparts: []\n\t\t};\n\t\trsaKey.parts.push({ name: 'e', data: publicExponent});\n\t\trsaKey.parts.push({ name: 'n', data: modulus});\n\t\treturn (new Key(rsaKey));\n\t}\n\tif (supportedAlgosById[algorithm] === 'ECDSA-P384-SHA384' ||\n\t    supportedAlgosById[algorithm] === 'ECDSA-P256-SHA256') {\n\t\tvar curve = 'nistp384';\n\t\tvar size = 384;\n\t\tif (supportedAlgosById[algorithm].match(/^ECDSA-P256-SHA256/)) {\n\t\t\tcurve = 'nistp256';\n\t\t\tsize = 256;\n\t\t}\n\n\t\tvar ecdsaKey = {\n\t\t\ttype: 'ecdsa',\n\t\t\tcurve: curve,\n\t\t\tsize: size,\n\t\t\tparts: [\n\t\t\t\t{name: 'curve', data: Buffer.from(curve) },\n\t\t\t\t{name: 'Q', data: utils.ecNormalize(keyBuffer) }\n\t\t\t]\n\t\t};\n\t\treturn (new Key(ecdsaKey));\n\t}\n\tthrow (new Error('Unsupported algorithm: ' +\n\t    supportedAlgosById[algorithm]));\n}\n\nfunction elementToBuf(e) {\n\treturn (Buffer.from(e.split(' ')[1], 'base64'));\n}\n\nfunction readDNSSECRSAPrivateKey(elements) {\n\tvar rsaParams = {};\n\telements.forEach(function (element) {\n\t\tif (element.split(' ')[0] === 'Modulus:')\n\t\t\trsaParams['n'] = elementToBuf(element);\n\t\telse if (element.split(' ')[0] === 'PublicExponent:')\n\t\t\trsaParams['e'] = elementToBuf(element);\n\t\telse if (element.split(' ')[0] === 'PrivateExponent:')\n\t\t\trsaParams['d'] = elementToBuf(element);\n\t\telse if (element.split(' ')[0] === 'Prime1:')\n\t\t\trsaParams['p'] = elementToBuf(element);\n\t\telse if (element.split(' ')[0] === 'Prime2:')\n\t\t\trsaParams['q'] = elementToBuf(element);\n\t\telse if (element.split(' ')[0] === 'Exponent1:')\n\t\t\trsaParams['dmodp'] = elementToBuf(element);\n\t\telse if (element.split(' ')[0] === 'Exponent2:')\n\t\t\trsaParams['dmodq'] = elementToBuf(element);\n\t\telse if (element.split(' ')[0] === 'Coefficient:')\n\t\t\trsaParams['iqmp'] = elementToBuf(element);\n\t});\n\t// now, make the key\n\tvar key = {\n\t\ttype: 'rsa',\n\t\tparts: [\n\t\t\t{ name: 'e', data: utils.mpNormalize(rsaParams['e'])},\n\t\t\t{ name: 'n', data: utils.mpNormalize(rsaParams['n'])},\n\t\t\t{ name: 'd', data: utils.mpNormalize(rsaParams['d'])},\n\t\t\t{ name: 'p', data: utils.mpNormalize(rsaParams['p'])},\n\t\t\t{ name: 'q', data: utils.mpNormalize(rsaParams['q'])},\n\t\t\t{ name: 'dmodp',\n\t\t\t    data: utils.mpNormalize(rsaParams['dmodp'])},\n\t\t\t{ name: 'dmodq',\n\t\t\t    data: utils.mpNormalize(rsaParams['dmodq'])},\n\t\t\t{ name: 'iqmp',\n\t\t\t    data: utils.mpNormalize(rsaParams['iqmp'])}\n\t\t]\n\t};\n\treturn (new PrivateKey(key));\n}\n\nfunction readDNSSECPrivateKey(alg, elements) {\n\tif (supportedAlgosById[alg].match(/^RSA-/)) {\n\t\treturn (readDNSSECRSAPrivateKey(elements));\n\t}\n\tif (supportedAlgosById[alg] === 'ECDSA-P384-SHA384' ||\n\t    supportedAlgosById[alg] === 'ECDSA-P256-SHA256') {\n\t\tvar d = Buffer.from(elements[0].split(' ')[1], 'base64');\n\t\tvar curve = 'nistp384';\n\t\tvar size = 384;\n\t\tif (supportedAlgosById[alg] === 'ECDSA-P256-SHA256') {\n\t\t\tcurve = 'nistp256';\n\t\t\tsize = 256;\n\t\t}\n\t\t// DNSSEC generates the public-key on the fly (go calculate it)\n\t\tvar publicKey = utils.publicFromPrivateECDSA(curve, d);\n\t\tvar Q = publicKey.part['Q'].data;\n\t\tvar ecdsaKey = {\n\t\t\ttype: 'ecdsa',\n\t\t\tcurve: curve,\n\t\t\tsize: size,\n\t\t\tparts: [\n\t\t\t\t{name: 'curve', data: Buffer.from(curve) },\n\t\t\t\t{name: 'd', data: d },\n\t\t\t\t{name: 'Q', data: Q }\n\t\t\t]\n\t\t};\n\t\treturn (new PrivateKey(ecdsaKey));\n\t}\n\tthrow (new Error('Unsupported algorithm: ' + supportedAlgosById[alg]));\n}\n\nfunction dnssecTimestamp(date) {\n\tvar year = date.getFullYear() + ''; //stringify\n\tvar month = (date.getMonth() + 1);\n\tvar timestampStr = year + month + date.getUTCDate();\n\ttimestampStr += '' + date.getUTCHours() + date.getUTCMinutes();\n\ttimestampStr += date.getUTCSeconds();\n\treturn (timestampStr);\n}\n\nfunction rsaAlgFromOptions(opts) {\n\tif (!opts || !opts.hashAlgo || opts.hashAlgo === 'sha1')\n\t\treturn ('5 (RSASHA1)');\n\telse if (opts.hashAlgo === 'sha256')\n\t\treturn ('8 (RSASHA256)');\n\telse if (opts.hashAlgo === 'sha512')\n\t\treturn ('10 (RSASHA512)');\n\telse\n\t\tthrow (new Error('Unknown or unsupported hash: ' +\n\t\t    opts.hashAlgo));\n}\n\nfunction writeRSA(key, options) {\n\t// if we're missing parts, add them.\n\tif (!key.part.dmodp || !key.part.dmodq) {\n\t\tutils.addRSAMissing(key);\n\t}\n\n\tvar out = '';\n\tout += 'Private-key-format: v1.3\\n';\n\tout += 'Algorithm: ' + rsaAlgFromOptions(options) + '\\n';\n\tvar n = utils.mpDenormalize(key.part['n'].data);\n\tout += 'Modulus: ' + n.toString('base64') + '\\n';\n\tvar e = utils.mpDenormalize(key.part['e'].data);\n\tout += 'PublicExponent: ' + e.toString('base64') + '\\n';\n\tvar d = utils.mpDenormalize(key.part['d'].data);\n\tout += 'PrivateExponent: ' + d.toString('base64') + '\\n';\n\tvar p = utils.mpDenormalize(key.part['p'].data);\n\tout += 'Prime1: ' + p.toString('base64') + '\\n';\n\tvar q = utils.mpDenormalize(key.part['q'].data);\n\tout += 'Prime2: ' + q.toString('base64') + '\\n';\n\tvar dmodp = utils.mpDenormalize(key.part['dmodp'].data);\n\tout += 'Exponent1: ' + dmodp.toString('base64') + '\\n';\n\tvar dmodq = utils.mpDenormalize(key.part['dmodq'].data);\n\tout += 'Exponent2: ' + dmodq.toString('base64') + '\\n';\n\tvar iqmp = utils.mpDenormalize(key.part['iqmp'].data);\n\tout += 'Coefficient: ' + iqmp.toString('base64') + '\\n';\n\t// Assume that we're valid as-of now\n\tvar timestamp = new Date();\n\tout += 'Created: ' + dnssecTimestamp(timestamp) + '\\n';\n\tout += 'Publish: ' + dnssecTimestamp(timestamp) + '\\n';\n\tout += 'Activate: ' + dnssecTimestamp(timestamp) + '\\n';\n\treturn (Buffer.from(out, 'ascii'));\n}\n\nfunction writeECDSA(key, options) {\n\tvar out = '';\n\tout += 'Private-key-format: v1.3\\n';\n\n\tif (key.curve === 'nistp256') {\n\t\tout += 'Algorithm: 13 (ECDSAP256SHA256)\\n';\n\t} else if (key.curve === 'nistp384') {\n\t\tout += 'Algorithm: 14 (ECDSAP384SHA384)\\n';\n\t} else {\n\t\tthrow (new Error('Unsupported curve'));\n\t}\n\tvar base64Key = key.part['d'].data.toString('base64');\n\tout += 'PrivateKey: ' + base64Key + '\\n';\n\n\t// Assume that we're valid as-of now\n\tvar timestamp = new Date();\n\tout += 'Created: ' + dnssecTimestamp(timestamp) + '\\n';\n\tout += 'Publish: ' + dnssecTimestamp(timestamp) + '\\n';\n\tout += 'Activate: ' + dnssecTimestamp(timestamp) + '\\n';\n\n\treturn (Buffer.from(out, 'ascii'));\n}\n\nfunction write(key, options) {\n\tif (PrivateKey.isPrivateKey(key)) {\n\t\tif (key.type === 'rsa') {\n\t\t\treturn (writeRSA(key, options));\n\t\t} else if (key.type === 'ecdsa') {\n\t\t\treturn (writeECDSA(key, options));\n\t\t} else {\n\t\t\tthrow (new Error('Unsupported algorithm: ' + key.type));\n\t\t}\n\t} else if (Key.isKey(key)) {\n\t\t/*\n\t\t * RFC3110 requires a keyname, and a keytype, which we\n\t\t * don't really have a mechanism for specifying such\n\t\t * additional metadata.\n\t\t */\n\t\tthrow (new Error('Format \"dnssec\" only supports ' +\n\t\t    'writing private keys'));\n\t} else {\n\t\tthrow (new Error('key is not a Key or PrivateKey'));\n\t}\n}\n","// Copyright 2018 Joyent, Inc.\n\nmodule.exports = {\n\tread: read,\n\treadPkcs8: readPkcs8,\n\twrite: write,\n\twritePkcs8: writePkcs8,\n\tpkcs8ToBuffer: pkcs8ToBuffer,\n\n\treadECDSACurve: readECDSACurve,\n\twriteECDSACurve: writeECDSACurve\n};\n\nvar assert = require('assert-plus');\nvar asn1 = require('asn1');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('../algs');\nvar utils = require('../utils');\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\nvar pem = require('./pem');\n\nfunction read(buf, options) {\n\treturn (pem.read(buf, options, 'pkcs8'));\n}\n\nfunction write(key, options) {\n\treturn (pem.write(key, options, 'pkcs8'));\n}\n\n/* Helper to read in a single mpint */\nfunction readMPInt(der, nm) {\n\tassert.strictEqual(der.peek(), asn1.Ber.Integer,\n\t    nm + ' is not an Integer');\n\treturn (utils.mpNormalize(der.readString(asn1.Ber.Integer, true)));\n}\n\nfunction readPkcs8(alg, type, der) {\n\t/* Private keys in pkcs#8 format have a weird extra int */\n\tif (der.peek() === asn1.Ber.Integer) {\n\t\tassert.strictEqual(type, 'private',\n\t\t    'unexpected Integer at start of public key');\n\t\tder.readString(asn1.Ber.Integer, true);\n\t}\n\n\tder.readSequence();\n\tvar next = der.offset + der.length;\n\n\tvar oid = der.readOID();\n\tswitch (oid) {\n\tcase '1.2.840.113549.1.1.1':\n\t\tder._offset = next;\n\t\tif (type === 'public')\n\t\t\treturn (readPkcs8RSAPublic(der));\n\t\telse\n\t\t\treturn (readPkcs8RSAPrivate(der));\n\tcase '1.2.840.10040.4.1':\n\t\tif (type === 'public')\n\t\t\treturn (readPkcs8DSAPublic(der));\n\t\telse\n\t\t\treturn (readPkcs8DSAPrivate(der));\n\tcase '1.2.840.10045.2.1':\n\t\tif (type === 'public')\n\t\t\treturn (readPkcs8ECDSAPublic(der));\n\t\telse\n\t\t\treturn (readPkcs8ECDSAPrivate(der));\n\tcase '1.3.101.112':\n\t\tif (type === 'public') {\n\t\t\treturn (readPkcs8EdDSAPublic(der));\n\t\t} else {\n\t\t\treturn (readPkcs8EdDSAPrivate(der));\n\t\t}\n\tcase '1.3.101.110':\n\t\tif (type === 'public') {\n\t\t\treturn (readPkcs8X25519Public(der));\n\t\t} else {\n\t\t\treturn (readPkcs8X25519Private(der));\n\t\t}\n\tdefault:\n\t\tthrow (new Error('Unknown key type OID ' + oid));\n\t}\n}\n\nfunction readPkcs8RSAPublic(der) {\n\t// bit string sequence\n\tder.readSequence(asn1.Ber.BitString);\n\tder.readByte();\n\tder.readSequence();\n\n\t// modulus\n\tvar n = readMPInt(der, 'modulus');\n\tvar e = readMPInt(der, 'exponent');\n\n\t// now, make the key\n\tvar key = {\n\t\ttype: 'rsa',\n\t\tsource: der.originalInput,\n\t\tparts: [\n\t\t\t{ name: 'e', data: e },\n\t\t\t{ name: 'n', data: n }\n\t\t]\n\t};\n\n\treturn (new Key(key));\n}\n\nfunction readPkcs8RSAPrivate(der) {\n\tder.readSequence(asn1.Ber.OctetString);\n\tder.readSequence();\n\n\tvar ver = readMPInt(der, 'version');\n\tassert.equal(ver[0], 0x0, 'unknown RSA private key version');\n\n\t// modulus then public exponent\n\tvar n = readMPInt(der, 'modulus');\n\tvar e = readMPInt(der, 'public exponent');\n\tvar d = readMPInt(der, 'private exponent');\n\tvar p = readMPInt(der, 'prime1');\n\tvar q = readMPInt(der, 'prime2');\n\tvar dmodp = readMPInt(der, 'exponent1');\n\tvar dmodq = readMPInt(der, 'exponent2');\n\tvar iqmp = readMPInt(der, 'iqmp');\n\n\t// now, make the key\n\tvar key = {\n\t\ttype: 'rsa',\n\t\tparts: [\n\t\t\t{ name: 'n', data: n },\n\t\t\t{ name: 'e', data: e },\n\t\t\t{ name: 'd', data: d },\n\t\t\t{ name: 'iqmp', data: iqmp },\n\t\t\t{ name: 'p', data: p },\n\t\t\t{ name: 'q', data: q },\n\t\t\t{ name: 'dmodp', data: dmodp },\n\t\t\t{ name: 'dmodq', data: dmodq }\n\t\t]\n\t};\n\n\treturn (new PrivateKey(key));\n}\n\nfunction readPkcs8DSAPublic(der) {\n\tder.readSequence();\n\n\tvar p = readMPInt(der, 'p');\n\tvar q = readMPInt(der, 'q');\n\tvar g = readMPInt(der, 'g');\n\n\t// bit string sequence\n\tder.readSequence(asn1.Ber.BitString);\n\tder.readByte();\n\n\tvar y = readMPInt(der, 'y');\n\n\t// now, make the key\n\tvar key = {\n\t\ttype: 'dsa',\n\t\tparts: [\n\t\t\t{ name: 'p', data: p },\n\t\t\t{ name: 'q', data: q },\n\t\t\t{ name: 'g', data: g },\n\t\t\t{ name: 'y', data: y }\n\t\t]\n\t};\n\n\treturn (new Key(key));\n}\n\nfunction readPkcs8DSAPrivate(der) {\n\tder.readSequence();\n\n\tvar p = readMPInt(der, 'p');\n\tvar q = readMPInt(der, 'q');\n\tvar g = readMPInt(der, 'g');\n\n\tder.readSequence(asn1.Ber.OctetString);\n\tvar x = readMPInt(der, 'x');\n\n\t/* The pkcs#8 format does not include the public key */\n\tvar y = utils.calculateDSAPublic(g, p, x);\n\n\tvar key = {\n\t\ttype: 'dsa',\n\t\tparts: [\n\t\t\t{ name: 'p', data: p },\n\t\t\t{ name: 'q', data: q },\n\t\t\t{ name: 'g', data: g },\n\t\t\t{ name: 'y', data: y },\n\t\t\t{ name: 'x', data: x }\n\t\t]\n\t};\n\n\treturn (new PrivateKey(key));\n}\n\nfunction readECDSACurve(der) {\n\tvar curveName, curveNames;\n\tvar j, c, cd;\n\n\tif (der.peek() === asn1.Ber.OID) {\n\t\tvar oid = der.readOID();\n\n\t\tcurveNames = Object.keys(algs.curves);\n\t\tfor (j = 0; j < curveNames.length; ++j) {\n\t\t\tc = curveNames[j];\n\t\t\tcd = algs.curves[c];\n\t\t\tif (cd.pkcs8oid === oid) {\n\t\t\t\tcurveName = c;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t} else {\n\t\t// ECParameters sequence\n\t\tder.readSequence();\n\t\tvar version = der.readString(asn1.Ber.Integer, true);\n\t\tassert.strictEqual(version[0], 1, 'ECDSA key not version 1');\n\n\t\tvar curve = {};\n\n\t\t// FieldID sequence\n\t\tder.readSequence();\n\t\tvar fieldTypeOid = der.readOID();\n\t\tassert.strictEqual(fieldTypeOid, '1.2.840.10045.1.1',\n\t\t    'ECDSA key is not from a prime-field');\n\t\tvar p = curve.p = utils.mpNormalize(\n\t\t    der.readString(asn1.Ber.Integer, true));\n\t\t/*\n\t\t * p always starts with a 1 bit, so count the zeros to get its\n\t\t * real size.\n\t\t */\n\t\tcurve.size = p.length * 8 - utils.countZeros(p);\n\n\t\t// Curve sequence\n\t\tder.readSequence();\n\t\tcurve.a = utils.mpNormalize(\n\t\t    der.readString(asn1.Ber.OctetString, true));\n\t\tcurve.b = utils.mpNormalize(\n\t\t    der.readString(asn1.Ber.OctetString, true));\n\t\tif (der.peek() === asn1.Ber.BitString)\n\t\t\tcurve.s = der.readString(asn1.Ber.BitString, true);\n\n\t\t// Combined Gx and Gy\n\t\tcurve.G = der.readString(asn1.Ber.OctetString, true);\n\t\tassert.strictEqual(curve.G[0], 0x4,\n\t\t    'uncompressed G is required');\n\n\t\tcurve.n = utils.mpNormalize(\n\t\t    der.readString(asn1.Ber.Integer, true));\n\t\tcurve.h = utils.mpNormalize(\n\t\t    der.readString(asn1.Ber.Integer, true));\n\t\tassert.strictEqual(curve.h[0], 0x1, 'a cofactor=1 curve is ' +\n\t\t    'required');\n\n\t\tcurveNames = Object.keys(algs.curves);\n\t\tvar ks = Object.keys(curve);\n\t\tfor (j = 0; j < curveNames.length; ++j) {\n\t\t\tc = curveNames[j];\n\t\t\tcd = algs.curves[c];\n\t\t\tvar equal = true;\n\t\t\tfor (var i = 0; i < ks.length; ++i) {\n\t\t\t\tvar k = ks[i];\n\t\t\t\tif (cd[k] === undefined)\n\t\t\t\t\tcontinue;\n\t\t\t\tif (typeof (cd[k]) === 'object' &&\n\t\t\t\t    cd[k].equals !== undefined) {\n\t\t\t\t\tif (!cd[k].equals(curve[k])) {\n\t\t\t\t\t\tequal = false;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t} else if (Buffer.isBuffer(cd[k])) {\n\t\t\t\t\tif (cd[k].toString('binary')\n\t\t\t\t\t    !== curve[k].toString('binary')) {\n\t\t\t\t\t\tequal = false;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tif (cd[k] !== curve[k]) {\n\t\t\t\t\t\tequal = false;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (equal) {\n\t\t\t\tcurveName = c;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\treturn (curveName);\n}\n\nfunction readPkcs8ECDSAPrivate(der) {\n\tvar curveName = readECDSACurve(der);\n\tassert.string(curveName, 'a known elliptic curve');\n\n\tder.readSequence(asn1.Ber.OctetString);\n\tder.readSequence();\n\n\tvar version = readMPInt(der, 'version');\n\tassert.equal(version[0], 1, 'unknown version of ECDSA key');\n\n\tvar d = der.readString(asn1.Ber.OctetString, true);\n\tvar Q;\n\n\tif (der.peek() == 0xa0) {\n\t\tder.readSequence(0xa0);\n\t\tder._offset += der.length;\n\t}\n\tif (der.peek() == 0xa1) {\n\t\tder.readSequence(0xa1);\n\t\tQ = der.readString(asn1.Ber.BitString, true);\n\t\tQ = utils.ecNormalize(Q);\n\t}\n\n\tif (Q === undefined) {\n\t\tvar pub = utils.publicFromPrivateECDSA(curveName, d);\n\t\tQ = pub.part.Q.data;\n\t}\n\n\tvar key = {\n\t\ttype: 'ecdsa',\n\t\tparts: [\n\t\t\t{ name: 'curve', data: Buffer.from(curveName) },\n\t\t\t{ name: 'Q', data: Q },\n\t\t\t{ name: 'd', data: d }\n\t\t]\n\t};\n\n\treturn (new PrivateKey(key));\n}\n\nfunction readPkcs8ECDSAPublic(der) {\n\tvar curveName = readECDSACurve(der);\n\tassert.string(curveName, 'a known elliptic curve');\n\n\tvar Q = der.readString(asn1.Ber.BitString, true);\n\tQ = utils.ecNormalize(Q);\n\n\tvar key = {\n\t\ttype: 'ecdsa',\n\t\tparts: [\n\t\t\t{ name: 'curve', data: Buffer.from(curveName) },\n\t\t\t{ name: 'Q', data: Q }\n\t\t]\n\t};\n\n\treturn (new Key(key));\n}\n\nfunction readPkcs8EdDSAPublic(der) {\n\tif (der.peek() === 0x00)\n\t\tder.readByte();\n\n\tvar A = utils.readBitString(der);\n\n\tvar key = {\n\t\ttype: 'ed25519',\n\t\tparts: [\n\t\t\t{ name: 'A', data: utils.zeroPadToLength(A, 32) }\n\t\t]\n\t};\n\n\treturn (new Key(key));\n}\n\nfunction readPkcs8X25519Public(der) {\n\tvar A = utils.readBitString(der);\n\n\tvar key = {\n\t\ttype: 'curve25519',\n\t\tparts: [\n\t\t\t{ name: 'A', data: utils.zeroPadToLength(A, 32) }\n\t\t]\n\t};\n\n\treturn (new Key(key));\n}\n\nfunction readPkcs8EdDSAPrivate(der) {\n\tif (der.peek() === 0x00)\n\t\tder.readByte();\n\n\tder.readSequence(asn1.Ber.OctetString);\n\tvar k = der.readString(asn1.Ber.OctetString, true);\n\tk = utils.zeroPadToLength(k, 32);\n\n\tvar A;\n\tif (der.peek() === asn1.Ber.BitString) {\n\t\tA = utils.readBitString(der);\n\t\tA = utils.zeroPadToLength(A, 32);\n\t} else {\n\t\tA = utils.calculateED25519Public(k);\n\t}\n\n\tvar key = {\n\t\ttype: 'ed25519',\n\t\tparts: [\n\t\t\t{ name: 'A', data: utils.zeroPadToLength(A, 32) },\n\t\t\t{ name: 'k', data: utils.zeroPadToLength(k, 32) }\n\t\t]\n\t};\n\n\treturn (new PrivateKey(key));\n}\n\nfunction readPkcs8X25519Private(der) {\n\tif (der.peek() === 0x00)\n\t\tder.readByte();\n\n\tder.readSequence(asn1.Ber.OctetString);\n\tvar k = der.readString(asn1.Ber.OctetString, true);\n\tk = utils.zeroPadToLength(k, 32);\n\n\tvar A = utils.calculateX25519Public(k);\n\n\tvar key = {\n\t\ttype: 'curve25519',\n\t\tparts: [\n\t\t\t{ name: 'A', data: utils.zeroPadToLength(A, 32) },\n\t\t\t{ name: 'k', data: utils.zeroPadToLength(k, 32) }\n\t\t]\n\t};\n\n\treturn (new PrivateKey(key));\n}\n\nfunction pkcs8ToBuffer(key) {\n\tvar der = new asn1.BerWriter();\n\twritePkcs8(der, key);\n\treturn (der.buffer);\n}\n\nfunction writePkcs8(der, key) {\n\tder.startSequence();\n\n\tif (PrivateKey.isPrivateKey(key)) {\n\t\tvar sillyInt = Buffer.from([0]);\n\t\tder.writeBuffer(sillyInt, asn1.Ber.Integer);\n\t}\n\n\tder.startSequence();\n\tswitch (key.type) {\n\tcase 'rsa':\n\t\tder.writeOID('1.2.840.113549.1.1.1');\n\t\tif (PrivateKey.isPrivateKey(key))\n\t\t\twritePkcs8RSAPrivate(key, der);\n\t\telse\n\t\t\twritePkcs8RSAPublic(key, der);\n\t\tbreak;\n\tcase 'dsa':\n\t\tder.writeOID('1.2.840.10040.4.1');\n\t\tif (PrivateKey.isPrivateKey(key))\n\t\t\twritePkcs8DSAPrivate(key, der);\n\t\telse\n\t\t\twritePkcs8DSAPublic(key, der);\n\t\tbreak;\n\tcase 'ecdsa':\n\t\tder.writeOID('1.2.840.10045.2.1');\n\t\tif (PrivateKey.isPrivateKey(key))\n\t\t\twritePkcs8ECDSAPrivate(key, der);\n\t\telse\n\t\t\twritePkcs8ECDSAPublic(key, der);\n\t\tbreak;\n\tcase 'ed25519':\n\t\tder.writeOID('1.3.101.112');\n\t\tif (PrivateKey.isPrivateKey(key))\n\t\t\tthrow (new Error('Ed25519 private keys in pkcs8 ' +\n\t\t\t    'format are not supported'));\n\t\twritePkcs8EdDSAPublic(key, der);\n\t\tbreak;\n\tdefault:\n\t\tthrow (new Error('Unsupported key type: ' + key.type));\n\t}\n\n\tder.endSequence();\n}\n\nfunction writePkcs8RSAPrivate(key, der) {\n\tder.writeNull();\n\tder.endSequence();\n\n\tder.startSequence(asn1.Ber.OctetString);\n\tder.startSequence();\n\n\tvar version = Buffer.from([0]);\n\tder.writeBuffer(version, asn1.Ber.Integer);\n\n\tder.writeBuffer(key.part.n.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.e.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.d.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.p.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.q.data, asn1.Ber.Integer);\n\tif (!key.part.dmodp || !key.part.dmodq)\n\t\tutils.addRSAMissing(key);\n\tder.writeBuffer(key.part.dmodp.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.dmodq.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.iqmp.data, asn1.Ber.Integer);\n\n\tder.endSequence();\n\tder.endSequence();\n}\n\nfunction writePkcs8RSAPublic(key, der) {\n\tder.writeNull();\n\tder.endSequence();\n\n\tder.startSequence(asn1.Ber.BitString);\n\tder.writeByte(0x00);\n\n\tder.startSequence();\n\tder.writeBuffer(key.part.n.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.e.data, asn1.Ber.Integer);\n\tder.endSequence();\n\n\tder.endSequence();\n}\n\nfunction writePkcs8DSAPrivate(key, der) {\n\tder.startSequence();\n\tder.writeBuffer(key.part.p.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.q.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.g.data, asn1.Ber.Integer);\n\tder.endSequence();\n\n\tder.endSequence();\n\n\tder.startSequence(asn1.Ber.OctetString);\n\tder.writeBuffer(key.part.x.data, asn1.Ber.Integer);\n\tder.endSequence();\n}\n\nfunction writePkcs8DSAPublic(key, der) {\n\tder.startSequence();\n\tder.writeBuffer(key.part.p.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.q.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.g.data, asn1.Ber.Integer);\n\tder.endSequence();\n\tder.endSequence();\n\n\tder.startSequence(asn1.Ber.BitString);\n\tder.writeByte(0x00);\n\tder.writeBuffer(key.part.y.data, asn1.Ber.Integer);\n\tder.endSequence();\n}\n\nfunction writeECDSACurve(key, der) {\n\tvar curve = algs.curves[key.curve];\n\tif (curve.pkcs8oid) {\n\t\t/* This one has a name in pkcs#8, so just write the oid */\n\t\tder.writeOID(curve.pkcs8oid);\n\n\t} else {\n\t\t// ECParameters sequence\n\t\tder.startSequence();\n\n\t\tvar version = Buffer.from([1]);\n\t\tder.writeBuffer(version, asn1.Ber.Integer);\n\n\t\t// FieldID sequence\n\t\tder.startSequence();\n\t\tder.writeOID('1.2.840.10045.1.1'); // prime-field\n\t\tder.writeBuffer(curve.p, asn1.Ber.Integer);\n\t\tder.endSequence();\n\n\t\t// Curve sequence\n\t\tder.startSequence();\n\t\tvar a = curve.p;\n\t\tif (a[0] === 0x0)\n\t\t\ta = a.slice(1);\n\t\tder.writeBuffer(a, asn1.Ber.OctetString);\n\t\tder.writeBuffer(curve.b, asn1.Ber.OctetString);\n\t\tder.writeBuffer(curve.s, asn1.Ber.BitString);\n\t\tder.endSequence();\n\n\t\tder.writeBuffer(curve.G, asn1.Ber.OctetString);\n\t\tder.writeBuffer(curve.n, asn1.Ber.Integer);\n\t\tvar h = curve.h;\n\t\tif (!h) {\n\t\t\th = Buffer.from([1]);\n\t\t}\n\t\tder.writeBuffer(h, asn1.Ber.Integer);\n\n\t\t// ECParameters\n\t\tder.endSequence();\n\t}\n}\n\nfunction writePkcs8ECDSAPublic(key, der) {\n\twriteECDSACurve(key, der);\n\tder.endSequence();\n\n\tvar Q = utils.ecNormalize(key.part.Q.data, true);\n\tder.writeBuffer(Q, asn1.Ber.BitString);\n}\n\nfunction writePkcs8ECDSAPrivate(key, der) {\n\twriteECDSACurve(key, der);\n\tder.endSequence();\n\n\tder.startSequence(asn1.Ber.OctetString);\n\tder.startSequence();\n\n\tvar version = Buffer.from([1]);\n\tder.writeBuffer(version, asn1.Ber.Integer);\n\n\tder.writeBuffer(key.part.d.data, asn1.Ber.OctetString);\n\n\tder.startSequence(0xa1);\n\tvar Q = utils.ecNormalize(key.part.Q.data, true);\n\tder.writeBuffer(Q, asn1.Ber.BitString);\n\tder.endSequence();\n\n\tder.endSequence();\n\tder.endSequence();\n}\n\nfunction writePkcs8EdDSAPublic(key, der) {\n\tder.endSequence();\n\n\tutils.writeBitString(der, key.part.A.data);\n}\n\nfunction writePkcs8EdDSAPrivate(key, der) {\n\tder.endSequence();\n\n\tvar k = utils.mpNormalize(key.part.k.data, true);\n\tder.startSequence(asn1.Ber.OctetString);\n\tder.writeBuffer(k, asn1.Ber.OctetString);\n\tder.endSequence();\n}\n","// Copyright 2015 Joyent, Inc.\n\nmodule.exports = Signature;\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('./algs');\nvar crypto = require('crypto');\nvar errs = require('./errors');\nvar utils = require('./utils');\nvar asn1 = require('asn1');\nvar SSHBuffer = require('./ssh-buffer');\n\nvar InvalidAlgorithmError = errs.InvalidAlgorithmError;\nvar SignatureParseError = errs.SignatureParseError;\n\nfunction Signature(opts) {\n\tassert.object(opts, 'options');\n\tassert.arrayOfObject(opts.parts, 'options.parts');\n\tassert.string(opts.type, 'options.type');\n\n\tvar partLookup = {};\n\tfor (var i = 0; i < opts.parts.length; ++i) {\n\t\tvar part = opts.parts[i];\n\t\tpartLookup[part.name] = part;\n\t}\n\n\tthis.type = opts.type;\n\tthis.hashAlgorithm = opts.hashAlgo;\n\tthis.curve = opts.curve;\n\tthis.parts = opts.parts;\n\tthis.part = partLookup;\n}\n\nSignature.prototype.toBuffer = function (format) {\n\tif (format === undefined)\n\t\tformat = 'asn1';\n\tassert.string(format, 'format');\n\n\tvar buf;\n\tvar stype = 'ssh-' + this.type;\n\n\tswitch (this.type) {\n\tcase 'rsa':\n\t\tswitch (this.hashAlgorithm) {\n\t\tcase 'sha256':\n\t\t\tstype = 'rsa-sha2-256';\n\t\t\tbreak;\n\t\tcase 'sha512':\n\t\t\tstype = 'rsa-sha2-512';\n\t\t\tbreak;\n\t\tcase 'sha1':\n\t\tcase undefined:\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow (new Error('SSH signature ' +\n\t\t\t    'format does not support hash ' +\n\t\t\t    'algorithm ' + this.hashAlgorithm));\n\t\t}\n\t\tif (format === 'ssh') {\n\t\t\tbuf = new SSHBuffer({});\n\t\t\tbuf.writeString(stype);\n\t\t\tbuf.writePart(this.part.sig);\n\t\t\treturn (buf.toBuffer());\n\t\t} else {\n\t\t\treturn (this.part.sig.data);\n\t\t}\n\t\tbreak;\n\n\tcase 'ed25519':\n\t\tif (format === 'ssh') {\n\t\t\tbuf = new SSHBuffer({});\n\t\t\tbuf.writeString(stype);\n\t\t\tbuf.writePart(this.part.sig);\n\t\t\treturn (buf.toBuffer());\n\t\t} else {\n\t\t\treturn (this.part.sig.data);\n\t\t}\n\t\tbreak;\n\n\tcase 'dsa':\n\tcase 'ecdsa':\n\t\tvar r, s;\n\t\tif (format === 'asn1') {\n\t\t\tvar der = new asn1.BerWriter();\n\t\t\tder.startSequence();\n\t\t\tr = utils.mpNormalize(this.part.r.data);\n\t\t\ts = utils.mpNormalize(this.part.s.data);\n\t\t\tder.writeBuffer(r, asn1.Ber.Integer);\n\t\t\tder.writeBuffer(s, asn1.Ber.Integer);\n\t\t\tder.endSequence();\n\t\t\treturn (der.buffer);\n\t\t} else if (format === 'ssh' && this.type === 'dsa') {\n\t\t\tbuf = new SSHBuffer({});\n\t\t\tbuf.writeString('ssh-dss');\n\t\t\tr = this.part.r.data;\n\t\t\tif (r.length > 20 && r[0] === 0x00)\n\t\t\t\tr = r.slice(1);\n\t\t\ts = this.part.s.data;\n\t\t\tif (s.length > 20 && s[0] === 0x00)\n\t\t\t\ts = s.slice(1);\n\t\t\tif ((this.hashAlgorithm &&\n\t\t\t    this.hashAlgorithm !== 'sha1') ||\n\t\t\t    r.length + s.length !== 40) {\n\t\t\t\tthrow (new Error('OpenSSH only supports ' +\n\t\t\t\t    'DSA signatures with SHA1 hash'));\n\t\t\t}\n\t\t\tbuf.writeBuffer(Buffer.concat([r, s]));\n\t\t\treturn (buf.toBuffer());\n\t\t} else if (format === 'ssh' && this.type === 'ecdsa') {\n\t\t\tvar inner = new SSHBuffer({});\n\t\t\tr = this.part.r.data;\n\t\t\tinner.writeBuffer(r);\n\t\t\tinner.writePart(this.part.s);\n\n\t\t\tbuf = new SSHBuffer({});\n\t\t\t/* XXX: find a more proper way to do this? */\n\t\t\tvar curve;\n\t\t\tif (r[0] === 0x00)\n\t\t\t\tr = r.slice(1);\n\t\t\tvar sz = r.length * 8;\n\t\t\tif (sz === 256)\n\t\t\t\tcurve = 'nistp256';\n\t\t\telse if (sz === 384)\n\t\t\t\tcurve = 'nistp384';\n\t\t\telse if (sz === 528)\n\t\t\t\tcurve = 'nistp521';\n\t\t\tbuf.writeString('ecdsa-sha2-' + curve);\n\t\t\tbuf.writeBuffer(inner.toBuffer());\n\t\t\treturn (buf.toBuffer());\n\t\t}\n\t\tthrow (new Error('Invalid signature format'));\n\tdefault:\n\t\tthrow (new Error('Invalid signature data'));\n\t}\n};\n\nSignature.prototype.toString = function (format) {\n\tassert.optionalString(format, 'format');\n\treturn (this.toBuffer(format).toString('base64'));\n};\n\nSignature.parse = function (data, type, format) {\n\tif (typeof (data) === 'string')\n\t\tdata = Buffer.from(data, 'base64');\n\tassert.buffer(data, 'data');\n\tassert.string(format, 'format');\n\tassert.string(type, 'type');\n\n\tvar opts = {};\n\topts.type = type.toLowerCase();\n\topts.parts = [];\n\n\ttry {\n\t\tassert.ok(data.length > 0, 'signature must not be empty');\n\t\tswitch (opts.type) {\n\t\tcase 'rsa':\n\t\t\treturn (parseOneNum(data, type, format, opts));\n\t\tcase 'ed25519':\n\t\t\treturn (parseOneNum(data, type, format, opts));\n\n\t\tcase 'dsa':\n\t\tcase 'ecdsa':\n\t\t\tif (format === 'asn1')\n\t\t\t\treturn (parseDSAasn1(data, type, format, opts));\n\t\t\telse if (opts.type === 'dsa')\n\t\t\t\treturn (parseDSA(data, type, format, opts));\n\t\t\telse\n\t\t\t\treturn (parseECDSA(data, type, format, opts));\n\n\t\tdefault:\n\t\t\tthrow (new InvalidAlgorithmError(type));\n\t\t}\n\n\t} catch (e) {\n\t\tif (e instanceof InvalidAlgorithmError)\n\t\t\tthrow (e);\n\t\tthrow (new SignatureParseError(type, format, e));\n\t}\n};\n\nfunction parseOneNum(data, type, format, opts) {\n\tif (format === 'ssh') {\n\t\ttry {\n\t\t\tvar buf = new SSHBuffer({buffer: data});\n\t\t\tvar head = buf.readString();\n\t\t} catch (e) {\n\t\t\t/* fall through */\n\t\t}\n\t\tif (buf !== undefined) {\n\t\t\tvar msg = 'SSH signature does not match expected ' +\n\t\t\t    'type (expected ' + type + ', got ' + head + ')';\n\t\t\tswitch (head) {\n\t\t\tcase 'ssh-rsa':\n\t\t\t\tassert.strictEqual(type, 'rsa', msg);\n\t\t\t\topts.hashAlgo = 'sha1';\n\t\t\t\tbreak;\n\t\t\tcase 'rsa-sha2-256':\n\t\t\t\tassert.strictEqual(type, 'rsa', msg);\n\t\t\t\topts.hashAlgo = 'sha256';\n\t\t\t\tbreak;\n\t\t\tcase 'rsa-sha2-512':\n\t\t\t\tassert.strictEqual(type, 'rsa', msg);\n\t\t\t\topts.hashAlgo = 'sha512';\n\t\t\t\tbreak;\n\t\t\tcase 'ssh-ed25519':\n\t\t\t\tassert.strictEqual(type, 'ed25519', msg);\n\t\t\t\topts.hashAlgo = 'sha512';\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow (new Error('Unknown SSH signature ' +\n\t\t\t\t    'type: ' + head));\n\t\t\t}\n\t\t\tvar sig = buf.readPart();\n\t\t\tassert.ok(buf.atEnd(), 'extra trailing bytes');\n\t\t\tsig.name = 'sig';\n\t\t\topts.parts.push(sig);\n\t\t\treturn (new Signature(opts));\n\t\t}\n\t}\n\topts.parts.push({name: 'sig', data: data});\n\treturn (new Signature(opts));\n}\n\nfunction parseDSAasn1(data, type, format, opts) {\n\tvar der = new asn1.BerReader(data);\n\tder.readSequence();\n\tvar r = der.readString(asn1.Ber.Integer, true);\n\tvar s = der.readString(asn1.Ber.Integer, true);\n\n\topts.parts.push({name: 'r', data: utils.mpNormalize(r)});\n\topts.parts.push({name: 's', data: utils.mpNormalize(s)});\n\n\treturn (new Signature(opts));\n}\n\nfunction parseDSA(data, type, format, opts) {\n\tif (data.length != 40) {\n\t\tvar buf = new SSHBuffer({buffer: data});\n\t\tvar d = buf.readBuffer();\n\t\tif (d.toString('ascii') === 'ssh-dss')\n\t\t\td = buf.readBuffer();\n\t\tassert.ok(buf.atEnd(), 'extra trailing bytes');\n\t\tassert.strictEqual(d.length, 40, 'invalid inner length');\n\t\tdata = d;\n\t}\n\topts.parts.push({name: 'r', data: data.slice(0, 20)});\n\topts.parts.push({name: 's', data: data.slice(20, 40)});\n\treturn (new Signature(opts));\n}\n\nfunction parseECDSA(data, type, format, opts) {\n\tvar buf = new SSHBuffer({buffer: data});\n\n\tvar r, s;\n\tvar inner = buf.readBuffer();\n\tvar stype = inner.toString('ascii');\n\tif (stype.slice(0, 6) === 'ecdsa-') {\n\t\tvar parts = stype.split('-');\n\t\tassert.strictEqual(parts[0], 'ecdsa');\n\t\tassert.strictEqual(parts[1], 'sha2');\n\t\topts.curve = parts[2];\n\t\tswitch (opts.curve) {\n\t\tcase 'nistp256':\n\t\t\topts.hashAlgo = 'sha256';\n\t\t\tbreak;\n\t\tcase 'nistp384':\n\t\t\topts.hashAlgo = 'sha384';\n\t\t\tbreak;\n\t\tcase 'nistp521':\n\t\t\topts.hashAlgo = 'sha512';\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow (new Error('Unsupported ECDSA curve: ' +\n\t\t\t    opts.curve));\n\t\t}\n\t\tinner = buf.readBuffer();\n\t\tassert.ok(buf.atEnd(), 'extra trailing bytes on outer');\n\t\tbuf = new SSHBuffer({buffer: inner});\n\t\tr = buf.readPart();\n\t} else {\n\t\tr = {data: inner};\n\t}\n\n\ts = buf.readPart();\n\tassert.ok(buf.atEnd(), 'extra trailing bytes');\n\n\tr.name = 'r';\n\ts.name = 's';\n\n\topts.parts.push(r);\n\topts.parts.push(s);\n\treturn (new Signature(opts));\n}\n\nSignature.isSignature = function (obj, ver) {\n\treturn (utils.isCompatible(obj, Signature, ver));\n};\n\n/*\n * API versions for Signature:\n * [1,0] -- initial ver\n * [2,0] -- support for rsa in full ssh format, compat with sshpk-agent\n *          hashAlgorithm property\n * [2,1] -- first tagged version\n */\nSignature.prototype._sshpkApiVersion = [2, 1];\n\nSignature._oldVersionDetect = function (obj) {\n\tassert.func(obj.toBuffer);\n\tif (obj.hasOwnProperty('hashAlgorithm'))\n\t\treturn ([2, 0]);\n\treturn ([1, 0]);\n};\n","var exports = module.exports = function SHA (algorithm) {\n  algorithm = algorithm.toLowerCase()\n\n  var Algorithm = exports[algorithm]\n  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')\n\n  return new Algorithm()\n}\n\nexports.sha = require('./sha')\nexports.sha1 = require('./sha1')\nexports.sha224 = require('./sha224')\nexports.sha256 = require('./sha256')\nexports.sha384 = require('./sha384')\nexports.sha512 = require('./sha512')\n","// Copyright 2015 Joyent, Inc.\n\nmodule.exports = SSHBuffer;\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\n\nfunction SSHBuffer(opts) {\n\tassert.object(opts, 'options');\n\tif (opts.buffer !== undefined)\n\t\tassert.buffer(opts.buffer, 'options.buffer');\n\n\tthis._size = opts.buffer ? opts.buffer.length : 1024;\n\tthis._buffer = opts.buffer || Buffer.alloc(this._size);\n\tthis._offset = 0;\n}\n\nSSHBuffer.prototype.toBuffer = function () {\n\treturn (this._buffer.slice(0, this._offset));\n};\n\nSSHBuffer.prototype.atEnd = function () {\n\treturn (this._offset >= this._buffer.length);\n};\n\nSSHBuffer.prototype.remainder = function () {\n\treturn (this._buffer.slice(this._offset));\n};\n\nSSHBuffer.prototype.skip = function (n) {\n\tthis._offset += n;\n};\n\nSSHBuffer.prototype.expand = function () {\n\tthis._size *= 2;\n\tvar buf = Buffer.alloc(this._size);\n\tthis._buffer.copy(buf, 0);\n\tthis._buffer = buf;\n};\n\nSSHBuffer.prototype.readPart = function () {\n\treturn ({data: this.readBuffer()});\n};\n\nSSHBuffer.prototype.readBuffer = function () {\n\tvar len = this._buffer.readUInt32BE(this._offset);\n\tthis._offset += 4;\n\tassert.ok(this._offset + len <= this._buffer.length,\n\t    'length out of bounds at +0x' + this._offset.toString(16) +\n\t    ' (data truncated?)');\n\tvar buf = this._buffer.slice(this._offset, this._offset + len);\n\tthis._offset += len;\n\treturn (buf);\n};\n\nSSHBuffer.prototype.readString = function () {\n\treturn (this.readBuffer().toString());\n};\n\nSSHBuffer.prototype.readCString = function () {\n\tvar offset = this._offset;\n\twhile (offset < this._buffer.length &&\n\t    this._buffer[offset] !== 0x00)\n\t\toffset++;\n\tassert.ok(offset < this._buffer.length, 'c string does not terminate');\n\tvar str = this._buffer.slice(this._offset, offset).toString();\n\tthis._offset = offset + 1;\n\treturn (str);\n};\n\nSSHBuffer.prototype.readInt = function () {\n\tvar v = this._buffer.readUInt32BE(this._offset);\n\tthis._offset += 4;\n\treturn (v);\n};\n\nSSHBuffer.prototype.readInt64 = function () {\n\tassert.ok(this._offset + 8 < this._buffer.length,\n\t    'buffer not long enough to read Int64');\n\tvar v = this._buffer.slice(this._offset, this._offset + 8);\n\tthis._offset += 8;\n\treturn (v);\n};\n\nSSHBuffer.prototype.readChar = function () {\n\tvar v = this._buffer[this._offset++];\n\treturn (v);\n};\n\nSSHBuffer.prototype.writeBuffer = function (buf) {\n\twhile (this._offset + 4 + buf.length > this._size)\n\t\tthis.expand();\n\tthis._buffer.writeUInt32BE(buf.length, this._offset);\n\tthis._offset += 4;\n\tbuf.copy(this._buffer, this._offset);\n\tthis._offset += buf.length;\n};\n\nSSHBuffer.prototype.writeString = function (str) {\n\tthis.writeBuffer(Buffer.from(str, 'utf8'));\n};\n\nSSHBuffer.prototype.writeCString = function (str) {\n\twhile (this._offset + 1 + str.length > this._size)\n\t\tthis.expand();\n\tthis._buffer.write(str, this._offset);\n\tthis._offset += str.length;\n\tthis._buffer[this._offset++] = 0;\n};\n\nSSHBuffer.prototype.writeInt = function (v) {\n\twhile (this._offset + 4 > this._size)\n\t\tthis.expand();\n\tthis._buffer.writeUInt32BE(v, this._offset);\n\tthis._offset += 4;\n};\n\nSSHBuffer.prototype.writeInt64 = function (v) {\n\tassert.buffer(v, 'value');\n\tif (v.length > 8) {\n\t\tvar lead = v.slice(0, v.length - 8);\n\t\tfor (var i = 0; i < lead.length; ++i) {\n\t\t\tassert.strictEqual(lead[i], 0,\n\t\t\t    'must fit in 64 bits of precision');\n\t\t}\n\t\tv = v.slice(v.length - 8, v.length);\n\t}\n\twhile (this._offset + 8 > this._size)\n\t\tthis.expand();\n\tv.copy(this._buffer, this._offset);\n\tthis._offset += 8;\n};\n\nSSHBuffer.prototype.writeChar = function (v) {\n\twhile (this._offset + 1 > this._size)\n\t\tthis.expand();\n\tthis._buffer[this._offset++] = v;\n};\n\nSSHBuffer.prototype.writePart = function (p) {\n\tthis.writeBuffer(p.data);\n};\n\nSSHBuffer.prototype.write = function (buf) {\n\twhile (this._offset + buf.length > this._size)\n\t\tthis.expand();\n\tbuf.copy(this._buffer, this._offset);\n\tthis._offset += buf.length;\n};\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Sha256 = require('./sha256')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(64)\n\nfunction Sha224 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha224, Sha256)\n\nSha224.prototype.init = function () {\n  this._a = 0xc1059ed8\n  this._b = 0x367cd507\n  this._c = 0x3070dd17\n  this._d = 0xf70e5939\n  this._e = 0xffc00b31\n  this._f = 0x68581511\n  this._g = 0x64f98fa7\n  this._h = 0xbefa4fa4\n\n  return this\n}\n\nSha224.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(28)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n\n  return H\n}\n\nmodule.exports = Sha224\n","// Copyright 2018 Joyent, Inc.\n\nmodule.exports = {\n\tread: read,\n\twrite: write\n};\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar rfc4253 = require('./rfc4253');\nvar Key = require('../key');\nvar SSHBuffer = require('../ssh-buffer');\nvar crypto = require('crypto');\nvar PrivateKey = require('../private-key');\n\nvar errors = require('../errors');\n\n// https://tartarus.org/~simon/putty-prerel-snapshots/htmldoc/AppendixC.html\nfunction read(buf, options) {\n\tvar lines = buf.toString('ascii').split(/[\\r\\n]+/);\n\tvar found = false;\n\tvar parts;\n\tvar si = 0;\n\tvar formatVersion;\n\twhile (si < lines.length) {\n\t\tparts = splitHeader(lines[si++]);\n\t\tif (parts) {\n\t\t\tformatVersion = {\n\t\t\t\t'putty-user-key-file-2': 2,\n\t\t\t\t'putty-user-key-file-3': 3\n\t\t\t}[parts[0].toLowerCase()];\n\t\t\tif (formatVersion) {\n\t\t\t\tfound = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\tif (!found) {\n\t\tthrow (new Error('No PuTTY format first line found'));\n\t}\n\tvar alg = parts[1];\n\n\tparts = splitHeader(lines[si++]);\n\tassert.equal(parts[0].toLowerCase(), 'encryption');\n\tvar encryption = parts[1];\n\n\tparts = splitHeader(lines[si++]);\n\tassert.equal(parts[0].toLowerCase(), 'comment');\n\tvar comment = parts[1];\n\n\tparts = splitHeader(lines[si++]);\n\tassert.equal(parts[0].toLowerCase(), 'public-lines');\n\tvar publicLines = parseInt(parts[1], 10);\n\tif (!isFinite(publicLines) || publicLines < 0 ||\n\t    publicLines > lines.length) {\n\t\tthrow (new Error('Invalid public-lines count'));\n\t}\n\n\tvar publicBuf = Buffer.from(\n\t    lines.slice(si, si + publicLines).join(''), 'base64');\n\tvar keyType = rfc4253.algToKeyType(alg);\n\tvar key = rfc4253.read(publicBuf);\n\tif (key.type !== keyType) {\n\t\tthrow (new Error('Outer key algorithm mismatch'));\n\t}\n\n\tsi += publicLines;\n\tif (lines[si]) {\n\t\tparts = splitHeader(lines[si++]);\n\t\tassert.equal(parts[0].toLowerCase(), 'private-lines');\n\t\tvar privateLines = parseInt(parts[1], 10);\n\t\tif (!isFinite(privateLines) || privateLines < 0 ||\n\t\t    privateLines > lines.length) {\n\t\t\tthrow (new Error('Invalid private-lines count'));\n\t\t}\n\n\t\tvar privateBuf = Buffer.from(\n\t\t\tlines.slice(si, si + privateLines).join(''), 'base64');\n\n\t\tif (encryption !== 'none' && formatVersion === 3) {\n\t\t\tthrow new Error('Encrypted keys arenot supported for' +\n\t\t\t' PuTTY format version 3');\n\t\t}\n\n\t\tif (encryption === 'aes256-cbc') {\n\t\t\tif (!options.passphrase) {\n\t\t\t\tthrow (new errors.KeyEncryptedError(\n\t\t\t\t\toptions.filename, 'PEM'));\n\t\t\t}\n\n\t\t\tvar iv = Buffer.alloc(16, 0);\n\t\t\tvar decipher = crypto.createDecipheriv(\n\t\t\t\t'aes-256-cbc',\n\t\t\t\tderivePPK2EncryptionKey(options.passphrase),\n\t\t\t\tiv);\n\t\t\tdecipher.setAutoPadding(false);\n\t\t\tprivateBuf = Buffer.concat([\n\t\t\t\tdecipher.update(privateBuf), decipher.final()]);\n\t\t}\n\n\t\tkey = new PrivateKey(key);\n\t\tif (key.type !== keyType) {\n\t\t\tthrow (new Error('Outer key algorithm mismatch'));\n\t\t}\n\n\t\tvar sshbuf = new SSHBuffer({buffer: privateBuf});\n\t\tvar privateKeyParts;\n\t\tif (alg === 'ssh-dss') {\n\t\t\tprivateKeyParts = [ {\n\t\t\t\tname: 'x',\n\t\t\t\tdata: sshbuf.readBuffer()\n\t\t\t}];\n\t\t} else if (alg === 'ssh-rsa') {\n\t\t\tprivateKeyParts = [\n\t\t\t\t{ name: 'd', data: sshbuf.readBuffer() },\n\t\t\t\t{ name: 'p', data: sshbuf.readBuffer() },\n\t\t\t\t{ name: 'q', data: sshbuf.readBuffer() },\n\t\t\t\t{ name: 'iqmp', data: sshbuf.readBuffer() }\n\t\t\t];\n\t\t} else if (alg.match(/^ecdsa-sha2-nistp/)) {\n\t\t\tprivateKeyParts = [ {\n\t\t\t\tname: 'd', data: sshbuf.readBuffer()\n\t\t\t} ];\n\t\t} else if (alg === 'ssh-ed25519') {\n\t\t\tprivateKeyParts = [ {\n\t\t\t\tname: 'k', data: sshbuf.readBuffer()\n\t\t\t} ];\n\t\t} else {\n\t\t\tthrow new Error('Unsupported PPK key type: ' + alg);\n\t\t}\n\n\t\tkey = new PrivateKey({\n\t\t\ttype: key.type,\n\t\t\tparts: key.parts.concat(privateKeyParts)\n\t\t});\n\t}\n\n\tkey.comment = comment;\n\treturn (key);\n}\n\nfunction derivePPK2EncryptionKey(passphrase) {\n\tvar hash1 = crypto.createHash('sha1').update(Buffer.concat([\n\t\tBuffer.from([0, 0, 0, 0]),\n\t\tBuffer.from(passphrase)\n\t])).digest();\n\tvar hash2 = crypto.createHash('sha1').update(Buffer.concat([\n\t\tBuffer.from([0, 0, 0, 1]),\n\t\tBuffer.from(passphrase)\n\t])).digest();\n\treturn (Buffer.concat([hash1, hash2]).slice(0, 32));\n}\n\nfunction splitHeader(line) {\n\tvar idx = line.indexOf(':');\n\tif (idx === -1)\n\t\treturn (null);\n\tvar header = line.slice(0, idx);\n\t++idx;\n\twhile (line[idx] === ' ')\n\t\t++idx;\n\tvar rest = line.slice(idx);\n\treturn ([header, rest]);\n}\n\nfunction write(key, options) {\n\tassert.object(key);\n\tif (!Key.isKey(key))\n\t\tthrow (new Error('Must be a public key'));\n\n\tvar alg = rfc4253.keyTypeToAlg(key);\n\tvar buf = rfc4253.write(key);\n\tvar comment = key.comment || '';\n\n\tvar b64 = buf.toString('base64');\n\tvar lines = wrap(b64, 64);\n\n\tlines.unshift('Public-Lines: ' + lines.length);\n\tlines.unshift('Comment: ' + comment);\n\tlines.unshift('Encryption: none');\n\tlines.unshift('PuTTY-User-Key-File-2: ' + alg);\n\n\treturn (Buffer.from(lines.join('\\n') + '\\n'));\n}\n\nfunction wrap(txt, len) {\n\tvar lines = [];\n\tvar pos = 0;\n\twhile (pos < txt.length) {\n\t\tlines.push(txt.slice(pos, pos + 64));\n\t\tpos += 64;\n\t}\n\treturn (lines);\n}\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n * in FIPS PUB 180-1\n * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for details.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha1 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha1, Hash)\n\nSha1.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl1 (num) {\n  return (num << 1) | (num >>> 31)\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha1.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha1.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha1\n","// Copyright 2015 Joyent, Inc.\n\nmodule.exports = {\n\tread: read,\n\twrite: write\n};\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar rfc4253 = require('./rfc4253');\nvar utils = require('../utils');\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\n\nvar sshpriv = require('./ssh-private');\n\n/*JSSTYLED*/\nvar SSHKEY_RE = /^([a-z0-9-]+)[ \\t]+([a-zA-Z0-9+\\/]+[=]*)([ \\t]+([^ \\t][^\\n]*[\\n]*)?)?$/;\n/*JSSTYLED*/\nvar SSHKEY_RE2 = /^([a-z0-9-]+)[ \\t\\n]+([a-zA-Z0-9+\\/][a-zA-Z0-9+\\/ \\t\\n=]*)([^a-zA-Z0-9+\\/ \\t\\n=].*)?$/;\n\nfunction read(buf, options) {\n\tif (typeof (buf) !== 'string') {\n\t\tassert.buffer(buf, 'buf');\n\t\tbuf = buf.toString('ascii');\n\t}\n\n\tvar trimmed = buf.trim().replace(/[\\\\\\r]/g, '');\n\tvar m = trimmed.match(SSHKEY_RE);\n\tif (!m)\n\t\tm = trimmed.match(SSHKEY_RE2);\n\tassert.ok(m, 'key must match regex');\n\n\tvar type = rfc4253.algToKeyType(m[1]);\n\tvar kbuf = Buffer.from(m[2], 'base64');\n\n\t/*\n\t * This is a bit tricky. If we managed to parse the key and locate the\n\t * key comment with the regex, then do a non-partial read and assert\n\t * that we have consumed all bytes. If we couldn't locate the key\n\t * comment, though, there may be whitespace shenanigans going on that\n\t * have conjoined the comment to the rest of the key. We do a partial\n\t * read in this case to try to make the best out of a sorry situation.\n\t */\n\tvar key;\n\tvar ret = {};\n\tif (m[4]) {\n\t\ttry {\n\t\t\tkey = rfc4253.read(kbuf);\n\n\t\t} catch (e) {\n\t\t\tm = trimmed.match(SSHKEY_RE2);\n\t\t\tassert.ok(m, 'key must match regex');\n\t\t\tkbuf = Buffer.from(m[2], 'base64');\n\t\t\tkey = rfc4253.readInternal(ret, 'public', kbuf);\n\t\t}\n\t} else {\n\t\tkey = rfc4253.readInternal(ret, 'public', kbuf);\n\t}\n\n\tassert.strictEqual(type, key.type);\n\n\tif (m[4] && m[4].length > 0) {\n\t\tkey.comment = m[4];\n\n\t} else if (ret.consumed) {\n\t\t/*\n\t\t * Now the magic: trying to recover the key comment when it's\n\t\t * gotten conjoined to the key or otherwise shenanigan'd.\n\t\t *\n\t\t * Work out how much base64 we used, then drop all non-base64\n\t\t * chars from the beginning up to this point in the the string.\n\t\t * Then offset in this and try to make up for missing = chars.\n\t\t */\n\t\tvar data = m[2] + (m[3] ? m[3] : '');\n\t\tvar realOffset = Math.ceil(ret.consumed / 3) * 4;\n\t\tdata = data.slice(0, realOffset - 2). /*JSSTYLED*/\n\t\t    replace(/[^a-zA-Z0-9+\\/=]/g, '') +\n\t\t    data.slice(realOffset - 2);\n\n\t\tvar padding = ret.consumed % 3;\n\t\tif (padding > 0 &&\n\t\t    data.slice(realOffset - 1, realOffset) !== '=')\n\t\t\trealOffset--;\n\t\twhile (data.slice(realOffset, realOffset + 1) === '=')\n\t\t\trealOffset++;\n\n\t\t/* Finally, grab what we think is the comment & clean it up. */\n\t\tvar trailer = data.slice(realOffset);\n\t\ttrailer = trailer.replace(/[\\r\\n]/g, ' ').\n\t\t    replace(/^\\s+/, '');\n\t\tif (trailer.match(/^[a-zA-Z0-9]/))\n\t\t\tkey.comment = trailer;\n\t}\n\n\treturn (key);\n}\n\nfunction write(key, options) {\n\tassert.object(key);\n\tif (!Key.isKey(key))\n\t\tthrow (new Error('Must be a public key'));\n\n\tvar parts = [];\n\tvar alg = rfc4253.keyTypeToAlg(key);\n\tparts.push(alg);\n\n\tvar buf = rfc4253.write(key);\n\tparts.push(buf.toString('base64'));\n\n\tif (key.comment)\n\t\tparts.push(key.comment);\n\n\treturn (Buffer.from(parts.join(' ')));\n}\n","// Copyright 2015 Joyent, Inc.\n\nmodule.exports = {\n\tread: read.bind(undefined, false, undefined),\n\treadType: read.bind(undefined, false),\n\twrite: write,\n\t/* semi-private api, used by sshpk-agent */\n\treadPartial: read.bind(undefined, true),\n\n\t/* shared with ssh format */\n\treadInternal: read,\n\tkeyTypeToAlg: keyTypeToAlg,\n\talgToKeyType: algToKeyType\n};\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('../algs');\nvar utils = require('../utils');\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\nvar SSHBuffer = require('../ssh-buffer');\n\nfunction algToKeyType(alg) {\n\tassert.string(alg);\n\tif (alg === 'ssh-dss')\n\t\treturn ('dsa');\n\telse if (alg === 'ssh-rsa')\n\t\treturn ('rsa');\n\telse if (alg === 'ssh-ed25519')\n\t\treturn ('ed25519');\n\telse if (alg === 'ssh-curve25519')\n\t\treturn ('curve25519');\n\telse if (alg.match(/^ecdsa-sha2-/))\n\t\treturn ('ecdsa');\n\telse\n\t\tthrow (new Error('Unknown algorithm ' + alg));\n}\n\nfunction keyTypeToAlg(key) {\n\tassert.object(key);\n\tif (key.type === 'dsa')\n\t\treturn ('ssh-dss');\n\telse if (key.type === 'rsa')\n\t\treturn ('ssh-rsa');\n\telse if (key.type === 'ed25519')\n\t\treturn ('ssh-ed25519');\n\telse if (key.type === 'curve25519')\n\t\treturn ('ssh-curve25519');\n\telse if (key.type === 'ecdsa')\n\t\treturn ('ecdsa-sha2-' + key.part.curve.data.toString());\n\telse\n\t\tthrow (new Error('Unknown key type ' + key.type));\n}\n\nfunction read(partial, type, buf, options) {\n\tif (typeof (buf) === 'string')\n\t\tbuf = Buffer.from(buf);\n\tassert.buffer(buf, 'buf');\n\n\tvar key = {};\n\n\tvar parts = key.parts = [];\n\tvar sshbuf = new SSHBuffer({buffer: buf});\n\n\tvar alg = sshbuf.readString();\n\tassert.ok(!sshbuf.atEnd(), 'key must have at least one part');\n\n\tkey.type = algToKeyType(alg);\n\n\tvar partCount = algs.info[key.type].parts.length;\n\tif (type && type === 'private')\n\t\tpartCount = algs.privInfo[key.type].parts.length;\n\n\twhile (!sshbuf.atEnd() && parts.length < partCount)\n\t\tparts.push(sshbuf.readPart());\n\twhile (!partial && !sshbuf.atEnd())\n\t\tparts.push(sshbuf.readPart());\n\n\tassert.ok(parts.length >= 1,\n\t    'key must have at least one part');\n\tassert.ok(partial || sshbuf.atEnd(),\n\t    'leftover bytes at end of key');\n\n\tvar Constructor = Key;\n\tvar algInfo = algs.info[key.type];\n\tif (type === 'private' || algInfo.parts.length !== parts.length) {\n\t\talgInfo = algs.privInfo[key.type];\n\t\tConstructor = PrivateKey;\n\t}\n\tassert.strictEqual(algInfo.parts.length, parts.length);\n\n\tif (key.type === 'ecdsa') {\n\t\tvar res = /^ecdsa-sha2-(.+)$/.exec(alg);\n\t\tassert.ok(res !== null);\n\t\tassert.strictEqual(res[1], parts[0].data.toString());\n\t}\n\n\tvar normalized = true;\n\tfor (var i = 0; i < algInfo.parts.length; ++i) {\n\t\tvar p = parts[i];\n\t\tp.name = algInfo.parts[i];\n\t\t/*\n\t\t * OpenSSH stores ed25519 \"private\" keys as seed + public key\n\t\t * concat'd together (k followed by A). We want to keep them\n\t\t * separate for other formats that don't do this.\n\t\t */\n\t\tif (key.type === 'ed25519' && p.name === 'k')\n\t\t\tp.data = p.data.slice(0, 32);\n\n\t\tif (p.name !== 'curve' && algInfo.normalize !== false) {\n\t\t\tvar nd;\n\t\t\tif (key.type === 'ed25519') {\n\t\t\t\tnd = utils.zeroPadToLength(p.data, 32);\n\t\t\t} else {\n\t\t\t\tnd = utils.mpNormalize(p.data);\n\t\t\t}\n\t\t\tif (nd.toString('binary') !==\n\t\t\t    p.data.toString('binary')) {\n\t\t\t\tp.data = nd;\n\t\t\t\tnormalized = false;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (normalized)\n\t\tkey._rfc4253Cache = sshbuf.toBuffer();\n\n\tif (partial && typeof (partial) === 'object') {\n\t\tpartial.remainder = sshbuf.remainder();\n\t\tpartial.consumed = sshbuf._offset;\n\t}\n\n\treturn (new Constructor(key));\n}\n\nfunction write(key, options) {\n\tassert.object(key);\n\n\tvar alg = keyTypeToAlg(key);\n\tvar i;\n\n\tvar algInfo = algs.info[key.type];\n\tif (PrivateKey.isPrivateKey(key))\n\t\talgInfo = algs.privInfo[key.type];\n\tvar parts = algInfo.parts;\n\n\tvar buf = new SSHBuffer({});\n\n\tbuf.writeString(alg);\n\n\tfor (i = 0; i < parts.length; ++i) {\n\t\tvar data = key.part[parts[i]].data;\n\t\tif (algInfo.normalize !== false) {\n\t\t\tif (key.type === 'ed25519')\n\t\t\t\tdata = utils.zeroPadToLength(data, 32);\n\t\t\telse\n\t\t\t\tdata = utils.mpNormalize(data);\n\t\t}\n\t\tif (key.type === 'ed25519' && parts[i] === 'k')\n\t\t\tdata = Buffer.concat([data, key.part.A.data]);\n\t\tbuf.writeBuffer(data);\n\t}\n\n\treturn (buf.toBuffer());\n}\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","// Copyright 2016 Joyent, Inc.\n\nmodule.exports = Certificate;\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('./algs');\nvar crypto = require('crypto');\nvar Fingerprint = require('./fingerprint');\nvar Signature = require('./signature');\nvar errs = require('./errors');\nvar util = require('util');\nvar utils = require('./utils');\nvar Key = require('./key');\nvar PrivateKey = require('./private-key');\nvar Identity = require('./identity');\n\nvar formats = {};\nformats['openssh'] = require('./formats/openssh-cert');\nformats['x509'] = require('./formats/x509');\nformats['pem'] = require('./formats/x509-pem');\n\nvar CertificateParseError = errs.CertificateParseError;\nvar InvalidAlgorithmError = errs.InvalidAlgorithmError;\n\nfunction Certificate(opts) {\n\tassert.object(opts, 'options');\n\tassert.arrayOfObject(opts.subjects, 'options.subjects');\n\tutils.assertCompatible(opts.subjects[0], Identity, [1, 0],\n\t    'options.subjects');\n\tutils.assertCompatible(opts.subjectKey, Key, [1, 0],\n\t    'options.subjectKey');\n\tutils.assertCompatible(opts.issuer, Identity, [1, 0], 'options.issuer');\n\tif (opts.issuerKey !== undefined) {\n\t\tutils.assertCompatible(opts.issuerKey, Key, [1, 0],\n\t\t    'options.issuerKey');\n\t}\n\tassert.object(opts.signatures, 'options.signatures');\n\tassert.buffer(opts.serial, 'options.serial');\n\tassert.date(opts.validFrom, 'options.validFrom');\n\tassert.date(opts.validUntil, 'optons.validUntil');\n\n\tassert.optionalArrayOfString(opts.purposes, 'options.purposes');\n\n\tthis._hashCache = {};\n\n\tthis.subjects = opts.subjects;\n\tthis.issuer = opts.issuer;\n\tthis.subjectKey = opts.subjectKey;\n\tthis.issuerKey = opts.issuerKey;\n\tthis.signatures = opts.signatures;\n\tthis.serial = opts.serial;\n\tthis.validFrom = opts.validFrom;\n\tthis.validUntil = opts.validUntil;\n\tthis.purposes = opts.purposes;\n}\n\nCertificate.formats = formats;\n\nCertificate.prototype.toBuffer = function (format, options) {\n\tif (format === undefined)\n\t\tformat = 'x509';\n\tassert.string(format, 'format');\n\tassert.object(formats[format], 'formats[format]');\n\tassert.optionalObject(options, 'options');\n\n\treturn (formats[format].write(this, options));\n};\n\nCertificate.prototype.toString = function (format, options) {\n\tif (format === undefined)\n\t\tformat = 'pem';\n\treturn (this.toBuffer(format, options).toString());\n};\n\nCertificate.prototype.fingerprint = function (algo) {\n\tif (algo === undefined)\n\t\talgo = 'sha256';\n\tassert.string(algo, 'algorithm');\n\tvar opts = {\n\t\ttype: 'certificate',\n\t\thash: this.hash(algo),\n\t\talgorithm: algo\n\t};\n\treturn (new Fingerprint(opts));\n};\n\nCertificate.prototype.hash = function (algo) {\n\tassert.string(algo, 'algorithm');\n\talgo = algo.toLowerCase();\n\tif (algs.hashAlgs[algo] === undefined)\n\t\tthrow (new InvalidAlgorithmError(algo));\n\n\tif (this._hashCache[algo])\n\t\treturn (this._hashCache[algo]);\n\n\tvar hash = crypto.createHash(algo).\n\t    update(this.toBuffer('x509')).digest();\n\tthis._hashCache[algo] = hash;\n\treturn (hash);\n};\n\nCertificate.prototype.isExpired = function (when) {\n\tif (when === undefined)\n\t\twhen = new Date();\n\treturn (!((when.getTime() >= this.validFrom.getTime()) &&\n\t\t(when.getTime() < this.validUntil.getTime())));\n};\n\nCertificate.prototype.isSignedBy = function (issuerCert) {\n\tutils.assertCompatible(issuerCert, Certificate, [1, 0], 'issuer');\n\n\tif (!this.issuer.equals(issuerCert.subjects[0]))\n\t\treturn (false);\n\tif (this.issuer.purposes && this.issuer.purposes.length > 0 &&\n\t    this.issuer.purposes.indexOf('ca') === -1) {\n\t\treturn (false);\n\t}\n\n\treturn (this.isSignedByKey(issuerCert.subjectKey));\n};\n\nCertificate.prototype.getExtension = function (keyOrOid) {\n\tassert.string(keyOrOid, 'keyOrOid');\n\tvar ext = this.getExtensions().filter(function (maybeExt) {\n\t\tif (maybeExt.format === 'x509')\n\t\t\treturn (maybeExt.oid === keyOrOid);\n\t\tif (maybeExt.format === 'openssh')\n\t\t\treturn (maybeExt.name === keyOrOid);\n\t\treturn (false);\n\t})[0];\n\treturn (ext);\n};\n\nCertificate.prototype.getExtensions = function () {\n\tvar exts = [];\n\tvar x509 = this.signatures.x509;\n\tif (x509 && x509.extras && x509.extras.exts) {\n\t\tx509.extras.exts.forEach(function (ext) {\n\t\t\text.format = 'x509';\n\t\t\texts.push(ext);\n\t\t});\n\t}\n\tvar openssh = this.signatures.openssh;\n\tif (openssh && openssh.exts) {\n\t\topenssh.exts.forEach(function (ext) {\n\t\t\text.format = 'openssh';\n\t\t\texts.push(ext);\n\t\t});\n\t}\n\treturn (exts);\n};\n\nCertificate.prototype.isSignedByKey = function (issuerKey) {\n\tutils.assertCompatible(issuerKey, Key, [1, 2], 'issuerKey');\n\n\tif (this.issuerKey !== undefined) {\n\t\treturn (this.issuerKey.\n\t\t    fingerprint('sha512').matches(issuerKey));\n\t}\n\n\tvar fmt = Object.keys(this.signatures)[0];\n\tvar valid = formats[fmt].verify(this, issuerKey);\n\tif (valid)\n\t\tthis.issuerKey = issuerKey;\n\treturn (valid);\n};\n\nCertificate.prototype.signWith = function (key) {\n\tutils.assertCompatible(key, PrivateKey, [1, 2], 'key');\n\tvar fmts = Object.keys(formats);\n\tvar didOne = false;\n\tfor (var i = 0; i < fmts.length; ++i) {\n\t\tif (fmts[i] !== 'pem') {\n\t\t\tvar ret = formats[fmts[i]].sign(this, key);\n\t\t\tif (ret === true)\n\t\t\t\tdidOne = true;\n\t\t}\n\t}\n\tif (!didOne) {\n\t\tthrow (new Error('Failed to sign the certificate for any ' +\n\t\t    'available certificate formats'));\n\t}\n};\n\nCertificate.createSelfSigned = function (subjectOrSubjects, key, options) {\n\tvar subjects;\n\tif (Array.isArray(subjectOrSubjects))\n\t\tsubjects = subjectOrSubjects;\n\telse\n\t\tsubjects = [subjectOrSubjects];\n\n\tassert.arrayOfObject(subjects);\n\tsubjects.forEach(function (subject) {\n\t\tutils.assertCompatible(subject, Identity, [1, 0], 'subject');\n\t});\n\n\tutils.assertCompatible(key, PrivateKey, [1, 2], 'private key');\n\n\tassert.optionalObject(options, 'options');\n\tif (options === undefined)\n\t\toptions = {};\n\tassert.optionalObject(options.validFrom, 'options.validFrom');\n\tassert.optionalObject(options.validUntil, 'options.validUntil');\n\tvar validFrom = options.validFrom;\n\tvar validUntil = options.validUntil;\n\tif (validFrom === undefined)\n\t\tvalidFrom = new Date();\n\tif (validUntil === undefined) {\n\t\tassert.optionalNumber(options.lifetime, 'options.lifetime');\n\t\tvar lifetime = options.lifetime;\n\t\tif (lifetime === undefined)\n\t\t\tlifetime = 10*365*24*3600;\n\t\tvalidUntil = new Date();\n\t\tvalidUntil.setTime(validUntil.getTime() + lifetime*1000);\n\t}\n\tassert.optionalBuffer(options.serial, 'options.serial');\n\tvar serial = options.serial;\n\tif (serial === undefined)\n\t\tserial = Buffer.from('0000000000000001', 'hex');\n\n\tvar purposes = options.purposes;\n\tif (purposes === undefined)\n\t\tpurposes = [];\n\n\tif (purposes.indexOf('signature') === -1)\n\t\tpurposes.push('signature');\n\n\t/* Self-signed certs are always CAs. */\n\tif (purposes.indexOf('ca') === -1)\n\t\tpurposes.push('ca');\n\tif (purposes.indexOf('crl') === -1)\n\t\tpurposes.push('crl');\n\n\t/*\n\t * If we weren't explicitly given any other purposes, do the sensible\n\t * thing and add some basic ones depending on the subject type.\n\t */\n\tif (purposes.length <= 3) {\n\t\tvar hostSubjects = subjects.filter(function (subject) {\n\t\t\treturn (subject.type === 'host');\n\t\t});\n\t\tvar userSubjects = subjects.filter(function (subject) {\n\t\t\treturn (subject.type === 'user');\n\t\t});\n\t\tif (hostSubjects.length > 0) {\n\t\t\tif (purposes.indexOf('serverAuth') === -1)\n\t\t\t\tpurposes.push('serverAuth');\n\t\t}\n\t\tif (userSubjects.length > 0) {\n\t\t\tif (purposes.indexOf('clientAuth') === -1)\n\t\t\t\tpurposes.push('clientAuth');\n\t\t}\n\t\tif (userSubjects.length > 0 || hostSubjects.length > 0) {\n\t\t\tif (purposes.indexOf('keyAgreement') === -1)\n\t\t\t\tpurposes.push('keyAgreement');\n\t\t\tif (key.type === 'rsa' &&\n\t\t\t    purposes.indexOf('encryption') === -1)\n\t\t\t\tpurposes.push('encryption');\n\t\t}\n\t}\n\n\tvar cert = new Certificate({\n\t\tsubjects: subjects,\n\t\tissuer: subjects[0],\n\t\tsubjectKey: key.toPublic(),\n\t\tissuerKey: key.toPublic(),\n\t\tsignatures: {},\n\t\tserial: serial,\n\t\tvalidFrom: validFrom,\n\t\tvalidUntil: validUntil,\n\t\tpurposes: purposes\n\t});\n\tcert.signWith(key);\n\n\treturn (cert);\n};\n\nCertificate.create =\n    function (subjectOrSubjects, key, issuer, issuerKey, options) {\n\tvar subjects;\n\tif (Array.isArray(subjectOrSubjects))\n\t\tsubjects = subjectOrSubjects;\n\telse\n\t\tsubjects = [subjectOrSubjects];\n\n\tassert.arrayOfObject(subjects);\n\tsubjects.forEach(function (subject) {\n\t\tutils.assertCompatible(subject, Identity, [1, 0], 'subject');\n\t});\n\n\tutils.assertCompatible(key, Key, [1, 0], 'key');\n\tif (PrivateKey.isPrivateKey(key))\n\t\tkey = key.toPublic();\n\tutils.assertCompatible(issuer, Identity, [1, 0], 'issuer');\n\tutils.assertCompatible(issuerKey, PrivateKey, [1, 2], 'issuer key');\n\n\tassert.optionalObject(options, 'options');\n\tif (options === undefined)\n\t\toptions = {};\n\tassert.optionalObject(options.validFrom, 'options.validFrom');\n\tassert.optionalObject(options.validUntil, 'options.validUntil');\n\tvar validFrom = options.validFrom;\n\tvar validUntil = options.validUntil;\n\tif (validFrom === undefined)\n\t\tvalidFrom = new Date();\n\tif (validUntil === undefined) {\n\t\tassert.optionalNumber(options.lifetime, 'options.lifetime');\n\t\tvar lifetime = options.lifetime;\n\t\tif (lifetime === undefined)\n\t\t\tlifetime = 10*365*24*3600;\n\t\tvalidUntil = new Date();\n\t\tvalidUntil.setTime(validUntil.getTime() + lifetime*1000);\n\t}\n\tassert.optionalBuffer(options.serial, 'options.serial');\n\tvar serial = options.serial;\n\tif (serial === undefined)\n\t\tserial = Buffer.from('0000000000000001', 'hex');\n\n\tvar purposes = options.purposes;\n\tif (purposes === undefined)\n\t\tpurposes = [];\n\n\tif (purposes.indexOf('signature') === -1)\n\t\tpurposes.push('signature');\n\n\tif (options.ca === true) {\n\t\tif (purposes.indexOf('ca') === -1)\n\t\t\tpurposes.push('ca');\n\t\tif (purposes.indexOf('crl') === -1)\n\t\t\tpurposes.push('crl');\n\t}\n\n\tvar hostSubjects = subjects.filter(function (subject) {\n\t\treturn (subject.type === 'host');\n\t});\n\tvar userSubjects = subjects.filter(function (subject) {\n\t\treturn (subject.type === 'user');\n\t});\n\tif (hostSubjects.length > 0) {\n\t\tif (purposes.indexOf('serverAuth') === -1)\n\t\t\tpurposes.push('serverAuth');\n\t}\n\tif (userSubjects.length > 0) {\n\t\tif (purposes.indexOf('clientAuth') === -1)\n\t\t\tpurposes.push('clientAuth');\n\t}\n\tif (userSubjects.length > 0 || hostSubjects.length > 0) {\n\t\tif (purposes.indexOf('keyAgreement') === -1)\n\t\t\tpurposes.push('keyAgreement');\n\t\tif (key.type === 'rsa' &&\n\t\t    purposes.indexOf('encryption') === -1)\n\t\t\tpurposes.push('encryption');\n\t}\n\n\tvar cert = new Certificate({\n\t\tsubjects: subjects,\n\t\tissuer: issuer,\n\t\tsubjectKey: key,\n\t\tissuerKey: issuerKey.toPublic(),\n\t\tsignatures: {},\n\t\tserial: serial,\n\t\tvalidFrom: validFrom,\n\t\tvalidUntil: validUntil,\n\t\tpurposes: purposes\n\t});\n\tcert.signWith(issuerKey);\n\n\treturn (cert);\n};\n\nCertificate.parse = function (data, format, options) {\n\tif (typeof (data) !== 'string')\n\t\tassert.buffer(data, 'data');\n\tif (format === undefined)\n\t\tformat = 'auto';\n\tassert.string(format, 'format');\n\tif (typeof (options) === 'string')\n\t\toptions = { filename: options };\n\tassert.optionalObject(options, 'options');\n\tif (options === undefined)\n\t\toptions = {};\n\tassert.optionalString(options.filename, 'options.filename');\n\tif (options.filename === undefined)\n\t\toptions.filename = '(unnamed)';\n\n\tassert.object(formats[format], 'formats[format]');\n\n\ttry {\n\t\tvar k = formats[format].read(data, options);\n\t\treturn (k);\n\t} catch (e) {\n\t\tthrow (new CertificateParseError(options.filename, format, e));\n\t}\n};\n\nCertificate.isCertificate = function (obj, ver) {\n\treturn (utils.isCompatible(obj, Certificate, ver));\n};\n\n/*\n * API versions for Certificate:\n * [1,0] -- initial ver\n * [1,1] -- openssh format now unpacks extensions\n */\nCertificate.prototype._sshpkApiVersion = [1, 1];\n\nCertificate._oldVersionDetect = function (obj) {\n\treturn ([1, 0]);\n};\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,\n  0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,\n  0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,\n  0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,\n  0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,\n  0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,\n  0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,\n  0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,\n  0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,\n  0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,\n  0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,\n  0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,\n  0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,\n  0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,\n  0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,\n  0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2\n]\n\nvar W = new Array(64)\n\nfunction Sha256 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha256, Hash)\n\nSha256.prototype.init = function () {\n  this._a = 0x6a09e667\n  this._b = 0xbb67ae85\n  this._c = 0x3c6ef372\n  this._d = 0xa54ff53a\n  this._e = 0x510e527f\n  this._f = 0x9b05688c\n  this._g = 0x1f83d9ab\n  this._h = 0x5be0cd19\n\n  return this\n}\n\nfunction ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x) {\n  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)\n}\n\nfunction sigma1 (x) {\n  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)\n}\n\nfunction gamma0 (x) {\n  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)\n}\n\nfunction gamma1 (x) {\n  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)\n}\n\nSha256.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n  var f = this._f | 0\n  var g = this._g | 0\n  var h = this._h | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0\n\n  for (var j = 0; j < 64; ++j) {\n    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0\n    var T2 = (sigma0(a) + maj(a, b, c)) | 0\n\n    h = g\n    g = f\n    f = e\n    e = (d + T1) | 0\n    d = c\n    c = b\n    b = a\n    a = (T1 + T2) | 0\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n  this._f = (f + this._f) | 0\n  this._g = (g + this._g) | 0\n  this._h = (h + this._h) | 0\n}\n\nSha256.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(32)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n  H.writeInt32BE(this._h, 28)\n\n  return H\n}\n\nmodule.exports = Sha256\n","// Copyright 2018 Joyent, Inc.\n\nmodule.exports = Key;\n\nvar assert = require('assert-plus');\nvar algs = require('./algs');\nvar crypto = require('crypto');\nvar Fingerprint = require('./fingerprint');\nvar Signature = require('./signature');\nvar DiffieHellman = require('./dhe').DiffieHellman;\nvar errs = require('./errors');\nvar utils = require('./utils');\nvar PrivateKey = require('./private-key');\nvar edCompat;\n\ntry {\n\tedCompat = require('./ed-compat');\n} catch (e) {\n\t/* Just continue through, and bail out if we try to use it. */\n}\n\nvar InvalidAlgorithmError = errs.InvalidAlgorithmError;\nvar KeyParseError = errs.KeyParseError;\n\nvar formats = {};\nformats['auto'] = require('./formats/auto');\nformats['pem'] = require('./formats/pem');\nformats['pkcs1'] = require('./formats/pkcs1');\nformats['pkcs8'] = require('./formats/pkcs8');\nformats['rfc4253'] = require('./formats/rfc4253');\nformats['ssh'] = require('./formats/ssh');\nformats['ssh-private'] = require('./formats/ssh-private');\nformats['openssh'] = formats['ssh-private'];\nformats['dnssec'] = require('./formats/dnssec');\nformats['putty'] = require('./formats/putty');\nformats['ppk'] = formats['putty'];\n\nfunction Key(opts) {\n\tassert.object(opts, 'options');\n\tassert.arrayOfObject(opts.parts, 'options.parts');\n\tassert.string(opts.type, 'options.type');\n\tassert.optionalString(opts.comment, 'options.comment');\n\n\tvar algInfo = algs.info[opts.type];\n\tif (typeof (algInfo) !== 'object')\n\t\tthrow (new InvalidAlgorithmError(opts.type));\n\n\tvar partLookup = {};\n\tfor (var i = 0; i < opts.parts.length; ++i) {\n\t\tvar part = opts.parts[i];\n\t\tpartLookup[part.name] = part;\n\t}\n\n\tthis.type = opts.type;\n\tthis.parts = opts.parts;\n\tthis.part = partLookup;\n\tthis.comment = undefined;\n\tthis.source = opts.source;\n\n\t/* for speeding up hashing/fingerprint operations */\n\tthis._rfc4253Cache = opts._rfc4253Cache;\n\tthis._hashCache = {};\n\n\tvar sz;\n\tthis.curve = undefined;\n\tif (this.type === 'ecdsa') {\n\t\tvar curve = this.part.curve.data.toString();\n\t\tthis.curve = curve;\n\t\tsz = algs.curves[curve].size;\n\t} else if (this.type === 'ed25519' || this.type === 'curve25519') {\n\t\tsz = 256;\n\t\tthis.curve = 'curve25519';\n\t} else {\n\t\tvar szPart = this.part[algInfo.sizePart];\n\t\tsz = szPart.data.length;\n\t\tsz = sz * 8 - utils.countZeros(szPart.data);\n\t}\n\tthis.size = sz;\n}\n\nKey.formats = formats;\n\nKey.prototype.toBuffer = function (format, options) {\n\tif (format === undefined)\n\t\tformat = 'ssh';\n\tassert.string(format, 'format');\n\tassert.object(formats[format], 'formats[format]');\n\tassert.optionalObject(options, 'options');\n\n\tif (format === 'rfc4253') {\n\t\tif (this._rfc4253Cache === undefined)\n\t\t\tthis._rfc4253Cache = formats['rfc4253'].write(this);\n\t\treturn (this._rfc4253Cache);\n\t}\n\n\treturn (formats[format].write(this, options));\n};\n\nKey.prototype.toString = function (format, options) {\n\treturn (this.toBuffer(format, options).toString());\n};\n\nKey.prototype.hash = function (algo, type) {\n\tassert.string(algo, 'algorithm');\n\tassert.optionalString(type, 'type');\n\tif (type === undefined)\n\t\ttype = 'ssh';\n\talgo = algo.toLowerCase();\n\tif (algs.hashAlgs[algo] === undefined)\n\t\tthrow (new InvalidAlgorithmError(algo));\n\n\tvar cacheKey = algo + '||' + type;\n\tif (this._hashCache[cacheKey])\n\t\treturn (this._hashCache[cacheKey]);\n\n\tvar buf;\n\tif (type === 'ssh') {\n\t\tbuf = this.toBuffer('rfc4253');\n\t} else if (type === 'spki') {\n\t\tbuf = formats.pkcs8.pkcs8ToBuffer(this);\n\t} else {\n\t\tthrow (new Error('Hash type ' + type + ' not supported'));\n\t}\n\tvar hash = crypto.createHash(algo).update(buf).digest();\n\tthis._hashCache[cacheKey] = hash;\n\treturn (hash);\n};\n\nKey.prototype.fingerprint = function (algo, type) {\n\tif (algo === undefined)\n\t\talgo = 'sha256';\n\tif (type === undefined)\n\t\ttype = 'ssh';\n\tassert.string(algo, 'algorithm');\n\tassert.string(type, 'type');\n\tvar opts = {\n\t\ttype: 'key',\n\t\thash: this.hash(algo, type),\n\t\talgorithm: algo,\n\t\thashType: type\n\t};\n\treturn (new Fingerprint(opts));\n};\n\nKey.prototype.defaultHashAlgorithm = function () {\n\tvar hashAlgo = 'sha1';\n\tif (this.type === 'rsa')\n\t\thashAlgo = 'sha256';\n\tif (this.type === 'dsa' && this.size > 1024)\n\t\thashAlgo = 'sha256';\n\tif (this.type === 'ed25519')\n\t\thashAlgo = 'sha512';\n\tif (this.type === 'ecdsa') {\n\t\tif (this.size <= 256)\n\t\t\thashAlgo = 'sha256';\n\t\telse if (this.size <= 384)\n\t\t\thashAlgo = 'sha384';\n\t\telse\n\t\t\thashAlgo = 'sha512';\n\t}\n\treturn (hashAlgo);\n};\n\nKey.prototype.createVerify = function (hashAlgo) {\n\tif (hashAlgo === undefined)\n\t\thashAlgo = this.defaultHashAlgorithm();\n\tassert.string(hashAlgo, 'hash algorithm');\n\n\t/* ED25519 is not supported by OpenSSL, use a javascript impl. */\n\tif (this.type === 'ed25519' && edCompat !== undefined)\n\t\treturn (new edCompat.Verifier(this, hashAlgo));\n\tif (this.type === 'curve25519')\n\t\tthrow (new Error('Curve25519 keys are not suitable for ' +\n\t\t    'signing or verification'));\n\n\tvar v, nm, err;\n\ttry {\n\t\tnm = hashAlgo.toUpperCase();\n\t\tv = crypto.createVerify(nm);\n\t} catch (e) {\n\t\terr = e;\n\t}\n\tif (v === undefined || (err instanceof Error &&\n\t    err.message.match(/Unknown message digest/))) {\n\t\tnm = 'RSA-';\n\t\tnm += hashAlgo.toUpperCase();\n\t\tv = crypto.createVerify(nm);\n\t}\n\tassert.ok(v, 'failed to create verifier');\n\tvar oldVerify = v.verify.bind(v);\n\tvar key = this.toBuffer('pkcs8');\n\tvar curve = this.curve;\n\tvar self = this;\n\tv.verify = function (signature, fmt) {\n\t\tif (Signature.isSignature(signature, [2, 0])) {\n\t\t\tif (signature.type !== self.type)\n\t\t\t\treturn (false);\n\t\t\tif (signature.hashAlgorithm &&\n\t\t\t    signature.hashAlgorithm !== hashAlgo)\n\t\t\t\treturn (false);\n\t\t\tif (signature.curve && self.type === 'ecdsa' &&\n\t\t\t    signature.curve !== curve)\n\t\t\t\treturn (false);\n\t\t\treturn (oldVerify(key, signature.toBuffer('asn1')));\n\n\t\t} else if (typeof (signature) === 'string' ||\n\t\t    Buffer.isBuffer(signature)) {\n\t\t\treturn (oldVerify(key, signature, fmt));\n\n\t\t/*\n\t\t * Avoid doing this on valid arguments, walking the prototype\n\t\t * chain can be quite slow.\n\t\t */\n\t\t} else if (Signature.isSignature(signature, [1, 0])) {\n\t\t\tthrow (new Error('signature was created by too old ' +\n\t\t\t    'a version of sshpk and cannot be verified'));\n\n\t\t} else {\n\t\t\tthrow (new TypeError('signature must be a string, ' +\n\t\t\t    'Buffer, or Signature object'));\n\t\t}\n\t};\n\treturn (v);\n};\n\nKey.prototype.createDiffieHellman = function () {\n\tif (this.type === 'rsa')\n\t\tthrow (new Error('RSA keys do not support Diffie-Hellman'));\n\n\treturn (new DiffieHellman(this));\n};\nKey.prototype.createDH = Key.prototype.createDiffieHellman;\n\nKey.parse = function (data, format, options) {\n\tif (typeof (data) !== 'string')\n\t\tassert.buffer(data, 'data');\n\tif (format === undefined)\n\t\tformat = 'auto';\n\tassert.string(format, 'format');\n\tif (typeof (options) === 'string')\n\t\toptions = { filename: options };\n\tassert.optionalObject(options, 'options');\n\tif (options === undefined)\n\t\toptions = {};\n\tassert.optionalString(options.filename, 'options.filename');\n\tif (options.filename === undefined)\n\t\toptions.filename = '(unnamed)';\n\n\tassert.object(formats[format], 'formats[format]');\n\n\ttry {\n\t\tvar k = formats[format].read(data, options);\n\t\tif (k instanceof PrivateKey)\n\t\t\tk = k.toPublic();\n\t\tif (!k.comment)\n\t\t\tk.comment = options.filename;\n\t\treturn (k);\n\t} catch (e) {\n\t\tif (e.name === 'KeyEncryptedError')\n\t\t\tthrow (e);\n\t\tthrow (new KeyParseError(options.filename, format, e));\n\t}\n};\n\nKey.isKey = function (obj, ver) {\n\treturn (utils.isCompatible(obj, Key, ver));\n};\n\n/*\n * API versions for Key:\n * [1,0] -- initial ver, may take Signature for createVerify or may not\n * [1,1] -- added pkcs1, pkcs8 formats\n * [1,2] -- added auto, ssh-private, openssh formats\n * [1,3] -- added defaultHashAlgorithm\n * [1,4] -- added ed support, createDH\n * [1,5] -- first explicitly tagged version\n * [1,6] -- changed ed25519 part names\n * [1,7] -- spki hash types\n */\nKey.prototype._sshpkApiVersion = [1, 7];\n\nKey._oldVersionDetect = function (obj) {\n\tassert.func(obj.toBuffer);\n\tassert.func(obj.fingerprint);\n\tif (obj.createDH)\n\t\treturn ([1, 4]);\n\tif (obj.defaultHashAlgorithm)\n\t\treturn ([1, 3]);\n\tif (obj.formats['auto'])\n\t\treturn ([1, 2]);\n\tif (obj.formats['pkcs1'])\n\t\treturn ([1, 1]);\n\treturn ([1, 0]);\n};\n","// Copyright 2015 Joyent, Inc.\n\nvar Buffer = require('safer-buffer').Buffer;\n\nvar algInfo = {\n\t'dsa': {\n\t\tparts: ['p', 'q', 'g', 'y'],\n\t\tsizePart: 'p'\n\t},\n\t'rsa': {\n\t\tparts: ['e', 'n'],\n\t\tsizePart: 'n'\n\t},\n\t'ecdsa': {\n\t\tparts: ['curve', 'Q'],\n\t\tsizePart: 'Q'\n\t},\n\t'ed25519': {\n\t\tparts: ['A'],\n\t\tsizePart: 'A'\n\t}\n};\nalgInfo['curve25519'] = algInfo['ed25519'];\n\nvar algPrivInfo = {\n\t'dsa': {\n\t\tparts: ['p', 'q', 'g', 'y', 'x']\n\t},\n\t'rsa': {\n\t\tparts: ['n', 'e', 'd', 'iqmp', 'p', 'q']\n\t},\n\t'ecdsa': {\n\t\tparts: ['curve', 'Q', 'd']\n\t},\n\t'ed25519': {\n\t\tparts: ['A', 'k']\n\t}\n};\nalgPrivInfo['curve25519'] = algPrivInfo['ed25519'];\n\nvar hashAlgs = {\n\t'md5': true,\n\t'sha1': true,\n\t'sha256': true,\n\t'sha384': true,\n\t'sha512': true\n};\n\n/*\n * Taken from\n * http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.pdf\n */\nvar curves = {\n\t'nistp256': {\n\t\tsize: 256,\n\t\tpkcs8oid: '1.2.840.10045.3.1.7',\n\t\tp: Buffer.from(('00' +\n\t\t    'ffffffff 00000001 00000000 00000000' +\n\t\t    '00000000 ffffffff ffffffff ffffffff').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\ta: Buffer.from(('00' +\n\t\t    'FFFFFFFF 00000001 00000000 00000000' +\n\t\t    '00000000 FFFFFFFF FFFFFFFF FFFFFFFC').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\tb: Buffer.from((\n\t\t    '5ac635d8 aa3a93e7 b3ebbd55 769886bc' +\n\t\t    '651d06b0 cc53b0f6 3bce3c3e 27d2604b').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\ts: Buffer.from(('00' +\n\t\t    'c49d3608 86e70493 6a6678e1 139d26b7' +\n\t\t    '819f7e90').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\tn: Buffer.from(('00' +\n\t\t    'ffffffff 00000000 ffffffff ffffffff' +\n\t\t    'bce6faad a7179e84 f3b9cac2 fc632551').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\tG: Buffer.from(('04' +\n\t\t    '6b17d1f2 e12c4247 f8bce6e5 63a440f2' +\n\t\t    '77037d81 2deb33a0 f4a13945 d898c296' +\n\t\t    '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16' +\n\t\t    '2bce3357 6b315ece cbb64068 37bf51f5').\n\t\t    replace(/ /g, ''), 'hex')\n\t},\n\t'nistp384': {\n\t\tsize: 384,\n\t\tpkcs8oid: '1.3.132.0.34',\n\t\tp: Buffer.from(('00' +\n\t\t    'ffffffff ffffffff ffffffff ffffffff' +\n\t\t    'ffffffff ffffffff ffffffff fffffffe' +\n\t\t    'ffffffff 00000000 00000000 ffffffff').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\ta: Buffer.from(('00' +\n\t\t    'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' +\n\t\t    'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE' +\n\t\t    'FFFFFFFF 00000000 00000000 FFFFFFFC').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\tb: Buffer.from((\n\t\t    'b3312fa7 e23ee7e4 988e056b e3f82d19' +\n\t\t    '181d9c6e fe814112 0314088f 5013875a' +\n\t\t    'c656398d 8a2ed19d 2a85c8ed d3ec2aef').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\ts: Buffer.from(('00' +\n\t\t    'a335926a a319a27a 1d00896a 6773a482' +\n\t\t    '7acdac73').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\tn: Buffer.from(('00' +\n\t\t    'ffffffff ffffffff ffffffff ffffffff' +\n\t\t    'ffffffff ffffffff c7634d81 f4372ddf' +\n\t\t    '581a0db2 48b0a77a ecec196a ccc52973').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\tG: Buffer.from(('04' +\n\t\t    'aa87ca22 be8b0537 8eb1c71e f320ad74' +\n\t\t    '6e1d3b62 8ba79b98 59f741e0 82542a38' +\n\t\t    '5502f25d bf55296c 3a545e38 72760ab7' +\n\t\t    '3617de4a 96262c6f 5d9e98bf 9292dc29' +\n\t\t    'f8f41dbd 289a147c e9da3113 b5f0b8c0' +\n\t\t    '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f').\n\t\t    replace(/ /g, ''), 'hex')\n\t},\n\t'nistp521': {\n\t\tsize: 521,\n\t\tpkcs8oid: '1.3.132.0.35',\n\t\tp: Buffer.from((\n\t\t    '01ffffff ffffffff ffffffff ffffffff' +\n\t\t    'ffffffff ffffffff ffffffff ffffffff' +\n\t\t    'ffffffff ffffffff ffffffff ffffffff' +\n\t\t    'ffffffff ffffffff ffffffff ffffffff' +\n\t\t    'ffff').replace(/ /g, ''), 'hex'),\n\t\ta: Buffer.from(('01FF' +\n\t\t    'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' +\n\t\t    'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' +\n\t\t    'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' +\n\t\t    'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFC').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\tb: Buffer.from(('51' +\n\t\t    '953eb961 8e1c9a1f 929a21a0 b68540ee' +\n\t\t    'a2da725b 99b315f3 b8b48991 8ef109e1' +\n\t\t    '56193951 ec7e937b 1652c0bd 3bb1bf07' +\n\t\t    '3573df88 3d2c34f1 ef451fd4 6b503f00').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\ts: Buffer.from(('00' +\n\t\t    'd09e8800 291cb853 96cc6717 393284aa' +\n\t\t    'a0da64ba').replace(/ /g, ''), 'hex'),\n\t\tn: Buffer.from(('01ff' +\n\t\t    'ffffffff ffffffff ffffffff ffffffff' +\n\t\t    'ffffffff ffffffff ffffffff fffffffa' +\n\t\t    '51868783 bf2f966b 7fcc0148 f709a5d0' +\n\t\t    '3bb5c9b8 899c47ae bb6fb71e 91386409').\n\t\t    replace(/ /g, ''), 'hex'),\n\t\tG: Buffer.from(('04' +\n\t\t    '00c6 858e06b7 0404e9cd 9e3ecb66 2395b442' +\n\t\t         '9c648139 053fb521 f828af60 6b4d3dba' +\n\t\t         'a14b5e77 efe75928 fe1dc127 a2ffa8de' +\n\t\t         '3348b3c1 856a429b f97e7e31 c2e5bd66' +\n\t\t    '0118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9' +\n\t\t         '98f54449 579b4468 17afbd17 273e662c' +\n\t\t         '97ee7299 5ef42640 c550b901 3fad0761' +\n\t\t         '353c7086 a272c240 88be9476 9fd16650').\n\t\t    replace(/ /g, ''), 'hex')\n\t}\n};\n\nmodule.exports = {\n\tinfo: algInfo,\n\tprivInfo: algPrivInfo,\n\thashAlgs: hashAlgs,\n\tcurves: curves\n};\n","// Copyright 2018 Joyent, Inc.\n\nmodule.exports = Fingerprint;\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('./algs');\nvar crypto = require('crypto');\nvar errs = require('./errors');\nvar Key = require('./key');\nvar PrivateKey = require('./private-key');\nvar Certificate = require('./certificate');\nvar utils = require('./utils');\n\nvar FingerprintFormatError = errs.FingerprintFormatError;\nvar InvalidAlgorithmError = errs.InvalidAlgorithmError;\n\nfunction Fingerprint(opts) {\n\tassert.object(opts, 'options');\n\tassert.string(opts.type, 'options.type');\n\tassert.buffer(opts.hash, 'options.hash');\n\tassert.string(opts.algorithm, 'options.algorithm');\n\n\tthis.algorithm = opts.algorithm.toLowerCase();\n\tif (algs.hashAlgs[this.algorithm] !== true)\n\t\tthrow (new InvalidAlgorithmError(this.algorithm));\n\n\tthis.hash = opts.hash;\n\tthis.type = opts.type;\n\tthis.hashType = opts.hashType;\n}\n\nFingerprint.prototype.toString = function (format) {\n\tif (format === undefined) {\n\t\tif (this.algorithm === 'md5' || this.hashType === 'spki')\n\t\t\tformat = 'hex';\n\t\telse\n\t\t\tformat = 'base64';\n\t}\n\tassert.string(format);\n\n\tswitch (format) {\n\tcase 'hex':\n\t\tif (this.hashType === 'spki')\n\t\t\treturn (this.hash.toString('hex'));\n\t\treturn (addColons(this.hash.toString('hex')));\n\tcase 'base64':\n\t\tif (this.hashType === 'spki')\n\t\t\treturn (this.hash.toString('base64'));\n\t\treturn (sshBase64Format(this.algorithm,\n\t\t    this.hash.toString('base64')));\n\tdefault:\n\t\tthrow (new FingerprintFormatError(undefined, format));\n\t}\n};\n\nFingerprint.prototype.matches = function (other) {\n\tassert.object(other, 'key or certificate');\n\tif (this.type === 'key' && this.hashType !== 'ssh') {\n\t\tutils.assertCompatible(other, Key, [1, 7], 'key with spki');\n\t\tif (PrivateKey.isPrivateKey(other)) {\n\t\t\tutils.assertCompatible(other, PrivateKey, [1, 6],\n\t\t\t    'privatekey with spki support');\n\t\t}\n\t} else if (this.type === 'key') {\n\t\tutils.assertCompatible(other, Key, [1, 0], 'key');\n\t} else {\n\t\tutils.assertCompatible(other, Certificate, [1, 0],\n\t\t    'certificate');\n\t}\n\n\tvar theirHash = other.hash(this.algorithm, this.hashType);\n\tvar theirHash2 = crypto.createHash(this.algorithm).\n\t    update(theirHash).digest('base64');\n\n\tif (this.hash2 === undefined)\n\t\tthis.hash2 = crypto.createHash(this.algorithm).\n\t\t    update(this.hash).digest('base64');\n\n\treturn (this.hash2 === theirHash2);\n};\n\n/*JSSTYLED*/\nvar base64RE = /^[A-Za-z0-9+\\/=]+$/;\n/*JSSTYLED*/\nvar hexRE = /^[a-fA-F0-9]+$/;\n\nFingerprint.parse = function (fp, options) {\n\tassert.string(fp, 'fingerprint');\n\n\tvar alg, hash, enAlgs;\n\tif (Array.isArray(options)) {\n\t\tenAlgs = options;\n\t\toptions = {};\n\t}\n\tassert.optionalObject(options, 'options');\n\tif (options === undefined)\n\t\toptions = {};\n\tif (options.enAlgs !== undefined)\n\t\tenAlgs = options.enAlgs;\n\tif (options.algorithms !== undefined)\n\t\tenAlgs = options.algorithms;\n\tassert.optionalArrayOfString(enAlgs, 'algorithms');\n\n\tvar hashType = 'ssh';\n\tif (options.hashType !== undefined)\n\t\thashType = options.hashType;\n\tassert.string(hashType, 'options.hashType');\n\n\tvar parts = fp.split(':');\n\tif (parts.length == 2) {\n\t\talg = parts[0].toLowerCase();\n\t\tif (!base64RE.test(parts[1]))\n\t\t\tthrow (new FingerprintFormatError(fp));\n\t\ttry {\n\t\t\thash = Buffer.from(parts[1], 'base64');\n\t\t} catch (e) {\n\t\t\tthrow (new FingerprintFormatError(fp));\n\t\t}\n\t} else if (parts.length > 2) {\n\t\talg = 'md5';\n\t\tif (parts[0].toLowerCase() === 'md5')\n\t\t\tparts = parts.slice(1);\n\t\tparts = parts.map(function (p) {\n\t\t\twhile (p.length < 2)\n\t\t\t\tp = '0' + p;\n\t\t\tif (p.length > 2)\n\t\t\t\tthrow (new FingerprintFormatError(fp));\n\t\t\treturn (p);\n\t\t});\n\t\tparts = parts.join('');\n\t\tif (!hexRE.test(parts) || parts.length % 2 !== 0)\n\t\t\tthrow (new FingerprintFormatError(fp));\n\t\ttry {\n\t\t\thash = Buffer.from(parts, 'hex');\n\t\t} catch (e) {\n\t\t\tthrow (new FingerprintFormatError(fp));\n\t\t}\n\t} else {\n\t\tif (hexRE.test(fp)) {\n\t\t\thash = Buffer.from(fp, 'hex');\n\t\t} else if (base64RE.test(fp)) {\n\t\t\thash = Buffer.from(fp, 'base64');\n\t\t} else {\n\t\t\tthrow (new FingerprintFormatError(fp));\n\t\t}\n\n\t\tswitch (hash.length) {\n\t\tcase 32:\n\t\t\talg = 'sha256';\n\t\t\tbreak;\n\t\tcase 16:\n\t\t\talg = 'md5';\n\t\t\tbreak;\n\t\tcase 20:\n\t\t\talg = 'sha1';\n\t\t\tbreak;\n\t\tcase 64:\n\t\t\talg = 'sha512';\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow (new FingerprintFormatError(fp));\n\t\t}\n\n\t\t/* Plain hex/base64: guess it's probably SPKI unless told. */\n\t\tif (options.hashType === undefined)\n\t\t\thashType = 'spki';\n\t}\n\n\tif (alg === undefined)\n\t\tthrow (new FingerprintFormatError(fp));\n\n\tif (algs.hashAlgs[alg] === undefined)\n\t\tthrow (new InvalidAlgorithmError(alg));\n\n\tif (enAlgs !== undefined) {\n\t\tenAlgs = enAlgs.map(function (a) { return a.toLowerCase(); });\n\t\tif (enAlgs.indexOf(alg) === -1)\n\t\t\tthrow (new InvalidAlgorithmError(alg));\n\t}\n\n\treturn (new Fingerprint({\n\t\talgorithm: alg,\n\t\thash: hash,\n\t\ttype: options.type || 'key',\n\t\thashType: hashType\n\t}));\n};\n\nfunction addColons(s) {\n\t/*JSSTYLED*/\n\treturn (s.replace(/(.{2})(?=.)/g, '$1:'));\n}\n\nfunction base64Strip(s) {\n\t/*JSSTYLED*/\n\treturn (s.replace(/=*$/, ''));\n}\n\nfunction sshBase64Format(alg, h) {\n\treturn (alg.toUpperCase() + ':' + base64Strip(h));\n}\n\nFingerprint.isFingerprint = function (obj, ver) {\n\treturn (utils.isCompatible(obj, Fingerprint, ver));\n};\n\n/*\n * API versions for Fingerprint:\n * [1,0] -- initial ver\n * [1,1] -- first tagged ver\n * [1,2] -- hashType and spki support\n */\nFingerprint.prototype._sshpkApiVersion = [1, 2];\n\nFingerprint._oldVersionDetect = function (obj) {\n\tassert.func(obj.toString);\n\tassert.func(obj.matches);\n\treturn ([1, 0]);\n};\n","// Copyright 2017 Joyent, Inc.\n\nmodule.exports = {\n\tDiffieHellman: DiffieHellman,\n\tgenerateECDSA: generateECDSA,\n\tgenerateED25519: generateED25519\n};\n\nvar assert = require('assert-plus');\nvar crypto = require('crypto');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('./algs');\nvar utils = require('./utils');\nvar nacl = require('tweetnacl');\n\nvar Key = require('./key');\nvar PrivateKey = require('./private-key');\n\nvar CRYPTO_HAVE_ECDH = (crypto.createECDH !== undefined);\n\nvar ecdh = require('ecc-jsbn');\nvar ec = require('ecc-jsbn/lib/ec');\nvar jsbn = require('jsbn').BigInteger;\n\nfunction DiffieHellman(key) {\n\tutils.assertCompatible(key, Key, [1, 4], 'key');\n\tthis._isPriv = PrivateKey.isPrivateKey(key, [1, 3]);\n\tthis._algo = key.type;\n\tthis._curve = key.curve;\n\tthis._key = key;\n\tif (key.type === 'dsa') {\n\t\tif (!CRYPTO_HAVE_ECDH) {\n\t\t\tthrow (new Error('Due to bugs in the node 0.10 ' +\n\t\t\t    'crypto API, node 0.12.x or later is required ' +\n\t\t\t    'to use DH'));\n\t\t}\n\t\tthis._dh = crypto.createDiffieHellman(\n\t\t    key.part.p.data, undefined,\n\t\t    key.part.g.data, undefined);\n\t\tthis._p = key.part.p;\n\t\tthis._g = key.part.g;\n\t\tif (this._isPriv)\n\t\t\tthis._dh.setPrivateKey(key.part.x.data);\n\t\tthis._dh.setPublicKey(key.part.y.data);\n\n\t} else if (key.type === 'ecdsa') {\n\t\tif (!CRYPTO_HAVE_ECDH) {\n\t\t\tthis._ecParams = new X9ECParameters(this._curve);\n\n\t\t\tif (this._isPriv) {\n\t\t\t\tthis._priv = new ECPrivate(\n\t\t\t\t    this._ecParams, key.part.d.data);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\tvar curve = {\n\t\t\t'nistp256': 'prime256v1',\n\t\t\t'nistp384': 'secp384r1',\n\t\t\t'nistp521': 'secp521r1'\n\t\t}[key.curve];\n\t\tthis._dh = crypto.createECDH(curve);\n\t\tif (typeof (this._dh) !== 'object' ||\n\t\t    typeof (this._dh.setPrivateKey) !== 'function') {\n\t\t\tCRYPTO_HAVE_ECDH = false;\n\t\t\tDiffieHellman.call(this, key);\n\t\t\treturn;\n\t\t}\n\t\tif (this._isPriv)\n\t\t\tthis._dh.setPrivateKey(key.part.d.data);\n\t\tthis._dh.setPublicKey(key.part.Q.data);\n\n\t} else if (key.type === 'curve25519') {\n\t\tif (this._isPriv) {\n\t\t\tutils.assertCompatible(key, PrivateKey, [1, 5], 'key');\n\t\t\tthis._priv = key.part.k.data;\n\t\t}\n\n\t} else {\n\t\tthrow (new Error('DH not supported for ' + key.type + ' keys'));\n\t}\n}\n\nDiffieHellman.prototype.getPublicKey = function () {\n\tif (this._isPriv)\n\t\treturn (this._key.toPublic());\n\treturn (this._key);\n};\n\nDiffieHellman.prototype.getPrivateKey = function () {\n\tif (this._isPriv)\n\t\treturn (this._key);\n\telse\n\t\treturn (undefined);\n};\nDiffieHellman.prototype.getKey = DiffieHellman.prototype.getPrivateKey;\n\nDiffieHellman.prototype._keyCheck = function (pk, isPub) {\n\tassert.object(pk, 'key');\n\tif (!isPub)\n\t\tutils.assertCompatible(pk, PrivateKey, [1, 3], 'key');\n\tutils.assertCompatible(pk, Key, [1, 4], 'key');\n\n\tif (pk.type !== this._algo) {\n\t\tthrow (new Error('A ' + pk.type + ' key cannot be used in ' +\n\t\t    this._algo + ' Diffie-Hellman'));\n\t}\n\n\tif (pk.curve !== this._curve) {\n\t\tthrow (new Error('A key from the ' + pk.curve + ' curve ' +\n\t\t    'cannot be used with a ' + this._curve +\n\t\t    ' Diffie-Hellman'));\n\t}\n\n\tif (pk.type === 'dsa') {\n\t\tassert.deepEqual(pk.part.p, this._p,\n\t\t    'DSA key prime does not match');\n\t\tassert.deepEqual(pk.part.g, this._g,\n\t\t    'DSA key generator does not match');\n\t}\n};\n\nDiffieHellman.prototype.setKey = function (pk) {\n\tthis._keyCheck(pk);\n\n\tif (pk.type === 'dsa') {\n\t\tthis._dh.setPrivateKey(pk.part.x.data);\n\t\tthis._dh.setPublicKey(pk.part.y.data);\n\n\t} else if (pk.type === 'ecdsa') {\n\t\tif (CRYPTO_HAVE_ECDH) {\n\t\t\tthis._dh.setPrivateKey(pk.part.d.data);\n\t\t\tthis._dh.setPublicKey(pk.part.Q.data);\n\t\t} else {\n\t\t\tthis._priv = new ECPrivate(\n\t\t\t    this._ecParams, pk.part.d.data);\n\t\t}\n\n\t} else if (pk.type === 'curve25519') {\n\t\tvar k = pk.part.k;\n\t\tif (!pk.part.k)\n\t\t\tk = pk.part.r;\n\t\tthis._priv = k.data;\n\t\tif (this._priv[0] === 0x00)\n\t\t\tthis._priv = this._priv.slice(1);\n\t\tthis._priv = this._priv.slice(0, 32);\n\t}\n\tthis._key = pk;\n\tthis._isPriv = true;\n};\nDiffieHellman.prototype.setPrivateKey = DiffieHellman.prototype.setKey;\n\nDiffieHellman.prototype.computeSecret = function (otherpk) {\n\tthis._keyCheck(otherpk, true);\n\tif (!this._isPriv)\n\t\tthrow (new Error('DH exchange has not been initialized with ' +\n\t\t    'a private key yet'));\n\n\tvar pub;\n\tif (this._algo === 'dsa') {\n\t\treturn (this._dh.computeSecret(\n\t\t    otherpk.part.y.data));\n\n\t} else if (this._algo === 'ecdsa') {\n\t\tif (CRYPTO_HAVE_ECDH) {\n\t\t\treturn (this._dh.computeSecret(\n\t\t\t    otherpk.part.Q.data));\n\t\t} else {\n\t\t\tpub = new ECPublic(\n\t\t\t    this._ecParams, otherpk.part.Q.data);\n\t\t\treturn (this._priv.deriveSharedSecret(pub));\n\t\t}\n\n\t} else if (this._algo === 'curve25519') {\n\t\tpub = otherpk.part.A.data;\n\t\twhile (pub[0] === 0x00 && pub.length > 32)\n\t\t\tpub = pub.slice(1);\n\t\tvar priv = this._priv;\n\t\tassert.strictEqual(pub.length, 32);\n\t\tassert.strictEqual(priv.length, 32);\n\n\t\tvar secret = nacl.box.before(new Uint8Array(pub),\n\t\t    new Uint8Array(priv));\n\n\t\treturn (Buffer.from(secret));\n\t}\n\n\tthrow (new Error('Invalid algorithm: ' + this._algo));\n};\n\nDiffieHellman.prototype.generateKey = function () {\n\tvar parts = [];\n\tvar priv, pub;\n\tif (this._algo === 'dsa') {\n\t\tthis._dh.generateKeys();\n\n\t\tparts.push({name: 'p', data: this._p.data});\n\t\tparts.push({name: 'q', data: this._key.part.q.data});\n\t\tparts.push({name: 'g', data: this._g.data});\n\t\tparts.push({name: 'y', data: this._dh.getPublicKey()});\n\t\tparts.push({name: 'x', data: this._dh.getPrivateKey()});\n\t\tthis._key = new PrivateKey({\n\t\t\ttype: 'dsa',\n\t\t\tparts: parts\n\t\t});\n\t\tthis._isPriv = true;\n\t\treturn (this._key);\n\n\t} else if (this._algo === 'ecdsa') {\n\t\tif (CRYPTO_HAVE_ECDH) {\n\t\t\tthis._dh.generateKeys();\n\n\t\t\tparts.push({name: 'curve',\n\t\t\t    data: Buffer.from(this._curve)});\n\t\t\tparts.push({name: 'Q', data: this._dh.getPublicKey()});\n\t\t\tparts.push({name: 'd', data: this._dh.getPrivateKey()});\n\t\t\tthis._key = new PrivateKey({\n\t\t\t\ttype: 'ecdsa',\n\t\t\t\tcurve: this._curve,\n\t\t\t\tparts: parts\n\t\t\t});\n\t\t\tthis._isPriv = true;\n\t\t\treturn (this._key);\n\n\t\t} else {\n\t\t\tvar n = this._ecParams.getN();\n\t\t\tvar r = new jsbn(crypto.randomBytes(n.bitLength()));\n\t\t\tvar n1 = n.subtract(jsbn.ONE);\n\t\t\tpriv = r.mod(n1).add(jsbn.ONE);\n\t\t\tpub = this._ecParams.getG().multiply(priv);\n\n\t\t\tpriv = Buffer.from(priv.toByteArray());\n\t\t\tpub = Buffer.from(this._ecParams.getCurve().\n\t\t\t    encodePointHex(pub), 'hex');\n\n\t\t\tthis._priv = new ECPrivate(this._ecParams, priv);\n\n\t\t\tparts.push({name: 'curve',\n\t\t\t    data: Buffer.from(this._curve)});\n\t\t\tparts.push({name: 'Q', data: pub});\n\t\t\tparts.push({name: 'd', data: priv});\n\n\t\t\tthis._key = new PrivateKey({\n\t\t\t\ttype: 'ecdsa',\n\t\t\t\tcurve: this._curve,\n\t\t\t\tparts: parts\n\t\t\t});\n\t\t\tthis._isPriv = true;\n\t\t\treturn (this._key);\n\t\t}\n\n\t} else if (this._algo === 'curve25519') {\n\t\tvar pair = nacl.box.keyPair();\n\t\tpriv = Buffer.from(pair.secretKey);\n\t\tpub = Buffer.from(pair.publicKey);\n\t\tpriv = Buffer.concat([priv, pub]);\n\t\tassert.strictEqual(priv.length, 64);\n\t\tassert.strictEqual(pub.length, 32);\n\n\t\tparts.push({name: 'A', data: pub});\n\t\tparts.push({name: 'k', data: priv});\n\t\tthis._key = new PrivateKey({\n\t\t\ttype: 'curve25519',\n\t\t\tparts: parts\n\t\t});\n\t\tthis._isPriv = true;\n\t\treturn (this._key);\n\t}\n\n\tthrow (new Error('Invalid algorithm: ' + this._algo));\n};\nDiffieHellman.prototype.generateKeys = DiffieHellman.prototype.generateKey;\n\n/* These are helpers for using ecc-jsbn (for node 0.10 compatibility). */\n\nfunction X9ECParameters(name) {\n\tvar params = algs.curves[name];\n\tassert.object(params);\n\n\tvar p = new jsbn(params.p);\n\tvar a = new jsbn(params.a);\n\tvar b = new jsbn(params.b);\n\tvar n = new jsbn(params.n);\n\tvar h = jsbn.ONE;\n\tvar curve = new ec.ECCurveFp(p, a, b);\n\tvar G = curve.decodePointHex(params.G.toString('hex'));\n\n\tthis.curve = curve;\n\tthis.g = G;\n\tthis.n = n;\n\tthis.h = h;\n}\nX9ECParameters.prototype.getCurve = function () { return (this.curve); };\nX9ECParameters.prototype.getG = function () { return (this.g); };\nX9ECParameters.prototype.getN = function () { return (this.n); };\nX9ECParameters.prototype.getH = function () { return (this.h); };\n\nfunction ECPublic(params, buffer) {\n\tthis._params = params;\n\tif (buffer[0] === 0x00)\n\t\tbuffer = buffer.slice(1);\n\tthis._pub = params.getCurve().decodePointHex(buffer.toString('hex'));\n}\n\nfunction ECPrivate(params, buffer) {\n\tthis._params = params;\n\tthis._priv = new jsbn(utils.mpNormalize(buffer));\n}\nECPrivate.prototype.deriveSharedSecret = function (pubKey) {\n\tassert.ok(pubKey instanceof ECPublic);\n\tvar S = pubKey._pub.multiply(this._priv);\n\treturn (Buffer.from(S.getX().toBigInteger().toByteArray()));\n};\n\nfunction generateED25519() {\n\tvar pair = nacl.sign.keyPair();\n\tvar priv = Buffer.from(pair.secretKey);\n\tvar pub = Buffer.from(pair.publicKey);\n\tassert.strictEqual(priv.length, 64);\n\tassert.strictEqual(pub.length, 32);\n\n\tvar parts = [];\n\tparts.push({name: 'A', data: pub});\n\tparts.push({name: 'k', data: priv.slice(0, 32)});\n\tvar key = new PrivateKey({\n\t\ttype: 'ed25519',\n\t\tparts: parts\n\t});\n\treturn (key);\n}\n\n/* Generates a new ECDSA private key on a given curve. */\nfunction generateECDSA(curve) {\n\tvar parts = [];\n\tvar key;\n\n\tif (CRYPTO_HAVE_ECDH) {\n\t\t/*\n\t\t * Node crypto doesn't expose key generation directly, but the\n\t\t * ECDH instances can generate keys. It turns out this just\n\t\t * calls into the OpenSSL generic key generator, and we can\n\t\t * read its output happily without doing an actual DH. So we\n\t\t * use that here.\n\t\t */\n\t\tvar osCurve = {\n\t\t\t'nistp256': 'prime256v1',\n\t\t\t'nistp384': 'secp384r1',\n\t\t\t'nistp521': 'secp521r1'\n\t\t}[curve];\n\n\t\tvar dh = crypto.createECDH(osCurve);\n\t\tdh.generateKeys();\n\n\t\tparts.push({name: 'curve',\n\t\t    data: Buffer.from(curve)});\n\t\tparts.push({name: 'Q', data: dh.getPublicKey()});\n\t\tparts.push({name: 'd', data: dh.getPrivateKey()});\n\n\t\tkey = new PrivateKey({\n\t\t\ttype: 'ecdsa',\n\t\t\tcurve: curve,\n\t\t\tparts: parts\n\t\t});\n\t\treturn (key);\n\t} else {\n\n\t\tvar ecParams = new X9ECParameters(curve);\n\n\t\t/* This algorithm taken from FIPS PUB 186-4 (section B.4.1) */\n\t\tvar n = ecParams.getN();\n\t\t/*\n\t\t * The crypto.randomBytes() function can only give us whole\n\t\t * bytes, so taking a nod from X9.62, we round up.\n\t\t */\n\t\tvar cByteLen = Math.ceil((n.bitLength() + 64) / 8);\n\t\tvar c = new jsbn(crypto.randomBytes(cByteLen));\n\n\t\tvar n1 = n.subtract(jsbn.ONE);\n\t\tvar priv = c.mod(n1).add(jsbn.ONE);\n\t\tvar pub = ecParams.getG().multiply(priv);\n\n\t\tpriv = Buffer.from(priv.toByteArray());\n\t\tpub = Buffer.from(ecParams.getCurve().\n\t\t    encodePointHex(pub), 'hex');\n\n\t\tparts.push({name: 'curve', data: Buffer.from(curve)});\n\t\tparts.push({name: 'Q', data: pub});\n\t\tparts.push({name: 'd', data: priv});\n\n\t\tkey = new PrivateKey({\n\t\t\ttype: 'ecdsa',\n\t\t\tcurve: curve,\n\t\t\tparts: parts\n\t\t});\n\t\treturn (key);\n\t}\n}\n","var Buffer = require('safe-buffer').Buffer\n\n// prototype class for hash functions\nfunction Hash (blockSize, finalSize) {\n  this._block = Buffer.alloc(blockSize)\n  this._finalSize = finalSize\n  this._blockSize = blockSize\n  this._len = 0\n}\n\nHash.prototype.update = function (data, enc) {\n  if (typeof data === 'string') {\n    enc = enc || 'utf8'\n    data = Buffer.from(data, enc)\n  }\n\n  var block = this._block\n  var blockSize = this._blockSize\n  var length = data.length\n  var accum = this._len\n\n  for (var offset = 0; offset < length;) {\n    var assigned = accum % blockSize\n    var remainder = Math.min(length - offset, blockSize - assigned)\n\n    for (var i = 0; i < remainder; i++) {\n      block[assigned + i] = data[offset + i]\n    }\n\n    accum += remainder\n    offset += remainder\n\n    if ((accum % blockSize) === 0) {\n      this._update(block)\n    }\n  }\n\n  this._len += length\n  return this\n}\n\nHash.prototype.digest = function (enc) {\n  var rem = this._len % this._blockSize\n\n  this._block[rem] = 0x80\n\n  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest\n  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize\n  this._block.fill(0, rem + 1)\n\n  if (rem >= this._finalSize) {\n    this._update(this._block)\n    this._block.fill(0)\n  }\n\n  var bits = this._len * 8\n\n  // uint32\n  if (bits <= 0xffffffff) {\n    this._block.writeUInt32BE(bits, this._blockSize - 4)\n\n  // uint64\n  } else {\n    var lowBits = (bits & 0xffffffff) >>> 0\n    var highBits = (bits - lowBits) / 0x100000000\n\n    this._block.writeUInt32BE(highBits, this._blockSize - 8)\n    this._block.writeUInt32BE(lowBits, this._blockSize - 4)\n  }\n\n  this._update(this._block)\n  var hash = this._hash()\n\n  return enc ? hash.toString(enc) : hash\n}\n\nHash.prototype._update = function () {\n  throw new Error('_update must be implemented by subclass')\n}\n\nmodule.exports = Hash\n","var inherits = require('inherits')\nvar SHA512 = require('./sha512')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(160)\n\nfunction Sha384 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha384, SHA512)\n\nSha384.prototype.init = function () {\n  this._ah = 0xcbbb9d5d\n  this._bh = 0x629a292a\n  this._ch = 0x9159015a\n  this._dh = 0x152fecd8\n  this._eh = 0x67332667\n  this._fh = 0x8eb44a87\n  this._gh = 0xdb0c2e0d\n  this._hh = 0x47b5481d\n\n  this._al = 0xc1059ed8\n  this._bl = 0x367cd507\n  this._cl = 0x3070dd17\n  this._dl = 0xf70e5939\n  this._el = 0xffc00b31\n  this._fl = 0x68581511\n  this._gl = 0x64f98fa7\n  this._hl = 0xbefa4fa4\n\n  return this\n}\n\nSha384.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(48)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n\n  return H\n}\n\nmodule.exports = Sha384\n","// Copyright 2017 Joyent, Inc.\n\nmodule.exports = Identity;\n\nvar assert = require('assert-plus');\nvar algs = require('./algs');\nvar crypto = require('crypto');\nvar Fingerprint = require('./fingerprint');\nvar Signature = require('./signature');\nvar errs = require('./errors');\nvar util = require('util');\nvar utils = require('./utils');\nvar asn1 = require('asn1');\nvar Buffer = require('safer-buffer').Buffer;\n\n/*JSSTYLED*/\nvar DNS_NAME_RE = /^([*]|[a-z0-9][a-z0-9\\-]{0,62})(?:\\.([*]|[a-z0-9][a-z0-9\\-]{0,62}))*$/i;\n\nvar oids = {};\noids.cn = '2.5.4.3';\noids.o = '2.5.4.10';\noids.ou = '2.5.4.11';\noids.l = '2.5.4.7';\noids.s = '2.5.4.8';\noids.c = '2.5.4.6';\noids.sn = '2.5.4.4';\noids.postalCode = '2.5.4.17';\noids.serialNumber = '2.5.4.5';\noids.street = '2.5.4.9';\noids.x500UniqueIdentifier = '2.5.4.45';\noids.role = '2.5.4.72';\noids.telephoneNumber = '2.5.4.20';\noids.description = '2.5.4.13';\noids.dc = '0.9.2342.19200300.100.1.25';\noids.uid = '0.9.2342.19200300.100.1.1';\noids.mail = '0.9.2342.19200300.100.1.3';\noids.title = '2.5.4.12';\noids.gn = '2.5.4.42';\noids.initials = '2.5.4.43';\noids.pseudonym = '2.5.4.65';\noids.emailAddress = '1.2.840.113549.1.9.1';\n\nvar unoids = {};\nObject.keys(oids).forEach(function (k) {\n\tunoids[oids[k]] = k;\n});\n\nfunction Identity(opts) {\n\tvar self = this;\n\tassert.object(opts, 'options');\n\tassert.arrayOfObject(opts.components, 'options.components');\n\tthis.components = opts.components;\n\tthis.componentLookup = {};\n\tthis.components.forEach(function (c) {\n\t\tif (c.name && !c.oid)\n\t\t\tc.oid = oids[c.name];\n\t\tif (c.oid && !c.name)\n\t\t\tc.name = unoids[c.oid];\n\t\tif (self.componentLookup[c.name] === undefined)\n\t\t\tself.componentLookup[c.name] = [];\n\t\tself.componentLookup[c.name].push(c);\n\t});\n\tif (this.componentLookup.cn && this.componentLookup.cn.length > 0) {\n\t\tthis.cn = this.componentLookup.cn[0].value;\n\t}\n\tassert.optionalString(opts.type, 'options.type');\n\tif (opts.type === undefined) {\n\t\tif (this.components.length === 1 &&\n\t\t    this.componentLookup.cn &&\n\t\t    this.componentLookup.cn.length === 1 &&\n\t\t    this.componentLookup.cn[0].value.match(DNS_NAME_RE)) {\n\t\t\tthis.type = 'host';\n\t\t\tthis.hostname = this.componentLookup.cn[0].value;\n\n\t\t} else if (this.componentLookup.dc &&\n\t\t    this.components.length === this.componentLookup.dc.length) {\n\t\t\tthis.type = 'host';\n\t\t\tthis.hostname = this.componentLookup.dc.map(\n\t\t\t    function (c) {\n\t\t\t\treturn (c.value);\n\t\t\t}).join('.');\n\n\t\t} else if (this.componentLookup.uid &&\n\t\t    this.components.length ===\n\t\t    this.componentLookup.uid.length) {\n\t\t\tthis.type = 'user';\n\t\t\tthis.uid = this.componentLookup.uid[0].value;\n\n\t\t} else if (this.componentLookup.cn &&\n\t\t    this.componentLookup.cn.length === 1 &&\n\t\t    this.componentLookup.cn[0].value.match(DNS_NAME_RE)) {\n\t\t\tthis.type = 'host';\n\t\t\tthis.hostname = this.componentLookup.cn[0].value;\n\n\t\t} else if (this.componentLookup.uid &&\n\t\t    this.componentLookup.uid.length === 1) {\n\t\t\tthis.type = 'user';\n\t\t\tthis.uid = this.componentLookup.uid[0].value;\n\n\t\t} else if (this.componentLookup.mail &&\n\t\t    this.componentLookup.mail.length === 1) {\n\t\t\tthis.type = 'email';\n\t\t\tthis.email = this.componentLookup.mail[0].value;\n\n\t\t} else if (this.componentLookup.cn &&\n\t\t    this.componentLookup.cn.length === 1) {\n\t\t\tthis.type = 'user';\n\t\t\tthis.uid = this.componentLookup.cn[0].value;\n\n\t\t} else {\n\t\t\tthis.type = 'unknown';\n\t\t}\n\t} else {\n\t\tthis.type = opts.type;\n\t\tif (this.type === 'host')\n\t\t\tthis.hostname = opts.hostname;\n\t\telse if (this.type === 'user')\n\t\t\tthis.uid = opts.uid;\n\t\telse if (this.type === 'email')\n\t\t\tthis.email = opts.email;\n\t\telse\n\t\t\tthrow (new Error('Unknown type ' + this.type));\n\t}\n}\n\nIdentity.prototype.toString = function () {\n\treturn (this.components.map(function (c) {\n\t\tvar n = c.name.toUpperCase();\n\t\t/*JSSTYLED*/\n\t\tn = n.replace(/=/g, '\\\\=');\n\t\tvar v = c.value;\n\t\t/*JSSTYLED*/\n\t\tv = v.replace(/,/g, '\\\\,');\n\t\treturn (n + '=' + v);\n\t}).join(', '));\n};\n\nIdentity.prototype.get = function (name, asArray) {\n\tassert.string(name, 'name');\n\tvar arr = this.componentLookup[name];\n\tif (arr === undefined || arr.length === 0)\n\t\treturn (undefined);\n\tif (!asArray && arr.length > 1)\n\t\tthrow (new Error('Multiple values for attribute ' + name));\n\tif (!asArray)\n\t\treturn (arr[0].value);\n\treturn (arr.map(function (c) {\n\t\treturn (c.value);\n\t}));\n};\n\nIdentity.prototype.toArray = function (idx) {\n\treturn (this.components.map(function (c) {\n\t\treturn ({\n\t\t\tname: c.name,\n\t\t\tvalue: c.value\n\t\t});\n\t}));\n};\n\n/*\n * These are from X.680 -- PrintableString allowed chars are in section 37.4\n * table 8. Spec for IA5Strings is \"1,6 + SPACE + DEL\" where 1 refers to\n * ISO IR #001 (standard ASCII control characters) and 6 refers to ISO IR #006\n * (the basic ASCII character set).\n */\n/* JSSTYLED */\nvar NOT_PRINTABLE = /[^a-zA-Z0-9 '(),+.\\/:=?-]/;\n/* JSSTYLED */\nvar NOT_IA5 = /[^\\x00-\\x7f]/;\n\nIdentity.prototype.toAsn1 = function (der, tag) {\n\tder.startSequence(tag);\n\tthis.components.forEach(function (c) {\n\t\tder.startSequence(asn1.Ber.Constructor | asn1.Ber.Set);\n\t\tder.startSequence();\n\t\tder.writeOID(c.oid);\n\t\t/*\n\t\t * If we fit in a PrintableString, use that. Otherwise use an\n\t\t * IA5String or UTF8String.\n\t\t *\n\t\t * If this identity was parsed from a DN, use the ASN.1 types\n\t\t * from the original representation (otherwise this might not\n\t\t * be a full match for the original in some validators).\n\t\t */\n\t\tif (c.asn1type === asn1.Ber.Utf8String ||\n\t\t    c.value.match(NOT_IA5)) {\n\t\t\tvar v = Buffer.from(c.value, 'utf8');\n\t\t\tder.writeBuffer(v, asn1.Ber.Utf8String);\n\n\t\t} else if (c.asn1type === asn1.Ber.IA5String ||\n\t\t    c.value.match(NOT_PRINTABLE)) {\n\t\t\tder.writeString(c.value, asn1.Ber.IA5String);\n\n\t\t} else {\n\t\t\tvar type = asn1.Ber.PrintableString;\n\t\t\tif (c.asn1type !== undefined)\n\t\t\t\ttype = c.asn1type;\n\t\t\tder.writeString(c.value, type);\n\t\t}\n\t\tder.endSequence();\n\t\tder.endSequence();\n\t});\n\tder.endSequence();\n};\n\nfunction globMatch(a, b) {\n\tif (a === '**' || b === '**')\n\t\treturn (true);\n\tvar aParts = a.split('.');\n\tvar bParts = b.split('.');\n\tif (aParts.length !== bParts.length)\n\t\treturn (false);\n\tfor (var i = 0; i < aParts.length; ++i) {\n\t\tif (aParts[i] === '*' || bParts[i] === '*')\n\t\t\tcontinue;\n\t\tif (aParts[i] !== bParts[i])\n\t\t\treturn (false);\n\t}\n\treturn (true);\n}\n\nIdentity.prototype.equals = function (other) {\n\tif (!Identity.isIdentity(other, [1, 0]))\n\t\treturn (false);\n\tif (other.components.length !== this.components.length)\n\t\treturn (false);\n\tfor (var i = 0; i < this.components.length; ++i) {\n\t\tif (this.components[i].oid !== other.components[i].oid)\n\t\t\treturn (false);\n\t\tif (!globMatch(this.components[i].value,\n\t\t    other.components[i].value)) {\n\t\t\treturn (false);\n\t\t}\n\t}\n\treturn (true);\n};\n\nIdentity.forHost = function (hostname) {\n\tassert.string(hostname, 'hostname');\n\treturn (new Identity({\n\t\ttype: 'host',\n\t\thostname: hostname,\n\t\tcomponents: [ { name: 'cn', value: hostname } ]\n\t}));\n};\n\nIdentity.forUser = function (uid) {\n\tassert.string(uid, 'uid');\n\treturn (new Identity({\n\t\ttype: 'user',\n\t\tuid: uid,\n\t\tcomponents: [ { name: 'uid', value: uid } ]\n\t}));\n};\n\nIdentity.forEmail = function (email) {\n\tassert.string(email, 'email');\n\treturn (new Identity({\n\t\ttype: 'email',\n\t\temail: email,\n\t\tcomponents: [ { name: 'mail', value: email } ]\n\t}));\n};\n\nIdentity.parseDN = function (dn) {\n\tassert.string(dn, 'dn');\n\tvar parts = [''];\n\tvar idx = 0;\n\tvar rem = dn;\n\twhile (rem.length > 0) {\n\t\tvar m;\n\t\t/*JSSTYLED*/\n\t\tif ((m = /^,/.exec(rem)) !== null) {\n\t\t\tparts[++idx] = '';\n\t\t\trem = rem.slice(m[0].length);\n\t\t/*JSSTYLED*/\n\t\t} else if ((m = /^\\\\,/.exec(rem)) !== null) {\n\t\t\tparts[idx] += ',';\n\t\t\trem = rem.slice(m[0].length);\n\t\t/*JSSTYLED*/\n\t\t} else if ((m = /^\\\\./.exec(rem)) !== null) {\n\t\t\tparts[idx] += m[0];\n\t\t\trem = rem.slice(m[0].length);\n\t\t/*JSSTYLED*/\n\t\t} else if ((m = /^[^\\\\,]+/.exec(rem)) !== null) {\n\t\t\tparts[idx] += m[0];\n\t\t\trem = rem.slice(m[0].length);\n\t\t} else {\n\t\t\tthrow (new Error('Failed to parse DN'));\n\t\t}\n\t}\n\tvar cmps = parts.map(function (c) {\n\t\tc = c.trim();\n\t\tvar eqPos = c.indexOf('=');\n\t\twhile (eqPos > 0 && c.charAt(eqPos - 1) === '\\\\')\n\t\t\teqPos = c.indexOf('=', eqPos + 1);\n\t\tif (eqPos === -1) {\n\t\t\tthrow (new Error('Failed to parse DN'));\n\t\t}\n\t\t/*JSSTYLED*/\n\t\tvar name = c.slice(0, eqPos).toLowerCase().replace(/\\\\=/g, '=');\n\t\tvar value = c.slice(eqPos + 1);\n\t\treturn ({ name: name, value: value });\n\t});\n\treturn (new Identity({ components: cmps }));\n};\n\nIdentity.fromArray = function (components) {\n\tassert.arrayOfObject(components, 'components');\n\tcomponents.forEach(function (cmp) {\n\t\tassert.object(cmp, 'component');\n\t\tassert.string(cmp.name, 'component.name');\n\t\tif (!Buffer.isBuffer(cmp.value) &&\n\t\t    !(typeof (cmp.value) === 'string')) {\n\t\t\tthrow (new Error('Invalid component value'));\n\t\t}\n\t});\n\treturn (new Identity({ components: components }));\n};\n\nIdentity.parseAsn1 = function (der, top) {\n\tvar components = [];\n\tder.readSequence(top);\n\tvar end = der.offset + der.length;\n\twhile (der.offset < end) {\n\t\tder.readSequence(asn1.Ber.Constructor | asn1.Ber.Set);\n\t\tvar after = der.offset + der.length;\n\t\tder.readSequence();\n\t\tvar oid = der.readOID();\n\t\tvar type = der.peek();\n\t\tvar value;\n\t\tswitch (type) {\n\t\tcase asn1.Ber.PrintableString:\n\t\tcase asn1.Ber.IA5String:\n\t\tcase asn1.Ber.OctetString:\n\t\tcase asn1.Ber.T61String:\n\t\t\tvalue = der.readString(type);\n\t\t\tbreak;\n\t\tcase asn1.Ber.Utf8String:\n\t\t\tvalue = der.readString(type, true);\n\t\t\tvalue = value.toString('utf8');\n\t\t\tbreak;\n\t\tcase asn1.Ber.CharacterString:\n\t\tcase asn1.Ber.BMPString:\n\t\t\tvalue = der.readString(type, true);\n\t\t\tvalue = value.toString('utf16le');\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tthrow (new Error('Unknown asn1 type ' + type));\n\t\t}\n\t\tcomponents.push({ oid: oid, asn1type: type, value: value });\n\t\tder._offset = after;\n\t}\n\tder._offset = end;\n\treturn (new Identity({\n\t\tcomponents: components\n\t}));\n};\n\nIdentity.isIdentity = function (obj, ver) {\n\treturn (utils.isCompatible(obj, Identity, ver));\n};\n\n/*\n * API versions for Identity:\n * [1,0] -- initial ver\n */\nIdentity.prototype._sshpkApiVersion = [1, 0];\n\nIdentity._oldVersionDetect = function (obj) {\n\treturn ([1, 0]);\n};\n","/* eslint-disable node/no-deprecated-api */\n\n'use strict'\n\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\nvar safer = {}\n\nvar key\n\nfor (key in buffer) {\n  if (!buffer.hasOwnProperty(key)) continue\n  if (key === 'SlowBuffer' || key === 'Buffer') continue\n  safer[key] = buffer[key]\n}\n\nvar Safer = safer.Buffer = {}\nfor (key in Buffer) {\n  if (!Buffer.hasOwnProperty(key)) continue\n  if (key === 'allocUnsafe' || key === 'allocUnsafeSlow') continue\n  Safer[key] = Buffer[key]\n}\n\nsafer.Buffer.prototype = Buffer.prototype\n\nif (!Safer.from || Safer.from === Uint8Array.from) {\n  Safer.from = function (value, encodingOrOffset, length) {\n    if (typeof value === 'number') {\n      throw new TypeError('The \"value\" argument must not be of type number. Received type ' + typeof value)\n    }\n    if (value && typeof value.length === 'undefined') {\n      throw new TypeError('The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ' + typeof value)\n    }\n    return Buffer(value, encodingOrOffset, length)\n  }\n}\n\nif (!Safer.alloc) {\n  Safer.alloc = function (size, fill, encoding) {\n    if (typeof size !== 'number') {\n      throw new TypeError('The \"size\" argument must be of type number. Received type ' + typeof size)\n    }\n    if (size < 0 || size >= 2 * (1 << 30)) {\n      throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n    }\n    var buf = Buffer(size)\n    if (!fill || fill.length === 0) {\n      buf.fill(0)\n    } else if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n    return buf\n  }\n}\n\nif (!safer.kStringMaxLength) {\n  try {\n    safer.kStringMaxLength = process.binding('buffer').kStringMaxLength\n  } catch (e) {\n    // we can't determine kStringMaxLength in environments where process.binding\n    // is unsupported, so let's not set it\n  }\n}\n\nif (!safer.constants) {\n  safer.constants = {\n    MAX_LENGTH: safer.kMaxLength\n  }\n  if (safer.kStringMaxLength) {\n    safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength\n  }\n}\n\nmodule.exports = safer\n","// Copyright 2017 Joyent, Inc.\n\nmodule.exports = {\n\tread: read,\n\tverify: verify,\n\tsign: sign,\n\tsignAsync: signAsync,\n\twrite: write,\n\n\t/* Internal private API */\n\tfromBuffer: fromBuffer,\n\ttoBuffer: toBuffer\n};\n\nvar assert = require('assert-plus');\nvar SSHBuffer = require('../ssh-buffer');\nvar crypto = require('crypto');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('../algs');\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\nvar Identity = require('../identity');\nvar rfc4253 = require('./rfc4253');\nvar Signature = require('../signature');\nvar utils = require('../utils');\nvar Certificate = require('../certificate');\n\nfunction verify(cert, key) {\n\t/*\n\t * We always give an issuerKey, so if our verify() is being called then\n\t * there was no signature. Return false.\n\t */\n\treturn (false);\n}\n\nvar TYPES = {\n\t'user': 1,\n\t'host': 2\n};\nObject.keys(TYPES).forEach(function (k) { TYPES[TYPES[k]] = k; });\n\nvar ECDSA_ALGO = /^ecdsa-sha2-([^@-]+)-cert-v01@openssh.com$/;\n\nfunction read(buf, options) {\n\tif (Buffer.isBuffer(buf))\n\t\tbuf = buf.toString('ascii');\n\tvar parts = buf.trim().split(/[ \\t\\n]+/g);\n\tif (parts.length < 2 || parts.length > 3)\n\t\tthrow (new Error('Not a valid SSH certificate line'));\n\n\tvar algo = parts[0];\n\tvar data = parts[1];\n\n\tdata = Buffer.from(data, 'base64');\n\treturn (fromBuffer(data, algo));\n}\n\nfunction fromBuffer(data, algo, partial) {\n\tvar sshbuf = new SSHBuffer({ buffer: data });\n\tvar innerAlgo = sshbuf.readString();\n\tif (algo !== undefined && innerAlgo !== algo)\n\t\tthrow (new Error('SSH certificate algorithm mismatch'));\n\tif (algo === undefined)\n\t\talgo = innerAlgo;\n\n\tvar cert = {};\n\tcert.signatures = {};\n\tcert.signatures.openssh = {};\n\n\tcert.signatures.openssh.nonce = sshbuf.readBuffer();\n\n\tvar key = {};\n\tvar parts = (key.parts = []);\n\tkey.type = getAlg(algo);\n\n\tvar partCount = algs.info[key.type].parts.length;\n\twhile (parts.length < partCount)\n\t\tparts.push(sshbuf.readPart());\n\tassert.ok(parts.length >= 1, 'key must have at least one part');\n\n\tvar algInfo = algs.info[key.type];\n\tif (key.type === 'ecdsa') {\n\t\tvar res = ECDSA_ALGO.exec(algo);\n\t\tassert.ok(res !== null);\n\t\tassert.strictEqual(res[1], parts[0].data.toString());\n\t}\n\n\tfor (var i = 0; i < algInfo.parts.length; ++i) {\n\t\tparts[i].name = algInfo.parts[i];\n\t\tif (parts[i].name !== 'curve' &&\n\t\t    algInfo.normalize !== false) {\n\t\t\tvar p = parts[i];\n\t\t\tp.data = utils.mpNormalize(p.data);\n\t\t}\n\t}\n\n\tcert.subjectKey = new Key(key);\n\n\tcert.serial = sshbuf.readInt64();\n\n\tvar type = TYPES[sshbuf.readInt()];\n\tassert.string(type, 'valid cert type');\n\n\tcert.signatures.openssh.keyId = sshbuf.readString();\n\n\tvar principals = [];\n\tvar pbuf = sshbuf.readBuffer();\n\tvar psshbuf = new SSHBuffer({ buffer: pbuf });\n\twhile (!psshbuf.atEnd())\n\t\tprincipals.push(psshbuf.readString());\n\tif (principals.length === 0)\n\t\tprincipals = ['*'];\n\n\tcert.subjects = principals.map(function (pr) {\n\t\tif (type === 'user')\n\t\t\treturn (Identity.forUser(pr));\n\t\telse if (type === 'host')\n\t\t\treturn (Identity.forHost(pr));\n\t\tthrow (new Error('Unknown identity type ' + type));\n\t});\n\n\tcert.validFrom = int64ToDate(sshbuf.readInt64());\n\tcert.validUntil = int64ToDate(sshbuf.readInt64());\n\n\tvar exts = [];\n\tvar extbuf = new SSHBuffer({ buffer: sshbuf.readBuffer() });\n\tvar ext;\n\twhile (!extbuf.atEnd()) {\n\t\text = { critical: true };\n\t\text.name = extbuf.readString();\n\t\text.data = extbuf.readBuffer();\n\t\texts.push(ext);\n\t}\n\textbuf = new SSHBuffer({ buffer: sshbuf.readBuffer() });\n\twhile (!extbuf.atEnd()) {\n\t\text = { critical: false };\n\t\text.name = extbuf.readString();\n\t\text.data = extbuf.readBuffer();\n\t\texts.push(ext);\n\t}\n\tcert.signatures.openssh.exts = exts;\n\n\t/* reserved */\n\tsshbuf.readBuffer();\n\n\tvar signingKeyBuf = sshbuf.readBuffer();\n\tcert.issuerKey = rfc4253.read(signingKeyBuf);\n\n\t/*\n\t * OpenSSH certs don't give the identity of the issuer, just their\n\t * public key. So, we use an Identity that matches anything. The\n\t * isSignedBy() function will later tell you if the key matches.\n\t */\n\tcert.issuer = Identity.forHost('**');\n\n\tvar sigBuf = sshbuf.readBuffer();\n\tcert.signatures.openssh.signature =\n\t    Signature.parse(sigBuf, cert.issuerKey.type, 'ssh');\n\n\tif (partial !== undefined) {\n\t\tpartial.remainder = sshbuf.remainder();\n\t\tpartial.consumed = sshbuf._offset;\n\t}\n\n\treturn (new Certificate(cert));\n}\n\nfunction int64ToDate(buf) {\n\tvar i = buf.readUInt32BE(0) * 4294967296;\n\ti += buf.readUInt32BE(4);\n\tvar d = new Date();\n\td.setTime(i * 1000);\n\td.sourceInt64 = buf;\n\treturn (d);\n}\n\nfunction dateToInt64(date) {\n\tif (date.sourceInt64 !== undefined)\n\t\treturn (date.sourceInt64);\n\tvar i = Math.round(date.getTime() / 1000);\n\tvar upper = Math.floor(i / 4294967296);\n\tvar lower = Math.floor(i % 4294967296);\n\tvar buf = Buffer.alloc(8);\n\tbuf.writeUInt32BE(upper, 0);\n\tbuf.writeUInt32BE(lower, 4);\n\treturn (buf);\n}\n\nfunction sign(cert, key) {\n\tif (cert.signatures.openssh === undefined)\n\t\tcert.signatures.openssh = {};\n\ttry {\n\t\tvar blob = toBuffer(cert, true);\n\t} catch (e) {\n\t\tdelete (cert.signatures.openssh);\n\t\treturn (false);\n\t}\n\tvar sig = cert.signatures.openssh;\n\tvar hashAlgo = undefined;\n\tif (key.type === 'rsa' || key.type === 'dsa')\n\t\thashAlgo = 'sha1';\n\tvar signer = key.createSign(hashAlgo);\n\tsigner.write(blob);\n\tsig.signature = signer.sign();\n\treturn (true);\n}\n\nfunction signAsync(cert, signer, done) {\n\tif (cert.signatures.openssh === undefined)\n\t\tcert.signatures.openssh = {};\n\ttry {\n\t\tvar blob = toBuffer(cert, true);\n\t} catch (e) {\n\t\tdelete (cert.signatures.openssh);\n\t\tdone(e);\n\t\treturn;\n\t}\n\tvar sig = cert.signatures.openssh;\n\n\tsigner(blob, function (err, signature) {\n\t\tif (err) {\n\t\t\tdone(err);\n\t\t\treturn;\n\t\t}\n\t\ttry {\n\t\t\t/*\n\t\t\t * This will throw if the signature isn't of a\n\t\t\t * type/algo that can be used for SSH.\n\t\t\t */\n\t\t\tsignature.toBuffer('ssh');\n\t\t} catch (e) {\n\t\t\tdone(e);\n\t\t\treturn;\n\t\t}\n\t\tsig.signature = signature;\n\t\tdone();\n\t});\n}\n\nfunction write(cert, options) {\n\tif (options === undefined)\n\t\toptions = {};\n\n\tvar blob = toBuffer(cert);\n\tvar out = getCertType(cert.subjectKey) + ' ' + blob.toString('base64');\n\tif (options.comment)\n\t\tout = out + ' ' + options.comment;\n\treturn (out);\n}\n\n\nfunction toBuffer(cert, noSig) {\n\tassert.object(cert.signatures.openssh, 'signature for openssh format');\n\tvar sig = cert.signatures.openssh;\n\n\tif (sig.nonce === undefined)\n\t\tsig.nonce = crypto.randomBytes(16);\n\tvar buf = new SSHBuffer({});\n\tbuf.writeString(getCertType(cert.subjectKey));\n\tbuf.writeBuffer(sig.nonce);\n\n\tvar key = cert.subjectKey;\n\tvar algInfo = algs.info[key.type];\n\talgInfo.parts.forEach(function (part) {\n\t\tbuf.writePart(key.part[part]);\n\t});\n\n\tbuf.writeInt64(cert.serial);\n\n\tvar type = cert.subjects[0].type;\n\tassert.notStrictEqual(type, 'unknown');\n\tcert.subjects.forEach(function (id) {\n\t\tassert.strictEqual(id.type, type);\n\t});\n\ttype = TYPES[type];\n\tbuf.writeInt(type);\n\n\tif (sig.keyId === undefined) {\n\t\tsig.keyId = cert.subjects[0].type + '_' +\n\t\t    (cert.subjects[0].uid || cert.subjects[0].hostname);\n\t}\n\tbuf.writeString(sig.keyId);\n\n\tvar sub = new SSHBuffer({});\n\tcert.subjects.forEach(function (id) {\n\t\tif (type === TYPES.host)\n\t\t\tsub.writeString(id.hostname);\n\t\telse if (type === TYPES.user)\n\t\t\tsub.writeString(id.uid);\n\t});\n\tbuf.writeBuffer(sub.toBuffer());\n\n\tbuf.writeInt64(dateToInt64(cert.validFrom));\n\tbuf.writeInt64(dateToInt64(cert.validUntil));\n\n\tvar exts = sig.exts;\n\tif (exts === undefined)\n\t\texts = [];\n\n\tvar extbuf = new SSHBuffer({});\n\texts.forEach(function (ext) {\n\t\tif (ext.critical !== true)\n\t\t\treturn;\n\t\textbuf.writeString(ext.name);\n\t\textbuf.writeBuffer(ext.data);\n\t});\n\tbuf.writeBuffer(extbuf.toBuffer());\n\n\textbuf = new SSHBuffer({});\n\texts.forEach(function (ext) {\n\t\tif (ext.critical === true)\n\t\t\treturn;\n\t\textbuf.writeString(ext.name);\n\t\textbuf.writeBuffer(ext.data);\n\t});\n\tbuf.writeBuffer(extbuf.toBuffer());\n\n\t/* reserved */\n\tbuf.writeBuffer(Buffer.alloc(0));\n\n\tsub = rfc4253.write(cert.issuerKey);\n\tbuf.writeBuffer(sub);\n\n\tif (!noSig)\n\t\tbuf.writeBuffer(sig.signature.toBuffer('ssh'));\n\n\treturn (buf.toBuffer());\n}\n\nfunction getAlg(certType) {\n\tif (certType === 'ssh-rsa-cert-v01@openssh.com')\n\t\treturn ('rsa');\n\tif (certType === 'ssh-dss-cert-v01@openssh.com')\n\t\treturn ('dsa');\n\tif (certType.match(ECDSA_ALGO))\n\t\treturn ('ecdsa');\n\tif (certType === 'ssh-ed25519-cert-v01@openssh.com')\n\t\treturn ('ed25519');\n\tthrow (new Error('Unsupported cert type ' + certType));\n}\n\nfunction getCertType(key) {\n\tif (key.type === 'rsa')\n\t\treturn ('ssh-rsa-cert-v01@openssh.com');\n\tif (key.type === 'dsa')\n\t\treturn ('ssh-dss-cert-v01@openssh.com');\n\tif (key.type === 'ecdsa')\n\t\treturn ('ecdsa-sha2-' + key.curve + '-cert-v01@openssh.com');\n\tif (key.type === 'ed25519')\n\t\treturn ('ssh-ed25519-cert-v01@openssh.com');\n\tthrow (new Error('Unsupported key type ' + key.type));\n}\n","// Copyright 2015 Joyent, Inc.\n\nmodule.exports = {\n\tread: read,\n\treadSSHPrivate: readSSHPrivate,\n\twrite: write\n};\n\nvar assert = require('assert-plus');\nvar asn1 = require('asn1');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('../algs');\nvar utils = require('../utils');\nvar crypto = require('crypto');\n\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\nvar pem = require('./pem');\nvar rfc4253 = require('./rfc4253');\nvar SSHBuffer = require('../ssh-buffer');\nvar errors = require('../errors');\n\nvar bcrypt;\n\nfunction read(buf, options) {\n\treturn (pem.read(buf, options));\n}\n\nvar MAGIC = 'openssh-key-v1';\n\nfunction readSSHPrivate(type, buf, options) {\n\tbuf = new SSHBuffer({buffer: buf});\n\n\tvar magic = buf.readCString();\n\tassert.strictEqual(magic, MAGIC, 'bad magic string');\n\n\tvar cipher = buf.readString();\n\tvar kdf = buf.readString();\n\tvar kdfOpts = buf.readBuffer();\n\n\tvar nkeys = buf.readInt();\n\tif (nkeys !== 1) {\n\t\tthrow (new Error('OpenSSH-format key file contains ' +\n\t\t    'multiple keys: this is unsupported.'));\n\t}\n\n\tvar pubKey = buf.readBuffer();\n\n\tif (type === 'public') {\n\t\tassert.ok(buf.atEnd(), 'excess bytes left after key');\n\t\treturn (rfc4253.read(pubKey));\n\t}\n\n\tvar privKeyBlob = buf.readBuffer();\n\tassert.ok(buf.atEnd(), 'excess bytes left after key');\n\n\tvar kdfOptsBuf = new SSHBuffer({ buffer: kdfOpts });\n\tswitch (kdf) {\n\tcase 'none':\n\t\tif (cipher !== 'none') {\n\t\t\tthrow (new Error('OpenSSH-format key uses KDF \"none\" ' +\n\t\t\t     'but specifies a cipher other than \"none\"'));\n\t\t}\n\t\tbreak;\n\tcase 'bcrypt':\n\t\tvar salt = kdfOptsBuf.readBuffer();\n\t\tvar rounds = kdfOptsBuf.readInt();\n\t\tvar cinf = utils.opensshCipherInfo(cipher);\n\t\tif (bcrypt === undefined) {\n\t\t\tbcrypt = require('bcrypt-pbkdf');\n\t\t}\n\n\t\tif (typeof (options.passphrase) === 'string') {\n\t\t\toptions.passphrase = Buffer.from(options.passphrase,\n\t\t\t    'utf-8');\n\t\t}\n\t\tif (!Buffer.isBuffer(options.passphrase)) {\n\t\t\tthrow (new errors.KeyEncryptedError(\n\t\t\t    options.filename, 'OpenSSH'));\n\t\t}\n\n\t\tvar pass = new Uint8Array(options.passphrase);\n\t\tvar salti = new Uint8Array(salt);\n\t\t/* Use the pbkdf to derive both the key and the IV. */\n\t\tvar out = new Uint8Array(cinf.keySize + cinf.blockSize);\n\t\tvar res = bcrypt.pbkdf(pass, pass.length, salti, salti.length,\n\t\t    out, out.length, rounds);\n\t\tif (res !== 0) {\n\t\t\tthrow (new Error('bcrypt_pbkdf function returned ' +\n\t\t\t    'failure, parameters invalid'));\n\t\t}\n\t\tout = Buffer.from(out);\n\t\tvar ckey = out.slice(0, cinf.keySize);\n\t\tvar iv = out.slice(cinf.keySize, cinf.keySize + cinf.blockSize);\n\t\tvar cipherStream = crypto.createDecipheriv(cinf.opensslName,\n\t\t    ckey, iv);\n\t\tcipherStream.setAutoPadding(false);\n\t\tvar chunk, chunks = [];\n\t\tcipherStream.once('error', function (e) {\n\t\t\tif (e.toString().indexOf('bad decrypt') !== -1) {\n\t\t\t\tthrow (new Error('Incorrect passphrase ' +\n\t\t\t\t    'supplied, could not decrypt key'));\n\t\t\t}\n\t\t\tthrow (e);\n\t\t});\n\t\tcipherStream.write(privKeyBlob);\n\t\tcipherStream.end();\n\t\twhile ((chunk = cipherStream.read()) !== null)\n\t\t\tchunks.push(chunk);\n\t\tprivKeyBlob = Buffer.concat(chunks);\n\t\tbreak;\n\tdefault:\n\t\tthrow (new Error(\n\t\t    'OpenSSH-format key uses unknown KDF \"' + kdf + '\"'));\n\t}\n\n\tbuf = new SSHBuffer({buffer: privKeyBlob});\n\n\tvar checkInt1 = buf.readInt();\n\tvar checkInt2 = buf.readInt();\n\tif (checkInt1 !== checkInt2) {\n\t\tthrow (new Error('Incorrect passphrase supplied, could not ' +\n\t\t    'decrypt key'));\n\t}\n\n\tvar ret = {};\n\tvar key = rfc4253.readInternal(ret, 'private', buf.remainder());\n\n\tbuf.skip(ret.consumed);\n\n\tvar comment = buf.readString();\n\tkey.comment = comment;\n\n\treturn (key);\n}\n\nfunction write(key, options) {\n\tvar pubKey;\n\tif (PrivateKey.isPrivateKey(key))\n\t\tpubKey = key.toPublic();\n\telse\n\t\tpubKey = key;\n\n\tvar cipher = 'none';\n\tvar kdf = 'none';\n\tvar kdfopts = Buffer.alloc(0);\n\tvar cinf = { blockSize: 8 };\n\tvar passphrase;\n\tif (options !== undefined) {\n\t\tpassphrase = options.passphrase;\n\t\tif (typeof (passphrase) === 'string')\n\t\t\tpassphrase = Buffer.from(passphrase, 'utf-8');\n\t\tif (passphrase !== undefined) {\n\t\t\tassert.buffer(passphrase, 'options.passphrase');\n\t\t\tassert.optionalString(options.cipher, 'options.cipher');\n\t\t\tcipher = options.cipher;\n\t\t\tif (cipher === undefined)\n\t\t\t\tcipher = 'aes128-ctr';\n\t\t\tcinf = utils.opensshCipherInfo(cipher);\n\t\t\tkdf = 'bcrypt';\n\t\t}\n\t}\n\n\tvar privBuf;\n\tif (PrivateKey.isPrivateKey(key)) {\n\t\tprivBuf = new SSHBuffer({});\n\t\tvar checkInt = crypto.randomBytes(4).readUInt32BE(0);\n\t\tprivBuf.writeInt(checkInt);\n\t\tprivBuf.writeInt(checkInt);\n\t\tprivBuf.write(key.toBuffer('rfc4253'));\n\t\tprivBuf.writeString(key.comment || '');\n\n\t\tvar n = 1;\n\t\twhile (privBuf._offset % cinf.blockSize !== 0)\n\t\t\tprivBuf.writeChar(n++);\n\t\tprivBuf = privBuf.toBuffer();\n\t}\n\n\tswitch (kdf) {\n\tcase 'none':\n\t\tbreak;\n\tcase 'bcrypt':\n\t\tvar salt = crypto.randomBytes(16);\n\t\tvar rounds = 16;\n\t\tvar kdfssh = new SSHBuffer({});\n\t\tkdfssh.writeBuffer(salt);\n\t\tkdfssh.writeInt(rounds);\n\t\tkdfopts = kdfssh.toBuffer();\n\n\t\tif (bcrypt === undefined) {\n\t\t\tbcrypt = require('bcrypt-pbkdf');\n\t\t}\n\t\tvar pass = new Uint8Array(passphrase);\n\t\tvar salti = new Uint8Array(salt);\n\t\t/* Use the pbkdf to derive both the key and the IV. */\n\t\tvar out = new Uint8Array(cinf.keySize + cinf.blockSize);\n\t\tvar res = bcrypt.pbkdf(pass, pass.length, salti, salti.length,\n\t\t    out, out.length, rounds);\n\t\tif (res !== 0) {\n\t\t\tthrow (new Error('bcrypt_pbkdf function returned ' +\n\t\t\t    'failure, parameters invalid'));\n\t\t}\n\t\tout = Buffer.from(out);\n\t\tvar ckey = out.slice(0, cinf.keySize);\n\t\tvar iv = out.slice(cinf.keySize, cinf.keySize + cinf.blockSize);\n\n\t\tvar cipherStream = crypto.createCipheriv(cinf.opensslName,\n\t\t    ckey, iv);\n\t\tcipherStream.setAutoPadding(false);\n\t\tvar chunk, chunks = [];\n\t\tcipherStream.once('error', function (e) {\n\t\t\tthrow (e);\n\t\t});\n\t\tcipherStream.write(privBuf);\n\t\tcipherStream.end();\n\t\twhile ((chunk = cipherStream.read()) !== null)\n\t\t\tchunks.push(chunk);\n\t\tprivBuf = Buffer.concat(chunks);\n\t\tbreak;\n\tdefault:\n\t\tthrow (new Error('Unsupported kdf ' + kdf));\n\t}\n\n\tvar buf = new SSHBuffer({});\n\n\tbuf.writeCString(MAGIC);\n\tbuf.writeString(cipher);\t/* cipher */\n\tbuf.writeString(kdf);\t\t/* kdf */\n\tbuf.writeBuffer(kdfopts);\t/* kdfoptions */\n\n\tbuf.writeInt(1);\t\t/* nkeys */\n\tbuf.writeBuffer(pubKey.toBuffer('rfc4253'));\n\n\tif (privBuf)\n\t\tbuf.writeBuffer(privBuf);\n\n\tbuf = buf.toBuffer();\n\n\tvar header;\n\tif (PrivateKey.isPrivateKey(key))\n\t\theader = 'OPENSSH PRIVATE KEY';\n\telse\n\t\theader = 'OPENSSH PUBLIC KEY';\n\n\tvar tmp = buf.toString('base64');\n\tvar len = tmp.length + (tmp.length / 70) +\n\t    18 + 16 + header.length*2 + 10;\n\tbuf = Buffer.alloc(len);\n\tvar o = 0;\n\to += buf.write('-----BEGIN ' + header + '-----\\n', o);\n\tfor (var i = 0; i < tmp.length; ) {\n\t\tvar limit = i + 70;\n\t\tif (limit > tmp.length)\n\t\t\tlimit = tmp.length;\n\t\to += buf.write(tmp.slice(i, limit), o);\n\t\tbuf[o++] = 10;\n\t\ti = limit;\n\t}\n\to += buf.write('-----END ' + header + '-----\\n', o);\n\n\treturn (buf.slice(0, o));\n}\n","// Copyright 2018 Joyent, Inc.\n\nmodule.exports = {\n\tread: read,\n\twrite: write\n};\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar utils = require('../utils');\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\n\nvar pem = require('./pem');\nvar ssh = require('./ssh');\nvar rfc4253 = require('./rfc4253');\nvar dnssec = require('./dnssec');\nvar putty = require('./putty');\n\nvar DNSSEC_PRIVKEY_HEADER_PREFIX = 'Private-key-format: v1';\n\nfunction read(buf, options) {\n\tif (typeof (buf) === 'string') {\n\t\tif (buf.trim().match(/^[-]+[ ]*BEGIN/))\n\t\t\treturn (pem.read(buf, options));\n\t\tif (buf.match(/^\\s*ssh-[a-z]/))\n\t\t\treturn (ssh.read(buf, options));\n\t\tif (buf.match(/^\\s*ecdsa-/))\n\t\t\treturn (ssh.read(buf, options));\n\t\tif (buf.match(/^putty-user-key-file-2:/i))\n\t\t\treturn (putty.read(buf, options));\n\t\tif (findDNSSECHeader(buf))\n\t\t\treturn (dnssec.read(buf, options));\n\t\tbuf = Buffer.from(buf, 'binary');\n\t} else {\n\t\tassert.buffer(buf);\n\t\tif (findPEMHeader(buf))\n\t\t\treturn (pem.read(buf, options));\n\t\tif (findSSHHeader(buf))\n\t\t\treturn (ssh.read(buf, options));\n\t\tif (findPuTTYHeader(buf))\n\t\t\treturn (putty.read(buf, options));\n\t\tif (findDNSSECHeader(buf))\n\t\t\treturn (dnssec.read(buf, options));\n\t}\n\tif (buf.readUInt32BE(0) < buf.length)\n\t\treturn (rfc4253.read(buf, options));\n\tthrow (new Error('Failed to auto-detect format of key'));\n}\n\nfunction findPuTTYHeader(buf) {\n\tvar offset = 0;\n\twhile (offset < buf.length &&\n\t    (buf[offset] === 32 || buf[offset] === 10 || buf[offset] === 9))\n\t\t++offset;\n\tif (offset + 22 <= buf.length &&\n\t    buf.slice(offset, offset + 22).toString('ascii').toLowerCase() ===\n\t    'putty-user-key-file-2:')\n\t\treturn (true);\n\treturn (false);\n}\n\nfunction findSSHHeader(buf) {\n\tvar offset = 0;\n\twhile (offset < buf.length &&\n\t    (buf[offset] === 32 || buf[offset] === 10 || buf[offset] === 9))\n\t\t++offset;\n\tif (offset + 4 <= buf.length &&\n\t    buf.slice(offset, offset + 4).toString('ascii') === 'ssh-')\n\t\treturn (true);\n\tif (offset + 6 <= buf.length &&\n\t    buf.slice(offset, offset + 6).toString('ascii') === 'ecdsa-')\n\t\treturn (true);\n\treturn (false);\n}\n\nfunction findPEMHeader(buf) {\n\tvar offset = 0;\n\twhile (offset < buf.length &&\n\t    (buf[offset] === 32 || buf[offset] === 10))\n\t\t++offset;\n\tif (buf[offset] !== 45)\n\t\treturn (false);\n\twhile (offset < buf.length &&\n\t    (buf[offset] === 45))\n\t\t++offset;\n\twhile (offset < buf.length &&\n\t    (buf[offset] === 32))\n\t\t++offset;\n\tif (offset + 5 > buf.length ||\n\t    buf.slice(offset, offset + 5).toString('ascii') !== 'BEGIN')\n\t\treturn (false);\n\treturn (true);\n}\n\nfunction findDNSSECHeader(buf) {\n\t// private case first\n\tif (buf.length <= DNSSEC_PRIVKEY_HEADER_PREFIX.length)\n\t\treturn (false);\n\tvar headerCheck = buf.slice(0, DNSSEC_PRIVKEY_HEADER_PREFIX.length);\n\tif (headerCheck.toString('ascii') === DNSSEC_PRIVKEY_HEADER_PREFIX)\n\t\treturn (true);\n\n\t// public-key RFC3110 ?\n\t// 'domain.com. IN KEY ...' or 'domain.com. IN DNSKEY ...'\n\t// skip any comment-lines\n\tif (typeof (buf) !== 'string') {\n\t\tbuf = buf.toString('ascii');\n\t}\n\tvar lines = buf.split('\\n');\n\tvar line = 0;\n\t/* JSSTYLED */\n\twhile (lines[line].match(/^\\;/))\n\t\tline++;\n\tif (lines[line].toString('ascii').match(/\\. IN KEY /))\n\t\treturn (true);\n\tif (lines[line].toString('ascii').match(/\\. IN DNSKEY /))\n\t\treturn (true);\n\treturn (false);\n}\n\nfunction write(key, options) {\n\tthrow (new Error('\"auto\" format cannot be used for writing'));\n}\n","// Copyright 2015 Joyent, Inc.\n\nmodule.exports = {\n\tbufferSplit: bufferSplit,\n\taddRSAMissing: addRSAMissing,\n\tcalculateDSAPublic: calculateDSAPublic,\n\tcalculateED25519Public: calculateED25519Public,\n\tcalculateX25519Public: calculateX25519Public,\n\tmpNormalize: mpNormalize,\n\tmpDenormalize: mpDenormalize,\n\tecNormalize: ecNormalize,\n\tcountZeros: countZeros,\n\tassertCompatible: assertCompatible,\n\tisCompatible: isCompatible,\n\topensslKeyDeriv: opensslKeyDeriv,\n\topensshCipherInfo: opensshCipherInfo,\n\tpublicFromPrivateECDSA: publicFromPrivateECDSA,\n\tzeroPadToLength: zeroPadToLength,\n\twriteBitString: writeBitString,\n\treadBitString: readBitString,\n\tpbkdf2: pbkdf2\n};\n\nvar assert = require('assert-plus');\nvar Buffer = require('safer-buffer').Buffer;\nvar PrivateKey = require('./private-key');\nvar Key = require('./key');\nvar crypto = require('crypto');\nvar algs = require('./algs');\nvar asn1 = require('asn1');\n\nvar ec = require('ecc-jsbn/lib/ec');\nvar jsbn = require('jsbn').BigInteger;\nvar nacl = require('tweetnacl');\n\nvar MAX_CLASS_DEPTH = 3;\n\nfunction isCompatible(obj, klass, needVer) {\n\tif (obj === null || typeof (obj) !== 'object')\n\t\treturn (false);\n\tif (needVer === undefined)\n\t\tneedVer = klass.prototype._sshpkApiVersion;\n\tif (obj instanceof klass &&\n\t    klass.prototype._sshpkApiVersion[0] == needVer[0])\n\t\treturn (true);\n\tvar proto = Object.getPrototypeOf(obj);\n\tvar depth = 0;\n\twhile (proto.constructor.name !== klass.name) {\n\t\tproto = Object.getPrototypeOf(proto);\n\t\tif (!proto || ++depth > MAX_CLASS_DEPTH)\n\t\t\treturn (false);\n\t}\n\tif (proto.constructor.name !== klass.name)\n\t\treturn (false);\n\tvar ver = proto._sshpkApiVersion;\n\tif (ver === undefined)\n\t\tver = klass._oldVersionDetect(obj);\n\tif (ver[0] != needVer[0] || ver[1] < needVer[1])\n\t\treturn (false);\n\treturn (true);\n}\n\nfunction assertCompatible(obj, klass, needVer, name) {\n\tif (name === undefined)\n\t\tname = 'object';\n\tassert.ok(obj, name + ' must not be null');\n\tassert.object(obj, name + ' must be an object');\n\tif (needVer === undefined)\n\t\tneedVer = klass.prototype._sshpkApiVersion;\n\tif (obj instanceof klass &&\n\t    klass.prototype._sshpkApiVersion[0] == needVer[0])\n\t\treturn;\n\tvar proto = Object.getPrototypeOf(obj);\n\tvar depth = 0;\n\twhile (proto.constructor.name !== klass.name) {\n\t\tproto = Object.getPrototypeOf(proto);\n\t\tassert.ok(proto && ++depth <= MAX_CLASS_DEPTH,\n\t\t    name + ' must be a ' + klass.name + ' instance');\n\t}\n\tassert.strictEqual(proto.constructor.name, klass.name,\n\t    name + ' must be a ' + klass.name + ' instance');\n\tvar ver = proto._sshpkApiVersion;\n\tif (ver === undefined)\n\t\tver = klass._oldVersionDetect(obj);\n\tassert.ok(ver[0] == needVer[0] && ver[1] >= needVer[1],\n\t    name + ' must be compatible with ' + klass.name + ' klass ' +\n\t    'version ' + needVer[0] + '.' + needVer[1]);\n}\n\nvar CIPHER_LEN = {\n\t'des-ede3-cbc': { key: 24, iv: 8 },\n\t'aes-128-cbc': { key: 16, iv: 16 },\n\t'aes-256-cbc': { key: 32, iv: 16 }\n};\nvar PKCS5_SALT_LEN = 8;\n\nfunction opensslKeyDeriv(cipher, salt, passphrase, count) {\n\tassert.buffer(salt, 'salt');\n\tassert.buffer(passphrase, 'passphrase');\n\tassert.number(count, 'iteration count');\n\n\tvar clen = CIPHER_LEN[cipher];\n\tassert.object(clen, 'supported cipher');\n\n\tsalt = salt.slice(0, PKCS5_SALT_LEN);\n\n\tvar D, D_prev, bufs;\n\tvar material = Buffer.alloc(0);\n\twhile (material.length < clen.key + clen.iv) {\n\t\tbufs = [];\n\t\tif (D_prev)\n\t\t\tbufs.push(D_prev);\n\t\tbufs.push(passphrase);\n\t\tbufs.push(salt);\n\t\tD = Buffer.concat(bufs);\n\t\tfor (var j = 0; j < count; ++j)\n\t\t\tD = crypto.createHash('md5').update(D).digest();\n\t\tmaterial = Buffer.concat([material, D]);\n\t\tD_prev = D;\n\t}\n\n\treturn ({\n\t    key: material.slice(0, clen.key),\n\t    iv: material.slice(clen.key, clen.key + clen.iv)\n\t});\n}\n\n/* See: RFC2898 */\nfunction pbkdf2(hashAlg, salt, iterations, size, passphrase) {\n\tvar hkey = Buffer.alloc(salt.length + 4);\n\tsalt.copy(hkey);\n\n\tvar gen = 0, ts = [];\n\tvar i = 1;\n\twhile (gen < size) {\n\t\tvar t = T(i++);\n\t\tgen += t.length;\n\t\tts.push(t);\n\t}\n\treturn (Buffer.concat(ts).slice(0, size));\n\n\tfunction T(I) {\n\t\thkey.writeUInt32BE(I, hkey.length - 4);\n\n\t\tvar hmac = crypto.createHmac(hashAlg, passphrase);\n\t\thmac.update(hkey);\n\n\t\tvar Ti = hmac.digest();\n\t\tvar Uc = Ti;\n\t\tvar c = 1;\n\t\twhile (c++ < iterations) {\n\t\t\thmac = crypto.createHmac(hashAlg, passphrase);\n\t\t\thmac.update(Uc);\n\t\t\tUc = hmac.digest();\n\t\t\tfor (var x = 0; x < Ti.length; ++x)\n\t\t\t\tTi[x] ^= Uc[x];\n\t\t}\n\t\treturn (Ti);\n\t}\n}\n\n/* Count leading zero bits on a buffer */\nfunction countZeros(buf) {\n\tvar o = 0, obit = 8;\n\twhile (o < buf.length) {\n\t\tvar mask = (1 << obit);\n\t\tif ((buf[o] & mask) === mask)\n\t\t\tbreak;\n\t\tobit--;\n\t\tif (obit < 0) {\n\t\t\to++;\n\t\t\tobit = 8;\n\t\t}\n\t}\n\treturn (o*8 + (8 - obit) - 1);\n}\n\nfunction bufferSplit(buf, chr) {\n\tassert.buffer(buf);\n\tassert.string(chr);\n\n\tvar parts = [];\n\tvar lastPart = 0;\n\tvar matches = 0;\n\tfor (var i = 0; i < buf.length; ++i) {\n\t\tif (buf[i] === chr.charCodeAt(matches))\n\t\t\t++matches;\n\t\telse if (buf[i] === chr.charCodeAt(0))\n\t\t\tmatches = 1;\n\t\telse\n\t\t\tmatches = 0;\n\n\t\tif (matches >= chr.length) {\n\t\t\tvar newPart = i + 1;\n\t\t\tparts.push(buf.slice(lastPart, newPart - matches));\n\t\t\tlastPart = newPart;\n\t\t\tmatches = 0;\n\t\t}\n\t}\n\tif (lastPart <= buf.length)\n\t\tparts.push(buf.slice(lastPart, buf.length));\n\n\treturn (parts);\n}\n\nfunction ecNormalize(buf, addZero) {\n\tassert.buffer(buf);\n\tif (buf[0] === 0x00 && buf[1] === 0x04) {\n\t\tif (addZero)\n\t\t\treturn (buf);\n\t\treturn (buf.slice(1));\n\t} else if (buf[0] === 0x04) {\n\t\tif (!addZero)\n\t\t\treturn (buf);\n\t} else {\n\t\twhile (buf[0] === 0x00)\n\t\t\tbuf = buf.slice(1);\n\t\tif (buf[0] === 0x02 || buf[0] === 0x03)\n\t\t\tthrow (new Error('Compressed elliptic curve points ' +\n\t\t\t    'are not supported'));\n\t\tif (buf[0] !== 0x04)\n\t\t\tthrow (new Error('Not a valid elliptic curve point'));\n\t\tif (!addZero)\n\t\t\treturn (buf);\n\t}\n\tvar b = Buffer.alloc(buf.length + 1);\n\tb[0] = 0x0;\n\tbuf.copy(b, 1);\n\treturn (b);\n}\n\nfunction readBitString(der, tag) {\n\tif (tag === undefined)\n\t\ttag = asn1.Ber.BitString;\n\tvar buf = der.readString(tag, true);\n\tassert.strictEqual(buf[0], 0x00, 'bit strings with unused bits are ' +\n\t    'not supported (0x' + buf[0].toString(16) + ')');\n\treturn (buf.slice(1));\n}\n\nfunction writeBitString(der, buf, tag) {\n\tif (tag === undefined)\n\t\ttag = asn1.Ber.BitString;\n\tvar b = Buffer.alloc(buf.length + 1);\n\tb[0] = 0x00;\n\tbuf.copy(b, 1);\n\tder.writeBuffer(b, tag);\n}\n\nfunction mpNormalize(buf) {\n\tassert.buffer(buf);\n\twhile (buf.length > 1 && buf[0] === 0x00 && (buf[1] & 0x80) === 0x00)\n\t\tbuf = buf.slice(1);\n\tif ((buf[0] & 0x80) === 0x80) {\n\t\tvar b = Buffer.alloc(buf.length + 1);\n\t\tb[0] = 0x00;\n\t\tbuf.copy(b, 1);\n\t\tbuf = b;\n\t}\n\treturn (buf);\n}\n\nfunction mpDenormalize(buf) {\n\tassert.buffer(buf);\n\twhile (buf.length > 1 && buf[0] === 0x00)\n\t\tbuf = buf.slice(1);\n\treturn (buf);\n}\n\nfunction zeroPadToLength(buf, len) {\n\tassert.buffer(buf);\n\tassert.number(len);\n\twhile (buf.length > len) {\n\t\tassert.equal(buf[0], 0x00);\n\t\tbuf = buf.slice(1);\n\t}\n\twhile (buf.length < len) {\n\t\tvar b = Buffer.alloc(buf.length + 1);\n\t\tb[0] = 0x00;\n\t\tbuf.copy(b, 1);\n\t\tbuf = b;\n\t}\n\treturn (buf);\n}\n\nfunction bigintToMpBuf(bigint) {\n\tvar buf = Buffer.from(bigint.toByteArray());\n\tbuf = mpNormalize(buf);\n\treturn (buf);\n}\n\nfunction calculateDSAPublic(g, p, x) {\n\tassert.buffer(g);\n\tassert.buffer(p);\n\tassert.buffer(x);\n\tg = new jsbn(g);\n\tp = new jsbn(p);\n\tx = new jsbn(x);\n\tvar y = g.modPow(x, p);\n\tvar ybuf = bigintToMpBuf(y);\n\treturn (ybuf);\n}\n\nfunction calculateED25519Public(k) {\n\tassert.buffer(k);\n\n\tvar kp = nacl.sign.keyPair.fromSeed(new Uint8Array(k));\n\treturn (Buffer.from(kp.publicKey));\n}\n\nfunction calculateX25519Public(k) {\n\tassert.buffer(k);\n\n\tvar kp = nacl.box.keyPair.fromSeed(new Uint8Array(k));\n\treturn (Buffer.from(kp.publicKey));\n}\n\nfunction addRSAMissing(key) {\n\tassert.object(key);\n\tassertCompatible(key, PrivateKey, [1, 1]);\n\n\tvar d = new jsbn(key.part.d.data);\n\tvar buf;\n\n\tif (!key.part.dmodp) {\n\t\tvar p = new jsbn(key.part.p.data);\n\t\tvar dmodp = d.mod(p.subtract(1));\n\n\t\tbuf = bigintToMpBuf(dmodp);\n\t\tkey.part.dmodp = {name: 'dmodp', data: buf};\n\t\tkey.parts.push(key.part.dmodp);\n\t}\n\tif (!key.part.dmodq) {\n\t\tvar q = new jsbn(key.part.q.data);\n\t\tvar dmodq = d.mod(q.subtract(1));\n\n\t\tbuf = bigintToMpBuf(dmodq);\n\t\tkey.part.dmodq = {name: 'dmodq', data: buf};\n\t\tkey.parts.push(key.part.dmodq);\n\t}\n}\n\nfunction publicFromPrivateECDSA(curveName, priv) {\n\tassert.string(curveName, 'curveName');\n\tassert.buffer(priv);\n\tvar params = algs.curves[curveName];\n\tvar p = new jsbn(params.p);\n\tvar a = new jsbn(params.a);\n\tvar b = new jsbn(params.b);\n\tvar curve = new ec.ECCurveFp(p, a, b);\n\tvar G = curve.decodePointHex(params.G.toString('hex'));\n\n\tvar d = new jsbn(mpNormalize(priv));\n\tvar pub = G.multiply(d);\n\tpub = Buffer.from(curve.encodePointHex(pub), 'hex');\n\n\tvar parts = [];\n\tparts.push({name: 'curve', data: Buffer.from(curveName)});\n\tparts.push({name: 'Q', data: pub});\n\n\tvar key = new Key({type: 'ecdsa', curve: curve, parts: parts});\n\treturn (key);\n}\n\nfunction opensshCipherInfo(cipher) {\n\tvar inf = {};\n\tswitch (cipher) {\n\tcase '3des-cbc':\n\t\tinf.keySize = 24;\n\t\tinf.blockSize = 8;\n\t\tinf.opensslName = 'des-ede3-cbc';\n\t\tbreak;\n\tcase 'blowfish-cbc':\n\t\tinf.keySize = 16;\n\t\tinf.blockSize = 8;\n\t\tinf.opensslName = 'bf-cbc';\n\t\tbreak;\n\tcase 'aes128-cbc':\n\tcase 'aes128-ctr':\n\tcase 'aes128-gcm@openssh.com':\n\t\tinf.keySize = 16;\n\t\tinf.blockSize = 16;\n\t\tinf.opensslName = 'aes-128-' + cipher.slice(7, 10);\n\t\tbreak;\n\tcase 'aes192-cbc':\n\tcase 'aes192-ctr':\n\tcase 'aes192-gcm@openssh.com':\n\t\tinf.keySize = 24;\n\t\tinf.blockSize = 16;\n\t\tinf.opensslName = 'aes-192-' + cipher.slice(7, 10);\n\t\tbreak;\n\tcase 'aes256-cbc':\n\tcase 'aes256-ctr':\n\tcase 'aes256-gcm@openssh.com':\n\t\tinf.keySize = 32;\n\t\tinf.blockSize = 16;\n\t\tinf.opensslName = 'aes-256-' + cipher.slice(7, 10);\n\t\tbreak;\n\tdefault:\n\t\tthrow (new Error(\n\t\t    'Unsupported openssl cipher \"' + cipher + '\"'));\n\t}\n\treturn (inf);\n}\n","// Copyright 2015 Joyent, Inc.\n\nvar Key = require('./key');\nvar Fingerprint = require('./fingerprint');\nvar Signature = require('./signature');\nvar PrivateKey = require('./private-key');\nvar Certificate = require('./certificate');\nvar Identity = require('./identity');\nvar errs = require('./errors');\n\nmodule.exports = {\n\t/* top-level classes */\n\tKey: Key,\n\tparseKey: Key.parse,\n\tFingerprint: Fingerprint,\n\tparseFingerprint: Fingerprint.parse,\n\tSignature: Signature,\n\tparseSignature: Signature.parse,\n\tPrivateKey: PrivateKey,\n\tparsePrivateKey: PrivateKey.parse,\n\tgeneratePrivateKey: PrivateKey.generate,\n\tCertificate: Certificate,\n\tparseCertificate: Certificate.parse,\n\tcreateSelfSignedCertificate: Certificate.createSelfSigned,\n\tcreateCertificate: Certificate.create,\n\tIdentity: Identity,\n\tidentityFromDN: Identity.parseDN,\n\tidentityForHost: Identity.forHost,\n\tidentityForUser: Identity.forUser,\n\tidentityForEmail: Identity.forEmail,\n\tidentityFromArray: Identity.fromArray,\n\n\t/* errors */\n\tFingerprintFormatError: errs.FingerprintFormatError,\n\tInvalidAlgorithmError: errs.InvalidAlgorithmError,\n\tKeyParseError: errs.KeyParseError,\n\tSignatureParseError: errs.SignatureParseError,\n\tKeyEncryptedError: errs.KeyEncryptedError,\n\tCertificateParseError: errs.CertificateParseError\n};\n","// Copyright 2015 Joyent, Inc.\n\nmodule.exports = {\n\tread: read,\n\treadPkcs1: readPkcs1,\n\twrite: write,\n\twritePkcs1: writePkcs1\n};\n\nvar assert = require('assert-plus');\nvar asn1 = require('asn1');\nvar Buffer = require('safer-buffer').Buffer;\nvar algs = require('../algs');\nvar utils = require('../utils');\n\nvar Key = require('../key');\nvar PrivateKey = require('../private-key');\nvar pem = require('./pem');\n\nvar pkcs8 = require('./pkcs8');\nvar readECDSACurve = pkcs8.readECDSACurve;\n\nfunction read(buf, options) {\n\treturn (pem.read(buf, options, 'pkcs1'));\n}\n\nfunction write(key, options) {\n\treturn (pem.write(key, options, 'pkcs1'));\n}\n\n/* Helper to read in a single mpint */\nfunction readMPInt(der, nm) {\n\tassert.strictEqual(der.peek(), asn1.Ber.Integer,\n\t    nm + ' is not an Integer');\n\treturn (utils.mpNormalize(der.readString(asn1.Ber.Integer, true)));\n}\n\nfunction readPkcs1(alg, type, der) {\n\tswitch (alg) {\n\tcase 'RSA':\n\t\tif (type === 'public')\n\t\t\treturn (readPkcs1RSAPublic(der));\n\t\telse if (type === 'private')\n\t\t\treturn (readPkcs1RSAPrivate(der));\n\t\tthrow (new Error('Unknown key type: ' + type));\n\tcase 'DSA':\n\t\tif (type === 'public')\n\t\t\treturn (readPkcs1DSAPublic(der));\n\t\telse if (type === 'private')\n\t\t\treturn (readPkcs1DSAPrivate(der));\n\t\tthrow (new Error('Unknown key type: ' + type));\n\tcase 'EC':\n\tcase 'ECDSA':\n\t\tif (type === 'private')\n\t\t\treturn (readPkcs1ECDSAPrivate(der));\n\t\telse if (type === 'public')\n\t\t\treturn (readPkcs1ECDSAPublic(der));\n\t\tthrow (new Error('Unknown key type: ' + type));\n\tcase 'EDDSA':\n\tcase 'EdDSA':\n\t\tif (type === 'private')\n\t\t\treturn (readPkcs1EdDSAPrivate(der));\n\t\tthrow (new Error(type + ' keys not supported with EdDSA'));\n\tdefault:\n\t\tthrow (new Error('Unknown key algo: ' + alg));\n\t}\n}\n\nfunction readPkcs1RSAPublic(der) {\n\t// modulus and exponent\n\tvar n = readMPInt(der, 'modulus');\n\tvar e = readMPInt(der, 'exponent');\n\n\t// now, make the key\n\tvar key = {\n\t\ttype: 'rsa',\n\t\tparts: [\n\t\t\t{ name: 'e', data: e },\n\t\t\t{ name: 'n', data: n }\n\t\t]\n\t};\n\n\treturn (new Key(key));\n}\n\nfunction readPkcs1RSAPrivate(der) {\n\tvar version = readMPInt(der, 'version');\n\tassert.strictEqual(version[0], 0);\n\n\t// modulus then public exponent\n\tvar n = readMPInt(der, 'modulus');\n\tvar e = readMPInt(der, 'public exponent');\n\tvar d = readMPInt(der, 'private exponent');\n\tvar p = readMPInt(der, 'prime1');\n\tvar q = readMPInt(der, 'prime2');\n\tvar dmodp = readMPInt(der, 'exponent1');\n\tvar dmodq = readMPInt(der, 'exponent2');\n\tvar iqmp = readMPInt(der, 'iqmp');\n\n\t// now, make the key\n\tvar key = {\n\t\ttype: 'rsa',\n\t\tparts: [\n\t\t\t{ name: 'n', data: n },\n\t\t\t{ name: 'e', data: e },\n\t\t\t{ name: 'd', data: d },\n\t\t\t{ name: 'iqmp', data: iqmp },\n\t\t\t{ name: 'p', data: p },\n\t\t\t{ name: 'q', data: q },\n\t\t\t{ name: 'dmodp', data: dmodp },\n\t\t\t{ name: 'dmodq', data: dmodq }\n\t\t]\n\t};\n\n\treturn (new PrivateKey(key));\n}\n\nfunction readPkcs1DSAPrivate(der) {\n\tvar version = readMPInt(der, 'version');\n\tassert.strictEqual(version.readUInt8(0), 0);\n\n\tvar p = readMPInt(der, 'p');\n\tvar q = readMPInt(der, 'q');\n\tvar g = readMPInt(der, 'g');\n\tvar y = readMPInt(der, 'y');\n\tvar x = readMPInt(der, 'x');\n\n\t// now, make the key\n\tvar key = {\n\t\ttype: 'dsa',\n\t\tparts: [\n\t\t\t{ name: 'p', data: p },\n\t\t\t{ name: 'q', data: q },\n\t\t\t{ name: 'g', data: g },\n\t\t\t{ name: 'y', data: y },\n\t\t\t{ name: 'x', data: x }\n\t\t]\n\t};\n\n\treturn (new PrivateKey(key));\n}\n\nfunction readPkcs1EdDSAPrivate(der) {\n\tvar version = readMPInt(der, 'version');\n\tassert.strictEqual(version.readUInt8(0), 1);\n\n\t// private key\n\tvar k = der.readString(asn1.Ber.OctetString, true);\n\n\tder.readSequence(0xa0);\n\tvar oid = der.readOID();\n\tassert.strictEqual(oid, '1.3.101.112', 'the ed25519 curve identifier');\n\n\tder.readSequence(0xa1);\n\tvar A = utils.readBitString(der);\n\n\tvar key = {\n\t\ttype: 'ed25519',\n\t\tparts: [\n\t\t\t{ name: 'A', data: utils.zeroPadToLength(A, 32) },\n\t\t\t{ name: 'k', data: k }\n\t\t]\n\t};\n\n\treturn (new PrivateKey(key));\n}\n\nfunction readPkcs1DSAPublic(der) {\n\tvar y = readMPInt(der, 'y');\n\tvar p = readMPInt(der, 'p');\n\tvar q = readMPInt(der, 'q');\n\tvar g = readMPInt(der, 'g');\n\n\tvar key = {\n\t\ttype: 'dsa',\n\t\tparts: [\n\t\t\t{ name: 'y', data: y },\n\t\t\t{ name: 'p', data: p },\n\t\t\t{ name: 'q', data: q },\n\t\t\t{ name: 'g', data: g }\n\t\t]\n\t};\n\n\treturn (new Key(key));\n}\n\nfunction readPkcs1ECDSAPublic(der) {\n\tder.readSequence();\n\n\tvar oid = der.readOID();\n\tassert.strictEqual(oid, '1.2.840.10045.2.1', 'must be ecPublicKey');\n\n\tvar curveOid = der.readOID();\n\n\tvar curve;\n\tvar curves = Object.keys(algs.curves);\n\tfor (var j = 0; j < curves.length; ++j) {\n\t\tvar c = curves[j];\n\t\tvar cd = algs.curves[c];\n\t\tif (cd.pkcs8oid === curveOid) {\n\t\t\tcurve = c;\n\t\t\tbreak;\n\t\t}\n\t}\n\tassert.string(curve, 'a known ECDSA named curve');\n\n\tvar Q = der.readString(asn1.Ber.BitString, true);\n\tQ = utils.ecNormalize(Q);\n\n\tvar key = {\n\t\ttype: 'ecdsa',\n\t\tparts: [\n\t\t\t{ name: 'curve', data: Buffer.from(curve) },\n\t\t\t{ name: 'Q', data: Q }\n\t\t]\n\t};\n\n\treturn (new Key(key));\n}\n\nfunction readPkcs1ECDSAPrivate(der) {\n\tvar version = readMPInt(der, 'version');\n\tassert.strictEqual(version.readUInt8(0), 1);\n\n\t// private key\n\tvar d = der.readString(asn1.Ber.OctetString, true);\n\n\tder.readSequence(0xa0);\n\tvar curve = readECDSACurve(der);\n\tassert.string(curve, 'a known elliptic curve');\n\n\tder.readSequence(0xa1);\n\tvar Q = der.readString(asn1.Ber.BitString, true);\n\tQ = utils.ecNormalize(Q);\n\n\tvar key = {\n\t\ttype: 'ecdsa',\n\t\tparts: [\n\t\t\t{ name: 'curve', data: Buffer.from(curve) },\n\t\t\t{ name: 'Q', data: Q },\n\t\t\t{ name: 'd', data: d }\n\t\t]\n\t};\n\n\treturn (new PrivateKey(key));\n}\n\nfunction writePkcs1(der, key) {\n\tder.startSequence();\n\n\tswitch (key.type) {\n\tcase 'rsa':\n\t\tif (PrivateKey.isPrivateKey(key))\n\t\t\twritePkcs1RSAPrivate(der, key);\n\t\telse\n\t\t\twritePkcs1RSAPublic(der, key);\n\t\tbreak;\n\tcase 'dsa':\n\t\tif (PrivateKey.isPrivateKey(key))\n\t\t\twritePkcs1DSAPrivate(der, key);\n\t\telse\n\t\t\twritePkcs1DSAPublic(der, key);\n\t\tbreak;\n\tcase 'ecdsa':\n\t\tif (PrivateKey.isPrivateKey(key))\n\t\t\twritePkcs1ECDSAPrivate(der, key);\n\t\telse\n\t\t\twritePkcs1ECDSAPublic(der, key);\n\t\tbreak;\n\tcase 'ed25519':\n\t\tif (PrivateKey.isPrivateKey(key))\n\t\t\twritePkcs1EdDSAPrivate(der, key);\n\t\telse\n\t\t\twritePkcs1EdDSAPublic(der, key);\n\t\tbreak;\n\tdefault:\n\t\tthrow (new Error('Unknown key algo: ' + key.type));\n\t}\n\n\tder.endSequence();\n}\n\nfunction writePkcs1RSAPublic(der, key) {\n\tder.writeBuffer(key.part.n.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.e.data, asn1.Ber.Integer);\n}\n\nfunction writePkcs1RSAPrivate(der, key) {\n\tvar ver = Buffer.from([0]);\n\tder.writeBuffer(ver, asn1.Ber.Integer);\n\n\tder.writeBuffer(key.part.n.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.e.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.d.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.p.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.q.data, asn1.Ber.Integer);\n\tif (!key.part.dmodp || !key.part.dmodq)\n\t\tutils.addRSAMissing(key);\n\tder.writeBuffer(key.part.dmodp.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.dmodq.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.iqmp.data, asn1.Ber.Integer);\n}\n\nfunction writePkcs1DSAPrivate(der, key) {\n\tvar ver = Buffer.from([0]);\n\tder.writeBuffer(ver, asn1.Ber.Integer);\n\n\tder.writeBuffer(key.part.p.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.q.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.g.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.y.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.x.data, asn1.Ber.Integer);\n}\n\nfunction writePkcs1DSAPublic(der, key) {\n\tder.writeBuffer(key.part.y.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.p.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.q.data, asn1.Ber.Integer);\n\tder.writeBuffer(key.part.g.data, asn1.Ber.Integer);\n}\n\nfunction writePkcs1ECDSAPublic(der, key) {\n\tder.startSequence();\n\n\tder.writeOID('1.2.840.10045.2.1'); /* ecPublicKey */\n\tvar curve = key.part.curve.data.toString();\n\tvar curveOid = algs.curves[curve].pkcs8oid;\n\tassert.string(curveOid, 'a known ECDSA named curve');\n\tder.writeOID(curveOid);\n\n\tder.endSequence();\n\n\tvar Q = utils.ecNormalize(key.part.Q.data, true);\n\tder.writeBuffer(Q, asn1.Ber.BitString);\n}\n\nfunction writePkcs1ECDSAPrivate(der, key) {\n\tvar ver = Buffer.from([1]);\n\tder.writeBuffer(ver, asn1.Ber.Integer);\n\n\tder.writeBuffer(key.part.d.data, asn1.Ber.OctetString);\n\n\tder.startSequence(0xa0);\n\tvar curve = key.part.curve.data.toString();\n\tvar curveOid = algs.curves[curve].pkcs8oid;\n\tassert.string(curveOid, 'a known ECDSA named curve');\n\tder.writeOID(curveOid);\n\tder.endSequence();\n\n\tder.startSequence(0xa1);\n\tvar Q = utils.ecNormalize(key.part.Q.data, true);\n\tder.writeBuffer(Q, asn1.Ber.BitString);\n\tder.endSequence();\n}\n\nfunction writePkcs1EdDSAPrivate(der, key) {\n\tvar ver = Buffer.from([1]);\n\tder.writeBuffer(ver, asn1.Ber.Integer);\n\n\tder.writeBuffer(key.part.k.data, asn1.Ber.OctetString);\n\n\tder.startSequence(0xa0);\n\tder.writeOID('1.3.101.112');\n\tder.endSequence();\n\n\tder.startSequence(0xa1);\n\tutils.writeBitString(der, key.part.A.data);\n\tder.endSequence();\n}\n\nfunction writePkcs1EdDSAPublic(der, key) {\n\tthrow (new Error('Public keys are not supported for EdDSA PKCS#1'));\n}\n"],"sourceRoot":""}