ssh-wrap 0.1.1

ssh wrap
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use anyhow::bail;
use async_compat::CompatExt;
use std::string::ToString;
use wezterm_ssh::{Config, ConfigMap, Session, SessionEvent};

pub struct SessionBuilder {
    pub user: String,
    pub host: String,
    pub pass: String,
    pub port: u16,
    pub identities_only: Option<bool>,
    pub userknown_hosts_file: Option<String>,
    pub wezterm_ssh_verbose: Option<bool>,
    pub wezterm_ssh_backend: SshBackend,
}

#[derive(Display, Debug, Default)]
pub enum SshBackend {
    #[strum(serialize = "libssh")]
    Libssh,
    #[strum(serialize = "ssh2")]
    #[default]
    Ssh2,
}

impl SessionBuilder {
    pub fn new_with_pass<U, H, P>(user: U, host: H, pass: P, port: u16) -> Self
    where
        U: AsRef<str>,
        H: AsRef<str>,
        P: AsRef<str>,
    {
        Self {
            user: user.as_ref().to_string(),
            host: host.as_ref().to_string(),
            pass: pass.as_ref().to_string(),
            port,
            identities_only: None,
            userknown_hosts_file: None,
            wezterm_ssh_verbose: None,
            wezterm_ssh_backend: Default::default(),
        }
    }

    fn identities_only(&self) -> &str {
        if let Some(i) = self.identities_only {
            if i {
                return "yes";
            }
        }
        "no"
    }

    pub fn disable_userknown_hosts_file(&mut self) -> &mut Self {
        self.userknown_hosts_file = Some("/dev/null".to_string());
        self
    }

    fn wezterm_ssh_verbose(&self) -> &str {
        if let Some(i) = self.wezterm_ssh_verbose {
            if i {
                return "true";
            }
        }
        "false"
    }

    fn configmap(&self) -> ConfigMap {
        let config = Config::new();
        let mut config = config.for_host(&self.host);
        config.insert("port".to_string(), self.port.to_string());
        config.insert("user".to_string(), self.user.to_string());
        config.insert(
            "identitiesonly".to_string(),
            self.identities_only().to_string(),
        );
        config.insert(
            "wezterm_ssh_verbose".to_string(),
            self.wezterm_ssh_verbose().to_string(),
        );
        config.insert(
            "wezterm_ssh_backend".to_string(),
            self.wezterm_ssh_backend.to_string(),
        );

        if let Some(path) = &self.userknown_hosts_file {
            config.insert("userknownhostsfile".to_string(), path.to_string());
        }

        config
    }

    pub async fn connect_with_pass(&self) -> anyhow::Result<Session> {
        let (session, events) = Session::connect(self.configmap())?;
        while let Ok(event) = events.recv().await {
            match event {
                SessionEvent::Banner(banner) => {
                    info!("SessionEvent Banner:{:?}", banner);
                }
                SessionEvent::HostVerify(verify) => {
                    info!("SessionEvent HostVerify:{:?}", verify);
                    verify.answer(true).compat().await?;
                }
                SessionEvent::Authenticate(auth) => {
                    info!("SessionEvent Authenticate:{:?}", auth);
                    auth.answer(vec![self.pass.to_string()]).compat().await?;
                }
                SessionEvent::Error(err) => {
                    error!("SessionEvent Error:{:?}", err);
                    bail!(err)
                }
                SessionEvent::Authenticated => {
                    info!("SessionEvent Authenticated");
                    break;
                }
            }
        }
        Ok(session)
    }
}