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 _;
45use std:: collections:: HashMap ;
56
67const 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
5194pub ( 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) ]
100254mod 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 \n Host: 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 \n Host: 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 \n Host: 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