Skip to content

Commit 95c7f91

Browse files
committed
feat(sandbox): L7 credential injection — query param rewriting and Basic auth encoding
Add two credential injection capabilities to the L7 proxy's SecretResolver: 1. Query parameter rewriting: resolve placeholder tokens in URL query parameter values (e.g. ?api_key=openshell:resolve:env:KEY) with proper percent-encoding of the resolved secret. 2. Basic Authorization header encoding: decode base64 Basic auth tokens, resolve placeholder tokens in the decoded username:password string, and re-encode before forwarding upstream. Both features operate within the existing rewrite_http_header_block flow and require no changes to the network policy file spec or proto schema. Closes NVIDIA#630
1 parent a7ebf3a commit 95c7f91

2 files changed

Lines changed: 346 additions & 1 deletion

File tree

‎crates/openshell-sandbox/Cargo.toml‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,9 @@ webpki-roots = { workspace = true }
5252
# HTTP
5353
bytes = { workspace = true }
5454

55+
# Encoding
56+
base64 = { workspace = true }
57+
5558
# IP network / CIDR parsing
5659
ipnet = "2"
5760

‎crates/openshell-sandbox/src/secrets.rs‎

Lines changed: 343 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
22
// SPDX-License-Identifier: Apache-2.0
33

4+
use base64::Engine as _;
45
use std::collections::HashMap;
56

67
const PLACEHOLDER_PREFIX: &str = "openshell:resolve:env:";
@@ -35,17 +36,59 @@ impl SecretResolver {
3536
}
3637

3738
pub(crate) fn rewrite_header_value(&self, value: &str) -> Option<String> {
39+
// Direct placeholder match: `x-api-key: openshell:resolve:env:KEY`
3840
if let Some(secret) = self.resolve_placeholder(value.trim()) {
3941
return Some(secret.to_string());
4042
}
4143

4244
let trimmed = value.trim();
45+
46+
// Basic auth decoding: `Basic <base64>` where the decoded content
47+
// contains a placeholder (e.g. `user:openshell:resolve:env:PASS`).
48+
// Decode, rewrite placeholders in the decoded string, re-encode.
49+
if let Some(encoded) = trimmed.strip_prefix("Basic ").map(str::trim) {
50+
if let Some(rewritten) = self.rewrite_basic_auth_token(encoded) {
51+
return Some(format!("Basic {rewritten}"));
52+
}
53+
}
54+
55+
// Prefixed placeholder: `Bearer openshell:resolve:env:KEY`
4356
let split_at = trimmed.find(char::is_whitespace)?;
4457
let prefix = &trimmed[..split_at];
4558
let candidate = trimmed[split_at..].trim();
4659
let secret = self.resolve_placeholder(candidate)?;
4760
Some(format!("{prefix} {secret}"))
4861
}
62+
63+
/// Decode a Base64-encoded Basic auth token, resolve any placeholders in
64+
/// the decoded `username:password` string, and re-encode.
65+
///
66+
/// Returns `None` if decoding fails or no placeholders are found.
67+
fn rewrite_basic_auth_token(&self, encoded: &str) -> Option<String> {
68+
let b64 = base64::engine::general_purpose::STANDARD;
69+
let decoded_bytes = b64.decode(encoded.trim()).ok()?;
70+
let decoded = std::str::from_utf8(&decoded_bytes).ok()?;
71+
72+
// Check if the decoded string contains any placeholder
73+
if !decoded.contains(PLACEHOLDER_PREFIX) {
74+
return None;
75+
}
76+
77+
// Rewrite all placeholder occurrences in the decoded string
78+
let mut rewritten = decoded.to_string();
79+
for (placeholder, secret) in &self.by_placeholder {
80+
if rewritten.contains(placeholder.as_str()) {
81+
rewritten = rewritten.replace(placeholder.as_str(), secret);
82+
}
83+
}
84+
85+
// Only return if we actually changed something
86+
if rewritten == decoded {
87+
return None;
88+
}
89+
90+
Some(b64.encode(rewritten.as_bytes()))
91+
}
4992
}
5093

5194
pub(crate) fn placeholder_for_env_key(key: &str) -> String {
@@ -68,7 +111,7 @@ pub(crate) fn rewrite_http_header_block(raw: &[u8], resolver: Option<&SecretReso
68111
};
69112

70113
let mut output = Vec::with_capacity(raw.len());
71-
output.extend_from_slice(request_line.as_bytes());
114+
output.extend_from_slice(rewrite_request_line(request_line, resolver).as_bytes());
72115
output.extend_from_slice(b"\r\n");
73116

74117
for line in lines {
@@ -96,6 +139,117 @@ pub(crate) fn rewrite_header_line(line: &str, resolver: &SecretResolver) -> Stri
96139
}
97140
}
98141

142+
/// Rewrite credential placeholders in the request line's URL query parameters.
143+
///
144+
/// Given a request line like `GET /api?key=openshell:resolve:env:API_KEY HTTP/1.1`,
145+
/// resolves placeholders in query parameter values and percent-encodes the
146+
/// resolved secret. Handles URLs with multiple query parameters and preserves
147+
/// parameters that don't contain placeholders.
148+
fn rewrite_request_line(line: &str, resolver: &SecretResolver) -> String {
149+
// Request line format: METHOD SP REQUEST-URI SP HTTP-VERSION
150+
let mut parts = line.splitn(3, ' ');
151+
let method = match parts.next() {
152+
Some(m) => m,
153+
None => return line.to_string(),
154+
};
155+
let uri = match parts.next() {
156+
Some(u) => u,
157+
None => return line.to_string(),
158+
};
159+
let version = match parts.next() {
160+
Some(v) => v,
161+
None => return line.to_string(),
162+
};
163+
164+
// Only rewrite if the URI contains a placeholder
165+
if !uri.contains(PLACEHOLDER_PREFIX) {
166+
return line.to_string();
167+
}
168+
169+
let rewritten_uri = rewrite_uri_query_params(uri, resolver);
170+
format!("{method} {rewritten_uri} {version}")
171+
}
172+
173+
/// Rewrite placeholders in query parameter values of a URI.
174+
///
175+
/// Splits the URI at `?`, parses key=value pairs from the query string,
176+
/// resolves any placeholder values, and percent-encodes the resolved secrets.
177+
/// Parameters without placeholders are preserved verbatim.
178+
fn rewrite_uri_query_params(uri: &str, resolver: &SecretResolver) -> String {
179+
let Some((path, query)) = uri.split_once('?') else {
180+
return uri.to_string();
181+
};
182+
183+
let mut rewritten_params = Vec::new();
184+
for param in query.split('&') {
185+
if let Some((key, value)) = param.split_once('=') {
186+
// Percent-decode the value before checking for placeholder
187+
let decoded_value = percent_decode(value);
188+
if let Some(secret) = resolver.resolve_placeholder(&decoded_value) {
189+
rewritten_params.push(format!("{key}={}", percent_encode(secret)));
190+
} else {
191+
rewritten_params.push(param.to_string());
192+
}
193+
} else {
194+
rewritten_params.push(param.to_string());
195+
}
196+
}
197+
198+
format!("{path}?{}", rewritten_params.join("&"))
199+
}
200+
201+
/// Percent-encode a string for safe use in URL query parameter values.
202+
///
203+
/// Encodes all characters except unreserved characters (RFC 3986 Section 2.3):
204+
/// ALPHA / DIGIT / "-" / "." / "_" / "~"
205+
fn percent_encode(input: &str) -> String {
206+
let mut encoded = String::with_capacity(input.len());
207+
for byte in input.bytes() {
208+
match byte {
209+
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {
210+
encoded.push(byte as char);
211+
}
212+
_ => {
213+
encoded.push_str(&format!("%{byte:02X}"));
214+
}
215+
}
216+
}
217+
encoded
218+
}
219+
220+
/// Percent-decode a URL-encoded string.
221+
fn percent_decode(input: &str) -> String {
222+
let mut decoded = Vec::with_capacity(input.len());
223+
let mut bytes = input.bytes();
224+
while let Some(b) = bytes.next() {
225+
if b == b'%' {
226+
let hi = bytes.next();
227+
let lo = bytes.next();
228+
if let (Some(h), Some(l)) = (hi, lo) {
229+
let hex = [h, l];
230+
if let Ok(s) = std::str::from_utf8(&hex) {
231+
if let Ok(val) = u8::from_str_radix(s, 16) {
232+
decoded.push(val);
233+
continue;
234+
}
235+
}
236+
// Invalid percent encoding — preserve verbatim
237+
decoded.push(b'%');
238+
decoded.push(h);
239+
decoded.push(l);
240+
} else {
241+
decoded.push(b'%');
242+
if let Some(h) = hi {
243+
decoded.push(h);
244+
}
245+
}
246+
} else {
247+
decoded.push(b);
248+
}
249+
}
250+
String::from_utf8_lossy(&decoded).into_owned()
251+
}
252+
99253
#[cfg(test)]
100254
mod tests {
101255
use super::*;
@@ -259,4 +413,192 @@ mod tests {
259413
let rewritten = rewrite_http_header_block(raw, None);
260414
assert_eq!(raw.as_slice(), rewritten.as_slice());
261415
}
416+
417+
// --- Query parameter rewriting tests ---
418+
419+
#[test]
420+
fn rewrites_query_param_placeholder_in_request_line() {
421+
let (child_env, resolver) = SecretResolver::from_provider_env(
422+
[("YOUTUBE_API_KEY".to_string(), "AIzaSy-secret".to_string())]
423+
.into_iter()
424+
.collect(),
425+
);
426+
let placeholder = child_env.get("YOUTUBE_API_KEY").unwrap();
427+
428+
let raw = format!(
429+
"GET /youtube/v3/search?part=snippet&key={placeholder} HTTP/1.1\r\n\
430+
Host: www.googleapis.com\r\n\r\n"
431+
);
432+
let rewritten = rewrite_http_header_block(raw.as_bytes(), resolver.as_ref());
433+
let rewritten = String::from_utf8(rewritten).expect("utf8");
434+
435+
assert!(
436+
rewritten.starts_with("GET /youtube/v3/search?part=snippet&key=AIzaSy-secret HTTP/1.1\r\n"),
437+
"Expected query param rewritten, got: {rewritten}"
438+
);
439+
assert!(!rewritten.contains("openshell:resolve:env:"));
440+
}
441+
442+
#[test]
443+
fn rewrites_query_param_with_special_chars_percent_encoded() {
444+
let (child_env, resolver) = SecretResolver::from_provider_env(
445+
[("API_KEY".to_string(), "key with spaces&symbols=yes".to_string())]
446+
.into_iter()
447+
.collect(),
448+
);
449+
let placeholder = child_env.get("API_KEY").unwrap();
450+
451+
let raw = format!(
452+
"GET /api?token={placeholder} HTTP/1.1\r\nHost: x\r\n\r\n"
453+
);
454+
let rewritten = rewrite_http_header_block(raw.as_bytes(), resolver.as_ref());
455+
let rewritten = String::from_utf8(rewritten).expect("utf8");
456+
457+
// Secret should be percent-encoded
458+
assert!(
459+
rewritten.contains("token=key%20with%20spaces%26symbols%3Dyes"),
460+
"Expected percent-encoded secret, got: {rewritten}"
461+
);
462+
}
463+
464+
#[test]
465+
fn rewrites_query_param_only_placeholder_first_param() {
466+
let (child_env, resolver) = SecretResolver::from_provider_env(
467+
[("KEY".to_string(), "secret123".to_string())]
468+
.into_iter()
469+
.collect(),
470+
);
471+
let placeholder = child_env.get("KEY").unwrap();
472+
473+
let raw = format!(
474+
"GET /api?key={placeholder}&format=json HTTP/1.1\r\nHost: x\r\n\r\n"
475+
);
476+
let rewritten = rewrite_http_header_block(raw.as_bytes(), resolver.as_ref());
477+
let rewritten = String::from_utf8(rewritten).expect("utf8");
478+
479+
assert!(
480+
rewritten.starts_with("GET /api?key=secret123&format=json HTTP/1.1"),
481+
"Expected first param rewritten, got: {rewritten}"
482+
);
483+
}
484+
485+
#[test]
486+
fn no_query_param_rewrite_without_placeholder() {
487+
let (_, resolver) = SecretResolver::from_provider_env(
488+
[("KEY".to_string(), "secret".to_string())]
489+
.into_iter()
490+
.collect(),
491+
);
492+
493+
let raw = b"GET /api?key=normalvalue HTTP/1.1\r\nHost: x\r\n\r\n";
494+
let rewritten = rewrite_http_header_block(raw, resolver.as_ref());
495+
assert_eq!(raw.as_slice(), rewritten.as_slice());
496+
}
497+
498+
// --- Basic Authorization header encoding tests ---
499+
500+
#[test]
501+
fn rewrites_basic_auth_placeholder_in_decoded_token() {
502+
use base64::Engine as _;
503+
let b64 = base64::engine::general_purpose::STANDARD;
504+
505+
let (child_env, resolver) = SecretResolver::from_provider_env(
506+
[("DB_PASSWORD".to_string(), "s3cret!".to_string())]
507+
.into_iter()
508+
.collect(),
509+
);
510+
let resolver = resolver.expect("resolver");
511+
let placeholder = child_env.get("DB_PASSWORD").unwrap();
512+
513+
// Simulate: agent constructs Basic auth with placeholder password
514+
let credentials = format!("admin:{placeholder}");
515+
let encoded = b64.encode(credentials.as_bytes());
516+
517+
let header_line = format!("Authorization: Basic {encoded}");
518+
let rewritten = rewrite_header_line(&header_line, &resolver);
519+
520+
// Decode the rewritten token to verify
521+
let rewritten_token = rewritten.strip_prefix("Authorization: Basic ").unwrap();
522+
let decoded = b64.decode(rewritten_token).unwrap();
523+
let decoded_str = std::str::from_utf8(&decoded).unwrap();
524+
525+
assert_eq!(decoded_str, "admin:s3cret!");
526+
assert!(!rewritten.contains("openshell:resolve:env:"));
527+
}
528+
529+
#[test]
530+
fn basic_auth_without_placeholder_unchanged() {
531+
let (_, resolver) = SecretResolver::from_provider_env(
532+
[("KEY".to_string(), "secret".to_string())]
533+
.into_iter()
534+
.collect(),
535+
);
536+
let resolver = resolver.expect("resolver");
537+
538+
// Normal Basic auth token without any placeholder
539+
use base64::Engine as _;
540+
let b64 = base64::engine::general_purpose::STANDARD;
541+
let encoded = b64.encode(b"user:password");
542+
let header_line = format!("Authorization: Basic {encoded}");
543+
544+
let rewritten = rewrite_header_line(&header_line, &resolver);
545+
assert_eq!(rewritten, header_line, "Should not modify non-placeholder Basic auth");
546+
}
547+
548+
#[test]
549+
fn basic_auth_full_round_trip_header_block() {
550+
use base64::Engine as _;
551+
let b64 = base64::engine::general_purpose::STANDARD;
552+
553+
let (child_env, resolver) = SecretResolver::from_provider_env(
554+
[("REGISTRY_PASS".to_string(), "hunter2".to_string())]
555+
.into_iter()
556+
.collect(),
557+
);
558+
let placeholder = child_env.get("REGISTRY_PASS").unwrap();
559+
let credentials = format!("deploy:{placeholder}");
560+
let encoded = b64.encode(credentials.as_bytes());
561+
562+
let raw = format!(
563+
"GET /v2/_catalog HTTP/1.1\r\n\
564+
Host: registry.example.com\r\n\
565+
Authorization: Basic {encoded}\r\n\
566+
Accept: application/json\r\n\r\n"
567+
);
568+
569+
let rewritten = rewrite_http_header_block(raw.as_bytes(), resolver.as_ref());
570+
let rewritten = String::from_utf8(rewritten).expect("utf8");
571+
572+
// Extract and decode the rewritten Basic token
573+
let auth_line = rewritten.lines().find(|l| l.starts_with("Authorization:")).unwrap();
574+
let token = auth_line.strip_prefix("Authorization: Basic ").unwrap();
575+
let decoded = b64.decode(token).unwrap();
576+
assert_eq!(std::str::from_utf8(&decoded).unwrap(), "deploy:hunter2");
577+
578+
// Other headers preserved
579+
assert!(rewritten.contains("Host: registry.example.com\r\n"));
580+
assert!(rewritten.contains("Accept: application/json\r\n"));
581+
assert!(!rewritten.contains("openshell:resolve:env:"));
582+
}
583+
584+
// --- Percent encoding tests ---
585+
586+
#[test]
587+
fn percent_encode_preserves_unreserved() {
588+
assert_eq!(percent_encode("abc123-._~"), "abc123-._~");
589+
}
590+
591+
#[test]
592+
fn percent_encode_encodes_special_chars() {
593+
assert_eq!(percent_encode("a b"), "a%20b");
594+
assert_eq!(percent_encode("key=val&x"), "key%3Dval%26x");
595+
}
596+
597+
#[test]
598+
fn percent_decode_round_trips() {
599+
let original = "hello world & more=stuff";
600+
let encoded = percent_encode(original);
601+
let decoded = percent_decode(&encoded);
602+
assert_eq!(decoded, original);
603+
}
262604
}

0 commit comments

Comments
 (0)