CasperSecurity
| Current Path : /bin/X11/ |
|
|
| Current File : //bin/X11/wscat |
#!/usr/bin/env node
'use strict';
const EventEmitter = require('events');
const fs = require('fs');
const HttpsProxyAgent = require('https-proxy-agent');
const program = require('commander');
const read = require('read');
const readline = require('readline');
const tty = require('tty');
const WebSocket = require('ws');
/**
* InputReader - processes console input.
*
* @extends EventEmitter
*/
class Console extends EventEmitter {
constructor() {
super();
this.stdin = process.stdin;
this.stdout = process.stdout;
this.stderr = process.stderr;
this.readlineInterface = readline.createInterface(this.stdin, this.stdout);
this.readlineInterface
.on('line', (data) => {
this.emit('line', data);
})
.on('close', () => {
this.emit('close');
});
this._resetInput = () => {
this.clear();
};
}
static get Colors() {
return {
Red: '\u001b[31m',
Green: '\u001b[32m',
Yellow: '\u001b[33m',
Blue: '\u001b[34m',
Default: '\u001b[39m'
};
}
static get Types() {
return {
Incoming: '< ',
Control: '',
Error: 'error: '
};
}
prompt() {
this.readlineInterface.prompt(true);
}
print(type, msg, color) {
if (tty.isatty(1)) {
this.clear();
if (programOptions.execute) color = type = '';
else if (!programOptions.color) color = '';
this.stdout.write(color + type + msg + Console.Colors.Default + '\n');
this.prompt();
} else if (type === Console.Types.Incoming) {
this.stdout.write(msg + '\n');
} else if (type === Console.Types.Error) {
this.stderr.write(type + msg + '\n');
} else {
// is a control message and we're not in a tty... drop it.
}
}
clear() {
if (tty.isatty(1)) {
this.stdout.write('\r\u001b[2K\u001b[3D');
}
}
pause() {
this.stdin.on('keypress', this._resetInput);
}
resume() {
this.stdin.removeListener('keypress', this._resetInput);
}
}
function collect(val, memo) {
memo.push(val);
return memo;
}
function noop() {}
/**
* The actual application
*/
const version = require('../package.json').version;
program
.version(version)
.usage('[options] (--listen <port> | --connect <url>)')
.option(
'--auth <username:password>',
'add basic HTTP authentication header (--connect only)'
)
.option('--ca <ca>', 'specify a Certificate Authority (--connect only)')
.option('--cert <cert>', 'specify a Client SSL Certificate (--connect only)')
.option('--host <host>', 'optional host')
.option(
'--key <key>',
"specify a Client SSL Certificate's key (--connect only)"
)
.option(
'--max-redirects [num]',
'maximum number of redirects allowed (--connect only)',
parseInt,
10
)
.option('--no-color', 'run without color')
.option(
'--passphrase [passphrase]',
"specify a Client SSL Certificate Key's passphrase (--connect only). " +
"If you don't provide a value, it will be prompted for"
)
.option(
'--proxy <[protocol://]host[:port]>',
'connect via a proxy. Proxy must support CONNECT method'
)
.option(
'--slash',
'enable slash commands for control frames (/ping, /pong, /close ' +
'[code [, reason]])'
)
.option('-c, --connect <url>', 'connect to a WebSocket server')
.option(
'-H, --header <header:value>',
'set an HTTP header. Repeat to set multiple (--connect only)',
collect,
[]
)
.option('-L, --location', 'follow redirects (--connect only)')
.option('-l, --listen <port>', 'listen on port')
.option('-n, --no-check', 'do not check for unauthorized certificates')
.option('-o, --origin <origin>', 'optional origin')
.option('-p, --protocol <version>', 'optional protocol version')
.option(
'-P, --show-ping-pong',
'print a notification when a ping or pong is received'
)
.option('-s, --subprotocol <protocol>', 'optional subprotocol', collect, [])
.option('-w, --wait <seconds>', 'wait given seconds after executing command')
.option('-x, --execute <command>', 'execute command after connecting')
.parse(process.argv);
const programOptions = program.opts();
if (programOptions.listen && programOptions.connect) {
console.error('\u001b[33merror: Use either --listen or --connect\u001b[39m');
process.exit(-1);
}
if (programOptions.listen) {
const wsConsole = new Console();
wsConsole.pause();
let ws = null;
const wss = new WebSocket.Server({ port: programOptions.listen }, () => {
wsConsole.print(
Console.Types.Control,
`Listening on port ${programOptions.listen} (press CTRL+C to quit)`,
Console.Colors.Green
);
wsConsole.clear();
});
wsConsole.on('close', () => {
if (ws) ws.close();
process.exit(0);
});
wsConsole.on('line', (data) => {
if (ws) {
ws.send(data);
wsConsole.prompt();
}
});
wss.on('connection', (newClient) => {
if (ws) return newClient.terminate();
ws = newClient;
wsConsole.resume();
wsConsole.prompt();
wsConsole.print(
Console.Types.Control,
'Client connected',
Console.Colors.Green
);
ws.on('close', (code, reason) => {
wsConsole.print(
Console.Types.Control,
`Disconnected (code: ${code}, reason: "${reason}")`,
Console.Colors.Green
);
wsConsole.clear();
wsConsole.pause();
ws = null;
});
ws.on('error', (err) => {
wsConsole.print(Console.Types.Error, err.message, Console.Colors.Yellow);
});
ws.on('message', (data) => {
wsConsole.print(Console.Types.Incoming, data, Console.Colors.Blue);
});
});
wss.on('error', (err) => {
wsConsole.print(Console.Types.Error, err.message, Console.Colors.Yellow);
process.exit(-1);
});
} else if (programOptions.connect) {
const options = {};
const cont = () => {
const wsConsole = new Console();
const headers = programOptions.header.reduce((acc, cur) => {
const i = cur.indexOf(':');
const key = cur.slice(0, i);
const value = cur.slice(i + 1);
acc[key] = value;
return acc;
}, {});
if (programOptions.auth) {
headers.Authorization =
'Basic ' + Buffer.from(programOptions.auth).toString('base64');
}
if (programOptions.host) headers.Host = programOptions.host;
if (programOptions.protocol)
options.protocolVersion = +programOptions.protocol;
if (programOptions.origin) options.origin = programOptions.origin;
if (!programOptions.check)
options.rejectUnauthorized = programOptions.check;
if (programOptions.ca) options.ca = fs.readFileSync(programOptions.ca);
if (programOptions.cert)
options.cert = fs.readFileSync(programOptions.cert);
if (programOptions.key) options.key = fs.readFileSync(programOptions.key);
if (programOptions.proxy)
options.agent = new HttpsProxyAgent(programOptions.proxy);
if (programOptions.location) options.followRedirects = true;
options.maxRedirects = programOptions.maxRedirects;
options.headers = headers;
let connectUrl = programOptions.connect;
if (!connectUrl.match(/\w+:\/\/.*$/i)) {
connectUrl = `ws://${connectUrl}`;
}
const ws = new WebSocket(connectUrl, programOptions.subprotocol, options);
ws.on('open', () => {
if (programOptions.execute) {
ws.send(programOptions.execute);
setTimeout(
() => {
ws.close();
},
programOptions.wait ? programOptions.wait * 1000 : 2000
);
} else {
wsConsole.print(
Console.Types.Control,
'Connected (press CTRL+C to quit)',
Console.Colors.Green
);
wsConsole.on('line', (data) => {
if (programOptions.slash && data[0] === '/') {
const toks = data.split(/\s+/);
switch (toks[0].substr(1)) {
case 'ping':
ws.ping(noop);
break;
case 'pong':
ws.pong(noop);
break;
case 'close': {
let closeStatusCode = 1000;
let closeReason = '';
if (toks.length >= 2) {
closeStatusCode = parseInt(toks[1]);
}
if (toks.length >= 3) {
closeReason = toks.slice(2).join(' ');
}
if (closeReason.length > 0) {
ws.close(closeStatusCode, closeReason);
} else {
ws.close(closeStatusCode);
}
break;
}
default:
wsConsole.print(
Console.Types.Error,
'Unrecognized slash command.',
Console.Colors.Yellow
);
}
} else {
ws.send(data);
}
wsConsole.prompt();
});
}
});
ws.on('close', (code, reason) => {
if (!programOptions.execute) {
wsConsole.print(
Console.Types.Control,
`Disconnected (code: ${code}, reason: "${reason}")`,
Console.Colors.Green
);
}
wsConsole.clear();
process.exit();
});
ws.on('error', (err) => {
wsConsole.print(Console.Types.Error, err.message, Console.Colors.Yellow);
process.exit(-1);
});
ws.on('message', (data) => {
wsConsole.print(Console.Types.Incoming, data, Console.Colors.Blue);
});
ws.on('ping', () => {
if (programOptions.showPingPong) {
wsConsole.print(
Console.Types.Incoming,
'Received ping',
Console.Colors.Blue
);
}
});
ws.on('pong', () => {
if (programOptions.showPingPong) {
wsConsole.print(
Console.Types.Incoming,
'Received pong',
Console.Colors.Blue
);
}
});
wsConsole.on('close', () => {
ws.close();
process.exit();
});
};
if (programOptions.passphrase === true) {
read(
{
prompt: 'Passphrase: ',
silent: true,
replace: '*'
},
(err, passphrase) => {
options.passphrase = passphrase;
cont();
}
);
} else if (typeof programOptions.passphrase === 'string') {
options.passphrase = programOptions.passphrase;
cont();
} else {
cont();
}
} else {
program.help();
}