ssh-rs ✨

English | 简体中文

Rust implementation of ssh2.0 client.

If you encounter any problems in use, welcome issues or PR .

Connection method：

1. Password:

rust fn main() { let mut session: Session<TcpStream> = ssh::create_session(); session.set_user_and_password("user", "password"); session.connect("ip:port").unwrap(); }

2. Public key:

Currently, only RSA-PKCS#1-PEM type encrypted files with the encryption format -----BEGIN RSA PRIVATE KEY----- are supported.

1. Use key file path：

rust fn main() { let mut session: Session<TcpStream> = ssh::create_session(); // pem format key path -> /xxx/xxx/id_rsa // KeyPairType::SshRsa -> Rsa type algorithm, currently only supports rsa. session.set_user_and_key_pair_path("user", "pem format key path", KeyPairType::SshRsa).unwrap(); session.connect("ip:port").unwrap(); }

2. Use key string：

rust fn main() { let mut session: Session<TcpStream> = ssh::create_session(); // pem format key string: // -----BEGIN RSA PRIVATE KEY----- // xxxxxxxxxxxxxxxxxxxxx // -----END RSA PRIVATE KEY----- // KeyPairType::SshRsa -> Rsa type algorithm, currently only supports rsa. session.set_user_and_key_pair("user", "pem format key string", KeyPairType::SshRsa).unwrap(); session.connect("ip:port").unwrap(); }

Enable global logging：

```rust fn main() { // isenablelog Whether to enable global logging // The default is false(Do not enable) // Can be set as true (enable) ssh::isenablelog(true);

let mut session: Session<TcpStream> = ssh::create_session();
session.set_user_and_password("user", "password");
session.connect("ip:port").unwrap();

} ```

Set timeout：

rust fn main() { let mut session: Session<TcpStream> = ssh::create_session(); // set_timeout // The unit is seconds // The default timeout is 30 seconds session.set_timeout(15); session.set_user_and_password("user", "password"); session.connect("ip:port").unwrap(); }

How to use：

Currently only supports exec shell scp these three functions.

1. exec

rust fn main() { let mut session = session(); // Usage 1 let exec = session.open_exec().unwrap(); let vec: Vec<u8> = exec.send_command("ls -all").unwrap(); println!("{}", String::from_utf8(vec).unwrap()); // Usage 2 let channel = session.open_channel().unwrap(); let exec = channel.open_exec().unwrap(); let vec: Vec<u8> = exec.send_command("ls -all").unwrap(); println!("{}", String::from_utf8(vec).unwrap()); // Close session. session.close().unwrap(); }

2. shell

```rust fn main() { let mut session = session(); // Usage 1 let mut shell = session.openshell().unwrap(); runshell(&mut shell); // Usage 2 let channel: Channel = session.openchannel().unwrap(); let mut shell = channel.openshell().unwrap(); run_shell(&mut shell); // Close channel. shell.close().unwrap(); // Close session. session.close().unwrap(); }

fn runshell(shell: &mut ChannelShell) { sleep(Duration::frommillis(500)); let vec = shell.read().unwrap(); println!("{}", String::from_utf8(vec).unwrap());

shell.write(b"ls -all\n").unwrap();

sleep(Duration::from_millis(500));

let vec = shell.read().unwrap();
println!("{}", String::from_utf8(vec).unwrap());

} ```

3. scp

```rust fn main() { let mut session: Session = session(); // Usage 1 let scp = session.open_scp().unwrap(); scp.upload("local path", "remote path").unwrap();

let scp = session.open_scp().unwrap();
scp.download("local path", "remote path").unwrap();

// Usage 2
let channel = session.open_channel().unwrap();
let scp = channel.open_scp().unwrap();
scp.upload("local path", "remote path").unwrap();

let channel = session.open_channel().unwrap();
let scp = channel.open_scp().unwrap();
scp.download("local path", "remote path").unwrap();

session.close().unwrap();

}

```

bio:

```rust fn main() { let mut session = ssh::createsession(); let bio = MyProxy::new("ip:port"); session.setuserandpassword("user", "password"); session.connectbio(bio).unwrap(); // Usage 1 let exec = session.openexec().unwrap(); let vec: Vec = exec.sendcommand("ls -all").unwrap(); println!("{}", String::fromutf8(vec).unwrap()); // Usage 2 let channel = session.openchannel().unwrap(); let exec = channel.openexec().unwrap(); let vec: Vec = exec.sendcommand("ls -all").unwrap(); println!("{}", String::fromutf8(vec).unwrap()); // Close session. session.close().unwrap(); }

// Use a real ssh server since I don't wanna implement a ssh-server in the example codes struct MyProxy { server: TcpStream, }

impl MyProxy { fn new(addr: A) -> Self where A: ToSocketAddrs, { Self { server: TcpStream::connect(addr).unwrap(), } } }

fn flush(&mut self) -> std::io::Result<()> {
    self.server.flush()
}