mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-21 23:50:45 +00:00
211 lines
5.2 KiB
JavaScript
211 lines
5.2 KiB
JavaScript
const test = require("node:test");
|
|
const assert = require("node:assert/strict");
|
|
const { EventEmitter } = require("node:events");
|
|
const { readFileSync } = require("node:fs");
|
|
const Module = require("node:module");
|
|
|
|
const passphraseHandler = require("./passphraseHandler.cjs");
|
|
const { releaseConnectionRef } = require("./sshConnectionPool.cjs");
|
|
|
|
function loadSftpBridgeWithProxySocket(proxySocket, overrides = {}) {
|
|
const bridgePath = require.resolve("./sftpBridge.cjs");
|
|
delete require.cache[bridgePath];
|
|
|
|
const originalLoad = Module._load;
|
|
Module._load = function patchedLoad(request, parent, isMain) {
|
|
if (request === "./proxyUtils.cjs") {
|
|
return {
|
|
createProxySocket: async () => proxySocket,
|
|
};
|
|
}
|
|
if (request === "ssh2" && overrides.SSHClient) {
|
|
const ssh2 = originalLoad.call(this, request, parent, isMain);
|
|
return {
|
|
...ssh2,
|
|
Client: overrides.SSHClient,
|
|
};
|
|
}
|
|
return originalLoad.call(this, request, parent, isMain);
|
|
};
|
|
|
|
try {
|
|
return require("./sftpBridge.cjs");
|
|
} finally {
|
|
Module._load = originalLoad;
|
|
}
|
|
}
|
|
|
|
class FailingSshClient extends EventEmitter {
|
|
constructor() {
|
|
super();
|
|
this.ended = false;
|
|
FailingSshClient.instances.push(this);
|
|
}
|
|
|
|
connect() {
|
|
queueMicrotask(() => {
|
|
const err = new Error("jump connect failed");
|
|
err.level = "client-socket";
|
|
this.emit("error", err);
|
|
});
|
|
}
|
|
|
|
end() {
|
|
this.ended = true;
|
|
}
|
|
|
|
forwardOut() {
|
|
throw new Error("forwardOut should not be called");
|
|
}
|
|
}
|
|
FailingSshClient.instances = [];
|
|
|
|
function createSender() {
|
|
return {
|
|
id: 1,
|
|
isDestroyed: () => false,
|
|
send: () => {},
|
|
};
|
|
}
|
|
|
|
test("openSftp clears its authentication timer when SSH becomes ready", () => {
|
|
const source = readFileSync(require.resolve("./sftpBridge/openConnection.cjs"), "utf8");
|
|
assert.match(
|
|
source,
|
|
/sshClient\.once\('ready', \(\) => \{\s*clearAuthReadyTimer\(\);\s*cleanup\(\);/,
|
|
);
|
|
});
|
|
|
|
test("openSftp cleans an opened proxy socket when target key passphrase is cancelled", async (t) => {
|
|
const originalRequestPassphrase = passphraseHandler.requestPassphrase;
|
|
t.after(() => {
|
|
passphraseHandler.requestPassphrase = originalRequestPassphrase;
|
|
});
|
|
passphraseHandler.requestPassphrase = async () => ({ cancelled: true });
|
|
|
|
const proxySocket = {
|
|
ended: false,
|
|
destroyed: false,
|
|
end() {
|
|
this.ended = true;
|
|
},
|
|
destroy() {
|
|
this.destroyed = true;
|
|
},
|
|
};
|
|
const bridge = loadSftpBridgeWithProxySocket(proxySocket);
|
|
|
|
await assert.rejects(
|
|
bridge.openSftp(
|
|
{ sender: createSender() },
|
|
{
|
|
sessionId: "sftp-cleanup-test",
|
|
hostname: "target.example",
|
|
port: 22,
|
|
username: "alice",
|
|
proxy: {
|
|
type: "socks5",
|
|
host: "proxy.example",
|
|
port: 1080,
|
|
},
|
|
privateKey: "-----BEGIN ENCRYPTED PRIVATE KEY-----\nkey\n-----END ENCRYPTED PRIVATE KEY-----",
|
|
keyId: "target-key",
|
|
},
|
|
),
|
|
/Passphrase entry cancelled/,
|
|
);
|
|
|
|
assert.equal(proxySocket.ended, true);
|
|
assert.equal(proxySocket.destroyed, true);
|
|
});
|
|
|
|
test("openSftp cleans a jump proxy socket when the first jump connection fails", async () => {
|
|
FailingSshClient.instances = [];
|
|
const proxySocket = {
|
|
ended: false,
|
|
destroyed: false,
|
|
end() {
|
|
this.ended = true;
|
|
},
|
|
destroy() {
|
|
this.destroyed = true;
|
|
},
|
|
};
|
|
const bridge = loadSftpBridgeWithProxySocket(proxySocket, {
|
|
SSHClient: FailingSshClient,
|
|
});
|
|
|
|
await assert.rejects(
|
|
bridge.openSftp(
|
|
{ sender: createSender() },
|
|
{
|
|
sessionId: "sftp-jump-cleanup-test",
|
|
hostname: "target.example",
|
|
port: 22,
|
|
username: "alice",
|
|
jumpHosts: [
|
|
{
|
|
hostname: "jump.example",
|
|
port: 22,
|
|
username: "jump",
|
|
proxy: {
|
|
type: "socks5",
|
|
host: "proxy.example",
|
|
port: 1080,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
),
|
|
/jump connect failed/,
|
|
);
|
|
|
|
assert.equal(proxySocket.ended, true);
|
|
assert.equal(proxySocket.destroyed, true);
|
|
assert.equal(FailingSshClient.instances[0]?.ended, true);
|
|
});
|
|
|
|
test("openSftpForSession holds a shared SSH connection until the SFTP handle closes", async () => {
|
|
const bridge = loadSftpBridgeWithProxySocket(null);
|
|
const sftpClients = new Map();
|
|
const fakeSftp = {
|
|
ended: false,
|
|
readdir: () => {},
|
|
stat: () => {},
|
|
mkdir: () => {},
|
|
unlink: () => {},
|
|
end() {
|
|
this.ended = true;
|
|
},
|
|
};
|
|
const conn = {
|
|
ended: false,
|
|
sftp(cb) {
|
|
cb(null, fakeSftp);
|
|
},
|
|
end() {
|
|
this.ended = true;
|
|
},
|
|
};
|
|
const connRef = { count: 1, conn, chainConnections: [] };
|
|
const session = {
|
|
conn,
|
|
stream: {},
|
|
connRef,
|
|
};
|
|
const sessions = new Map([["session-1", session]]);
|
|
bridge.init({ sftpClients, sessions, electronModule: {} });
|
|
|
|
const opened = await bridge.openSftpForSession(null, { sessionId: "session-1" });
|
|
|
|
assert.equal(opened.ok, true);
|
|
assert.equal(connRef.count, 2);
|
|
assert.equal(releaseConnectionRef(session), false);
|
|
assert.equal(conn.ended, false);
|
|
|
|
await bridge.closeSftp(null, { sftpId: opened.sftpId });
|
|
|
|
assert.equal(fakeSftp.ended, true);
|
|
assert.equal(conn.ended, true);
|
|
});
|