Skip to main content

driftsync_core/
security.rs

1use std::fs;
2use std::path::{Component, Path, PathBuf};
3
4use crate::DriftError;
5
6pub const MAX_MANAGED_FILE_BYTES: u64 = 2 * 1024 * 1024;
7
8pub fn is_windows_reserved_device_name(segment: &str) -> bool {
9    let stem = segment.split('.').next().unwrap_or(segment).trim();
10    let upper = stem.to_ascii_uppercase();
11    matches!(
12        upper.as_str(),
13        "CON"
14            | "PRN"
15            | "AUX"
16            | "NUL"
17            | "COM1"
18            | "COM2"
19            | "COM3"
20            | "COM4"
21            | "COM5"
22            | "COM6"
23            | "COM7"
24            | "COM8"
25            | "COM9"
26            | "LPT1"
27            | "LPT2"
28            | "LPT3"
29            | "LPT4"
30            | "LPT5"
31            | "LPT6"
32            | "LPT7"
33            | "LPT8"
34            | "LPT9"
35    )
36}
37
38pub fn validate_target_name(raw: &str) -> Result<String, DriftError> {
39    let trimmed = raw.trim();
40    if trimmed.is_empty()
41        || trimmed.len() > 128
42        || trimmed.starts_with('.')
43        || trimmed.starts_with('-')
44        || trimmed.ends_with('.')
45        || trimmed.contains('/')
46        || trimmed.contains('\\')
47        || trimmed.contains(':')
48        || trimmed.contains("..")
49        || is_windows_reserved_device_name(trimmed)
50        || trimmed
51            .chars()
52            .any(|c| c.is_ascii_control() || c.is_whitespace())
53    {
54        return Err(DriftError::InvalidTargetName(raw.to_string()));
55    }
56    Ok(trimmed.to_string())
57}
58
59pub fn ensure_no_symlink_in_chain(root: &Path, relative: &Path) -> Result<PathBuf, DriftError> {
60    if root.exists() {
61        let root_meta = fs::symlink_metadata(root).map_err(|source| DriftError::Io {
62            path: root.to_path_buf(),
63            source,
64        })?;
65        if root_meta.file_type().is_symlink() {
66            return Err(DriftError::SymlinkDetected(root.to_path_buf()));
67        }
68    }
69
70    let mut current = root.to_path_buf();
71    for comp in relative.components() {
72        if let Component::Normal(part) = comp {
73            current.push(part);
74            if let Ok(meta) = fs::symlink_metadata(&current)
75                && meta.file_type().is_symlink()
76            {
77                return Err(DriftError::SymlinkDetected(current));
78            }
79        }
80    }
81    Ok(current)
82}
83
84pub fn read_bounded_file(path: &Path) -> Result<String, DriftError> {
85    let meta = fs::symlink_metadata(path).map_err(|source| DriftError::Io {
86        path: path.to_path_buf(),
87        source,
88    })?;
89    if meta.file_type().is_symlink() {
90        return Err(DriftError::SymlinkDetected(path.to_path_buf()));
91    }
92    if meta.len() > MAX_MANAGED_FILE_BYTES {
93        return Err(DriftError::FileTooLarge {
94            path: path.to_path_buf(),
95            size_bytes: meta.len(),
96            max_bytes: MAX_MANAGED_FILE_BYTES,
97        });
98    }
99    fs::read_to_string(path).map_err(|source| DriftError::Io {
100        path: path.to_path_buf(),
101        source,
102    })
103}
104
105pub fn scan_for_hardcoded_secrets(content: &str) -> Option<&'static str> {
106    for header in [
107        "-----BEGIN RSA PRIVATE KEY-----",
108        "-----BEGIN OPENSSH PRIVATE KEY-----",
109        "-----BEGIN EC PRIVATE KEY-----",
110        "-----BEGIN PRIVATE KEY-----",
111        "-----BEGIN DSA PRIVATE KEY-----",
112    ] {
113        if content.contains(header) {
114            return Some("PEM Private Key");
115        }
116    }
117
118    for token in tokenize_candidates(content) {
119        if let Some(rest) = token
120            .strip_prefix("ghp_")
121            .or_else(|| token.strip_prefix("gho_"))
122            .or_else(|| token.strip_prefix("ghs_"))
123            .or_else(|| token.strip_prefix("ghu_"))
124            && rest.len() >= 20
125            && rest.chars().all(|c| c.is_ascii_alphanumeric())
126        {
127            return Some("GitHub Personal Access Token");
128        }
129        if let Some(rest) = token.strip_prefix("github_pat_")
130            && rest.len() >= 20
131            && rest.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
132        {
133            return Some("GitHub Fine-Grained PAT");
134        }
135        if let Some(rest) = token.strip_prefix("glpat-")
136            && rest.len() >= 20
137            && rest
138                .chars()
139                .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
140        {
141            return Some("GitLab Personal Access Token");
142        }
143        if let Some(rest) = token.strip_prefix("AKIA")
144            && rest.len() == 16
145            && rest
146                .chars()
147                .all(|c| c.is_ascii_uppercase() || c.is_ascii_digit())
148        {
149            return Some("AWS Access Key ID");
150        }
151        if let Some(rest) = token
152            .strip_prefix("xoxb-")
153            .or_else(|| token.strip_prefix("xoxp-"))
154            .or_else(|| token.strip_prefix("xoxa-"))
155            .or_else(|| token.strip_prefix("xoxr-"))
156            && rest.len() >= 12
157            && rest.chars().all(|c| c.is_ascii_alphanumeric() || c == '-')
158        {
159            return Some("Slack Token");
160        }
161        if let Some(rest) = token.strip_prefix("sk-")
162            && rest.len() >= 24
163            && rest
164                .chars()
165                .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
166        {
167            return Some("API Secret Key (sk-*)");
168        }
169    }
170
171    None
172}
173
174fn tokenize_candidates(content: &str) -> impl Iterator<Item = &str> {
175    content.split(|c: char| {
176        c.is_whitespace()
177            || matches!(
178                c,
179                '"' | '\'' | '`' | ',' | ';' | '(' | ')' | '[' | ']' | '{' | '}' | '='
180            )
181    })
182}
183
184pub fn redact_sensitive_text(input: &str) -> String {
185    let mut out = String::with_capacity(input.len());
186    for line in input.split_inclusive('\n') {
187        out.push_str(&redact_line(line));
188    }
189    out
190}
191
192fn redact_line(line: &str) -> String {
193    let mut masked = line.to_string();
194
195    for scheme in ["https://", "http://", "ssh://"] {
196        if let Some(scheme_idx) = masked.find(scheme) {
197            let after_scheme_start = scheme_idx + scheme.len();
198            let after_scheme = &masked[after_scheme_start..];
199            let host_end = after_scheme
200                .find(['/', ' ', '"', '\'', '\n', '\r'])
201                .unwrap_or(after_scheme.len());
202            let authority = &after_scheme[..host_end];
203            if let Some(at_idx) = authority.find('@') {
204                let userinfo = &authority[..at_idx];
205                if scheme != "ssh://" || userinfo.contains(':') || userinfo != "git" {
206                    let prefix = &masked[..after_scheme_start];
207                    let suffix = &after_scheme[at_idx..];
208                    masked = format!("{prefix}[REDACTED]{suffix}");
209                }
210            }
211        }
212    }
213
214    for prefix in [
215        "ghp_",
216        "gho_",
217        "ghs_",
218        "ghu_",
219        "github_pat_",
220        "glpat-",
221        "AKIA",
222        "xoxb-",
223        "xoxp-",
224        "sk-",
225    ] {
226        let mut search_from = 0;
227        while let Some(rel_idx) = masked[search_from..].find(prefix) {
228            let start = search_from + rel_idx;
229            let after_prefix = &masked[start + prefix.len()..];
230            let token_len: usize = after_prefix
231                .chars()
232                .take_while(|c| c.is_ascii_alphanumeric() || *c == '_' || *c == '-')
233                .map(char::len_utf8)
234                .sum();
235            if token_len >= 12 {
236                let end = start + prefix.len() + token_len;
237                let replacement = format!("{prefix}[REDACTED]");
238                masked.replace_range(start..end, &replacement);
239                search_from = start + replacement.len();
240            } else {
241                search_from = start + prefix.len();
242            }
243        }
244    }
245
246    masked
247}