Top 10 Examples of "ssh2 in functional component" in JavaScript
Dive into secure and efficient coding practices with our curated list of the top 10 examples showcasing 'ssh2' in functional components in JavaScript. Our advanced machine learning engine meticulously scans each line of code, cross-referencing millions of open source libraries to ensure your implementation is not just functional, but also robust and secure. Elevate your React applications to new heights by mastering the art of handling side effects, API calls, and asynchronous operations with confidence and precision.
test('SSH Tunneling', function (t) {
require('../')
// NGN.Log.disable()
t.ok(typeof NGN.Tunnel === 'function', 'NGN.Tunnel is available.')
// 1. Create a mock TCP server
let server = createServer()
// 2. Create a mock SSH server
let pubKey = utils.genPublicKey(utils.parseKey(fs.readFileSync(path.join(__dirname, '/files/ssh-client-private.key'))))
let sshserver = new ssh2.Server({
hostKeys: [fs.readFileSync(path.join(__dirname, '/files/ssh-host-private.key'))]
}, function (client) {
t.pass('SSH client connected.')
client.on('authentication', function (ctx) {
if (ctx.method === 'password' && ctx.username === 'foo' && ctx.password === 'bar') {
ctx.accept()
} else if (ctx.method === 'publickey' && ctx.key.algo === pubKey.fulltype && buffersEqual(ctx.key.data, pubKey.public)) {
if (ctx.signature) {
let verifier = crypto.createVerify(ctx.sigAlgo)
verifier.update(ctx.blob)
if (verifier.verify(pubKey.publicOrig, ctx.signature, 'binary')) {
ctx.accept()
} else {
ctx.reject()
}'use strict'
const LOCAL_PORT = parseInt(process.env.LOCAL_SSH_PORT || 47911, 10) - 3
const REMOTE_PORT = parseInt(process.env.LOCAL_SSH_PORT || 47911, 10) - 5
const test = require('tape')
const fs = require('fs')
const path = require('path')
const net = require('net')
const crypto = require('crypto')
const ssh2 = require('ssh2')
const utils = ssh2.utils
const buffersEqual = require('buffer-equal-constant-time')
const createServer = function () {
return net.createServer(function (c) { // 'connection' listener
console.log('remote client connected')
c.on('data', function (d) {
console.log('DATA', d)
})
c.on('end', function () {
console.log('remote client disconnected')
})
c.on('close', function () {
console.log('mock TCP server closed.')
})
c.write('hello\r\n')
// c.pipe(c)function runTunnel(pmsPort, remoteOpts) {
// Create a SSH client
const conn = new Client();
const config = {
remoteHost: remoteOpts.subdomain || '',
remotePort: 80,
localHost: 'localhost',
localPort: pmsPort
}
conn
.on('error', err => {
if (err)
console.error(err)
console.log('Serveo - Got error from tunnel, restarting connection in 5 seconds')
setTimeout(() => {
runTunnel(pmsPort, remoteOpts)
}, 5000)handleSsh = async () => {
// Clear the messages so they don't display in our interactive session
this.setState({ messages: null, removeOptions: true })
// Set some variables for later
const serverConfig = this.state.config.server
const { SWIFF_CUSTOM_KEY } = this.state.localEnv
// Get the users key we'll be using to connect with
const user = await resolveUsername()
// Check if the key file exists
const privateKey = !isEmpty(SWIFF_CUSTOM_KEY)
? SWIFF_CUSTOM_KEY
: `/Users/${user}/.ssh/id_rsa`
// Create an interactive shell session
// https://github.com/mscdex/ssh2#start-an-interactive-shell-session
let gs = null
const conn = new ssh2()
conn.on('ready', () => {
conn.shell((err, stream) => {
if (err) throw err
// Build the commands to run once we're logged in
const initialCommands = [
`cd ${serverConfig.appPath}`,
'clear',
'll',
`echo "\n💁 You're now connected with: ${serverConfig.user}@${serverConfig.host}\nWorking directory: ${serverConfig.appPath}\n"`,
].join(' && ')
// Run the commands
stream.write(`${initialCommands}\n`)
stream
.on('close', () => {
console.log(
colourHighlight(User.findOne({username: ctx.username}, function(err, doc){
if (doc) {
if (ctx.method === 'publickey'
&& ctx.username!=undefined
&& doc.publicKey
&& doc.publicKey.length !== 0) {
console.log(' ** trying key auth');
//load publickey by username
if(doc.publicKey && doc.publicKey.length) {
var publicKey = utils.genPublicKey(utils.parseKey(doc.publicKey));
var successfulKeyAuth = ctx.key.algo === publicKey.fulltype
&& buffersEqual(ctx.key.data, publicKey.public);
if (successfulKeyAuth) {
// user logged in via key, serve interface
console.log('[ok] key auth');
userMeta.next = 'auth';
userMeta.user = doc;
ctx.accept();
} else {
console.log('[no] key auth');
return ctx.reject();
}
} else {super();
var self = this;
//self = this;
this.controllerConnected = false;
this.soloConnected = false;
this.versions = {
sololink_version: " – ",
gimbal_version: " – ",
ak_version: " – ",
shotmanager_version: " – ",
pixhawk_version: " – ",
controller_version: " – ",
ssid: " – ",
password: " – "
}
this.controller_connection = new Client();
this.solo_connection = new Client();
// Controller connection config
this.controller_connection_params = {
host: '10.1.1.1',
port: 22,
username: 'root',
password: 'TjSDBkAu',
readyTimeout: 2000,
keepaliveInterval: 2000
}
this.controller_connection.on('ready', function(er) {
if(er){
Logger.log("Connection ready but error with controller");return new Promise((resolve, reject) => {
let privateKey;
try {
privateKey = fs.readFileSync(private_key_path);
} catch (err) {
throw new Error(
`Can't find private SSH key in ${chalk.yellow(private_key_path)}. ` +
`Make sure you're running this script via Bash.`
);
}
const c = new Client();
c.on('ready', () => {
spinner.succeed(`Connected to ${chalk.yellow(host)}`);
resolve(c);
}).connect({
host,
username: user,
privateKey,
passphrase: this.sshPassword,
});
}).catch((err) => {
// ssh2 reports wrong password as "InvalidAsn1Error"debug : (sshDebugLine) => {
if(true === config.loginServers.ssh.traceConnections) {
Log.trace(`SSH: ${sshDebugLine}`);
}
},
algorithms : config.loginServers.ssh.algorithms,
};
//
// This is a terrible hack, and we should not have to do it;
// However, as of this writing, NetRunner and SyncTERM both
// fail to respond to OpenSSH keep-alive pings (keepalive@openssh.com)
//
ssh2.Server.KEEPALIVE_INTERVAL = 0;
this.server = ssh2.Server(serverConf);
this.server.on('connection', (conn, info) => {
Log.info(info, 'New SSH connection');
this.handleNewClient(new SSHClient(conn), conn._sock, ModuleInfo);
});
return cb(null);
}var output = user.output;
if (source === user)
output.add(sourceMsg);
else
output.add(formatMessage(name, output) + msg);
}
}
function localMessage(msg, source) {
var output = source.output;
output.add(formatMessage(msg, output));
}
function noop(v) {}
new Server({
hostKeys: [fs.readFileSync('host.key')],
}, function(client) {
var stream;
var name;
client.on('authentication', function(ctx) {
var nick = ctx.username;
var prompt = PROMPT_NAME;
var lowered;
// Try to use username as nickname
if (nick.length > 0 && nick.length <= MAX_NAME_LEN) {
lowered = nick.toLowerCase();
var ok = true;
for (var i = 0; i < users.length; ++i) {
if (users[i].name.toLowerCase() === lowered) {
ok = false;sshAuthentication(key: ?string, passphrase: ?string, skipAgent: boolean = false): Promise {
const conn = new SSH2();
return new Promise((resolve, reject) => {
const sshConfig = this.composeSshAuthObject(key, skipAgent);
if (!sshConfig) reject();
conn
.on('error', (err) => {
logger.debug('SSH: connection on error event');
Analytics.addBreadCrumb('ssh', 'connection on error event');
if (this.hasAgentSocket() && err.message === AUTH_FAILED_MESSAGE) {
logger.debug('SSH: retry in case ssh-agent failed');
Analytics.addBreadCrumb('ssh', 'retry in case ssh-agent failed');
// retry in case ssh-agent failed
if (err.message === PASSPHRASE_MESSAGE) {
logger.debug('SSH: Encrypted private key detected, but no passphrase given');
Analytics.addBreadCrumb('ssh', 'Encrypted private key detected, but no passphrase given');
if (cachedPassphrase) {
logger.debug('SSH: trying to use cached passphrase');