rustploy 0.1.2

Rustploy PaaS daemon — lightweight self-hosted deployment platform
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Validação de `<name>`, `<reference>` (tag) e `<digest>` da OCI Distribution
//! Spec — implementada como scanner manual (sem a crate `regex`) porque a
//! gramática é regular e pequena. Ver `docs/plano-registry-embutido.md`.
//!
//! Gramática de `<name>` (distribution/reference/regexp.go):
//!   alphanumeric := [a-z0-9]+
//!   separator    := '.' | '_' | '__' | '-'+
//!   component    := alphanumeric (separator alphanumeric)*
//!   name         := component ('/' component)*        (máx. 255 chars)
//!
//! Por construção só aceita `[a-z0-9._/-]`, o que já rejeita path traversal
//! (`..`, `../`, `\`), maiúsculas, `:` e componentes vazios (`//`, `/` líder
//! ou final) — crítico porque `<name>` vira caminho de arquivo no storage CAS.

/// Valida `<name>` contra a gramática OCI distribution-spec.
pub fn is_valid_name(name: &str) -> bool {
    if name.is_empty() || name.len() > 255 {
        return false;
    }
    name.split('/').all(is_valid_component)
}

fn is_alnum(b: u8) -> bool {
    b.is_ascii_lowercase() || b.is_ascii_digit()
}

fn is_valid_component(c: &str) -> bool {
    let b = c.as_bytes();
    if b.is_empty() {
        return false;
    }
    if !is_alnum(b[0]) {
        return false;
    }
    let mut i = 1;
    while i < b.len() && is_alnum(b[i]) {
        i += 1;
    }
    while i < b.len() {
        // Consome exatamente um token separador: '.', '_', "__" ou '-'+.
        match b[i] {
            b'.' => i += 1,
            b'_' => {
                i += 1;
                if i < b.len() && b[i] == b'_' {
                    i += 1; // "__" é um único separador; "___" não existe na gramática
                }
            }
            b'-' => {
                while i < b.len() && b[i] == b'-' {
                    i += 1;
                }
            }
            _ => return false,
        }
        // Todo separador tem que ser seguido por pelo menos um alfanumérico
        // (senão o componente termina em separador, ou há dois seguidos).
        let run_start = i;
        while i < b.len() && is_alnum(b[i]) {
            i += 1;
        }
        if i == run_start {
            return false;
        }
    }
    true
}

/// Valida `<reference>` quando não é um digest — regex da spec:
/// `[a-zA-Z0-9_][a-zA-Z0-9._-]{0,127}` (máx. 128 chars).
pub fn is_valid_tag(tag: &str) -> bool {
    let b = tag.as_bytes();
    if b.is_empty() || b.len() > 128 {
        return false;
    }
    let is_head = |c: u8| c.is_ascii_alphanumeric() || c == b'_';
    let is_tail = |c: u8| c.is_ascii_alphanumeric() || matches!(c, b'.' | b'_' | b'-');
    is_head(b[0]) && b[1..].iter().all(|&c| is_tail(c))
}

/// Extrai os 64 hex lowercase de `sha256:<hex>`. Único algoritmo suportado
/// nesta fase.
pub fn parse_digest(s: &str) -> Option<&str> {
    let hex = s.strip_prefix("sha256:")?;
    (hex.len() == 64 && hex.bytes().all(|b| b.is_ascii_hexdigit())).then_some(hex)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn rejeita_path_traversal_e_formatos_invalidos() {
        let bad = [
            "../etc/passwd",
            "..",
            "app/../etc",
            "app/..",
            "a/./b",
            "App",
            "a:b",
            "a\\b",
            "",
            "a//b",
            "/a",
            "a/",
            "-a",
            "a-",
            ".a",
            "a.",
            "a..b",
            "a___b",
            &"a".repeat(256),
        ];
        for name in bad {
            assert!(!is_valid_name(name), "aceitou indevidamente: {name:?}");
        }
    }

    #[test]
    fn aceita_nomes_validos() {
        let good = ["hello", "myorg/app", "a/b/c-1_2.3", "a__b", "a--b", "a.b.c"];
        for name in good {
            assert!(is_valid_name(name), "rejeitou indevidamente: {name:?}");
        }
    }

    #[test]
    fn valida_tags() {
        assert!(is_valid_tag("v1"));
        assert!(is_valid_tag("latest"));
        assert!(is_valid_tag("1.0.0-rc1"));
        assert!(!is_valid_tag(""));
        assert!(!is_valid_tag(".v1"));
        assert!(!is_valid_tag(&"a".repeat(129)));
    }

    #[test]
    fn valida_digest() {
        let hex = "a".repeat(64);
        let digest = format!("sha256:{hex}");
        assert_eq!(parse_digest(&digest), Some(hex.as_str()));
        assert_eq!(parse_digest("sha256:abc"), None);
        assert_eq!(parse_digest("md5:abc"), None);
        assert_eq!(parse_digest(&format!("sha256:{}", "Z".repeat(64))), None);
    }
}