first commit

build/node_modules/ssh2/test/fixtures/bad_rsa_private_key

@@ -0,0 +1,26 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEAz7MF4vhgw6HxNf3KtVf3VULTYgrRSlv+cCZdB1xxI1p/nGyu
+/eekUn5C+mGeDS488DX5ulzicxVpL7pamc/tFNcp91MrR7PiIMK2l+bwbZJubbLj
+DHhNcBklnFOSKxtmQRfuorGakpy/kXmIxF5of0xXGns6DlHRq9dGCJIXvrkqhcEb
+k4n2y4aV4VOiMHdo6FrFQVPzA8DlbJP2SjIFZ/0VdK7O7eiyiqV1p1xlbTQQ5rAX
+LdsshBn/GvoBOTCVupMXurn2582vgGh26Mmovj2QGzScMGUVttkMlnxUmKT/aQka
+mC0vR54QOW7lyWPjAitOV0qgmtGm3/cl7W7NjwIDAQABAoIBAFxH0C+951BEXWV9
+s1jLEqshG8YNxFtjcDLn+KFSoznv9Y7MgxtwlgPI8X1Jbe2xQ4X+lUwGBN7Y/nkk
+NSjtxwphZtXqb+pVs/yWRoZLJzunucSnnFVoBg/uPFWuk9zvOYlmVrKWcnT9i+fY
+tbl5sLgOdQzg/zRpidztssIQFti3o2jnpyrEGcepPWLkfCgqPfGmNv78BAIt/6iT
+zYDB4GMSq/LnPTIOFsIOvlkZg3RCcLWeAPRC+lvFQVY+M/uJL5WIbA5il1IMMKH7
+MULWpRO3lnb1JVrkZlBldK5uew6AN3tHDQOmg+C2JuIbOZ35J9dcnwsE+IptWWBj
+XiFRJCECgYEA8BeuufkslureqOycaPLMkqchMTue1OxbLJFvPN+dh/cW6Lng3b8+
+xAyzZrc0vccH/jl9WVHhIZ7TcKXDzSmmrtnZ/3m1c4gANGqIPwO+emL1ZzzkIKGd
+FrLeBZKP4TWry9kjg4cG1SKGpcB5ngJMPXUxMZNe74tC4Hk820PkFjcCgYEA3XXn
+ngRCgH9N1eKSD2daxxlBhTTSnTgjU+dDaDFQzPIhJCcS8HwyQBQmNTOSXXK9sShC
+fdXAsmiBby5WEBq/K5+cXeDG2ZlFLyPovEgTUrLgraw42PYs0+A8Ls7dFk7PuMez
+3G2gUPkY039JiyXKfcog9/dIRfbWCwzQ6s7TV2kCgYEArsme81cahhgg1zvCNokk
+M1Omz2/HFt2nFpAeOmPVDGnu7Kh9sxGKgTF53bpclBh0kjiKL99zFYXKCoUzQYYk
+CcEhemLBnYUSGRbBb5arMfAfFfR3Y+YkNaUsC0SCqILpOfMvbo57g+ipu7ufDlA/
+7rIFiUDvaVap7j909W+8egsCgYEAsuc/0DBixMmSyHl7QwRcmkC15HVSu32RVIOb
+ub01KAtmaH1EWJAMTCW64/mggOtjgI0kgeE/BSFVhsqo7eOdkhEj0db27OxbroRU
+zF1xdrpYtRRO7D6a4iLgm3OzuQS72+tASo8pFqDUxG6sq8NAvLOgRJE4ioSoT07w
+KvAgXRkCgYEAmWgcsX/BdNcKOteSDtPkys5NRtWCBz7Coxb+xXXoXz1FVegBolpY
+wXVePvXTIbU8VJOLunMyH5wpmMUiJbTX9v2o/yfpsH0ci4GaAeVtqpA=
+-----END RSA PRIVATE KEY-----

build/node_modules/ssh2/test/fixtures/id_dsa

@@ -0,0 +1,12 @@
+-----BEGIN DSA PRIVATE KEY-----
+MIIBuwIBAAKBgQC3/2VIGHgqHuxvhPa6rryqqLy6sQmjeSIwyrIW5F/o8W4sz/mE
+0noDSW4PaoXjgPQv5egj1EByws6dMOUqLaZHNWNn+Lh/jkKlwKyhbSCAjqoWH3v3
+uI1j58GO/eZ2+REijfyA0XJxdm7kqEexxbg0UpFr1F/eLBUxpLIbhhS1cwIVAKcB
+B9DnAObuPJGTwYTCaIIBQDy9AoGAJicW0pIFwgoTYsIeywmUQopJ3FQ4M3eDwQ0U
+T33pzWvBZFN2OsUDTFg64PNm9ow09wk042qMg168eKCUTp2iR/Y9R4xTj8dls8iv
+aMGMZ/B32eURIjUREGiXYTyG1pfuB2znSvr/5pavhuz5yG9M0AJCiYiexdaQKO3N
+oJp6T3ACgYEAsep79p4WljnawrJc928zGq6dLYjs+5apYhqx4vf2l3Z2u26VqVNG
+i5zZkUzhWQYV3/qtEOpO43dyZTHW+d9L8ni6HbXFWRVx60WE+5WKkzkimHJ6gox2
+kDvOqPudiS34KJOCEYYLEnJmK8aUZBZzWFORXkN8QgA/h9ts8AU785UCFAVXZMWq
+CteWCH2HzcY2x/65dMwL
+-----END DSA PRIVATE KEY-----

build/node_modules/ssh2/test/fixtures/id_ecdsa

@@ -0,0 +1,5 @@
+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEIPMZuWP7fMsZeyC1XXVUALVebJOX7PTwmsPql9qG25SeoAoGCCqGSM49
+AwEHoUQDQgAEB/B6mC5lrekKPWfGEkKpnCk08+dRnzFUg2jUHpaIrOTt4jGdvq6T
+yAN57asB+PYmFyVIpi35NcmicF18qX3ayg==
+-----END EC PRIVATE KEY-----

build/node_modules/ssh2/test/fixtures/id_rsa

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXQIBAAKBgQDL0yFO4W4xbdrJk/i+CW3itPATvhRkS+x+gKmkdH739AqWYP6r
+kTFAmFTw9gLJ/c2tN7ow0T0QUR9iUsv/3QzTuwsjBu0feo3CVxwMkaJTo5ks9XBo
+OW0R3tyCcOLlAcQ1WjC7cv5Ifn4gXLLM+k8/y/m3u8ERtidNxbRqpQ/gPQIDAQAB
+AoGABirSRC/ABNDdIOJQUXe5knWFGiPTPCGr+zvrZiV8PgZtV5WBvzE6e0jgsRXQ
+icobMhWQla+PGHJL786vi4NlwuhwKcF7Pd908ofej1eeBOd1u/HQ/qsfxPdxI0zF
+dcWPYgAOo9ydOMGcSx4v1zDIgFInELJzKbv64LJQD0/xhoUCQQD7KhJ7M8Nkwsr2
+iKCyWTFM2M8/VKltgaiSmsNKZETashk5tKOrM3EWX4RcB/DnvHe8VNyYpC6Sd1uQ
+AHwPDfxDAkEAz7+7hDybH6Cfvmr8kUOlDXiJJWXp5lP37FLzMDU6a9wTKZFnh57F
+e91zRmKlQTegFet93MXaFYljRkI+4lMpfwJBAPPLbNEF973Qjq4rBMDZbs9HDDRO
++35+AqD7dGC7X1Jg2bd3rf66GiU7ZgDm/GIUQK0gOlg31bT6AniO39zFGH0CQFBh
+Yd9HR8nT7xrQ8EoQPzNYGNBUf0xz3rAcZCWZ4rHK48sojEMoBkbnputrzX7PU+xH
+QlqCXuAIWVXc2dHd1WcCQQDIUJHPOsgeAfTLoRRRURp/m8zZ9IpbaPTyDstPVNYe
+zARW3Oa/tzPqdO6NWaetCp17u7Kb6X9np7Vz17i/4KED
+-----END RSA PRIVATE KEY-----

build/node_modules/ssh2/test/fixtures/id_rsa.ppk

@@ -0,0 +1,26 @@
+PuTTY-User-Key-File-2: ssh-rsa
+Encryption: none
+Comment: rsa-key-20150522
+Public-Lines: 6
+AAAAB3NzaC1yc2EAAAABJQAAAQB1quqP0rhl78NOLD4lj+1x5FGAqZ3aqo6GiEPz
+KOaQmy86FuJMK0nHj3gUKTa/Kvaa+8PZyeu+uVseHg47YrynCOcJEEnpqvbArc8M
+xMWuUnTUMrjvokGDOBBiQu4UAE4bybpgXkNHJfbrcDVgivmv3Ikn8PVIZ1rLBMLZ
+6Lzn0rjPjFD0X4WqsAJW2SFiZnsjMZtVL2TWadNTyyfjjm2NCRBvd32VLohkSe9Q
+BZBD6MW8YQyBKUnEF/7WNY0eehDVrfx1YqPOV1bDwFUhRaAYpLDLDR0KCAPvx7qb
+8G5Cq0TIBsEr3H8ztNRcOTQoaKgn0T18M7cyS4ykoNLYW4Zx
+Private-Lines: 14
+AAABACyF3DZraF3sBLXLjSL4MFSblHXfUHxAiPSiQzlpa/9dUCPRTrUJddzOgHZU
+yJtcXU9mLm4VDRe7wZyxbSs6Hd5WZUGzIuLLEUH8k4hKdE/MLDSdkhV7qhX5iaij
+tAeRaammRoVUGXTd7rnzGx2cXnnkvkZ22VmqkQ6MLg1DTmWNfOO9cdwFGdQawf/n
+yUV0nTkWsHXy5Qrozq9wRFk8eyw+pFllxqavsNftZX8VDiQt27JLZPTU4LGkH660
+3gq1KhNS/l05TlXnMZGjlcPN8UEaBzmCWRezhJSttjs5Kgp1K3yDf4ozMR/HWOCj
+Jq8fd3VIgli6ML8yjr/c0A0T9MUAAACBAL1/byxHiCvY/2C+/L5T+ZZq13jdZuYK
+MmOFaNITgEdNGWSIFYRzhLKGXj7awQWOIW6chj470GNOfQjFL1TvXhbwfqW6esDa
+kETOYQPYQHZijABcn7uurMUm/bu5x/z9gYkAfniOCI5vmvMvJ09JcZ0iUmFWDZZY
+fAutBvrt+n/vAAAAgQCe9jrA51wn1/wzKmWF+2+OWFUG9usheIcEbHB8mxLguLfU
++x4i+2vLo0FtXEPAw+Bt7Tge4t0m6USiVZXtW/QKsh0kMj4mNVHFz+XXw4l1QOYv
+n5TjnLepiP7majXv4GHI2eOcHkyly4sIkj4jNLYqvT86hMxW4IC+jtJEWhn/nwAA
+AIEAlJ8cExu2WrWukTDJQHrVegtvdJUhNjol2wLucPuWwSxKuB8FHYwaPRYRkf3d
+DkZ53hhjJZ0BVkAaQ28uqM09xKD+q1H4/r0nnbtlV4uHLl3cCD5mGrH8I/iDPJX4
+fFIqCa0+n1D6RzvDqs1QIu+PGSp0K6vHOOS5fP0ZpuT025E=
+Private-MAC: 4ca26008c85b901f4d2766b0924c25e527678d7e

build/node_modules/ssh2/test/fixtures/id_rsa_enc

@@ -0,0 +1,30 @@
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-128-CBC,CCE70744FB28F2EFB1D74377281A780C
+
+1WiGnqpSGXFIg+WYr7T2XN72C1YrNQ1jmRISb32TB/Rh2Zo47fjyQnv9impz8b6m
+91R/qF7uCLI0fswvT5oqwn1L0vUAA0YtW/E2IQJEx5GPiaexoDJYYfu2yy036Kca
+e9VtCajgrV+kycg1CknCxQKMcKXNq8Czvq66PM4Bzknek5hhdmxHxOl0QAE+8EXt
+pnasOGz3szTUKkD6givwWgvDXY3BnVG46fXff99Xqgb6fx5IDbAkVKaxWIN/c81E
+b0rcfyoLb7yjPgNYn9vUI6Z+24NMYUYARzb3dG5geaeX0BYb/VlCtJUsP0Rp2P2P
+jl+cdvBKaeOvA9gPo/jAtSOFexQRs7AzKzoOLYU1fokd8HhqxOKAljn9ujmEqif7
+qcimk2s7ff6tSSlxtRzDP+Uq9d1u5tyaONRV2lwj+GdP1gRoOmdZL5chdvoAi0I8
+5eMf58hEuN2d4h4FryO6z7K+XQ9oo6/N/xHU0U/t2Pco9oY2L6oWMDxKwbfPhaD5
+CcoEElsK4XFArYDielEq9Y1sXaEuwR5I0ksDDsANp74r9Bhcqz60gJa6hVz0ouEU
+QA67wV9+TRmulKRxwANvqxQwqPuxqcTPeJjXSUN/ZCaDwYmI+d1poxMx2fQzT82M
+onlgOWq+3HbCotyoeFpCameymwDQzmrYdMBr7oWLgnOrxmJ89zDc6+jkHFgQJvnU
+atyeVDqe866ZvvIGWS+r/EsDjV3cTW/cJvdsC+5BpnoXoVF4LqxE3LFbEbQBvqio
+4enCZpspQSMOJra37vSofbD+DyI5Wd+y8SBmfDLjyDFhT0spW9aN99uFqSc3UElA
+SAmnFmpYBFEQrRGpvpu5sC0c/YjZeRXr0/F1xPpIT1SWzpRsbcsWRBDzWjLOKWQx
+8ytwc2QS7eKedfqkPWpYKW0Qtps+XgnGWA6PBX42IYhLsKANRfhFXQv5LPqLNNOn
+3EsG9pd+0dBpfxFQfyyAKAUuvpJNgJ6kNx8VSj8Ppj8lyUdGa9YucgB02m7gHC9U
+A4YyJsIcjo6IcrjM+ez1govRRS0nE8AUb8ups9tn8mdBwqcPCrgcJhV7JkOYNJYh
+NAh0vgmneOq8LSVs2SRaL3uuLNbjh1LR9iViwbIY8kMQXkiXa2/V+PFwt5oqeX5f
+2x3yzCeGBiQW10InyBBnKutbPD85R4YJhQ55bOMDSFfGGqwOU1QURiO1NUzf9n/2
++E8VE7J/IQoO0TrJpC+EV0ROKME9W6+AvEFdmdIigbq3bkdEgSixyLnrhV8V8T4N
+nbKlLoqfXt8DmT+h8XPzgsu0Fq/PNi6xBaiUsaN9tK6OP2ZVjr9ihbeLTI0rcKDr
+XX2cWPvTcboRLt+S4wmqchMf7Kxa2PfX5Tf+KCcdZNQO4YqS23wQZgk61kuOQCsS
+uOop+ICI7yWZkjqCOzGOeHLl/7FyFeprsFDIwD1g20y9bzibbJlbQPhwXSalqDQT
+MWLH3rdFuvgLH7ujtjxSakES+VzkOhbnmb/Wypbl1D7P7GT2seau16EEGQDhDzcJ
+Q4d/BjR2WqqxmC79MOAvUWAu6fZQjPD30/gYPGpMaEuiLrDlzDqvf+oi4A9+EtRL
+-----END RSA PRIVATE KEY-----

build/node_modules/ssh2/test/fixtures/ssh_host_dsa_key

@@ -0,0 +1,12 @@
+-----BEGIN DSA PRIVATE KEY-----
+MIIBuwIBAAKBgQDEK+daQ7RuajwxkmBmogb0iUSi/w2RYKuvC2EiviBu3S2s9Bfq
+gROKscAnURrxpTOa+iYeI7hRzfuX0qFmnFwXIjKJBjqBdg9r76UR5UNytnWQkJ5x
+lxsZThMeAMw38SvmRMw15kkgxycKGqu4yvNLGyVwN02bPVjLcEVLWLCM1wIVAK50
+5JqF0nmGXFkcmNtxR24/mNXTAoGBAIc2p8C8b08OTQPmfZI+Wq8a+CuEr5R36bMW
+TAs5etqmO2aVo5zvR0MnTjoS2ZDbuznDG9RiSuIB+ivr/daEwi+K+Ha8pZfYjXCG
+ldzvmr5I4x8rkH3zyn7BADnc+/q3pa8AnZvTme5eNsxn1Pu/rmC/8KKnhmzRggqP
+N8ORhoQQAoGAMCvoMcsDAui2d/WVpgHZZEFlxfbf4dPUPYb5zf2xOiMG9OK+Cbv3
+NaLZwk/Hd2g4L3nwTKDASxfmRcrbuaOg/d7aDjQ2mJz18Js4IjY34QpgLspGCNX/
+6rJSQ+ov1Z2Etr95N4Tzm3qpxW5BH9TTgaC/ntb9NRqIzNPCvAHXmlcCFBxgZpyb
+4GUgmqhTOMtmBkJ7QpL9
+-----END DSA PRIVATE KEY-----

build/node_modules/ssh2/test/fixtures/ssh_host_ecdsa_key

@@ -0,0 +1,5 @@
+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEICrdbIIYmW/XTK9hxaQZZ56IGwG0NhqD2eppYUJNZsECoAoGCCqGSM49
+AwEHoUQDQgAEa+MuLv++3ft5HPFIsM2hQnmHPF12q08/MaHoGud4yqp3evyomjZN
+xbsSb39fv8t6XX1u1rm5oHQcBV5Mqomaeg==
+-----END EC PRIVATE KEY-----

build/node_modules/ssh2/test/fixtures/ssh_host_rsa_key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQC57UB/5H0M+t+mopksrltCCIXghryzofJjau+8tuMT9CG6ta3S
+O9aKApJUUG/xtc88giVhB7HFABX/oob+jrkSthR8s/whULC8E+GhvOBjHydRUZIs
+aPYOMBb42HcbOsgq3li/hwOcDk0vY00hZDKCum9BgvRAb7dPEkw2dmiCQQIDAQAB
+AoGAMG+HOwoaLbR5aR64yrQNYBF6Vvii1iUdURr9o2r9kygpVUuZIcim5kMvPbnK
+v+w+NaQt+q4XeJvCH1uG0W/69FwnphfaOVmCCUtsoJ6sU3fWr9x59MtKL2Llh8xR
+50lz6R+eDXoYRDq245hG9BFn/bu0vtqQqx06mlZJcjaRocECQQDjdYFmr+DSww3x
+VNx0G0DUkaQZZ+iqZiT3Zund2pcBB4aLiewOrqj0GFct4+YNzgxIXPejmS0eSokN
+N2lC3NxZAkEA0UGjN5TG5/LEK3zcYtx2kpXryenrYORo1n2L/WPMZ0mjLQyd4LJr
+ibfgVUfwX/kV3vgGYLwjpgcaTiMsecv4KQJAYMmMgZSPdz+WvD1e/WznXkyG5mSn
+xXJngnrhQw0TulVodBIBR5IcxJli510VdIRcB6K/oXa5ky0mOmB8wv3WKQJBAKEF
+PxE//KbzWhyUogm4180IbD4dMDCI0ltqlFRRfTJlqZi6wqnq4XFB+u/kwYU4aKoA
+dPfvDgduI8HIsyqt17ECQDI/HC8PiYsDIOyVpQuQdIAsbGmoavK7X1MVEWR2nj9t
+7BbUVFSnVKynL4TWIJZ6xP8WQwkDBQc5WjognHDaUTQ=
+-----END RSA PRIVATE KEY-----

build/node_modules/ssh2/test/test-openssh.js

@@ -0,0 +1,459 @@
+var Server = require('../lib/server');
+var utils = require('ssh2-streams').utils;
+
+var semver = require('semver');
+
+var fs = require('fs');
+var crypto = require('crypto');
+var path = require('path');
+var join = path.join;
+var assert = require('assert');
+var spawn = require('child_process').spawn;
+var exec = require('child_process').exec;
+
+var t = -1;
+var group = path.basename(__filename, '.js') + '/';
+var fixturesdir = join(__dirname, 'fixtures');
+
+var CLIENT_TIMEOUT = 5000;
+var USER = 'nodejs';
+var HOST_KEY_RSA = fs.readFileSync(join(fixturesdir, 'ssh_host_rsa_key'));
+var HOST_KEY_DSA = fs.readFileSync(join(fixturesdir, 'ssh_host_dsa_key'));
+var HOST_KEY_ECDSA = fs.readFileSync(join(fixturesdir, 'ssh_host_ecdsa_key'));
+var CLIENT_KEY_RSA_PATH = join(fixturesdir, 'id_rsa');
+var CLIENT_KEY_RSA = fs.readFileSync(CLIENT_KEY_RSA_PATH);
+var CLIENT_KEY_RSA_PUB = utils.genPublicKey(utils.parseKey(CLIENT_KEY_RSA));
+var CLIENT_KEY_DSA_PATH = join(fixturesdir, 'id_dsa');
+var CLIENT_KEY_DSA = fs.readFileSync(CLIENT_KEY_DSA_PATH);
+var CLIENT_KEY_DSA_PUB = utils.genPublicKey(utils.parseKey(CLIENT_KEY_DSA));
+if (semver.gte(process.version, '5.2.0')) {
+  var CLIENT_KEY_ECDSA_PATH = join(fixturesdir, 'id_ecdsa');
+  var CLIENT_KEY_ECDSA = fs.readFileSync(CLIENT_KEY_ECDSA_PATH);
+  var CLIENT_KEY_ECDSA_PUB = utils.genPublicKey(
+    utils.parseKey(CLIENT_KEY_ECDSA)
+  );
+}
+var opensshVer;
+var DEBUG = false;
+
+// Fix file modes to avoid OpenSSH client complaints about keys' permissions
+fs.readdirSync(fixturesdir).forEach(function(file) {
+  fs.chmodSync(join(fixturesdir, file), '0600');
+});
+
+var tests = [
+  { run: function() {
+      var what = this.what;
+      var server;
+
+      server = setup(
+        this,
+        { privateKeyPath: CLIENT_KEY_RSA_PATH },
+        { hostKeys: [HOST_KEY_RSA] }
+      );
+
+      server.on('connection', function(conn) {
+        conn.on('authentication', function(ctx) {
+          if (ctx.method === 'none')
+            return ctx.reject();
+          assert(ctx.method === 'publickey',
+                 makeMsg(what, 'Unexpected auth method: ' + ctx.method));
+          assert(ctx.username === USER,
+                 makeMsg(what, 'Unexpected username: ' + ctx.username));
+          assert(ctx.key.algo === 'ssh-rsa',
+                 makeMsg(what, 'Unexpected key algo: ' + ctx.key.algo));
+          assert.deepEqual(CLIENT_KEY_RSA_PUB.public,
+                           ctx.key.data,
+                           makeMsg(what, 'Public key mismatch'));
+          if (ctx.signature) {
+            var verifier = crypto.createVerify('RSA-SHA1');
+            var pem = CLIENT_KEY_RSA_PUB.publicOrig;
+            verifier.update(ctx.blob);
+            assert(verifier.verify(pem, ctx.signature),
+                   makeMsg(what, 'Could not verify PK signature'));
+            ctx.accept();
+          } else
+            ctx.accept();
+        }).on('ready', function() {
+          conn.on('session', function(accept, reject) {
+            var session = accept();
+            if (session) {
+              session.on('exec', function(accept, reject) {
+                var stream = accept();
+                if (stream) {
+                  stream.exit(0);
+                  stream.end();
+                }
+              }).on('pty', function(accept, reject) {
+                accept && accept();
+              });
+            }
+          });
+        });
+      });
+    },
+    what: 'Authenticate with an RSA key'
+  },
+  { run: function() {
+      var what = this.what;
+      var server;
+
+      server = setup(
+        this,
+        { privateKeyPath: CLIENT_KEY_DSA_PATH },
+        { hostKeys: [HOST_KEY_RSA] }
+      );
+
+      server.on('connection', function(conn) {
+        conn.on('authentication', function(ctx) {
+          if (ctx.method === 'none')
+            return ctx.reject();
+          assert(ctx.method === 'publickey',
+                 makeMsg(what, 'Unexpected auth method: ' + ctx.method));
+          assert(ctx.username === USER,
+                 makeMsg(what, 'Unexpected username: ' + ctx.username));
+          assert(ctx.key.algo === 'ssh-dss',
+                 makeMsg(what, 'Unexpected key algo: ' + ctx.key.algo));
+          assert.deepEqual(CLIENT_KEY_DSA_PUB.public,
+                           ctx.key.data,
+                           makeMsg(what, 'Public key mismatch'));
+          if (ctx.signature) {
+            var verifier = crypto.createVerify('DSA-SHA1');
+            var pem = CLIENT_KEY_DSA_PUB.publicOrig;
+            verifier.update(ctx.blob);
+            assert(verifier.verify(pem, ctx.signature),
+                   makeMsg(what, 'Could not verify PK signature'));
+            ctx.accept();
+          } else
+            ctx.accept();
+        }).on('ready', function() {
+          conn.on('session', function(accept, reject) {
+            var session = accept();
+            if (session) {
+              session.on('exec', function(accept, reject) {
+                var stream = accept();
+                if (stream) {
+                  stream.exit(0);
+                  stream.end();
+                }
+              }).on('pty', function(accept, reject) {
+                accept && accept();
+              });
+            }
+          });
+        });
+      });
+    },
+    what: 'Authenticate with a DSA key'
+  },
+  { run: function() {
+      if (semver.lt(process.version, '5.2.0'))
+        return next();
+      var what = this.what;
+      var server;
+
+      server = setup(
+        this,
+        { privateKeyPath: CLIENT_KEY_ECDSA_PATH },
+        { hostKeys: [HOST_KEY_RSA] }
+      );
+
+      server.on('connection', function(conn) {
+        conn.on('authentication', function(ctx) {
+          if (ctx.method === 'none')
+            return ctx.reject();
+          assert(ctx.method === 'publickey',
+                 makeMsg(what, 'Unexpected auth method: ' + ctx.method));
+          assert(ctx.username === USER,
+                 makeMsg(what, 'Unexpected username: ' + ctx.username));
+          assert(ctx.key.algo === 'ecdsa-sha2-nistp256',
+                 makeMsg(what, 'Unexpected key algo: ' + ctx.key.algo));
+          assert.deepEqual(CLIENT_KEY_ECDSA_PUB.public,
+                           ctx.key.data,
+                           makeMsg(what, 'Public key mismatch'));
+          if (ctx.signature) {
+            var verifier = crypto.createVerify('sha256');
+            var pem = CLIENT_KEY_ECDSA_PUB.publicOrig;
+            verifier.update(ctx.blob);
+            assert(verifier.verify(pem, ctx.signature),
+                   makeMsg(what, 'Could not verify PK signature'));
+            ctx.accept();
+          } else
+            ctx.accept();
+        }).on('ready', function() {
+          conn.on('session', function(accept, reject) {
+            var session = accept();
+            if (session) {
+              session.on('exec', function(accept, reject) {
+                var stream = accept();
+                if (stream) {
+                  stream.exit(0);
+                  stream.end();
+                }
+              }).on('pty', function(accept, reject) {
+                accept && accept();
+              });
+            }
+          });
+        });
+      });
+    },
+    what: 'Authenticate with a ECDSA key'
+  },
+  { run: function() {
+      var server;
+
+      server = setup(
+        this,
+        { privateKeyPath: CLIENT_KEY_RSA_PATH },
+        { hostKeys: [HOST_KEY_DSA] }
+      );
+
+      server.on('connection', function(conn) {
+        conn.on('authentication', function(ctx) {
+          ctx.accept();
+        }).on('ready', function() {
+          conn.on('session', function(accept, reject) {
+            var session = accept();
+            if (session) {
+              session.on('exec', function(accept, reject) {
+                var stream = accept();
+                if (stream) {
+                  stream.exit(0);
+                  stream.end();
+                }
+              }).on('pty', function(accept, reject) {
+                accept && accept();
+              });
+            }
+          });
+        });
+      });
+    },
+    what: 'Server with DSA host key'
+  },
+  { run: function() {
+      if (semver.lt(process.version, '5.2.0'))
+        return next();
+      var server;
+
+      server = setup(
+        this,
+        { privateKeyPath: CLIENT_KEY_RSA_PATH },
+        { hostKeys: [HOST_KEY_ECDSA] }
+      );
+
+      server.on('connection', function(conn) {
+        conn.on('authentication', function(ctx) {
+          ctx.accept();
+        }).on('ready', function() {
+          conn.on('session', function(accept, reject) {
+            var session = accept();
+            if (session) {
+              session.on('exec', function(accept, reject) {
+                var stream = accept();
+                if (stream) {
+                  stream.exit(0);
+                  stream.end();
+                }
+              }).on('pty', function(accept, reject) {
+                accept && accept();
+              });
+            }
+          });
+        });
+      });
+    },
+    what: 'Server with ECDSA host key'
+  },
+  { run: function() {
+      var server;
+      var what = this.what;
+
+      server = setup(
+        this,
+        { privateKeyPath: CLIENT_KEY_RSA_PATH },
+        { hostKeys: [HOST_KEY_RSA] }
+      );
+
+      server.on('_child', function(childProc) {
+        childProc.stderr.once('data', function(data) {
+          childProc.stdin.end();
+        });
+        childProc.stdin.write('ping');
+      }).on('connection', function(conn) {
+        conn.on('authentication', function(ctx) {
+          ctx.accept();
+        }).on('ready', function() {
+          conn.on('session', function(accept, reject) {
+            var session = accept();
+            assert(session, makeMsg(what, 'Missing session'));
+            session.on('exec', function(accept, reject) {
+              var stream = accept();
+              assert(stream, makeMsg(what, 'Missing exec stream'));
+              stream.stdin.on('data', function(data) {
+                stream.stdout.write('pong on stdout');
+                stream.stderr.write('pong on stderr');
+              }).on('end', function() {
+                stream.stdout.write('pong on stdout');
+                stream.stderr.write('pong on stderr');
+                stream.exit(0);
+                stream.close();
+              });
+            }).on('pty', function(accept, reject) {
+              accept && accept();
+            });
+          });
+        });
+      });
+    },
+    what: 'Server closes stdin too early'
+  },
+];
+
+function setup(self, clientcfg, servercfg) {
+  self.state = {
+    serverReady: false,
+    clientClose: false,
+    serverClose: false
+  };
+
+  var client;
+  var server = new Server(servercfg);
+
+  server.on('error', onError)
+        .on('connection', function(conn) {
+          conn.on('error', onError)
+              .on('ready', onReady);
+          server.close();
+        })
+        .on('close', onClose);
+
+  function onError(err) {
+    var which = (arguments.length >= 3 ? 'client' : 'server');
+    assert(false, makeMsg(self.what, 'Unexpected ' + which + ' error: ' + err));
+  }
+  function onReady() {
+    assert(!self.state.serverReady,
+           makeMsg(self.what, 'Received multiple ready events for server'));
+    self.state.serverReady = true;
+    self.onReady && self.onReady();
+  }
+  function onClose() {
+    if (arguments.length >= 3) {
+      assert(!self.state.clientClose,
+             makeMsg(self.what, 'Received multiple close events for client'));
+      self.state.clientClose = true;
+    } else {
+      assert(!self.state.serverClose,
+             makeMsg(self.what, 'Received multiple close events for server'));
+      self.state.serverClose = true;
+    }
+    if (self.state.clientClose && self.state.serverClose)
+      next();
+  }
+
+  process.nextTick(function() {
+    server.listen(0, 'localhost', function() {
+      var cmd = 'ssh';
+      var args = ['-o', 'UserKnownHostsFile=/dev/null',
+                  '-o', 'StrictHostKeyChecking=no',
+                  '-o', 'CheckHostIP=no',
+                  '-o', 'ConnectTimeout=3',
+                  '-o', 'GlobalKnownHostsFile=/dev/null',
+                  '-o', 'GSSAPIAuthentication=no',
+                  '-o', 'IdentitiesOnly=yes',
+                  '-o', 'BatchMode=yes',
+                  '-o', 'VerifyHostKeyDNS=no',
+
+                  '-vvvvvv',
+                  '-T',
+                  '-o', 'KbdInteractiveAuthentication=no',
+                  '-o', 'HostbasedAuthentication=no',
+                  '-o', 'PasswordAuthentication=no',
+                  '-o', 'PubkeyAuthentication=yes',
+                  '-o', 'PreferredAuthentications=publickey'];
+      if (clientcfg.privateKeyPath)
+        args.push('-o', 'IdentityFile=' + clientcfg.privateKeyPath);
+      if (!/^[0-6]\./.test(opensshVer)) {
+        // OpenSSH 7.0+ disables DSS/DSA host (and user) key support by
+        // default, so we explicitly enable it here
+        args.push('-o', 'HostKeyAlgorithms=+ssh-dss');
+      }
+      args.push('-p', server.address().port.toString(),
+                '-l', USER,
+                'localhost',
+                'uptime');
+
+      client = spawn(cmd, args);
+      server.emit('_child', client);
+      if (DEBUG) {
+        client.stdout.pipe(process.stdout);
+        client.stderr.pipe(process.stderr);
+      } else {
+        client.stdout.resume();
+        client.stderr.resume();
+      }
+      client.on('error', function(err) {
+        onError(err, null, null);
+      }).on('exit', function(code) {
+        clearTimeout(client.timer);
+        if (code !== 0)
+          return onError(new Error('Non-zero exit code ' + code), null, null);
+        onClose(null, null, null);
+      });
+
+      client.timer = setTimeout(function() {
+        assert(false, makeMsg(self.what, 'Client timeout'));
+      }, CLIENT_TIMEOUT);
+    });
+  });
+  return server;
+}
+
+function next() {
+  if (Array.isArray(process._events.exit))
+    process._events.exit = process._events.exit[1];
+  if (++t === tests.length)
+    return;
+
+  var v = tests[t];
+  v.run.call(v);
+}
+
+function makeMsg(what, msg) {
+  return '[' + group + what + ']: ' + msg;
+}
+
+process.once('uncaughtException', function(err) {
+  if (t > -1 && !/(?:^|\n)AssertionError: /i.test(''+err))
+    console.log(makeMsg(tests[t].what, 'Unexpected Exception:'));
+  throw err;
+});
+process.once('exit', function() {
+  assert(t === tests.length,
+         makeMsg('_exit',
+                 'Only finished ' + t + '/' + tests.length + ' tests'));
+});
+
+
+// Get OpenSSH client version first
+exec('ssh -V', function(err, stdout, stderr) {
+  if (err) {
+    console.log('OpenSSH client is required for these tests');
+    process.exitCode = 5;
+    return;
+  }
+  var re = /^OpenSSH_([\d\.]+)/;
+  var m = re.exec(stdout.toString());
+  if (!m || !m[1]) {
+    m = re.exec(stderr.toString());
+    if (!m || !m[1]) {
+      console.log('OpenSSH client is required for these tests');
+      process.exitCode = 5;
+      return;
+    }
+  }
+  opensshVer = m[1];
+  next();
+});

build/node_modules/ssh2/test/test.js

@@ -0,0 +1,22 @@
+var spawn = require('child_process').spawn,
+    join = require('path').join;
+
+var files = require('fs').readdirSync(__dirname).filter(function(f) {
+      return (f.substr(0, 5) === 'test-');
+    }).map(function(f) {
+      return join(__dirname, f);
+    }),
+    f = -1;
+
+function next() {
+  if (++f < files.length) {
+    spawn(process.argv[0], [ files[f] ], { stdio: 'inherit' })
+      .on('exit', function(code) {
+        if (code === 0)
+          process.nextTick(next);
+        else
+          process.exit(code);
+      });
+  }
+}
+next();