driftsync_core/
security.rs1use 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(¤t)
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}