sshkeyman 0.1.2

Web-based SSH key & config manager in Rust. 
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
121
122
123
124
125
126
127
128

use askama::Template;
use axum::extract::{Form, Query};
use axum::http::HeaderMap;
use axum::response::{Html, Redirect};
use serde::Deserialize;

use crate::i18n::{Locale, LocaleMap};
use crate::remote;

#[derive(Template)]
#[template(path = "remote_copy.html")]
pub struct RemoteCopyTemplate {
    pub key_name: String,
    pub flash: Option<String>,
    pub flash_is_error: bool,
    pub t: &'static LocaleMap,
}

#[derive(Deserialize)]
pub struct CopyQuery {
    pub flash_error: Option<String>,
    pub flash_param: Option<String>,
}

pub async fn copy_page(
    axum::extract::Path(name): axum::extract::Path<String>,
    Query(query): Query<CopyQuery>,
    headers: HeaderMap,
) -> Html<String> {
    let locale =
        Locale::from_accept_language(headers.get("accept-language").and_then(|v| v.to_str().ok()));

    let flash_is_error = query.flash_error.is_some();
    let flash = query
        .flash_error
        .map(|msg| locale.resolve_flash(&msg, query.flash_param.as_deref()));

    let tmpl = RemoteCopyTemplate {
        key_name: name,
        flash,
        flash_is_error,
        t: locale.map,
    };

    Html(
        tmpl.render()
            .unwrap_or_else(|e| format!("Template error: {}", e)),
    )
}

#[derive(Deserialize)]
pub struct CopyForm {
    pub key_name: String,
    pub host: String,
    pub port: String,
    pub username: String,
    pub auth_method: String,
    pub password: String,
    pub key_path: String,
    pub passphrase: String,
}

pub async fn copy_execute(Form(form): Form<CopyForm>) -> Redirect {
    let port: u16 = form.port.parse().unwrap_or(22);

    let password = if form.password.is_empty() {
        None
    } else {
        Some(form.password.as_str())
    };
    let key_path = if form.key_path.is_empty() {
        None
    } else {
        Some(form.key_path.as_str())
    };
    let passphrase = if form.passphrase.is_empty() {
        None
    } else {
        Some(form.passphrase.as_str())
    };

    // Client-side validation fallback — show errors inline
    if form.host.trim().is_empty() {
        return Redirect::to(&format!(
            "/copy/{}?flash_error=flash_validation_host_required",
            form.key_name
        ));
    }
    if form.username.trim().is_empty() {
        return Redirect::to(&format!(
            "/copy/{}?flash_error=flash_validation_username_required",
            form.key_name
        ));
    }
    if form.auth_method == "password" && form.password.is_empty() {
        return Redirect::to(&format!(
            "/copy/{}?flash_error=flash_validation_password_required",
            form.key_name
        ));
    }
    if form.auth_method == "key" && form.key_path.is_empty() {
        return Redirect::to(&format!(
            "/copy/{}?flash_error=flash_validation_key_path_required",
            form.key_name
        ));
    }

    match remote::copy_key_to_remote(&remote::RemoteCopyConfig {
        key_name: &form.key_name,
        host: form.host.trim(),
        port,
        username: form.username.trim(),
        auth_method: &form.auth_method,
        password,
        key_path,
        passphrase,
    }) {
        Ok(()) => Redirect::to(&format!(
            "/?selected={}&flash=flash_copy_success&flash_param={}",
            form.key_name, form.host
        )),
        Err(e) => Redirect::to(&format!(
            "/copy/{}?flash_error={}",
            form.key_name,
            e.replace(' ', "+")
        )),
    }
}