ssh-client-wrapper 2.2.0 → 2.2.3

package/Dockerfile

@@ -1,5 +1,4 @@
 # syntax=docker/dockerfile:1
-#build WHEEL client code
 FROM --platform=linux/amd64 node:hydrogen-bookworm-slim
 #FROM --platform=linux/amd64 node:hydrogen-bullseye-slim
 #FROM --platform=linux/amd64 node:hydrogen-buster-slim

package/README.md

@@ -4,3 +4,9 @@
 [![Maintainability](https://api.codeclimate.com/v1/badges/8f3c0ea00e755ae31081/maintainability)](https://codeclimate.com/github/so5/ssh-client-wrapper/maintainability)
 # ssh-client-wrapper
 open ssh client wrapper library for nodejs
+
+
+# how to test on local machine
+```
+docker-compose up --build
+```

package/lib/fork.js

@@ -58,7 +58,7 @@ function sshLoginCallback(output, ptyProcess, pw, ph, logger = debugSendPty) {
 /**
  * create pty for master ssh session and store to hostInfo.masterPty
  */
-function createMastePty(hostInfo) {
+function createMasterPty(hostInfo) {
   debug("fork pty for master connection");
 
   if (hostInfo.masterPty) {
@@ -125,6 +125,6 @@ async function fork(hostInfo, cmd, args, timeout, outputCallback) {
 }
 module.exports = {
   fork,
-  createMastePty,
+  createMasterPty,
   sshLoginCallback
 };

package/lib/sshExec.js

@@ -5,7 +5,7 @@ const debug = require("debug")("sshClientWrapper:debug:sshExec");
 const debugVerbose = require("debug")("sshClientWrapper:verbose:sshExec");
 const debugSendMasterPty = require("debug")("sshClientWrapper:insecure:sshExec_masterPty");
 const { sendPty, sshCmd, getSshOption, sanityCheck, watchDogTimer } = require("./util.js");
-const { fork, createMastePty, sshLoginCallback } = require("./fork.js");
+const { fork, createMasterPty, sshLoginCallback } = require("./fork.js");
 
 /**
  * Execute command on remote host.
@@ -15,6 +15,7 @@ const { fork, createMastePty, sshLoginCallback } = require("./fork.js");
  * @param {Function} outputCallback - Callback routine for stdout and stderr.
  */
 async function sshExec(hostInfo, cmd, timeout, outputCallback) {
+  debug("sshExec called");
   await connect(hostInfo);
   debug("exec", cmd, "on remote server");
   const args = getSshOption(hostInfo, false);
@@ -46,16 +47,13 @@ async function sshExec(hostInfo, cmd, timeout, outputCallback) {
  * @param {Integer} timeout - timeout in secconds
  */
 async function canConnect(hostInfo, timeout = 60) {
-  debug("sanity check");
+  debug("canConnect called");
   sanityCheck(hostInfo);
 
-  debug("check connectibity");
-
-  try {
-    await connect(hostInfo, timeout);
-  } finally {
-    await disconnect(hostInfo);
-  }
+  await connect(hostInfo, timeout);
+  await disconnect(hostInfo);
+  //if connection fail, Error is throwed.
+  //so, if we reach here, connection must be succeeded
   return true;
 }
 
@@ -97,16 +95,17 @@ async function existsMaster(hostInfo, argTimeout) {
  * @param {Object} hostInfo - hostinfo object
  */
 async function connect(hostInfo, timeout = 60) {
+  debug("connect called");
+
   if (await existsMaster(hostInfo, timeout)) {
     debugVerbose("master connection exists");
     return;
   }
 
   debug(`create master pty for ${hostInfo.host}`);
-  createMastePty(hostInfo, debugSendMasterPty);
+  createMasterPty(hostInfo, debugSendMasterPty);
 
   debug(`create master ssh session to ${hostInfo.host}`);
-
   const words = crypto.randomUUID();
   const re = new RegExp(`^${words}`);
 
@@ -177,6 +176,8 @@ async function connect(hostInfo, timeout = 60) {
  * @param {Object} hostInfo - hostinfo object
  */
 async function disconnect(hostInfo) {
+  debug("disconnect called");
+
   if (await existsMaster(hostInfo)) {
     const args = getSshOption(hostInfo);
     args.push("-Oexit");
@@ -218,6 +219,7 @@ async function disconnect(hostInfo) {
  * @returns {string[]} - output from ls
  */
 async function ls(hostInfo, target, lsOpt, timeout) {
+  debug("ls called");
   const outputArray = [];
   try {
     await sshExec(hostInfo, `ls ${lsOpt.join(" ")} ${target}`, timeout, (data)=>{

package/lib/util.js

@@ -11,6 +11,53 @@ const rePwPrompt = /password:/;
 const rePhPrompt = /Enter passphrase for key/;
 const reNewHostPrompt = /Are you sure you want to continue connecting/;
 
+const Ajv = require("ajv");
+
+const ajv = new Ajv({
+  allErrors: true,
+  removeAdditional: "all",
+  coerceTypes: true,
+  logger: {
+    log: debug,
+    warn: debug,
+    error: debug
+  }
+});
+require("ajv-keywords")(ajv, "transform");
+
+//never validate password and passphrase value to avoid security insident
+const hostInfoSchema = {
+  type: "object",
+  properties: {
+    host: { type: "string", pattern: "\\S+", transform: ["trim"] },
+    user: { type: "string", pattern: "\\S+", transform: ["trim"] },
+    port: { type: "number", minimum: 0, maximum: 65535 },
+    keyFile: { type: "string", pattern: "\\S+", transform: ["trim"] },
+    noStrictHostkeyChecking: { type: "boolean" },
+    ControlPersist: { type: "number", minimum: 0 },
+    ConnectTimeout: { type: "number", minimum: 0 },
+    maxRetry: { type: "number", minimum: 0 },
+    retryMinTimeout: { type: "number", minimum: 0 },
+    retryMaxTimeout: { type: "number", minimum: 0 },
+    sshOpt: { type: "array", minItems: 1, items: { type: "string", pattern: "\\S+", transform: ["trim"] } }
+  },
+  required: ["host"],
+  additionalProperties: false
+};
+
+const stringOptions = [
+  "user",
+  "keyFile"
+];
+const numberOptions = [
+  "ControlPersist",
+  "ConnectTimeout",
+  "maxRetry",
+  "retryMinTimeout",
+  "retryMaxTimeout"
+];
+
+const validate = ajv.compile(hostInfoSchema);
 
 /**
  * bridge function to functions which need string
@@ -23,18 +70,62 @@ const buff2String = (func, data)=>{
 
 /**
  * check if given hostInfo object is OK
- * @param { Object} hostInfo - host information object defined in index.js
+ * @param { Object } hostInfo - host information object defined in index.js
  */
 const sanityCheck = (hostInfo)=>{
-  if (typeof hostInfo.host !== "string" || hostInfo.host === "") {
-    throw new Error("host must be non-empty string");
-  }
-  if (Object.prototype.hasOwnProperty.call(hostInfo, "port") && (typeof hostInfo.port === "string" || Number.isInteger(hostInfo.port))) {
-    const port = Number(hostInfo.port);
-    if (port < 0 || port > 65535) {
-      throw new Error("port number must be in the range of 0 to 65535");
+  debug("sanityCheck called", hostInfo);
+  //keep password, passphrase, and masterPty
+  const { password, passphrase, masterPty } = hostInfo;
+  validate(hostInfo);
+
+  if (validate !== null && Array.isArray(validate.errors)) {
+    for (const e of validate.errors) {
+      debug("validation error:", e);
+      const prop = e.instancePath.replace(/^\//, "");
+      if (e.keyword === "required" && e.params.missingProperty === "host") {
+        throw new Error("host is required");
+      }
+      if (prop === "host") {
+        if (hostInfo.host === "") {
+          throw new Error("empty host is not allowed");
+        }
+        const err = new Error("invalid host specified");
+        err.hostInfo = hostInfo;
+        err.validationError = e;
+        throw err;
+      }
+      if (prop.startsWith("sshOpt")) {
+        debug("remove empty member of sshOpt");
+        hostInfo.sshOpt = hostInfo.sshOpt.filter((opt)=>{
+          return opt !== "";
+        });
+        continue;
+      } else if (stringOptions.includes(prop) && hostInfo[prop] === "") {
+        debug("remove empty string option", prop, hostInfo[prop]);
+        delete hostInfo[prop];
+        continue;
+      } else if (numberOptions.includes(prop) && ["minimum", "maximum"].includes(e.keyword)) {
+        debug("remove out of range number option", prop, hostInfo[prop]);
+        delete hostInfo[prop];
+        continue;
+      } else {
+        const err = new Error(`invalid ${prop} specified ${hostInfo[prop]}`);
+        err.hostInfo = hostInfo;
+        err.validationError = e;
+        throw err;
+      }
     }
   }
+  if (["string", "function"].includes(typeof password)) {
+    hostInfo.password = password;
+  }
+  if (["string", "function"].includes(typeof passphrase)) {
+    hostInfo.password = password;
+  }
+  if (masterPty === null || typeof masterPty === "function") {
+    hostInfo.masterPty = masterPty;
+  }
+  return hostInfo;
 };
 
 /**
@@ -43,6 +134,7 @@ const sanityCheck = (hostInfo)=>{
  * @param {boolean} withoutDestination - return except for hostname
  */
 const getSshOption = (hostInfo, withoutDestination)=>{
+  debug("getSshOption called");
   const args = [];
 
   if (!withoutDestination) {
@@ -140,7 +232,7 @@ const watchDogTimer = (timeout, label, cb)=>{
     })
     .catch((err)=>{
       if (err.name === "AbortError") {
-        debug(`timeout was aborted because ${label} has done`);
+        debug(`timeout was aborted because ${label} has finished or canceled`);
       } else {
         throw err;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "2.2.0",
+  "version": "2.2.3",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",
@@ -34,12 +34,12 @@
     "*.js": "eslint --fix"
   },
   "dependencies": {
+    "ajv": "^8.12.0",
+    "ajv-keywords": "^5.1.0",
     "debug": "^4.3.4",
     "glob": "^10.3.10",
     "node-pty": "^0.10.1",
-    "nyc": "^15.1.0",
-    "promise-retry": "^2.0.1",
-    "rewire": "^7.0.0"
+    "promise-retry": "^2.0.1"
   },
   "devDependencies": {
     "chai": "^4.3.7",
@@ -56,6 +56,8 @@
     "lint-staged": "^13.2.1",
     "mocha": "^10.2.0",
     "sinon": "^15.0.3",
+    "rewire": "^7.0.0",
+    "nyc": "^15.1.0",
     "sinon-chai": "^3.7.0"
   }
 }

package/test/interface.js

@@ -33,15 +33,11 @@ describe("test for interface", ()=>{
       expect(()=>{
         //eslint-disable-next-line no-new
         new SshClientWrapper({});
-      }).to.throw("host must be non-empty string");
-      expect(()=>{
-        //eslint-disable-next-line no-new
-        new SshClientWrapper({ host: 1 });
-      }).to.throw("host must be non-empty string");
+      }).to.throw("host is required");
       expect(()=>{
         //eslint-disable-next-line no-new
         new SshClientWrapper({ host: "" });
-      }).to.throw("host must be non-empty string");
+      }).to.throw("empty host is not allowed");
     });
     it("should successfully instanciate only with host prop", ()=>{
       expect(new SshClientWrapper({ host: "hoge" })).to.have.property("exec");

package/test/rsyncExec.js

@@ -28,7 +28,7 @@ const { checkRsyncVersion, send, recv } = require("../lib/rsyncExec.js");
 
 //test helpers
 const { sshExec, disconnect } = require("../lib/sshExec.js");
-const hostInfo = require("./util/hostInfo.js");
+const hostInfo = require("./testUtil/hostInfo.js");
 const {
   clearLocalTestFiles,
   clearRemoteTestFiles,
@@ -40,7 +40,7 @@ const {
   remoteRoot,
   remoteEmptyDir,
   remoteFiles
-} = require("./util/testFiles");
+} = require("./testUtil/testFiles");
 
 const formatLsOutput = (array)=>{
   const rt = [];

package/test/sshExec.js

@@ -17,8 +17,8 @@ const sshout = sinon.stub();
 const { sshExec, canConnect, disconnect, ls } = require("../lib/sshExec.js");
 
 //test helpers
-const hostInfo = require("./util/hostInfo.js");
-const { clearRemoteTestFiles, clearLocalTestFiles, createRemoteFiles, nonExisting, remoteRoot, remoteEmptyDir } = require("./util/testFiles.js");
+const hostInfo = require("./testUtil/hostInfo.js");
+const { clearRemoteTestFiles, clearLocalTestFiles, createRemoteFiles, nonExisting, remoteRoot, remoteEmptyDir } = require("./testUtil/testFiles.js");
 
 describe("test for ssh execution", function() {
   this.timeout(65000);//eslint-disable-line no-invalid-this
@@ -97,11 +97,11 @@ describe("test for ssh execution", function() {
     });
     it("should be rejected if port number is out of range(-1)", async ()=>{
       hostInfo2.port = -1;
-      return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith(255);
+      return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith("invalid port specified -1");
     });
     it("should be rejected if port number is out of range(65536)", async ()=>{
       hostInfo2.port = 65536;
-      return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith(255);
+      return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith("invalid port specified 65536");
     });
   });
   describe("#ls", ()=>{

package/test/{util → testUtil}/hostInfo.js

@@ -2,7 +2,7 @@
 module.exports = {
   host: process.env.TEST_HOST || "localhost",
   user: process.env.TEST_USER || null,
-  port: process.env.TEST_PORT || null,
+  port: process.env.TEST_PORT || 22,
   password: process.env.TEST_PW,
   passphrase: process.env.TEST_PH,
   keyFile: process.env.TEST_PRIVATE_KEY,

package/test/util.js

@@ -0,0 +1,76 @@
+"use strict";
+process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
+
+//setup test framework
+const chai = require("chai");
+const { expect } = require("chai");
+chai.use(require("chai-as-promised"));
+
+
+//testee
+const { sanityCheck } = require("../lib/util.js");
+
+describe("test for sanityCheck", ()=>{
+  const host = "testHostName";
+  it("should throw error for empty host", ()=>{
+    expect(sanityCheck.bind(null, { host: "   ", user: "   ", port: 22 })).to.throw(/empty host is not allowed/);
+  });
+  it("should throw error if host is not in argument object", ()=>{
+    expect(sanityCheck.bind(null, { user: "   ", port: 22 })).to.throw(/host is required/);
+  });
+  it("should just remove empty string props", ()=>{
+    expect(sanityCheck({ host, user: "   ", port: 22 })).to.deep.equal({ host, port: 22 });
+  });
+  it("should remove empty string member in sshOpt", ()=>{
+    expect(sanityCheck({ host, sshOpt: ["foo", "  ", "bar"], user: "user", port: 33 })).to.deep.equal({ host, sshOpt: ["foo", "bar"], user: "user", port: 33 });
+  });
+  it("should just chage type if string value specified for number", ()=>{
+    expect(sanityCheck({
+      host,
+      port: "11",
+      ControlPersist: "22",
+      ConnectTimeout: "33",
+      maxRetry: "44",
+      retryMinTimeout: "55",
+      retryMaxTimeout: "66"
+    })).to.deep.equal({
+      host,
+      port: 11,
+      ControlPersist: 22,
+      ConnectTimeout: 33,
+      maxRetry: 44,
+      retryMinTimeout: 55,
+      retryMaxTimeout: 66
+    });
+  });
+  it("should remove out of range members", ()=>{
+    expect(sanityCheck({
+      host,
+      ControlPersist: "-1",
+      ConnectTimeout: "-1",
+      maxRetry: "-1",
+      retryMinTimeout: "-1",
+      retryMaxTimeout: "-1"
+    })).to.deep.equal({
+      host
+    });
+  });
+  it("should just chage type if string value specified for boolean member", ()=>{
+    expect(sanityCheck({
+      host,
+      noStrictHostkeyChecking: "true"
+    })).to.deep.equal({
+      host,
+      noStrictHostkeyChecking: true
+    });
+  });
+  it("should just chage type if number value specified for boolean member", ()=>{
+    expect(sanityCheck({
+      host,
+      noStrictHostkeyChecking: 0
+    })).to.deep.equal({
+      host,
+      noStrictHostkeyChecking: false
+    });
+  });
+});