ssh_cli/vps/
modelo.rs

1//! Modelo de dados `VpsRegistro` (schema v2).
2//!
3//! Senhas usam `SecretString` para zeroize automático via `Drop`. O TOML
4//! gravado em disco: texto claro (0o600) ou cifrado (`sshcli-enc:v1:`) se houver chave mestra.
5//! `Debug` é customizado para NUNCA expor valores sensíveis.
6//!
7//! Schema v2: auth por senha **ou** chave, dualidade max_command/max_output,
8//! `disable_sudo` e migração automática de `max_chars` legado.
9
10use secrecy::{ExposeSecret, SecretString};
11use serde::{Deserialize, Serialize};
12
13/// Versão atual do schema do arquivo `config.toml`.
14pub const SCHEMA_VERSION_ATUAL: u32 = 2;
15
16/// Timeout padrão em milissegundos (default 60s).
17pub const TIMEOUT_PADRAO_MS: u64 = 60_000;
18
19/// Limite padrão de caracteres no **comando** (automação one-shot maxChars).
20pub const MAX_COMMAND_CHARS_PADRAO: usize = 1_000;
21
22/// Limite padrão de caracteres em **output** capturado.
23pub const MAX_OUTPUT_CHARS_PADRAO: usize = 100_000;
24
25/// Registro de uma VPS no arquivo de configuração.
26#[derive(Clone, Serialize, Deserialize)]
27pub struct VpsRegistro {
28    /// Nome lógico único da VPS.
29    pub nome: String,
30    /// Hostname ou IP do servidor.
31    pub host: String,
32    /// Porta SSH.
33    pub porta: u16,
34    /// Usuário SSH.
35    pub usuario: String,
36    /// Senha SSH (vazia se auth só por chave).
37    #[serde(default, with = "secret_string_serde")]
38    pub senha: SecretString,
39    /// Caminho absoluto ou expandível para chave privada OpenSSH.
40    #[serde(default)]
41    pub key_path: Option<String>,
42    /// Passphrase da chave privada (opcional).
43    #[serde(default, with = "opcao_secret_string_serde")]
44    pub key_passphrase: Option<SecretString>,
45    /// Timeout em milissegundos.
46    pub timeout_ms: u64,
47    /// Limite de caracteres do comando (entrada). `0` = ilimitado em runtime.
48    #[serde(default = "default_max_command_chars")]
49    pub max_command_chars: usize,
50    /// Limite de caracteres de stdout/stderr. Aceita alias legado `max_chars`.
51    #[serde(default = "default_max_output_chars", alias = "max_chars")]
52    pub max_output_chars: usize,
53    /// Senha para `sudo` (opcional).
54    #[serde(default, with = "opcao_secret_string_serde")]
55    pub senha_sudo: Option<SecretString>,
56    /// Senha para `su -` (opcional).
57    #[serde(default, with = "opcao_secret_string_serde")]
58    pub senha_su: Option<SecretString>,
59    /// Se true, `sudo-exec` e `su-exec` são recusados para este host.
60    #[serde(default)]
61    pub disable_sudo: bool,
62    /// Versão do schema deste registro.
63    pub schema_version: u32,
64    /// Timestamp RFC 3339 de inclusão.
65    pub adicionado_em: String,
66}
67
68fn default_max_command_chars() -> usize {
69    MAX_COMMAND_CHARS_PADRAO
70}
71
72fn default_max_output_chars() -> usize {
73    MAX_OUTPUT_CHARS_PADRAO
74}
75
76impl std::fmt::Debug for VpsRegistro {
77    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78        f.debug_struct("VpsRegistro")
79            .field("nome", &self.nome)
80            .field("host", &self.host)
81            .field("porta", &self.porta)
82            .field("usuario", &self.usuario)
83            .field("senha", &"<redacted>")
84            .field("key_path", &self.key_path)
85            .field(
86                "key_passphrase",
87                &self.key_passphrase.as_ref().map(|_| "<redacted>"),
88            )
89            .field("timeout_ms", &self.timeout_ms)
90            .field("max_command_chars", &self.max_command_chars)
91            .field("max_output_chars", &self.max_output_chars)
92            .field(
93                "senha_sudo",
94                &self.senha_sudo.as_ref().map(|_| "<redacted>"),
95            )
96            .field("senha_su", &self.senha_su.as_ref().map(|_| "<redacted>"))
97            .field("disable_sudo", &self.disable_sudo)
98            .field("schema_version", &self.schema_version)
99            .field("adicionado_em", &self.adicionado_em)
100            .finish()
101    }
102}
103
104impl VpsRegistro {
105    /// Cria um novo registro aplicando defaults.
106    #[must_use]
107    #[allow(clippy::too_many_arguments)]
108    pub fn novo(
109        nome: String,
110        host: String,
111        porta: u16,
112        usuario: String,
113        senha: SecretString,
114        key_path: Option<String>,
115        key_passphrase: Option<SecretString>,
116        timeout_ms: Option<u64>,
117        max_command_chars: Option<usize>,
118        max_output_chars: Option<usize>,
119        senha_sudo: Option<SecretString>,
120        senha_su: Option<SecretString>,
121        disable_sudo: bool,
122    ) -> Self {
123        Self {
124            nome,
125            host,
126            porta,
127            usuario,
128            senha,
129            key_path,
130            key_passphrase,
131            timeout_ms: timeout_ms.unwrap_or(TIMEOUT_PADRAO_MS),
132            max_command_chars: max_command_chars.unwrap_or(MAX_COMMAND_CHARS_PADRAO),
133            max_output_chars: max_output_chars.unwrap_or(MAX_OUTPUT_CHARS_PADRAO),
134            senha_sudo,
135            senha_su,
136            disable_sudo,
137            schema_version: SCHEMA_VERSION_ATUAL,
138            adicionado_em: chrono::Utc::now().to_rfc3339(),
139        }
140    }
141
142    /// Retorna true se há senha não vazia.
143    #[must_use]
144    pub fn tem_senha(&self) -> bool {
145        !self.senha.expose_secret().is_empty()
146    }
147
148    /// Retorna true se há caminho de chave privada.
149    #[must_use]
150    pub fn tem_chave(&self) -> bool {
151        self.key_path.as_ref().is_some_and(|p| !p.trim().is_empty())
152    }
153
154    /// Valida que existe pelo menos um método de autenticação.
155    pub fn validar_credenciais(&self) -> Result<(), String> {
156        if !self.tem_senha() && !self.tem_chave() {
157            return Err(
158                "é obrigatório fornecer --password ou --key (auth password ou chave privada)"
159                    .to_string(),
160            );
161        }
162        Ok(())
163    }
164
165    /// Normaliza schema após deserialização (migração v1 → v2).
166    pub fn normalizar_schema(&mut self) {
167        if self.schema_version < SCHEMA_VERSION_ATUAL {
168            self.schema_version = SCHEMA_VERSION_ATUAL;
169        }
170        if self.max_command_chars == 0 && self.max_output_chars == 0 {
171            // nada: 0 significa ilimitado na validação de runtime
172        }
173    }
174}
175
176/// Interpreta string de limite (`"none"`, `"0"` ou número).
177///
178/// `0`/`none` → `0` (ilimitado no runtime).
179#[must_use]
180pub fn parse_limite_chars(s: &str) -> usize {
181    let t = s.trim();
182    if t.eq_ignore_ascii_case("none") || t == "0" {
183        0
184    } else {
185        t.parse().unwrap_or(MAX_OUTPUT_CHARS_PADRAO)
186    }
187}
188
189/// Converte limite de config em valor efetivo para truncagem/validação.
190///
191/// `0` = sem limite (`usize::MAX` para comparação).
192#[must_use]
193pub fn limite_efetivo(configurado: usize) -> usize {
194    if configurado == 0 {
195        usize::MAX
196    } else {
197        configurado
198    }
199}
200
201mod secret_string_serde {
202    use super::{ExposeSecret, SecretString};
203    use serde::{Deserialize, Deserializer, Serializer};
204
205    pub fn serialize<S: Serializer>(valor: &SecretString, s: S) -> Result<S::Ok, S::Error> {
206        let plain = valor.expose_secret();
207        let out = crate::secrets::serializar_segredo(plain).map_err(serde::ser::Error::custom)?;
208        s.serialize_str(&out)
209    }
210
211    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<SecretString, D::Error> {
212        let s = String::deserialize(d)?;
213        let plain = crate::secrets::deserializar_segredo(&s).map_err(serde::de::Error::custom)?;
214        Ok(SecretString::from(plain))
215    }
216}
217
218mod opcao_secret_string_serde {
219    use super::{ExposeSecret, SecretString};
220    use serde::{Deserialize, Deserializer, Serializer};
221
222    pub fn serialize<S: Serializer>(valor: &Option<SecretString>, s: S) -> Result<S::Ok, S::Error> {
223        match valor {
224            Some(v) => {
225                let out = crate::secrets::serializar_segredo(v.expose_secret())
226                    .map_err(serde::ser::Error::custom)?;
227                s.serialize_some(&out)
228            }
229            None => s.serialize_none(),
230        }
231    }
232
233    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Option<SecretString>, D::Error> {
234        let opt = Option::<String>::deserialize(d)?;
235        match opt {
236            None => Ok(None),
237            Some(s) => {
238                let plain =
239                    crate::secrets::deserializar_segredo(&s).map_err(serde::de::Error::custom)?;
240                Ok(Some(SecretString::from(plain)))
241            }
242        }
243    }
244}
245
246#[cfg(test)]
247mod testes {
248    use super::*;
249
250    #[test]
251    fn novo_registro_aplica_defaults() {
252        let r = VpsRegistro::novo(
253            "teste".into(),
254            "1.2.3.4".into(),
255            22,
256            "root".into(),
257            SecretString::from("senha".to_string()),
258            None,
259            None,
260            None,
261            None,
262            None,
263            None,
264            None,
265            false,
266        );
267        assert_eq!(r.timeout_ms, TIMEOUT_PADRAO_MS);
268        assert_eq!(r.max_command_chars, MAX_COMMAND_CHARS_PADRAO);
269        assert_eq!(r.max_output_chars, MAX_OUTPUT_CHARS_PADRAO);
270        assert_eq!(r.schema_version, SCHEMA_VERSION_ATUAL);
271        assert!(!r.adicionado_em.is_empty());
272    }
273
274    #[test]
275    fn debug_nao_exibe_senha() {
276        let r = VpsRegistro::novo(
277            "t".into(),
278            "h".into(),
279            22,
280            "u".into(),
281            SecretString::from("senha-super-secreta".to_string()),
282            None,
283            None,
284            None,
285            None,
286            None,
287            None,
288            None,
289            false,
290        );
291        let dbg = format!("{r:?}");
292        assert!(!dbg.contains("senha-super-secreta"));
293        assert!(dbg.contains("redacted"));
294    }
295
296    #[test]
297    fn round_trip_toml_preserva_dados() {
298        let r = VpsRegistro::novo(
299            "producao".into(),
300            "srv.exemplo.com".into(),
301            2222,
302            "admin".into(),
303            SecretString::from("senha-do-admin-longa".to_string()),
304            Some("/home/u/.ssh/id_ed25519".into()),
305            None,
306            Some(5000),
307            Some(500),
308            Some(50_000),
309            Some(SecretString::from("sudopass".to_string())),
310            None,
311            false,
312        );
313        let toml_str = toml::to_string(&r).expect("serializar");
314        let r2: VpsRegistro = toml::from_str(&toml_str).expect("deserializar");
315        assert_eq!(r2.nome, "producao");
316        assert_eq!(r2.porta, 2222);
317        assert_eq!(r2.senha.expose_secret(), "senha-do-admin-longa");
318        assert_eq!(r2.key_path.as_deref(), Some("/home/u/.ssh/id_ed25519"));
319        assert_eq!(r2.max_command_chars, 500);
320        assert_eq!(r2.max_output_chars, 50_000);
321        assert_eq!(
322            r2.senha_sudo
323                .as_ref()
324                .map(|s| s.expose_secret().to_string()),
325            Some("sudopass".to_string())
326        );
327        assert!(r2.senha_su.is_none());
328    }
329
330    #[test]
331    fn migra_max_chars_legado() {
332        let legado = r#"
333nome = "x"
334host = "h"
335porta = 22
336usuario = "u"
337senha = "s"
338timeout_ms = 30000
339max_chars = 4242
340schema_version = 1
341adicionado_em = "2020-01-01T00:00:00Z"
342"#;
343        let r: VpsRegistro = toml::from_str(legado).expect("deserializar legado");
344        assert_eq!(r.max_output_chars, 4242);
345        assert_eq!(r.max_command_chars, MAX_COMMAND_CHARS_PADRAO);
346    }
347
348    #[test]
349    fn validar_credenciais_exige_password_ou_key() {
350        let mut r = VpsRegistro::novo(
351            "t".into(),
352            "h".into(),
353            22,
354            "u".into(),
355            SecretString::from(String::new()),
356            None,
357            None,
358            None,
359            None,
360            None,
361            None,
362            None,
363            false,
364        );
365        assert!(r.validar_credenciais().is_err());
366        r.key_path = Some("/tmp/k".into());
367        assert!(r.validar_credenciais().is_ok());
368    }
369
370    #[test]
371    fn parse_limite_none_e_zero() {
372        assert_eq!(parse_limite_chars("none"), 0);
373        assert_eq!(parse_limite_chars("0"), 0);
374        assert_eq!(parse_limite_chars("1000"), 1000);
375        assert_eq!(limite_efetivo(0), usize::MAX);
376        assert_eq!(limite_efetivo(10), 10);
377    }
378}
ssh_cli/vps/modelo.rs

ssh_cli/vps/
modelo.rs
