,
+ openssh_cert_path: Option,
+ addrs: A,
+ ) -> Result {
+ let key_pair = load_secret_key(key_path, None)?;
+
+ // load ssh certificate
+ let mut openssh_cert = None;
+ if openssh_cert_path.is_some() {
+ openssh_cert = Some(load_openssh_certificate(openssh_cert_path.unwrap())?);
+ }
+
+ let config = client::Config {
+ inactivity_timeout: Some(Duration::from_secs(5)),
+ ..<_>::default()
+ };
+
+ let config = Arc::new(config);
+ let sh = Client {};
+
+ let mut session = client::connect(config, addrs, sh).await?;
+
+ // use publickey authentication, with or without certificate
+ if openssh_cert.is_none() {
+ let auth_res = session
+ .authenticate_publickey(
+ user,
+ PrivateKeyWithHashAlg::new(
+ Arc::new(key_pair),
+ session.best_supported_rsa_hash().await?.flatten(),
+ ),
+ )
+ .await?;
+
+ if !auth_res.success() {
+ anyhow::bail!("Authentication (with publickey) failed");
+ }
+ } else {
+ let auth_res = session
+ .authenticate_openssh_cert(user, Arc::new(key_pair), openssh_cert.unwrap())
+ .await?;
+
+ if !auth_res.success() {
+ anyhow::bail!("Authentication (with publickey+cert) failed");
+ }
+ }
+
+ Ok(Self { session })
+ }
+
+ async fn call(&mut self, command: &str) -> Result {
+ let mut channel = self.session.channel_open_session().await?;
+
+ // This example doesn't terminal resizing after the connection is established
+ let (w, h) = termion::terminal_size()?;
+
+ // Request an interactive PTY from the server
+ channel
+ .request_pty(
+ false,
+ &env::var("TERM").unwrap_or("xterm".into()),
+ w as u32,
+ h as u32,
+ 0,
+ 0,
+ &[], // ideally you want to pass the actual terminal modes here
+ )
+ .await?;
+ channel.exec(true, command).await?;
+
+ let code;
+ let mut stdin = tokio_fd::AsyncFd::try_from(0)?;
+ let mut stdout = tokio_fd::AsyncFd::try_from(1)?;
+ let mut buf = vec![0; 1024];
+ let mut stdin_closed = false;
+
+ loop {
+ // Handle one of the possible events:
+ tokio::select! {
+ // There's terminal input available from the user
+ r = stdin.read(&mut buf), if !stdin_closed => {
+ match r {
+ Ok(0) => {
+ stdin_closed = true;
+ channel.eof().await?;
+ },
+ // Send it to the server
+ Ok(n) => channel.data(&buf[..n]).await?,
+ Err(e) => return Err(e.into()),
+ };
+ },
+ // There's an event available on the session channel
+ Some(msg) = channel.wait() => {
+ match msg {
+ // Write data to the terminal
+ ChannelMsg::Data { ref data } => {
+ stdout.write_all(data).await?;
+ stdout.flush().await?;
+ }
+ // The command has returned an exit code
+ ChannelMsg::ExitStatus { exit_status } => {
+ code = exit_status;
+ if !stdin_closed {
+ channel.eof().await?;
+ }
+ break;
+ }
+ _ => {}
+ }
+ },
+ }
+ }
+ Ok(code)
+ }
+
+ async fn close(&mut self) -> Result<()> {
+ self.session
+ .disconnect(Disconnect::ByApplication, "", "English")
+ .await?;
+ Ok(())
+ }
+}
+
+#[derive(clap::Parser)]
+#[clap(trailing_var_arg = true)]
+pub struct Cli {
+ #[clap(index = 1)]
+ host: String,
+
+ #[clap(long, short, default_value_t = 22)]
+ port: u16,
+
+ #[clap(long, short)]
+ username: Option,
+
+ #[clap(long, short = 'k')]
+ private_key: PathBuf,
+
+ #[clap(long, short = 'o')]
+ openssh_certificate: Option,
+
+ #[clap(multiple = true, index = 2, required = true)]
+ command: Vec,
+}
diff --git a/russh/examples/client_exec_simple.rs b/russh/examples/client_exec_simple.rs
new file mode 100644
index 00000000..694b27b6
--- /dev/null
+++ b/russh/examples/client_exec_simple.rs
@@ -0,0 +1,194 @@
+use std::borrow::Cow;
+///
+/// Run this example with:
+/// cargo run --example client_exec_simple -- -k
+///
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::Result;
+use clap::Parser;
+use log::info;
+use russh::keys::*;
+use russh::*;
+use tokio::io::AsyncWriteExt;
+use tokio::net::ToSocketAddrs;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+ env_logger::builder()
+ .filter_level(log::LevelFilter::Debug)
+ .init();
+
+ // CLI options are defined later in this file
+ let cli = Cli::parse();
+
+ info!("Connecting to {}:{}", cli.host, cli.port);
+ info!("Key path: {:?}", cli.private_key);
+ info!("OpenSSH Certificate path: {:?}", cli.openssh_certificate);
+
+ // Session is a wrapper around a russh client, defined down below
+ let mut ssh = Session::connect(
+ cli.private_key,
+ cli.username.unwrap_or("root".to_string()),
+ cli.openssh_certificate,
+ (cli.host, cli.port),
+ )
+ .await?;
+ info!("Connected");
+
+ let code = ssh
+ .call(
+ &cli.command
+ .into_iter()
+ .map(|x| shell_escape::escape(x.into())) // arguments are escaped manually since the SSH protocol doesn't support quoting
+ .collect::>()
+ .join(" "),
+ )
+ .await?;
+
+ println!("Exitcode: {:?}", code);
+ ssh.close().await?;
+ Ok(())
+}
+
+struct Client {}
+
+// More SSH event handlers
+// can be defined in this trait
+// In this example, we're only using Channel, so these aren't needed.
+impl client::Handler for Client {
+ type Error = russh::Error;
+
+ async fn check_server_key(
+ &mut self,
+ _server_public_key: &ssh_key::PublicKey,
+ ) -> Result {
+ Ok(true)
+ }
+}
+
+/// This struct is a convenience wrapper
+/// around a russh client
+pub struct Session {
+ session: client::Handle,
+}
+
+impl Session {
+ async fn connect, A: ToSocketAddrs>(
+ key_path: P,
+ user: impl Into,
+ openssh_cert_path: Option,
+ addrs: A,
+ ) -> Result {
+ let key_pair = load_secret_key(key_path, None)?;
+
+ // load ssh certificate
+ let mut openssh_cert = None;
+ if openssh_cert_path.is_some() {
+ openssh_cert = Some(load_openssh_certificate(openssh_cert_path.unwrap())?);
+ }
+
+ let config = client::Config {
+ inactivity_timeout: Some(Duration::from_secs(5)),
+ preferred: Preferred {
+ kex: Cow::Owned(vec![
+ russh::kex::CURVE25519_PRE_RFC_8731,
+ russh::kex::EXTENSION_SUPPORT_AS_CLIENT,
+ ]),
+ ..Default::default()
+ },
+ ..<_>::default()
+ };
+
+ let config = Arc::new(config);
+ let sh = Client {};
+
+ let mut session = client::connect(config, addrs, sh).await?;
+ // use publickey authentication, with or without certificate
+ if openssh_cert.is_none() {
+ let auth_res = session
+ .authenticate_publickey(
+ user,
+ PrivateKeyWithHashAlg::new(
+ Arc::new(key_pair),
+ session.best_supported_rsa_hash().await?.flatten(),
+ ),
+ )
+ .await?;
+
+ if !auth_res.success() {
+ anyhow::bail!("Authentication (with publickey) failed");
+ }
+ } else {
+ let auth_res = session
+ .authenticate_openssh_cert(user, Arc::new(key_pair), openssh_cert.unwrap())
+ .await?;
+
+ if !auth_res.success() {
+ anyhow::bail!("Authentication (with publickey+cert) failed");
+ }
+ }
+
+ Ok(Self { session })
+ }
+
+ async fn call(&mut self, command: &str) -> Result {
+ let mut channel = self.session.channel_open_session().await?;
+ channel.exec(true, command).await?;
+
+ let mut code = None;
+ let mut stdout = tokio::io::stdout();
+
+ loop {
+ // There's an event available on the session channel
+ let Some(msg) = channel.wait().await else {
+ break;
+ };
+ match msg {
+ // Write data to the terminal
+ ChannelMsg::Data { ref data } => {
+ stdout.write_all(data).await?;
+ stdout.flush().await?;
+ }
+ // The command has returned an exit code
+ ChannelMsg::ExitStatus { exit_status } => {
+ code = Some(exit_status);
+ // cannot leave the loop immediately, there might still be more data to receive
+ }
+ _ => {}
+ }
+ }
+ Ok(code.expect("program did not exit cleanly"))
+ }
+
+ async fn close(&mut self) -> Result<()> {
+ self.session
+ .disconnect(Disconnect::ByApplication, "", "English")
+ .await?;
+ Ok(())
+ }
+}
+
+#[derive(clap::Parser)]
+#[clap(trailing_var_arg = true)]
+pub struct Cli {
+ #[clap(index = 1)]
+ host: String,
+
+ #[clap(long, short, default_value_t = 22)]
+ port: u16,
+
+ #[clap(long, short)]
+ username: Option,
+
+ #[clap(long, short = 'k')]
+ private_key: PathBuf,
+
+ #[clap(long, short = 'o')]
+ openssh_certificate: Option,
+
+ #[clap(multiple = true, index = 2, required = true)]
+ command: Vec,
+}
diff --git a/russh/examples/client_open_direct_tcpip.rs b/russh/examples/client_open_direct_tcpip.rs
new file mode 100644
index 00000000..db29b594
--- /dev/null
+++ b/russh/examples/client_open_direct_tcpip.rs
@@ -0,0 +1,211 @@
+use std::net::SocketAddr;
+///
+/// Run this example with:
+/// cargo run --example client_open_direct_tcpip -- --private-key --local-addr --forward-addr
+///
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use anyhow::Result;
+use clap::Parser;
+use key::PrivateKeyWithHashAlg;
+use log::info;
+use russh::keys::*;
+use russh::*;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::{TcpListener, TcpStream, ToSocketAddrs};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+ env_logger::builder()
+ .filter_level(log::LevelFilter::Info)
+ .init();
+
+ // CLI options are defined later in this file
+ let cli = Cli::parse();
+
+ info!("Connecting to server: {}:{}", cli.host, cli.port);
+ info!("Key path: {:?}", cli.private_key);
+ info!("OpenSSH Certificate path: {:?}", cli.openssh_certificate);
+
+ let forward_addr: SocketAddr = cli.forward_addr.parse()?;
+ let listener = TcpListener::bind(&cli.local_addr).await?;
+ info!("listen on: {}", &cli.local_addr);
+
+ // Session is a wrapper around a russh client, defined down below
+ let mut ssh = Session::connect(
+ cli.private_key,
+ cli.openssh_certificate,
+ cli.username.unwrap_or("root".to_string()),
+ (cli.host.clone(), cli.port),
+ )
+ .await?;
+ info!("Server: {}:{} Connected", cli.host, cli.port);
+
+ let (socket, o_addr) = listener.accept().await?;
+ info!("originator address: {}", o_addr);
+ ssh.call(socket, o_addr, forward_addr).await?;
+
+ ssh.close().await?;
+
+ Ok(())
+}
+
+struct Client {}
+
+// More SSH event handlers
+// can be defined in this trait
+// In this example, we're only using Channel, so these aren't needed.
+impl client::Handler for Client {
+ type Error = russh::Error;
+
+ async fn check_server_key(
+ &mut self,
+ _server_public_key: &ssh_key::PublicKey,
+ ) -> Result {
+ Ok(true)
+ }
+}
+
+/// This struct is a convenience wrapper
+/// around a russh client
+pub struct Session {
+ session: client::Handle,
+}
+
+impl Session {
+ async fn connect, A: ToSocketAddrs>(
+ key_path: P,
+ openssh_cert_path: Option,
+ user: impl Into,
+ addrs: A,
+ ) -> Result {
+ let key_pair = load_secret_key(key_path, None)?;
+ let config = client::Config::default();
+ // load ssh certificate
+ let mut openssh_cert = None;
+ if openssh_cert_path.is_some() {
+ openssh_cert = Some(load_openssh_certificate(openssh_cert_path.unwrap())?);
+ }
+
+ let config = Arc::new(config);
+ let sh = Client {};
+
+ let mut session = client::connect(config, addrs, sh).await?;
+ // use publickey authentication, with or without certificate
+ if openssh_cert.is_none() {
+ let auth_res = session
+ .authenticate_publickey(
+ user,
+ PrivateKeyWithHashAlg::new(
+ Arc::new(key_pair),
+ session.best_supported_rsa_hash().await?.flatten(),
+ ),
+ )
+ .await?;
+
+ if !auth_res.success() {
+ anyhow::bail!("Authentication (with publickey) failed");
+ }
+ } else {
+ let auth_res = session
+ .authenticate_openssh_cert(user, Arc::new(key_pair), openssh_cert.unwrap())
+ .await?;
+
+ if !auth_res.success() {
+ anyhow::bail!("Authentication (with publickey+cert) failed");
+ }
+ }
+
+ Ok(Self { session })
+ }
+
+ async fn call(
+ &mut self,
+ mut stream: TcpStream,
+ originator_addr: SocketAddr,
+ forward_addr: SocketAddr,
+ ) -> Result<()> {
+ let mut channel = self
+ .session
+ .channel_open_direct_tcpip(
+ forward_addr.ip().to_string(),
+ forward_addr.port().into(),
+ originator_addr.ip().to_string(),
+ originator_addr.port().into(),
+ )
+ .await?;
+ // There's an event available on the session channel
+ let mut stream_closed = false;
+ let mut buf = vec![0; 65536];
+ loop {
+ // Handle one of the possible events:
+ tokio::select! {
+ // There's socket input available from the client
+ r = stream.read(&mut buf), if !stream_closed => {
+ match r {
+ Ok(0) => {
+ stream_closed = true;
+ channel.eof().await?;
+ },
+ // Send it to the server
+ Ok(n) => channel.data(&buf[..n]).await?,
+ Err(e) => return Err(e.into()),
+ };
+ },
+ // There's an event available on the session channel
+ Some(msg) = channel.wait() => {
+ match msg {
+ // Write data to the client
+ ChannelMsg::Data { ref data } => {
+ stream.write_all(data).await?;
+ }
+ ChannelMsg::Eof => {
+ if !stream_closed {
+ channel.eof().await?;
+ }
+ break;
+ }
+ ChannelMsg::WindowAdjusted { new_size:_ }=> {
+ // Ignore this message type
+ }
+ _ => {todo!()}
+ }
+ },
+ }
+ }
+ Ok(())
+ }
+
+ async fn close(&mut self) -> Result<()> {
+ self.session
+ .disconnect(Disconnect::ByApplication, "", "English")
+ .await?;
+ Ok(())
+ }
+}
+
+#[derive(clap::Parser)]
+#[clap(trailing_var_arg = true)]
+pub struct Cli {
+ #[clap(index = 1)]
+ host: String,
+
+ #[clap(long, short, default_value_t = 22)]
+ port: u16,
+
+ #[clap(long, short = 'o')]
+ openssh_certificate: Option,
+
+ #[clap(long, short)]
+ username: Option,
+
+ #[clap(long, short = 'k')]
+ private_key: PathBuf,
+
+ #[clap(long, short = 'l')]
+ local_addr: String,
+
+ #[clap(long, short = 'f')]
+ forward_addr: String,
+}
diff --git a/russh/examples/echoserver.rs b/russh/examples/echoserver.rs
index 64dbae92..6123297b 100644
--- a/russh/examples/echoserver.rs
+++ b/russh/examples/echoserver.rs
@@ -1,10 +1,10 @@
use std::collections::HashMap;
use std::sync::Arc;
-use async_trait::async_trait;
-use russh::server::{Msg, Session};
+use rand_core::OsRng;
+use russh::keys::{Certificate, *};
+use russh::server::{Msg, Server as _, Session};
use russh::*;
-use russh_keys::*;
use tokio::sync::Mutex;
#[tokio::main]
@@ -17,29 +17,33 @@ async fn main() {
inactivity_timeout: Some(std::time::Duration::from_secs(3600)),
auth_rejection_time: std::time::Duration::from_secs(3),
auth_rejection_time_initial: Some(std::time::Duration::from_secs(0)),
- keys: vec![russh_keys::key::KeyPair::generate_ed25519().unwrap()],
+ keys: vec![
+ russh::keys::PrivateKey::random(&mut OsRng, russh::keys::Algorithm::Ed25519).unwrap(),
+ ],
+ preferred: Preferred {
+ // kex: std::borrow::Cow::Owned(vec![russh::kex::DH_GEX_SHA256]),
+ ..Preferred::default()
+ },
..Default::default()
};
let config = Arc::new(config);
- let sh = Server {
+ let mut sh = Server {
clients: Arc::new(Mutex::new(HashMap::new())),
id: 0,
};
- russh::server::run(config, ("0.0.0.0", 2222), sh)
- .await
- .unwrap();
+ sh.run_on_address(config, ("0.0.0.0", 2222)).await.unwrap();
}
#[derive(Clone)]
struct Server {
- clients: Arc>>,
+ clients: Arc>>,
id: usize,
}
impl Server {
async fn post(&mut self, data: CryptoVec) {
let mut clients = self.clients.lock().await;
- for ((id, channel), ref mut s) in clients.iter_mut() {
+ for (id, (channel, ref mut s)) in clients.iter_mut() {
if *id != self.id {
let _ = s.data(*channel, data.clone()).await;
}
@@ -54,61 +58,87 @@ impl server::Server for Server {
self.id += 1;
s
}
+ fn handle_session_error(&mut self, _error: ::Error) {
+ eprintln!("Session error: {:#?}", _error);
+ }
}
-#[async_trait]
impl server::Handler for Server {
- type Error = anyhow::Error;
+ type Error = russh::Error;
async fn channel_open_session(
- self,
+ &mut self,
channel: Channel,
- session: Session,
- ) -> Result<(Self, bool, Session), Self::Error> {
+ session: &mut Session,
+ ) -> Result {
{
let mut clients = self.clients.lock().await;
- clients.insert((self.id, channel.id()), session.handle());
+ clients.insert(self.id, (channel.id(), session.handle()));
}
- Ok((self, true, session))
+ Ok(true)
}
async fn auth_publickey(
- self,
+ &mut self,
_: &str,
- _: &key::PublicKey,
- ) -> Result<(Self, server::Auth), Self::Error> {
- Ok((self, server::Auth::Accept))
+ _key: &ssh_key::PublicKey,
+ ) -> Result {
+ Ok(server::Auth::Accept)
+ }
+
+ async fn auth_openssh_certificate(
+ &mut self,
+ _user: &str,
+ _certificate: &Certificate,
+ ) -> Result {
+ Ok(server::Auth::Accept)
}
async fn data(
- mut self,
+ &mut self,
channel: ChannelId,
data: &[u8],
- mut session: Session,
- ) -> Result<(Self, Session), Self::Error> {
+ session: &mut Session,
+ ) -> Result<(), Self::Error> {
+ // Sending Ctrl+C ends the session and disconnects the client
+ if data == [3] {
+ return Err(russh::Error::Disconnect);
+ }
+
let data = CryptoVec::from(format!("Got data: {}\r\n", String::from_utf8_lossy(data)));
self.post(data.clone()).await;
- session.data(channel, data);
- Ok((self, session))
+ session.data(channel, data)?;
+ Ok(())
}
async fn tcpip_forward(
- self,
+ &mut self,
address: &str,
port: &mut u32,
- session: Session,
- ) -> Result<(Self, bool, Session), Self::Error> {
+ session: &mut Session,
+ ) -> Result {
let handle = session.handle();
let address = address.to_string();
let port = *port;
tokio::spawn(async move {
- let mut channel = handle
+ let channel = handle
.channel_open_forwarded_tcpip(address, port, "1.2.3.4", 1234)
.await
.unwrap();
let _ = channel.data(&b"Hello from a forwarded port"[..]).await;
let _ = channel.eof().await;
});
- Ok((self, true, session))
+ Ok(true)
+ }
+}
+
+impl Drop for Server {
+ fn drop(&mut self) {
+ let id = self.id;
+ let clients = self.clients.clone();
+ tokio::spawn(async move {
+ let mut clients = clients.lock().await;
+ clients.remove(&id);
+ });
}
}
diff --git a/russh/examples/ratatui_app.rs b/russh/examples/ratatui_app.rs
new file mode 100644
index 00000000..757c976e
--- /dev/null
+++ b/russh/examples/ratatui_app.rs
@@ -0,0 +1,271 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use rand_core::OsRng;
+use ratatui::backend::CrosstermBackend;
+use ratatui::layout::Rect;
+use ratatui::style::{Color, Style};
+use ratatui::widgets::{Block, Borders, Clear, Paragraph};
+use ratatui::{Terminal, TerminalOptions, Viewport};
+use russh::keys::ssh_key::PublicKey;
+use russh::server::*;
+use russh::{Channel, ChannelId, Pty};
+use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
+use tokio::sync::Mutex;
+
+type SshTerminal = Terminal>;
+
+struct App {
+ pub counter: usize,
+}
+
+impl App {
+ pub fn new() -> App {
+ Self { counter: 0 }
+ }
+}
+
+struct TerminalHandle {
+ sender: UnboundedSender>,
+ // The sink collects the data which is finally sent to sender.
+ sink: Vec,
+}
+
+impl TerminalHandle {
+ async fn start(handle: Handle, channel_id: ChannelId) -> Self {
+ let (sender, mut receiver) = unbounded_channel::>();
+ tokio::spawn(async move {
+ while let Some(data) = receiver.recv().await {
+ let result = handle.data(channel_id, data.into()).await;
+ if result.is_err() {
+ eprintln!("Failed to send data: {:?}", result);
+ }
+ }
+ });
+ Self {
+ sender,
+ sink: Vec::new(),
+ }
+ }
+}
+
+// The crossterm backend writes to the terminal handle.
+impl std::io::Write for TerminalHandle {
+ fn write(&mut self, buf: &[u8]) -> std::io::Result {
+ self.sink.extend_from_slice(buf);
+ Ok(buf.len())
+ }
+
+ fn flush(&mut self) -> std::io::Result<()> {
+ let result = self.sender.send(self.sink.clone());
+ if result.is_err() {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::BrokenPipe,
+ result.unwrap_err(),
+ ));
+ }
+
+ self.sink.clear();
+ Ok(())
+ }
+}
+
+#[derive(Clone)]
+struct AppServer {
+ clients: Arc>>,
+ id: usize,
+}
+
+impl AppServer {
+ pub fn new() -> Self {
+ Self {
+ clients: Arc::new(Mutex::new(HashMap::new())),
+ id: 0,
+ }
+ }
+
+ pub async fn run(&mut self) -> Result<(), anyhow::Error> {
+ let clients = self.clients.clone();
+ tokio::spawn(async move {
+ loop {
+ tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+
+ for (_, (terminal, app)) in clients.lock().await.iter_mut() {
+ app.counter += 1;
+
+ terminal
+ .draw(|f| {
+ let area = f.area();
+ f.render_widget(Clear, area);
+ let style = match app.counter % 3 {
+ 0 => Style::default().fg(Color::Red),
+ 1 => Style::default().fg(Color::Green),
+ _ => Style::default().fg(Color::Blue),
+ };
+ let paragraph = Paragraph::new(format!("Counter: {}", app.counter))
+ .alignment(ratatui::layout::Alignment::Center)
+ .style(style);
+ let block = Block::default()
+ .title("Press 'c' to reset the counter!")
+ .borders(Borders::ALL);
+ f.render_widget(paragraph.block(block), area);
+ })
+ .unwrap();
+ }
+ }
+ });
+
+ let config = Config {
+ inactivity_timeout: Some(std::time::Duration::from_secs(3600)),
+ auth_rejection_time: std::time::Duration::from_secs(3),
+ auth_rejection_time_initial: Some(std::time::Duration::from_secs(0)),
+ keys: vec![
+ russh::keys::PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap(),
+ ],
+ nodelay: true,
+ ..Default::default()
+ };
+
+ self.run_on_address(Arc::new(config), ("0.0.0.0", 2222))
+ .await?;
+ Ok(())
+ }
+}
+
+impl Server for AppServer {
+ type Handler = Self;
+ fn new_client(&mut self, _: Option) -> Self {
+ let s = self.clone();
+ self.id += 1;
+ s
+ }
+}
+
+impl Handler for AppServer {
+ type Error = anyhow::Error;
+
+ async fn channel_open_session(
+ &mut self,
+ channel: Channel,
+ session: &mut Session,
+ ) -> Result {
+ let terminal_handle = TerminalHandle::start(session.handle(), channel.id()).await;
+
+ let backend = CrosstermBackend::new(terminal_handle);
+
+ // the correct viewport area will be set when the client request a pty
+ let options = TerminalOptions {
+ viewport: Viewport::Fixed(Rect::default()),
+ };
+
+ let terminal = Terminal::with_options(backend, options)?;
+ let app = App::new();
+
+ let mut clients = self.clients.lock().await;
+ clients.insert(self.id, (terminal, app));
+
+ Ok(true)
+ }
+
+ async fn auth_publickey(&mut self, _: &str, _: &PublicKey) -> Result {
+ Ok(Auth::Accept)
+ }
+
+ async fn data(
+ &mut self,
+ channel: ChannelId,
+ data: &[u8],
+ session: &mut Session,
+ ) -> Result<(), Self::Error> {
+ match data {
+ // Pressing 'q' closes the connection.
+ b"q" => {
+ self.clients.lock().await.remove(&self.id);
+ session.close(channel)?;
+ }
+ // Pressing 'c' resets the counter for the app.
+ // Only the client with the id sees the counter reset.
+ b"c" => {
+ let mut clients = self.clients.lock().await;
+ let (_, app) = clients.get_mut(&self.id).unwrap();
+ app.counter = 0;
+ }
+ _ => {}
+ }
+
+ Ok(())
+ }
+
+ /// The client's window size has changed.
+ async fn window_change_request(
+ &mut self,
+ _: ChannelId,
+ col_width: u32,
+ row_height: u32,
+ _: u32,
+ _: u32,
+ _: &mut Session,
+ ) -> Result<(), Self::Error> {
+ let rect = Rect {
+ x: 0,
+ y: 0,
+ width: col_width as u16,
+ height: row_height as u16,
+ };
+
+ let mut clients = self.clients.lock().await;
+ let (terminal, _) = clients.get_mut(&self.id).unwrap();
+ terminal.resize(rect)?;
+
+ Ok(())
+ }
+
+ /// The client requests a pseudo-terminal with the given
+ /// specifications.
+ ///
+ /// **Note:** Success or failure should be communicated to the client by calling
+ /// `session.channel_success(channel)` or `session.channel_failure(channel)` respectively.
+ async fn pty_request(
+ &mut self,
+ channel: ChannelId,
+ _: &str,
+ col_width: u32,
+ row_height: u32,
+ _: u32,
+ _: u32,
+ _: &[(Pty, u32)],
+ session: &mut Session,
+ ) -> Result<(), Self::Error> {
+ let rect = Rect {
+ x: 0,
+ y: 0,
+ width: col_width as u16,
+ height: row_height as u16,
+ };
+
+ let mut clients = self.clients.lock().await;
+ let (terminal, _) = clients.get_mut(&self.id).unwrap();
+ terminal.resize(rect)?;
+
+ session.channel_success(channel)?;
+
+ Ok(())
+ }
+}
+
+impl Drop for AppServer {
+ fn drop(&mut self) {
+ let id = self.id;
+ let clients = self.clients.clone();
+ tokio::spawn(async move {
+ let mut clients = clients.lock().await;
+ clients.remove(&id);
+ });
+ }
+}
+
+#[tokio::main]
+async fn main() {
+ let mut server = AppServer::new();
+ server.run().await.expect("Failed running server");
+}
diff --git a/russh/examples/ratatui_shared_app.rs b/russh/examples/ratatui_shared_app.rs
new file mode 100644
index 00000000..d221c382
--- /dev/null
+++ b/russh/examples/ratatui_shared_app.rs
@@ -0,0 +1,270 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use rand_core::OsRng;
+use ratatui::backend::CrosstermBackend;
+use ratatui::layout::Rect;
+use ratatui::style::{Color, Style};
+use ratatui::widgets::{Block, Borders, Clear, Paragraph};
+use ratatui::{Terminal, TerminalOptions, Viewport};
+use russh::keys::ssh_key::PublicKey;
+use russh::server::*;
+use russh::{Channel, ChannelId, Pty};
+use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
+use tokio::sync::Mutex;
+
+type SshTerminal = Terminal>;
+
+struct App {
+ pub counter: usize,
+}
+
+impl App {
+ pub fn new() -> App {
+ Self { counter: 0 }
+ }
+}
+
+struct TerminalHandle {
+ sender: UnboundedSender>,
+ // The sink collects the data which is finally sent to sender.
+ sink: Vec,
+}
+
+impl TerminalHandle {
+ async fn start(handle: Handle, channel_id: ChannelId) -> Self {
+ let (sender, mut receiver) = unbounded_channel::>();
+ tokio::spawn(async move {
+ while let Some(data) = receiver.recv().await {
+ let result = handle.data(channel_id, data.into()).await;
+ if result.is_err() {
+ eprintln!("Failed to send data: {:?}", result);
+ }
+ }
+ });
+ Self {
+ sender,
+ sink: Vec::new(),
+ }
+ }
+}
+
+// The crossterm backend writes to the terminal handle.
+impl std::io::Write for TerminalHandle {
+ fn write(&mut self, buf: &[u8]) -> std::io::Result {
+ self.sink.extend_from_slice(buf);
+ Ok(buf.len())
+ }
+
+ fn flush(&mut self) -> std::io::Result<()> {
+ let result = self.sender.send(self.sink.clone());
+ if result.is_err() {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::BrokenPipe,
+ result.unwrap_err(),
+ ));
+ }
+
+ self.sink.clear();
+ Ok(())
+ }
+}
+
+#[derive(Clone)]
+struct AppServer {
+ clients: Arc>>,
+ id: usize,
+ app: Arc>,
+}
+
+impl AppServer {
+ pub fn new() -> Self {
+ Self {
+ clients: Arc::new(Mutex::new(HashMap::new())),
+ id: 0,
+ app: Arc::new(Mutex::new(App::new())),
+ }
+ }
+
+ pub async fn run(&mut self) -> Result<(), anyhow::Error> {
+ let app = self.app.clone();
+ let clients = self.clients.clone();
+ tokio::spawn(async move {
+ loop {
+ tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+ app.lock().await.counter += 1;
+ let counter = app.lock().await.counter;
+ for (_, terminal) in clients.lock().await.iter_mut() {
+ terminal
+ .draw(|f| {
+ let area = f.area();
+ f.render_widget(Clear, area);
+ let style = match counter % 3 {
+ 0 => Style::default().fg(Color::Red),
+ 1 => Style::default().fg(Color::Green),
+ _ => Style::default().fg(Color::Blue),
+ };
+ let paragraph = Paragraph::new(format!("Counter: {counter}"))
+ .alignment(ratatui::layout::Alignment::Center)
+ .style(style);
+ let block = Block::default()
+ .title("Press 'c' to reset the counter!")
+ .borders(Borders::ALL);
+ f.render_widget(paragraph.block(block), area);
+ })
+ .unwrap();
+ }
+ }
+ });
+
+ let config = Config {
+ inactivity_timeout: Some(std::time::Duration::from_secs(3600)),
+ auth_rejection_time: std::time::Duration::from_secs(3),
+ auth_rejection_time_initial: Some(std::time::Duration::from_secs(0)),
+ keys: vec![
+ russh::keys::PrivateKey::random(&mut OsRng, ssh_key::Algorithm::Ed25519).unwrap(),
+ ],
+ nodelay: true,
+ ..Default::default()
+ };
+
+ self.run_on_address(Arc::new(config), ("0.0.0.0", 2222))
+ .await?;
+ Ok(())
+ }
+}
+
+impl Server for AppServer {
+ type Handler = Self;
+ fn new_client(&mut self, _: Option) -> Self {
+ let s = self.clone();
+ self.id += 1;
+ s
+ }
+}
+
+impl Handler for AppServer {
+ type Error = anyhow::Error;
+
+ async fn channel_open_session(
+ &mut self,
+ channel: Channel,
+ session: &mut Session,
+ ) -> Result {
+ let terminal_handle = TerminalHandle::start(session.handle(), channel.id()).await;
+
+ let backend = CrosstermBackend::new(terminal_handle);
+
+ // the correct viewport area will be set when the client request a pty
+ let options = TerminalOptions {
+ viewport: Viewport::Fixed(Rect::default()),
+ };
+
+ let terminal = Terminal::with_options(backend, options)?;
+
+ let mut clients = self.clients.lock().await;
+ clients.insert(self.id, terminal);
+
+ Ok(true)
+ }
+
+ async fn auth_publickey(&mut self, _: &str, _: &PublicKey) -> Result {
+ Ok(Auth::Accept)
+ }
+
+ async fn data(
+ &mut self,
+ channel: ChannelId,
+ data: &[u8],
+ session: &mut Session,
+ ) -> Result<(), Self::Error> {
+ let app = self.app.clone();
+ match data {
+ // Pressing 'q' closes the connection.
+ b"q" => {
+ self.clients.lock().await.remove(&self.id);
+ session.close(channel)?;
+ }
+ // Pressing 'c' resets the counter for the app.
+ // Every client sees the counter reset.
+ b"c" => {
+ app.lock().await.counter = 0;
+ }
+ _ => {}
+ }
+
+ Ok(())
+ }
+
+ /// The client's pseudo-terminal window size has changed.
+ async fn window_change_request(
+ &mut self,
+ _: ChannelId,
+ col_width: u32,
+ row_height: u32,
+ _: u32,
+ _: u32,
+ _: &mut Session,
+ ) -> Result<(), Self::Error> {
+ let rect = Rect {
+ x: 0,
+ y: 0,
+ width: col_width as u16,
+ height: row_height as u16,
+ };
+
+ let mut clients = self.clients.lock().await;
+ clients.get_mut(&self.id).unwrap().resize(rect)?;
+
+ Ok(())
+ }
+
+ /// The client requests a pseudo-terminal with the given
+ /// specifications.
+ ///
+ /// **Note:** Success or failure should be communicated to the client by calling
+ /// `session.channel_success(channel)` or `session.channel_failure(channel)` respectively.
+ async fn pty_request(
+ &mut self,
+ channel: ChannelId,
+ _: &str,
+ col_width: u32,
+ row_height: u32,
+ _: u32,
+ _: u32,
+ _: &[(Pty, u32)],
+ session: &mut Session,
+ ) -> Result<(), Self::Error> {
+ let rect = Rect {
+ x: 0,
+ y: 0,
+ width: col_width as u16,
+ height: row_height as u16,
+ };
+
+ let mut clients = self.clients.lock().await;
+ let terminal = clients.get_mut(&self.id).unwrap();
+ terminal.resize(rect)?;
+
+ session.channel_success(channel)?;
+
+ Ok(())
+ }
+}
+
+impl Drop for AppServer {
+ fn drop(&mut self) {
+ let id = self.id;
+ let clients = self.clients.clone();
+ tokio::spawn(async move {
+ let mut clients = clients.lock().await;
+ clients.remove(&id);
+ });
+ }
+}
+
+#[tokio::main]
+async fn main() {
+ let mut server = AppServer::new();
+ server.run().await.expect("Failed running server");
+}
diff --git a/russh/examples/remote_shell_call.rs b/russh/examples/remote_shell_call.rs
deleted file mode 100644
index b77750b4..00000000
--- a/russh/examples/remote_shell_call.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-use std::io::Write;
-use std::path::Path;
-use std::sync::Arc;
-use std::time::Duration;
-
-use anyhow::Result;
-use async_trait::async_trait;
-use log::info;
-use russh::*;
-use russh_keys::*;
-use tokio::net::ToSocketAddrs;
-
-#[tokio::main]
-async fn main() -> Result<()> {
- env_logger::builder()
- .filter_level(log::LevelFilter::Debug)
- .init();
-
- let args: Vec = std::env::args().collect();
- let (host, key) = match args.get(1..3) {
- Some(args) => (&args[0], &args[1]),
- None => {
- eprintln!("Usage: {} ", args[0]);
- std::process::exit(1);
- }
- };
-
- info!("Connecting to {host}");
- info!("Key path: {key}");
-
- let mut ssh = Session::connect(key, "root", host).await?;
- let r = ssh.call("whoami").await?;
- assert!(r.success());
- println!("Result: {}", r.output());
- ssh.close().await?;
- Ok(())
-}
-
-struct Client {}
-
-#[async_trait]
-impl client::Handler for Client {
- type Error = russh::Error;
-
- async fn check_server_key(
- self,
- _server_public_key: &key::PublicKey,
- ) -> Result<(Self, bool), Self::Error> {
- Ok((self, true))
- }
-}
-
-pub struct Session {
- session: client::Handle,
-}
-
-impl Session {
- async fn connect, A: ToSocketAddrs>(
- key_path: P,
- user: impl Into,
- addrs: A,
- ) -> Result {
- let key_pair = load_secret_key(key_path, None)?;
- let config = client::Config {
- inactivity_timeout: Some(Duration::from_secs(5)),
- ..<_>::default()
- };
- let config = Arc::new(config);
- let sh = Client {};
- let mut session = client::connect(config, addrs, sh).await?;
- let _auth_res = session
- .authenticate_publickey(user, Arc::new(key_pair))
- .await?;
- Ok(Self { session })
- }
-
- async fn call(&mut self, command: &str) -> Result
