butlerx
4 years ago
67 changed files with 2210 additions and 1762 deletions
File diff suppressed because it is too large
@ -0,0 +1,25 @@ |
|||||
|
[package] |
||||
|
name = "wetty" |
||||
|
version = "2.1.0" |
||||
|
authors = ["butlerx <butlerx@notthe.cloud>"] |
||||
|
edition = "2018" |
||||
|
description = "WeTTY = Web + TTY. Terminal access in browser over http/https" |
||||
|
repository = "https://github.com/butlerx/wetty" |
||||
|
license = "MIT" |
||||
|
readme = "README.md" |
||||
|
include = ["src/**/*", "Cargo.toml", "configs/**/*.yaml", "client/**/*"] |
||||
|
|
||||
|
[dependencies] |
||||
|
futures = "0.3" |
||||
|
handlebars = "3.5" |
||||
|
lazy_static = "1.4.0" |
||||
|
log = "0.4" |
||||
|
prometheus = { version = "0.11.0", features = ["process"] } |
||||
|
pty = "0.2" |
||||
|
serde = { version = "1.0", features = ["derive"] } |
||||
|
serde_json = "1.0" |
||||
|
stderrlog = "0.4.3" |
||||
|
structopt = "0.3.21" |
||||
|
tokio = { version = "1", features = ["full"] } |
||||
|
toml = "0.5" |
||||
|
warp = "0.3" |
||||
|
Before Width: | Height: | Size: 165 KiB After Width: | Height: | Size: 165 KiB |
@ -1,16 +0,0 @@ |
|||||
import { createInterface } from 'readline'; |
|
||||
|
|
||||
ask('Enter your username'); |
|
||||
|
|
||||
function ask(question: string): Promise<string> { |
|
||||
const rlp = createInterface({ |
|
||||
input: process.stdin, |
|
||||
output: process.stdout, |
|
||||
}); |
|
||||
return new Promise(resolve => { |
|
||||
rlp.question(`${question}: `, answer => { |
|
||||
rlp.close(); |
|
||||
resolve(answer); |
|
||||
}); |
|
||||
}); |
|
||||
} |
|
||||
@ -0,0 +1,114 @@ |
|||||
|
extern crate toml; |
||||
|
|
||||
|
use serde::{Deserialize, Serialize}; |
||||
|
use std::{ |
||||
|
env, fs, |
||||
|
net::{IpAddr, Ipv4Addr, SocketAddr}, |
||||
|
path::PathBuf, |
||||
|
str::FromStr, |
||||
|
}; |
||||
|
use toml::de::Error; |
||||
|
|
||||
|
fn get_env<T: FromStr>(key: &str, default: T) -> T { |
||||
|
match env::var(key) { |
||||
|
Ok(val) => val.parse::<T>().unwrap_or(default), |
||||
|
Err(_) => default, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#[derive(Clone, Deserialize, Debug, Serialize)] |
||||
|
pub struct SSH { |
||||
|
/// Server to ssh to
|
||||
|
pub host: String, |
||||
|
/// default user to use when ssh-ing
|
||||
|
pub user: String, |
||||
|
/// shh authentication, method. Defaults to "password", you can use "publickey,password" instead'
|
||||
|
pub auth: String, |
||||
|
/// Password to use when sshing
|
||||
|
pub pass: Option<String>, |
||||
|
/// path to an optional client private key, connection will be password-less and insecure!
|
||||
|
pub key: Option<String>, |
||||
|
/// Port to ssh to
|
||||
|
pub port: i16, |
||||
|
/// ssh knownHosts file to use
|
||||
|
pub known_hosts: String, |
||||
|
/// alternative ssh configuration file, see "-F" option in ssh(1)
|
||||
|
pub config: Option<String>, |
||||
|
} |
||||
|
impl Default for SSH { |
||||
|
fn default() -> Self { |
||||
|
SSH { |
||||
|
user: get_env("SSHUSER", "".to_string()), |
||||
|
host: get_env("SSHHOST", "localhost".to_string()), |
||||
|
auth: get_env("SSHAUTH", "password".to_string()), |
||||
|
port: get_env("SSHPORT", 22), |
||||
|
known_hosts: get_env("KNOWNHOSTS", "/dev/null".to_string()), |
||||
|
config: None, |
||||
|
key: None, |
||||
|
pass: None, |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#[derive(Clone, Deserialize, Debug, Serialize)] |
||||
|
pub struct Server { |
||||
|
/// URL base to serve resources from
|
||||
|
pub base: String, |
||||
|
/// address to listen on including the port eg: 0.0.0.0:3000
|
||||
|
pub address: SocketAddr, |
||||
|
// Page title
|
||||
|
pub title: String, |
||||
|
/// allow wetty to be embedded in an iframe
|
||||
|
pub allow_iframe: bool, |
||||
|
} |
||||
|
impl Default for Server { |
||||
|
fn default() -> Self { |
||||
|
Server { |
||||
|
base: get_env("BASE", "wetty".to_string()), |
||||
|
address: get_env( |
||||
|
"ADDRESS", |
||||
|
SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 3030), |
||||
|
), |
||||
|
title: get_env("TITLE", "WeTTy - The Web Terminal Emulator".to_string()), |
||||
|
allow_iframe: false, |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
fn default_command() -> String { |
||||
|
get_env("COMMAND", "login".to_string()) |
||||
|
} |
||||
|
|
||||
|
fn force_ssh() -> bool { |
||||
|
get_env("FORCESSH", false) |
||||
|
} |
||||
|
|
||||
|
#[derive(Clone, Deserialize, Debug, Serialize)] |
||||
|
pub struct Config { |
||||
|
#[serde(default)] |
||||
|
pub server: Server, |
||||
|
#[serde(default)] |
||||
|
pub ssh: SSH, |
||||
|
#[serde(default = "force_ssh")] |
||||
|
/// Force sshing to local machine over login if running as root
|
||||
|
pub force_ssh: bool, |
||||
|
#[serde(default = "default_command")] |
||||
|
/// Command to run on server. Login will use ssh if connecting to different server
|
||||
|
pub default_command: String, |
||||
|
} |
||||
|
|
||||
|
impl Config { |
||||
|
pub fn from_file(filename: &PathBuf) -> Result<Self, Error> { |
||||
|
debug!("loading config; path={:?}", filename); |
||||
|
let contents = fs::read_to_string(filename).expect("Something went wrong reading the file"); |
||||
|
toml::from_str(&*contents) |
||||
|
} |
||||
|
|
||||
|
pub fn print_default() { |
||||
|
let conf: Config = toml::from_str("").expect("failed to set default"); |
||||
|
println!( |
||||
|
"{}", |
||||
|
toml::Value::try_from(conf).expect("failed to Serialize conf to toml") |
||||
|
) |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,85 @@ |
|||||
|
#[macro_use] extern crate lazy_static; |
||||
|
#[macro_use] extern crate log; |
||||
|
#[macro_use] extern crate prometheus; |
||||
|
extern crate pty; |
||||
|
extern crate stderrlog; |
||||
|
|
||||
|
mod config; |
||||
|
mod middlewares; |
||||
|
mod routes; |
||||
|
|
||||
|
use config::{Server,Config}; |
||||
|
use handlebars::Handlebars; |
||||
|
use std::sync::Arc; |
||||
|
use std::{io::Result, path::PathBuf}; |
||||
|
use structopt::StructOpt; |
||||
|
use warp::Filter; |
||||
|
|
||||
|
/// WeTTy server
|
||||
|
#[derive(Debug, StructOpt)] |
||||
|
struct Args { |
||||
|
/// Configuration file config path
|
||||
|
#[structopt(short, long, parse(from_os_str), default_value = "configs/config.toml")] |
||||
|
config: PathBuf, |
||||
|
/// Silence all output
|
||||
|
#[structopt(short, long)] |
||||
|
quiet: bool, |
||||
|
/// Increase message verbosity
|
||||
|
#[structopt(short, long, parse(from_occurrences))] |
||||
|
verbose: usize, |
||||
|
/// Print default config
|
||||
|
#[structopt(short, long)] |
||||
|
print: bool, |
||||
|
} |
||||
|
|
||||
|
#[tokio::main] |
||||
|
async fn main() -> Result<()> { |
||||
|
let args = Args::from_args(); |
||||
|
if args.print { |
||||
|
return Ok(Config::print_default()); |
||||
|
} |
||||
|
|
||||
|
stderrlog::new() |
||||
|
.module(module_path!()) |
||||
|
.quiet(args.quiet) |
||||
|
.verbosity(args.verbose) |
||||
|
.timestamp(stderrlog::Timestamp::Second) |
||||
|
.init() |
||||
|
.unwrap(); |
||||
|
|
||||
|
let log = warp::log("wetty"); |
||||
|
let metrics = warp::log::custom(middlewares::metrics); |
||||
|
|
||||
|
let conf = Config::from_file(&args.config)?; |
||||
|
info!("config loaded; path={:?}", args.config); |
||||
|
|
||||
|
let metrics_route = warp::path!("metrics").and_then(routes::metrics::handler).with(metrics); |
||||
|
let health = warp::path!("health").and_then(routes::health::handler).with(metrics); |
||||
|
|
||||
|
let base = warp::path(conf.server.base); |
||||
|
let socket = base.clone().and(warp::path!("socket.io")) |
||||
|
.and(warp::ws()) |
||||
|
.and_then(routes::socket::handler) |
||||
|
.with(metrics); |
||||
|
|
||||
|
let hb = Arc::new(Handlebars::new()); |
||||
|
let client = base.clone().or(base.clone().and(warp::path!("ssh" / String ))) |
||||
|
.and(||warp::any().map(|| conf.server.clone())) |
||||
|
.map(move |_user, config: Server|routes::html::render(hb.clone(), config.title,config.base)) |
||||
|
.with(metrics); |
||||
|
|
||||
|
let routes = warp::fs::dir("client/build") |
||||
|
.or(client) |
||||
|
.or(metrics_route) |
||||
|
.or(health) |
||||
|
.or(socket) |
||||
|
.with(log); |
||||
|
|
||||
|
info!( |
||||
|
"Server started; address={}", |
||||
|
conf.server.address, |
||||
|
); |
||||
|
warp::serve(routes).run(conf.server.address).await; |
||||
|
info!("Server shutting down"); |
||||
|
Ok(()) |
||||
|
} |
||||
@ -1,114 +0,0 @@ |
|||||
#!/usr/bin/env node |
|
||||
|
|
||||
/** |
|
||||
* Create WeTTY server |
|
||||
* @module WeTTy |
|
||||
* |
|
||||
* This is the cli Interface for wetty. |
|
||||
*/ |
|
||||
import yargs from 'yargs'; |
|
||||
import { logger } from './shared/logger.js'; |
|
||||
import { start } from './server.js'; |
|
||||
import { loadConfigFile, mergeCliConf } from './shared/config.js'; |
|
||||
|
|
||||
const opts = yargs |
|
||||
.options('conf', { |
|
||||
type: 'string', |
|
||||
description: 'config file to load config from', |
|
||||
}) |
|
||||
.option('ssl-key', { |
|
||||
type: 'string', |
|
||||
description: 'path to SSL key', |
|
||||
}) |
|
||||
.option('ssl-cert', { |
|
||||
type: 'string', |
|
||||
description: 'path to SSL certificate', |
|
||||
}) |
|
||||
.option('ssh-host', { |
|
||||
description: 'ssh server host', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('ssh-port', { |
|
||||
description: 'ssh server port', |
|
||||
type: 'number', |
|
||||
}) |
|
||||
.option('ssh-user', { |
|
||||
description: 'ssh user', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('title', { |
|
||||
description: 'window title', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('ssh-auth', { |
|
||||
description: |
|
||||
'defaults to "password", you can use "publickey,password" instead', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('ssh-pass', { |
|
||||
description: 'ssh password', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('ssh-key', { |
|
||||
demand: false, |
|
||||
description: |
|
||||
'path to an optional client private key (connection will be password-less and insecure!)', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('ssh-config', { |
|
||||
description: 'Specifies an alternative ssh configuration file. For further details see "-F" option in ssh(1)', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('force-ssh', { |
|
||||
description: 'Connecting through ssh even if running as root', |
|
||||
type: 'boolean', |
|
||||
}) |
|
||||
.option('known-hosts', { |
|
||||
description: 'path to known hosts file', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('base', { |
|
||||
alias: 'b', |
|
||||
description: 'base path to wetty', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('port', { |
|
||||
alias: 'p', |
|
||||
description: 'wetty listen port', |
|
||||
type: 'number', |
|
||||
}) |
|
||||
.option('host', { |
|
||||
description: 'wetty listen host', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('command', { |
|
||||
alias: 'c', |
|
||||
description: 'command to run in shell', |
|
||||
type: 'string', |
|
||||
}) |
|
||||
.option('allow-iframe', { |
|
||||
description: |
|
||||
'Allow wetty to be embedded in an iframe, defaults to allowing same origin', |
|
||||
type: 'boolean', |
|
||||
}) |
|
||||
.option('help', { |
|
||||
alias: 'h', |
|
||||
type: 'boolean', |
|
||||
description: 'Print help message', |
|
||||
}) |
|
||||
.boolean('allow_discovery').argv; |
|
||||
|
|
||||
if (!opts.help) { |
|
||||
loadConfigFile(opts.conf) |
|
||||
.then(config => mergeCliConf(opts, config)) |
|
||||
.then(conf => |
|
||||
start(conf.ssh, conf.server, conf.command, conf.forceSSH, conf.ssl), |
|
||||
) |
|
||||
.catch((err: Error) => { |
|
||||
logger.error(err); |
|
||||
process.exitCode = 1; |
|
||||
}); |
|
||||
} else { |
|
||||
yargs.showHelp(); |
|
||||
process.exitCode = 0; |
|
||||
} |
|
||||
@ -0,0 +1,48 @@ |
|||||
|
use prometheus::{HistogramVec, IntCounter, IntCounterVec}; |
||||
|
use warp::filters::log::Info; |
||||
|
|
||||
|
lazy_static! { |
||||
|
static ref INCOMING_REQUESTS: IntCounter = |
||||
|
register_int_counter!("incoming_requests", "Incoming Requests") |
||||
|
.expect("metric can be created"); |
||||
|
static ref RESPONSE_CODE_COLLECTOR: IntCounterVec = register_int_counter_vec!( |
||||
|
opts!("response_code", "Response Codes"), |
||||
|
&["method", "path", "status", "type"] |
||||
|
) |
||||
|
.expect("metric can be created"); |
||||
|
static ref RESPONSE_TIME_COLLECTOR: HistogramVec = register_histogram_vec!( |
||||
|
histogram_opts!("response_time", "Response Times"), |
||||
|
&["method", "path"] |
||||
|
) |
||||
|
.expect("metric can be created"); |
||||
|
} |
||||
|
|
||||
|
pub fn metrics(info: Info) { |
||||
|
let (method, path, status_code) = ( |
||||
|
info.method().to_string(), |
||||
|
info.path(), |
||||
|
info.status().as_u16(), |
||||
|
); |
||||
|
INCOMING_REQUESTS.inc(); |
||||
|
RESPONSE_TIME_COLLECTOR |
||||
|
.with_label_values(&[&method, &path]) |
||||
|
.observe(info.elapsed().as_secs_f64()); |
||||
|
match status_code { |
||||
|
500..=599 => RESPONSE_CODE_COLLECTOR |
||||
|
.with_label_values(&[&method, &path, &status_code.to_string(), "500"]) |
||||
|
.inc(), |
||||
|
400..=499 => RESPONSE_CODE_COLLECTOR |
||||
|
.with_label_values(&[&method, &path, &status_code.to_string(), "400"]) |
||||
|
.inc(), |
||||
|
300..=399 => RESPONSE_CODE_COLLECTOR |
||||
|
.with_label_values(&[&method, &path, &status_code.to_string(), "300"]) |
||||
|
.inc(), |
||||
|
200..=299 => RESPONSE_CODE_COLLECTOR |
||||
|
.with_label_values(&[&method, &path, &status_code.to_string(), "200"]) |
||||
|
.inc(), |
||||
|
100..=199 => RESPONSE_CODE_COLLECTOR |
||||
|
.with_label_values(&[&method, &path, &status_code.to_string(), "100"]) |
||||
|
.inc(), |
||||
|
_ => (), |
||||
|
}; |
||||
|
} |
||||
@ -0,0 +1,6 @@ |
|||||
|
use crate::routes::Responce; |
||||
|
use warp::{http::StatusCode, Reply}; |
||||
|
|
||||
|
pub async fn handler() -> Responce<impl Reply> { |
||||
|
Ok(StatusCode::OK) |
||||
|
} |
||||
@ -0,0 +1,50 @@ |
|||||
|
use handlebars::Handlebars; |
||||
|
use serde_json::json; |
||||
|
use std::sync::Arc; |
||||
|
use warp::Reply; |
||||
|
|
||||
|
pub fn render(hbs: Arc<Handlebars>, title: String, base: String) -> impl Reply { |
||||
|
let value = json!({ |
||||
|
"title": title, |
||||
|
"base": base, |
||||
|
"js": ["wetty"], |
||||
|
"css": ["styles", "options", "overlay", "terminal"] |
||||
|
}); |
||||
|
warp::reply::html( |
||||
|
hbs.render_template(INDEX_HTML, &value) |
||||
|
.unwrap_or_else(|err| err.to_string()), |
||||
|
) |
||||
|
} |
||||
|
|
||||
|
pub static INDEX_HTML: &str = r#"<!DOCTYPE html> |
||||
|
<html lang="en"> |
||||
|
<head> |
||||
|
<meta charset="utf8"> |
||||
|
<meta http-equiv="X-UA-Compatible" content="IE=edge"> |
||||
|
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no"> |
||||
|
<link rel="icon" type="image/x-icon" href="{{base}}/favicon.ico"> |
||||
|
<title>{{title}}</title> |
||||
|
{{#each css}} |
||||
|
<link rel="stylesheet" href="{{base}}/assets/css/{{this}}.css" /> |
||||
|
{{/each}} |
||||
|
</head> |
||||
|
<body> |
||||
|
<div id="overlay"> |
||||
|
<div class="error"> |
||||
|
<div id="msg"></div> |
||||
|
<input type="button" onclick="location.reload();" value="reconnect" /> |
||||
|
</div> |
||||
|
</div> |
||||
|
<div id="options"> |
||||
|
<a class="toggler" |
||||
|
href="\#" |
||||
|
alt="Toggle options" |
||||
|
><i class="fas fa-cogs"></i></a> |
||||
|
<textarea class="editor"></textarea> |
||||
|
</div> |
||||
|
<div id="terminal"></div> |
||||
|
{{#each js}} |
||||
|
<script type="module" src="{{base}}/client/{{this}}.js"></script> |
||||
|
{{/each}} |
||||
|
</body> |
||||
|
</html>"#; |
||||
@ -0,0 +1,20 @@ |
|||||
|
use crate::routes::Responce; |
||||
|
use prometheus::{self, Encoder}; |
||||
|
use warp::Reply; |
||||
|
|
||||
|
pub async fn handler() -> Responce<impl Reply> { |
||||
|
let encoder = prometheus::TextEncoder::new(); |
||||
|
let mut buffer = Vec::new(); |
||||
|
if let Err(e) = encoder.encode(&prometheus::gather(), &mut buffer) { |
||||
|
error!("could not encode prometheus metrics; error={}", e); |
||||
|
}; |
||||
|
let res = match String::from_utf8(buffer.clone()) { |
||||
|
Ok(v) => v, |
||||
|
Err(e) => { |
||||
|
error!("prometheus metrics could not be from_utf8'd; error={}", e); |
||||
|
String::default() |
||||
|
} |
||||
|
}; |
||||
|
buffer.clear(); |
||||
|
Ok(res) |
||||
|
} |
||||
@ -0,0 +1,8 @@ |
|||||
|
use warp::Rejection; |
||||
|
|
||||
|
pub mod health; |
||||
|
pub mod html; |
||||
|
pub mod metrics; |
||||
|
pub mod socket; |
||||
|
|
||||
|
type Responce<T> = std::result::Result<T, Rejection>; |
||||
@ -0,0 +1,45 @@ |
|||||
|
use crate::routes::Responce; |
||||
|
use futures::{SinkExt, StreamExt}; |
||||
|
use prometheus::IntGauge; |
||||
|
use serde::{Deserialize, Serialize}; |
||||
|
use warp::{ |
||||
|
ws::{Message, WebSocket, Ws}, |
||||
|
Reply, |
||||
|
}; |
||||
|
|
||||
|
lazy_static! { |
||||
|
static ref CONNECTED_CLIENTS: IntGauge = register_int_gauge!("connected_clients", "Connected Clients").expect("metric can be created"); |
||||
|
} |
||||
|
|
||||
|
pub async fn handler(ws: Ws) -> Responce<impl Reply> { |
||||
|
Ok(ws.on_upgrade(move |socket| handle_connection(socket, ))) |
||||
|
} |
||||
|
|
||||
|
async fn handle_connection(ws: WebSocket) { |
||||
|
let (mut sender, mut rcv) = ws.split(); |
||||
|
|
||||
|
info!("Connection Opened;"); |
||||
|
CONNECTED_CLIENTS.inc(); |
||||
|
|
||||
|
while let Some(event) = rcv.next().await { |
||||
|
match event { |
||||
|
Ok(msg) => { |
||||
|
debug!( |
||||
|
"Message recieved from websocket; msg={:?}", |
||||
|
msg, ); |
||||
|
if let Ok(txt) = msg.to_str() { |
||||
|
//handle message
|
||||
|
} |
||||
|
} |
||||
|
Err(err) => { |
||||
|
error!( |
||||
|
"websocket error; error={}", |
||||
|
err |
||||
|
); |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
info!("Connection Dropped;"); |
||||
|
CONNECTED_CLIENTS.dec(); |
||||
|
} |
||||
@ -1,73 +0,0 @@ |
|||||
/** |
|
||||
* Create WeTTY server |
|
||||
* @module WeTTy |
|
||||
*/ |
|
||||
import type SocketIO from 'socket.io'; |
|
||||
import type { SSH, SSL, Server } from './shared/interfaces.js'; |
|
||||
import { getCommand } from './server/command.js'; |
|
||||
import { logger } from './shared/logger.js'; |
|
||||
import { login } from './server/login.js'; |
|
||||
import { server } from './server/socketServer.js'; |
|
||||
import { spawn } from './server/spawn.js'; |
|
||||
import { |
|
||||
sshDefault, |
|
||||
serverDefault, |
|
||||
forceSSHDefault, |
|
||||
defaultCommand, |
|
||||
} from './shared/defaults.js'; |
|
||||
|
|
||||
/** |
|
||||
* Starts WeTTy Server |
|
||||
* @name startServer |
|
||||
* @returns Promise that resolves SocketIO server |
|
||||
*/ |
|
||||
export async function start( |
|
||||
ssh: SSH = sshDefault, |
|
||||
serverConf: Server = serverDefault, |
|
||||
command: string = defaultCommand, |
|
||||
forcessh: boolean = forceSSHDefault, |
|
||||
ssl?: SSL, |
|
||||
): Promise<SocketIO.Server> { |
|
||||
if (ssh.key) { |
|
||||
logger.warn(`!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
||||
! Password-less auth enabled using private key from ${ssh.key}. |
|
||||
! This is dangerous, anything that reaches the wetty server |
|
||||
! will be able to run remote operations without authentication. |
|
||||
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!`);
|
|
||||
} |
|
||||
|
|
||||
const io = await server(serverConf, ssl); |
|
||||
/** |
|
||||
* Wetty server connected too |
|
||||
* @fires WeTTy#connnection |
|
||||
*/ |
|
||||
io.on('connection', async (socket: SocketIO.Socket) => { |
|
||||
/** |
|
||||
* @event wetty#connection |
|
||||
* @name connection |
|
||||
*/ |
|
||||
logger.info('Connection accepted.'); |
|
||||
const [args, sshUser] = getCommand(socket, ssh, command, forcessh); |
|
||||
logger.debug('Command Generated', { |
|
||||
user: sshUser, |
|
||||
cmd: args.join(' '), |
|
||||
}); |
|
||||
|
|
||||
if (sshUser) { |
|
||||
spawn(socket, args); |
|
||||
} else { |
|
||||
try { |
|
||||
const username = await login(socket); |
|
||||
args[1] = `${username.trim()}@${args[1]}`; |
|
||||
logger.debug('Spawning term', { |
|
||||
username: username.trim(), |
|
||||
cmd: args.join(' ').trim(), |
|
||||
}); |
|
||||
spawn(socket, args); |
|
||||
} catch (error) { |
|
||||
logger.info('Disconnect signal sent', { err: error }); |
|
||||
} |
|
||||
} |
|
||||
}); |
|
||||
return io; |
|
||||
} |
|
||||
@ -1,50 +0,0 @@ |
|||||
import url from 'url'; |
|
||||
import type { Socket } from 'socket.io'; |
|
||||
import type { SSH } from '../shared/interfaces'; |
|
||||
import { address } from './command/address.js'; |
|
||||
import { loginOptions } from './command/login.js'; |
|
||||
import { sshOptions } from './command/ssh.js'; |
|
||||
|
|
||||
const localhost = (host: string): boolean => |
|
||||
process.getuid() === 0 && |
|
||||
(host === 'localhost' || host === '0.0.0.0' || host === '127.0.0.1'); |
|
||||
|
|
||||
const urlArgs = ( |
|
||||
referer: string, |
|
||||
def: { [s: string]: string }, |
|
||||
): { [s: string]: string } => |
|
||||
Object.assign(def, url.parse(referer, true).query); |
|
||||
|
|
||||
export function getCommand( |
|
||||
{ |
|
||||
request: { headers }, |
|
||||
client: { |
|
||||
conn: { remoteAddress }, |
|
||||
}, |
|
||||
}: Socket, |
|
||||
{ user, host, port, auth, pass, key, knownHosts, config }: SSH, |
|
||||
command: string, |
|
||||
forcessh: boolean, |
|
||||
): [string[], boolean] { |
|
||||
const sshAddress = address(headers, user, host); |
|
||||
const localLogin = !forcessh && localhost(host); |
|
||||
return localLogin |
|
||||
? [loginOptions(command, remoteAddress), localLogin] |
|
||||
: [ |
|
||||
sshOptions( |
|
||||
{ |
|
||||
...urlArgs(headers.referer, { |
|
||||
port: `${port}`, |
|
||||
pass: pass || '', |
|
||||
command, |
|
||||
auth, |
|
||||
knownHosts, |
|
||||
config: config || '', |
|
||||
}), |
|
||||
host: sshAddress, |
|
||||
}, |
|
||||
key, |
|
||||
), |
|
||||
user !== '' || user.includes('@') || sshAddress.includes('@'), |
|
||||
]; |
|
||||
} |
|
||||
@ -1,14 +0,0 @@ |
|||||
export function address( |
|
||||
headers: Record<string, string>, |
|
||||
user: string, |
|
||||
host: string, |
|
||||
): string { |
|
||||
// Check request-header for username
|
|
||||
const remoteUser = headers['remote-user']; |
|
||||
if (remoteUser) { |
|
||||
return `${remoteUser}@${host}`; |
|
||||
} |
|
||||
const match = headers.referer.match('.+/ssh/([^/]+)$'); |
|
||||
const fallback = user ? `${user}@${host}` : host; |
|
||||
return match ? `${match[1].split('?')[0]}@${host}` : fallback; |
|
||||
} |
|
||||
@ -1,12 +0,0 @@ |
|||||
import isUndefined from 'lodash/isUndefined.js'; |
|
||||
|
|
||||
const getRemoteAddress = (remoteAddress: string): string => |
|
||||
isUndefined(remoteAddress.split(':')[3]) |
|
||||
? 'localhost' |
|
||||
: remoteAddress.split(':')[3]; |
|
||||
|
|
||||
export function loginOptions(command: string, remoteAddress: string): string[] { |
|
||||
return command === 'login' |
|
||||
? [command, '-h', getRemoteAddress(remoteAddress)] |
|
||||
: [command]; |
|
||||
} |
|
||||
@ -1,52 +0,0 @@ |
|||||
import isUndefined from 'lodash/isUndefined.js'; |
|
||||
import { logger } from '../../shared/logger.js'; |
|
||||
|
|
||||
export function sshOptions( |
|
||||
{ |
|
||||
pass, |
|
||||
path, |
|
||||
command, |
|
||||
host, |
|
||||
port, |
|
||||
auth, |
|
||||
knownHosts, |
|
||||
config, |
|
||||
}: Record<string, string>, |
|
||||
key?: string, |
|
||||
): string[] { |
|
||||
const cmd = parseCommand(command, path); |
|
||||
const hostChecking = knownHosts !== '/dev/null' ? 'yes' : 'no'; |
|
||||
logger.info(`Authentication Type: ${auth}`); |
|
||||
let sshRemoteOptsBase = ['ssh', host, '-t']; |
|
||||
if (config !== '') { |
|
||||
sshRemoteOptsBase = sshRemoteOptsBase.concat(['-F', config]); |
|
||||
} |
|
||||
sshRemoteOptsBase = sshRemoteOptsBase.concat([ |
|
||||
'-p', |
|
||||
port, |
|
||||
'-o', |
|
||||
`PreferredAuthentications=${auth}`, |
|
||||
'-o', |
|
||||
`UserKnownHostsFile=${knownHosts}`, |
|
||||
'-o', |
|
||||
`StrictHostKeyChecking=${hostChecking}`, |
|
||||
]); |
|
||||
if (!isUndefined(key)) { |
|
||||
return sshRemoteOptsBase.concat(['-i', key, cmd]); |
|
||||
} |
|
||||
if (pass !== '') { |
|
||||
return ['sshpass', '-p', pass].concat(sshRemoteOptsBase, [cmd]); |
|
||||
} |
|
||||
if (auth === 'none') { |
|
||||
sshRemoteOptsBase.splice(sshRemoteOptsBase.indexOf('-o'), 2); |
|
||||
} |
|
||||
|
|
||||
return cmd === '' ? sshRemoteOptsBase : sshRemoteOptsBase.concat([cmd]); |
|
||||
} |
|
||||
|
|
||||
function parseCommand(command: string, path?: string): string { |
|
||||
if (command === 'login' && isUndefined(path)) return ''; |
|
||||
return !isUndefined(path) |
|
||||
? `$SHELL -c "cd ${path};${command === 'login' ? '$SHELL' : command}"` |
|
||||
: command; |
|
||||
} |
|
||||
@ -1,35 +0,0 @@ |
|||||
import type SocketIO from 'socket.io'; |
|
||||
import pty from 'node-pty'; |
|
||||
import { dirname, resolve as resolvePath } from 'path'; |
|
||||
import { fileURLToPath } from 'url'; |
|
||||
import { xterm } from './shared/xterm.js'; |
|
||||
|
|
||||
const executable = resolvePath( |
|
||||
dirname(fileURLToPath(import.meta.url)), |
|
||||
'..', |
|
||||
'buffer.js', |
|
||||
); |
|
||||
|
|
||||
export function login(socket: SocketIO.Socket): Promise<string> { |
|
||||
// Request carries no username information
|
|
||||
// Create terminal and ask user for username
|
|
||||
const term = pty.spawn('/usr/bin/env', ['node', executable], xterm); |
|
||||
let buf = ''; |
|
||||
return new Promise((resolve, reject) => { |
|
||||
term.on('exit', () => { |
|
||||
resolve(buf); |
|
||||
}); |
|
||||
term.on('data', (data: string) => { |
|
||||
socket.emit('data', data); |
|
||||
}); |
|
||||
socket |
|
||||
.on('input', (input: string) => { |
|
||||
term.write(input); |
|
||||
buf = /\177/.exec(input) ? buf.slice(0, -1) : buf + input; |
|
||||
}) |
|
||||
.on('disconnect', () => { |
|
||||
term.kill(); |
|
||||
reject(); |
|
||||
}); |
|
||||
}); |
|
||||
} |
|
||||
@ -1,15 +0,0 @@ |
|||||
import isUndefined from 'lodash/isUndefined.js'; |
|
||||
import type { IPtyForkOptions } from 'node-pty'; |
|
||||
|
|
||||
export const xterm: IPtyForkOptions = { |
|
||||
name: 'xterm-256color', |
|
||||
cols: 80, |
|
||||
rows: 30, |
|
||||
cwd: process.cwd(), |
|
||||
env: Object.assign( |
|
||||
{}, |
|
||||
...Object.keys(process.env) |
|
||||
.filter((key: string) => !isUndefined(process.env[key])) |
|
||||
.map((key: string) => ({ [key]: process.env[key] })), |
|
||||
), |
|
||||
}; |
|
||||
@ -1,44 +0,0 @@ |
|||||
import type SocketIO from 'socket.io'; |
|
||||
import express from 'express'; |
|
||||
import compression from 'compression'; |
|
||||
import winston from 'express-winston'; |
|
||||
|
|
||||
import type { SSL, SSLBuffer, Server } from '../shared/interfaces.js'; |
|
||||
import { favicon, redirect } from './socketServer/middleware.js'; |
|
||||
import { html } from './socketServer/html.js'; |
|
||||
import { listen } from './socketServer/socket.js'; |
|
||||
import { logger } from '../shared/logger.js'; |
|
||||
import { serveStatic, trim } from './socketServer/assets.js'; |
|
||||
import { policies } from './socketServer/security.js'; |
|
||||
import { loadSSL } from './socketServer/ssl.js'; |
|
||||
|
|
||||
export async function server( |
|
||||
{ base, port, host, title, allowIframe }: Server, |
|
||||
ssl?: SSL, |
|
||||
): Promise<SocketIO.Server> { |
|
||||
const basePath = trim(base); |
|
||||
logger.info('Starting server', { |
|
||||
ssl, |
|
||||
port, |
|
||||
base, |
|
||||
title, |
|
||||
}); |
|
||||
|
|
||||
const app = express(); |
|
||||
const client = html(basePath, title); |
|
||||
app |
|
||||
.use(`${basePath}/web_modules`, serveStatic('web_modules')) |
|
||||
.use(`${basePath}/assets`, serveStatic('assets')) |
|
||||
.use(`${basePath}/client`, serveStatic('client')) |
|
||||
.use(winston.logger(logger)) |
|
||||
.use(compression()) |
|
||||
.use(favicon(basePath)) |
|
||||
.use(redirect) |
|
||||
.use(policies(allowIframe)) |
|
||||
.get(basePath, client) |
|
||||
.get(`${basePath}/ssh/:user`, client); |
|
||||
|
|
||||
const sslBuffer: SSLBuffer = await loadSSL(ssl); |
|
||||
|
|
||||
return listen(app, host, port, basePath, sslBuffer); |
|
||||
} |
|
||||
@ -1,5 +0,0 @@ |
|||||
import express from 'express'; |
|
||||
import { assetsPath } from './shared/path.js'; |
|
||||
|
|
||||
export const trim = (str: string): string => str.replace(/\/*$/, ''); |
|
||||
export const serveStatic = (path: string) => express.static(assetsPath(path)); |
|
||||
@ -1,55 +0,0 @@ |
|||||
import type { Request, Response, RequestHandler } from 'express'; |
|
||||
import { isDev } from '../../shared/env.js'; |
|
||||
|
|
||||
const jsFiles = isDev ? ['dev', 'wetty'] : ['wetty']; |
|
||||
const cssFiles = ['styles', 'options', 'overlay', 'terminal']; |
|
||||
|
|
||||
const render = ( |
|
||||
title: string, |
|
||||
favicon: string, |
|
||||
css: string[], |
|
||||
js: string[], |
|
||||
): string => `<!doctype html>
|
|
||||
<html lang="en"> |
|
||||
<head> |
|
||||
<meta charset="utf8"> |
|
||||
<meta http-equiv="X-UA-Compatible" content="IE=edge"> |
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no"> |
|
||||
<link rel="icon" type="image/x-icon" href="${favicon}"> |
|
||||
<title>${title}</title> |
|
||||
${css.map(file => `<link rel="stylesheet" href="${file}" />`).join('\n')} |
|
||||
</head> |
|
||||
<body> |
|
||||
<div id="overlay"> |
|
||||
<div class="error"> |
|
||||
<div id="msg"></div> |
|
||||
<input type="button" onclick="location.reload();" value="reconnect" /> |
|
||||
</div> |
|
||||
</div> |
|
||||
<div id="options"> |
|
||||
<a class="toggler" |
|
||||
href="#" |
|
||||
alt="Toggle options" |
|
||||
><i class="fas fa-cogs"></i></a> |
|
||||
<textarea class="editor"></textarea> |
|
||||
</div> |
|
||||
<div id="terminal"></div> |
|
||||
${js |
|
||||
.map(file => `<script type="module" src="${file}"></script>`) |
|
||||
.join('\n')} |
|
||||
</body> |
|
||||
</html>`;
|
|
||||
|
|
||||
export const html = (base: string, title: string): RequestHandler => ( |
|
||||
_req: Request, |
|
||||
res: Response, |
|
||||
): void => { |
|
||||
res.send( |
|
||||
render( |
|
||||
title, |
|
||||
`${base}/favicon.ico`, |
|
||||
cssFiles.map(css => `${base}/assets/css/${css}.css`), |
|
||||
jsFiles.map(js => `${base}/client/${js}.js`), |
|
||||
), |
|
||||
); |
|
||||
}; |
|
||||
@ -1,99 +0,0 @@ |
|||||
import type { Request, Response, NextFunction, RequestHandler } from 'express'; |
|
||||
import etag from 'etag'; |
|
||||
import fresh from 'fresh'; |
|
||||
import parseUrl from 'parseurl'; |
|
||||
import fs from 'fs'; |
|
||||
import { assetsPath } from './shared/path.js'; |
|
||||
|
|
||||
const ONE_YEAR_MS = 60 * 60 * 24 * 365 * 1000; // 1 year
|
|
||||
|
|
||||
/** |
|
||||
* Determine if the cached representation is fresh. |
|
||||
* @param req - server request |
|
||||
* @param res - server response |
|
||||
* @returns if the cache is fresh or not |
|
||||
*/ |
|
||||
const isFresh = (req: Request, res: Response): boolean => |
|
||||
fresh(req.headers, { |
|
||||
etag: res.getHeader('ETag'), |
|
||||
'last-modified': res.getHeader('Last-Modified'), |
|
||||
}); |
|
||||
|
|
||||
/** |
|
||||
* redirect requests with trailing / to remove it |
|
||||
* |
|
||||
* @param req - server request |
|
||||
* @param res - server response |
|
||||
* @param next - next middleware to call on finish |
|
||||
*/ |
|
||||
export function redirect( |
|
||||
req: Request, |
|
||||
res: Response, |
|
||||
next: NextFunction, |
|
||||
): void { |
|
||||
if (req.path.substr(-1) === '/' && req.path.length > 1) |
|
||||
res.redirect(301, req.path.slice(0, -1) + req.url.slice(req.path.length)); |
|
||||
else next(); |
|
||||
} |
|
||||
|
|
||||
/** |
|
||||
* Serves the favicon located by the given `path`. |
|
||||
* |
|
||||
* @param basePath - server base path |
|
||||
* @returns middleware |
|
||||
*/ |
|
||||
export function favicon(basePath: string): RequestHandler { |
|
||||
const path = assetsPath('assets', 'favicon.ico'); |
|
||||
return (req: Request, res: Response, next: NextFunction): void => { |
|
||||
if (getPathName(req) !== `${basePath}/favicon.ico`) { |
|
||||
next(); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
if (req.method !== 'GET' && req.method !== 'HEAD') { |
|
||||
res.statusCode = req.method === 'OPTIONS' ? 200 : 405; |
|
||||
res.setHeader('Allow', 'GET, HEAD, OPTIONS'); |
|
||||
res.setHeader('Content-Length', '0'); |
|
||||
res.end(); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
fs.readFile(path, (err: Error | null, buf: Buffer) => { |
|
||||
if (err) return next(err); |
|
||||
Object.entries({ |
|
||||
'Cache-Control': `public, max-age=${Math.floor(ONE_YEAR_MS / 1000)}`, |
|
||||
ETag: etag(buf), |
|
||||
}).forEach(([key, value]) => { |
|
||||
res.setHeader(key, value); |
|
||||
}); |
|
||||
|
|
||||
// Validate freshness
|
|
||||
if (isFresh(req, res)) { |
|
||||
res.statusCode = 304; |
|
||||
return res.end(); |
|
||||
} |
|
||||
|
|
||||
// Send icon
|
|
||||
res.statusCode = 200; |
|
||||
res.setHeader('Content-Length', buf.length); |
|
||||
res.setHeader('Content-Type', 'image/x-icon'); |
|
||||
return res.end(buf); |
|
||||
}); |
|
||||
}; |
|
||||
} |
|
||||
|
|
||||
/** |
|
||||
* Get the request pathname. |
|
||||
* |
|
||||
* @param requests |
|
||||
* @returns path name or undefined |
|
||||
*/ |
|
||||
|
|
||||
function getPathName(req: Request): string | undefined { |
|
||||
try { |
|
||||
const url = parseUrl(req); |
|
||||
return url?.pathname ? url.pathname : undefined; |
|
||||
} catch (e) { |
|
||||
return undefined; |
|
||||
} |
|
||||
} |
|
||||
@ -1,25 +0,0 @@ |
|||||
import helmet from 'helmet'; |
|
||||
import type { Request, Response } from 'express'; |
|
||||
|
|
||||
export const policies = (allowIframe: boolean) => ( |
|
||||
req: Request, |
|
||||
res: Response, |
|
||||
next: (err?: unknown) => void, |
|
||||
) => { |
|
||||
helmet({ |
|
||||
frameguard: allowIframe ? false : { action: 'sameorigin' }, |
|
||||
referrerPolicy: { policy: ['no-referrer-when-downgrade'] }, |
|
||||
contentSecurityPolicy: { |
|
||||
directives: { |
|
||||
defaultSrc: ["'self'"], |
|
||||
scriptSrc: ["'self'", "'unsafe-inline'", "'unsafe-eval'"], |
|
||||
styleSrc: ["'self'", "'unsafe-inline'"], |
|
||||
fontSrc: ["'self'", 'data:'], |
|
||||
connectSrc: [ |
|
||||
"'self'", |
|
||||
(req.protocol === 'http' ? 'ws://' : 'wss://') + req.get('host'), |
|
||||
], |
|
||||
}, |
|
||||
}, |
|
||||
})(req, res, next); |
|
||||
}; |
|
||||
@ -1,12 +0,0 @@ |
|||||
import findUp from 'find-up'; |
|
||||
import { resolve, dirname } from 'path'; |
|
||||
import { fileURLToPath } from 'url'; |
|
||||
|
|
||||
const filePath = dirname( |
|
||||
findUp.sync('package.json', { |
|
||||
cwd: dirname(fileURLToPath(import.meta.url)), |
|
||||
}) || process.cwd(), |
|
||||
); |
|
||||
|
|
||||
export const assetsPath = (...args: string[]) => |
|
||||
resolve(filePath, 'build', ...args); |
|
||||
@ -1,36 +0,0 @@ |
|||||
import type express from 'express'; |
|
||||
import socket from 'socket.io'; |
|
||||
import http from 'http'; |
|
||||
import https from 'https'; |
|
||||
import isUndefined from 'lodash/isUndefined.js'; |
|
||||
|
|
||||
import { logger } from '../../shared/logger.js'; |
|
||||
import type { SSLBuffer } from '../../shared/interfaces.js'; |
|
||||
|
|
||||
export const listen = ( |
|
||||
app: express.Express, |
|
||||
host: string, |
|
||||
port: number, |
|
||||
path: string, |
|
||||
{ key, cert }: SSLBuffer, |
|
||||
): SocketIO.Server => |
|
||||
socket( |
|
||||
!isUndefined(key) && !isUndefined(cert) |
|
||||
? https.createServer({ key, cert }, app).listen(port, host, () => { |
|
||||
logger.info('Server started', { |
|
||||
port, |
|
||||
connection: 'https', |
|
||||
}); |
|
||||
}) |
|
||||
: http.createServer(app).listen(port, host, () => { |
|
||||
logger.info('Server started', { |
|
||||
port, |
|
||||
connection: 'http', |
|
||||
}); |
|
||||
}), |
|
||||
{ |
|
||||
path: `${path}/socket.io`, |
|
||||
pingInterval: 3000, |
|
||||
pingTimeout: 7000, |
|
||||
}, |
|
||||
); |
|
||||
@ -1,14 +0,0 @@ |
|||||
import fs from 'fs-extra'; |
|
||||
import isUndefined from 'lodash/isUndefined.js'; |
|
||||
import { resolve } from 'path'; |
|
||||
import type { SSL, SSLBuffer } from '../../shared/interfaces'; |
|
||||
|
|
||||
export async function loadSSL(ssl?: SSL): Promise<SSLBuffer> { |
|
||||
if (isUndefined(ssl) || isUndefined(ssl.key) || isUndefined(ssl.cert)) |
|
||||
return {}; |
|
||||
const [key, cert]: Buffer[] = await Promise.all([ |
|
||||
fs.readFile(resolve(ssl.key)), |
|
||||
fs.readFile(resolve(ssl.cert)), |
|
||||
]); |
|
||||
return { key, cert }; |
|
||||
} |
|
||||
@ -1,38 +0,0 @@ |
|||||
import type SocketIO from 'socket.io'; |
|
||||
import isUndefined from 'lodash/isUndefined.js'; |
|
||||
import pty from 'node-pty'; |
|
||||
import { logger } from '../shared/logger.js'; |
|
||||
import { xterm } from './shared/xterm.js'; |
|
||||
|
|
||||
export function spawn(socket: SocketIO.Socket, args: string[]): void { |
|
||||
const term = pty.spawn('/usr/bin/env', args, xterm); |
|
||||
const { pid } = term; |
|
||||
const address = args[0] === 'ssh' ? args[1] : 'localhost'; |
|
||||
logger.info('Process Started on behalf of user', { |
|
||||
pid, |
|
||||
address, |
|
||||
}); |
|
||||
socket.emit('login'); |
|
||||
term.on('exit', (code: number) => { |
|
||||
logger.info('Process exited', { code, pid }); |
|
||||
socket.emit('logout'); |
|
||||
socket |
|
||||
.removeAllListeners('disconnect') |
|
||||
.removeAllListeners('resize') |
|
||||
.removeAllListeners('input'); |
|
||||
}); |
|
||||
term.on('data', (data: string) => { |
|
||||
socket.emit('data', data); |
|
||||
}); |
|
||||
socket |
|
||||
.on('resize', ({ cols, rows }) => { |
|
||||
term.resize(cols, rows); |
|
||||
}) |
|
||||
.on('input', input => { |
|
||||
if (!isUndefined(term)) term.write(input); |
|
||||
}) |
|
||||
.on('disconnect', () => { |
|
||||
term.kill(); |
|
||||
logger.info('Process exited', { code: 0, pid }); |
|
||||
}); |
|
||||
} |
|
||||
@ -1,134 +0,0 @@ |
|||||
import fs from 'fs-extra'; |
|
||||
import path from 'path'; |
|
||||
import JSON5 from 'json5'; |
|
||||
import isUndefined from 'lodash/isUndefined.js'; |
|
||||
import type { Arguments } from 'yargs'; |
|
||||
|
|
||||
import type { Config, SSH, Server, SSL } from './interfaces'; |
|
||||
import { |
|
||||
sshDefault, |
|
||||
serverDefault, |
|
||||
forceSSHDefault, |
|
||||
defaultCommand, |
|
||||
} from './defaults.js'; |
|
||||
|
|
||||
type confValue = |
|
||||
| boolean |
|
||||
| string |
|
||||
| number |
|
||||
| undefined |
|
||||
| unknown |
|
||||
| SSH |
|
||||
| Server |
|
||||
| SSL; |
|
||||
/** |
|
||||
* Cast given value to boolean |
|
||||
* |
|
||||
* @param value - variable to cast |
|
||||
* @returns variable cast to boolean |
|
||||
*/ |
|
||||
function ensureBoolean(value: confValue): boolean { |
|
||||
switch (value) { |
|
||||
case true: |
|
||||
case 'true': |
|
||||
case 1: |
|
||||
case '1': |
|
||||
case 'on': |
|
||||
case 'yes': |
|
||||
return true; |
|
||||
default: |
|
||||
return false; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/** |
|
||||
* Load JSON5 config from file and merge with default args |
|
||||
* If no path is provided the default config is returned |
|
||||
* |
|
||||
* @param filepath - path to config to load |
|
||||
* @returns variable cast to boolean |
|
||||
*/ |
|
||||
export async function loadConfigFile(filepath?: string): Promise<Config> { |
|
||||
if (isUndefined(filepath)) { |
|
||||
return { |
|
||||
ssh: sshDefault, |
|
||||
server: serverDefault, |
|
||||
command: defaultCommand, |
|
||||
forceSSH: forceSSHDefault, |
|
||||
}; |
|
||||
} |
|
||||
const content = await fs.readFile(path.resolve(filepath)); |
|
||||
const parsed = JSON5.parse(content.toString()) as Config; |
|
||||
return { |
|
||||
ssh: isUndefined(parsed.ssh) |
|
||||
? sshDefault |
|
||||
: Object.assign(sshDefault, parsed.ssh), |
|
||||
server: isUndefined(parsed.server) |
|
||||
? serverDefault |
|
||||
: Object.assign(serverDefault, parsed.server), |
|
||||
command: isUndefined(parsed.command) ? defaultCommand : `${parsed.command}`, |
|
||||
forceSSH: isUndefined(parsed.forceSSH) |
|
||||
? forceSSHDefault |
|
||||
: ensureBoolean(parsed.forceSSH), |
|
||||
ssl: parsed.ssl, |
|
||||
}; |
|
||||
} |
|
||||
|
|
||||
/** |
|
||||
* Merge 2 objects removing undefined fields |
|
||||
* |
|
||||
* @param target - base object |
|
||||
* @param source - object to get new values from |
|
||||
* @returns merged object |
|
||||
* |
|
||||
*/ |
|
||||
const objectAssign = ( |
|
||||
target: SSH | Server, |
|
||||
source: Record<string, confValue>, |
|
||||
): SSH | Server => |
|
||||
Object.fromEntries( |
|
||||
Object.entries(source).map(([key, value]) => [ |
|
||||
key, |
|
||||
isUndefined(source[key]) ? target[key] : value, |
|
||||
]), |
|
||||
) as SSH | Server; |
|
||||
|
|
||||
/** |
|
||||
* Merge cli arguemens with config object |
|
||||
* |
|
||||
* @param opts - Object containing cli args |
|
||||
* @param config - Config object |
|
||||
* @returns merged configuration |
|
||||
* |
|
||||
*/ |
|
||||
export function mergeCliConf(opts: Arguments, config: Config): Config { |
|
||||
const ssl = { |
|
||||
key: opts['ssl-key'], |
|
||||
cert: opts['ssl-cert'], |
|
||||
...config.ssl, |
|
||||
} as SSL; |
|
||||
return { |
|
||||
ssh: objectAssign(config.ssh, { |
|
||||
user: opts['ssh-user'], |
|
||||
host: opts['ssh-host'], |
|
||||
auth: opts['ssh-auth'], |
|
||||
port: opts['ssh-port'], |
|
||||
pass: opts['ssh-pass'], |
|
||||
key: opts['ssh-key'], |
|
||||
config: opts['ssh-config'], |
|
||||
knownHosts: opts['known-hosts'], |
|
||||
}) as SSH, |
|
||||
server: objectAssign(config.server, { |
|
||||
base: opts.base, |
|
||||
host: opts.host, |
|
||||
port: opts.port, |
|
||||
title: opts.title, |
|
||||
allowIframe: opts['allow-iframe'], |
|
||||
}) as Server, |
|
||||
command: isUndefined(opts.command) ? config.command : `${opts.command}`, |
|
||||
forceSSH: isUndefined(opts['force-ssh']) |
|
||||
? config.forceSSH |
|
||||
: ensureBoolean(opts['force-ssh']), |
|
||||
ssl: isUndefined(ssl.key) || isUndefined(ssl.cert) ? undefined : ssl, |
|
||||
}; |
|
||||
} |
|
||||
@ -1,23 +0,0 @@ |
|||||
import type { SSH, Server } from './interfaces'; |
|
||||
|
|
||||
export const sshDefault: SSH = { |
|
||||
user: process.env.SSHUSER || '', |
|
||||
host: process.env.SSHHOST || 'localhost', |
|
||||
auth: process.env.SSHAUTH || 'password', |
|
||||
pass: process.env.SSHPASS || undefined, |
|
||||
key: process.env.SSHKEY || undefined, |
|
||||
port: parseInt(process.env.SSHPORT || '22', 10), |
|
||||
knownHosts: process.env.KNOWNHOSTS || '/dev/null', |
|
||||
config: process.env.SSHCONFIG || undefined, |
|
||||
}; |
|
||||
|
|
||||
export const serverDefault: Server = { |
|
||||
base: process.env.BASE || '/wetty/', |
|
||||
port: parseInt(process.env.PORT || '3000', 10), |
|
||||
host: '0.0.0.0', |
|
||||
title: process.env.TITLE || 'WeTTy - The Web Terminal Emulator', |
|
||||
allowIframe: false, |
|
||||
}; |
|
||||
|
|
||||
export const forceSSHDefault = process.env.FORCESSH === 'true' || false; |
|
||||
export const defaultCommand = process.env.COMMAND || 'login'; |
|
||||
@ -1 +0,0 @@ |
|||||
export const isDev = process.env.NODE_ENV === 'development'; |
|
||||
@ -1,38 +0,0 @@ |
|||||
export interface SSH { |
|
||||
[s: string]: string | number | boolean | undefined; |
|
||||
user: string; |
|
||||
host: string; |
|
||||
auth: string; |
|
||||
port: number; |
|
||||
knownHosts: string; |
|
||||
pass?: string; |
|
||||
key?: string; |
|
||||
config?: string; |
|
||||
} |
|
||||
|
|
||||
export interface SSL { |
|
||||
key: string; |
|
||||
cert: string; |
|
||||
} |
|
||||
|
|
||||
export interface SSLBuffer { |
|
||||
key?: Buffer; |
|
||||
cert?: Buffer; |
|
||||
} |
|
||||
|
|
||||
export interface Server { |
|
||||
[s: string]: string | number | boolean; |
|
||||
port: number; |
|
||||
host: string; |
|
||||
title: string; |
|
||||
base: string; |
|
||||
allowIframe: boolean; |
|
||||
} |
|
||||
|
|
||||
export interface Config { |
|
||||
ssh: SSH; |
|
||||
server: Server; |
|
||||
forceSSH: boolean; |
|
||||
command: string; |
|
||||
ssl?: SSL; |
|
||||
} |
|
||||
@ -1,24 +0,0 @@ |
|||||
import winston from 'winston'; |
|
||||
|
|
||||
import { isDev } from './env.js'; |
|
||||
|
|
||||
const { combine, timestamp, label, simple, json, colorize } = winston.format; |
|
||||
|
|
||||
const dev = combine( |
|
||||
colorize(), |
|
||||
label({ label: 'Wetty' }), |
|
||||
timestamp(), |
|
||||
simple(), |
|
||||
); |
|
||||
|
|
||||
const prod = combine(label({ label: 'Wetty' }), timestamp(), json()); |
|
||||
|
|
||||
export const logger = winston.createLogger({ |
|
||||
format: isDev ? dev : prod, |
|
||||
transports: [ |
|
||||
new winston.transports.Console({ |
|
||||
level: isDev ? 'debug' : 'info', |
|
||||
handleExceptions: true, |
|
||||
}), |
|
||||
], |
|
||||
}); |
|
||||
@ -1,6 +0,0 @@ |
|||||
{ |
|
||||
"extends": "./tsconfig.json", |
|
||||
"include": [ |
|
||||
"src/client" |
|
||||
] |
|
||||
} |
|
||||
@ -1,14 +0,0 @@ |
|||||
{ |
|
||||
"extends": "./tsconfig.json", |
|
||||
"compilerOptions": { |
|
||||
"incremental": true, |
|
||||
"outDir": "./build", |
|
||||
"sourceMap": true |
|
||||
}, |
|
||||
"include": [ |
|
||||
"src" |
|
||||
], |
|
||||
"exclude": [ |
|
||||
"src/client" |
|
||||
] |
|
||||
} |
|
||||
File diff suppressed because it is too large
Loading…
Reference in new issue