1use super::{
2 BufferedHttpClient, ErrorCode, Header, HttpCallEvidence, HttpError, Request, Response,
3};
4use crate::asset::{AssetDirectory, AssetFile};
5use dekopon_capability::{HttpConstraints, SignedDownload};
6use reqwest::{Method, Url};
7use tokio::time::timeout_at;
8use tracing::Instrument as _;
9
10const WINDOW_BYTES: u32 = 65_536;
11const LOCATION_BYTES: usize = 8192;
12
13#[derive(Clone, Copy, Debug, Eq, PartialEq)]
14pub enum Window {
15 Tail(u32),
16 Offset { start: u64, length: u32 },
17}
18
19#[derive(Clone, Copy, Debug, Eq, PartialEq)]
20pub struct Coverage {
21 pub start: u64,
22 pub end_exclusive: u64,
23 pub total: u64,
24}
25
26pub enum DownloadResponse {
27 Api(Response),
28 Storage {
29 status: u16,
30 coverage: Option<Coverage>,
31 body: Option<AssetFile>,
32 },
33}
34
35#[derive(Clone, Copy, Debug, Eq, PartialEq, thiserror::Error)]
36pub enum DownloadError {
37 #[error("signed download is not authorized")]
38 Denied,
39 #[error("signed download redirect refused")]
40 RedirectRefused,
41 #[error("signed download request limit exhausted")]
42 RequestLimit,
43 #[error("signed download timed out")]
44 Timeout,
45 #[error("signed download exceeds the response limit")]
46 ResponseTooLarge(Option<super::ByteLimitExceeded>),
47 #[error("signed download is incomplete")]
48 Incomplete,
49 #[error("signed download storage request failed")]
50 Storage,
51 #[error("signed download asset I/O failed")]
52 Internal,
53}
54
55impl DownloadError {
56 fn label(self) -> &'static str {
57 match self {
58 Self::Denied => "denied",
59 Self::RedirectRefused => "redirect-refused",
60 Self::RequestLimit => "host-call-limit",
61 Self::Timeout => "timeout",
62 Self::ResponseTooLarge(_) => "response-too-large",
63 Self::Incomplete => "incomplete",
64 Self::Storage => "storage",
65 Self::Internal => "internal",
66 }
67 }
68
69 const fn byte_limit(self) -> Option<super::ByteLimitExceeded> {
70 match self {
71 Self::ResponseTooLarge(exceeded) => exceeded,
72 Self::Denied
73 | Self::RedirectRefused
74 | Self::RequestLimit
75 | Self::Timeout
76 | Self::Incomplete
77 | Self::Storage
78 | Self::Internal => None,
79 }
80 }
81}
82
83impl From<HttpError> for DownloadError {
84 fn from(error: HttpError) -> Self {
85 match error.code {
86 ErrorCode::HostCallLimit => Self::RequestLimit,
87 ErrorCode::Timeout => Self::Timeout,
88 ErrorCode::ResponseTooLarge => Self::ResponseTooLarge(error.byte_limit),
89 ErrorCode::Denied
90 | ErrorCode::InvalidMethod
91 | ErrorCode::InvalidUri
92 | ErrorCode::InvalidHeader
93 | ErrorCode::RequestTooLarge => Self::Denied,
94 ErrorCode::Dns | ErrorCode::Connect | ErrorCode::Tls | ErrorCode::Protocol => {
95 Self::Storage
96 }
97 ErrorCode::Internal => Self::Internal,
98 }
99 }
100}
101
102pub(super) struct Destination {
103 uri: dekopon_core::Redacted<Url>,
104 client: reqwest::Client,
105 headers: reqwest::header::HeaderMap,
106 authority: String,
107 request_bytes: u64,
108 span: tracing::Span,
109}
110
111#[derive(Default)]
112struct DownloadScan {
113 location: Vec<u8>,
114 credential: Vec<u8>,
115}
116
117enum FetchedRange {
118 Range { coverage: Coverage, body: AssetFile },
119 Status(u16),
120}
121
122impl Destination {
123 async fn new(
124 uri: Url,
125 grant: HttpConstraints,
126 ceilings: super::HttpHostCeilings,
127 deadline: tokio::time::Instant,
128 #[cfg(feature = "native-test")] transport: Option<crate::test_transport::Transport>,
129 ) -> Result<Self, DownloadError> {
130 let budget = deadline
131 .checked_duration_since(tokio::time::Instant::now())
132 .ok_or(DownloadError::Timeout)?;
133 let mut validator = BufferedHttpClient::authorized(grant.clone(), ceilings, budget)
134 .map_err(|_cause| DownloadError::Internal)?;
135 validator.deadline = deadline;
136 #[cfg(feature = "native-test")]
137 {
138 validator.test_transport = transport;
139 }
140 let prepared = validator
141 .prepare(
142 Request {
143 method: "GET".to_owned(),
144 uri: uri.as_str().to_owned(),
145 headers: vec![
146 Header {
147 name: "accept-encoding".to_owned(),
148 value: b"identity".to_vec(),
149 },
150 Header {
151 name: "user-agent".to_owned(),
152 value: b"dekopon".to_vec(),
153 },
154 ],
155 body: vec![],
156 },
157 &grant,
158 None,
159 )
160 .await
161 .map_err(|error| match error.code {
162 ErrorCode::Denied => DownloadError::RedirectRefused,
163 ErrorCode::InvalidMethod
164 | ErrorCode::InvalidUri
165 | ErrorCode::InvalidHeader
166 | ErrorCode::RequestTooLarge
167 | ErrorCode::HostCallLimit
168 | ErrorCode::Dns
169 | ErrorCode::Connect
170 | ErrorCode::Tls
171 | ErrorCode::Timeout
172 | ErrorCode::Protocol
173 | ErrorCode::ResponseTooLarge
174 | ErrorCode::Internal => DownloadError::from(error),
175 })?;
176 let client = if prepared.addresses.is_empty() {
177 reqwest::Client::new()
178 } else {
179 validator
180 .pinned_client(
181 &prepared.host,
182 &prepared.addresses,
183 validator.remaining().map_err(DownloadError::from)?,
184 )
185 .map_err(DownloadError::from)?
186 };
187 Ok(Self {
188 uri: dekopon_core::Redacted::new(prepared.url),
189 client,
190 headers: prepared.headers,
191 authority: prepared.authority,
192 request_bytes: prepared.request_bytes,
193 span: tracing::Span::none(),
194 })
195 }
196}
197
198impl BufferedHttpClient {
199 pub async fn signed_download(
200 &mut self,
201 api_uri: String,
202 window: Window,
203 directory: &AssetDirectory,
204 ) -> Result<DownloadResponse, DownloadError> {
205 let result = self
206 .signed_download_checked(api_uri, window, directory)
207 .await;
208 let violation = match &result {
209 Ok(_) => None,
210 Err(error) => match error {
211 DownloadError::Denied => Some(super::PolicyViolation::Denied),
212 DownloadError::RedirectRefused => Some(super::PolicyViolation::RedirectRefused),
213 DownloadError::RequestLimit => Some(super::PolicyViolation::HostCallLimit),
214 DownloadError::ResponseTooLarge(exceeded) => {
215 Some(super::PolicyViolation::ByteLimit(*exceeded))
216 }
217 DownloadError::Timeout
218 | DownloadError::Incomplete
219 | DownloadError::Storage
220 | DownloadError::Internal => None,
221 },
222 };
223 self.policy_violation = violation.or(self.policy_violation);
224 result
225 }
226
227 async fn signed_download_checked(
228 &mut self,
229 api_uri: String,
230 window: Window,
231 directory: &AssetDirectory,
232 ) -> Result<DownloadResponse, DownloadError> {
233 self.attempted = true;
234 if self.credential.is_none() {
235 return Err(DownloadError::Denied);
236 }
237 let grant = self.grant.as_ref().ok_or(DownloadError::Denied)?;
238 match grant.signed_download {
239 Some(SignedDownload::GithubActionsLogsV1) => {}
240 None => return Err(DownloadError::Denied),
241 }
242 let length = match window {
243 Window::Tail(length) | Window::Offset { length, .. } => length,
244 };
245 if length == 0 || length > WINDOW_BYTES || !api_route(&api_uri) {
246 return Err(DownloadError::Denied);
247 }
248 let api = self.signed_api_request(api_uri).await?;
249 if api.status != 302 {
250 return Ok(DownloadResponse::Api(api));
251 }
252 let uri = location(&api.headers)?;
253 let mut grant = self.grant.clone().ok_or(DownloadError::Denied)?;
254 grant.allowed_hosts = vec![
255 uri.host_str()
256 .ok_or(DownloadError::RedirectRefused)?
257 .to_owned(),
258 ];
259 grant.allowed_methods = vec!["GET".to_owned()];
260 grant.signed_download = None;
261 grant.request_templates.clear();
262 grant.propagate_trace = false;
263 grant.allow_plaintext_loopback = false;
264 let mut ceilings = self.ceilings.clone();
265 ceilings.non_public_https = std::sync::Arc::new(Vec::new());
266 let mut destination = self.storage_destination(uri, grant, ceilings).await?;
267 let probe = self
268 .fetch_storage(
269 &mut destination,
270 Coverage {
271 start: 0,
272 end_exclusive: 1,
273 total: 0,
274 },
275 &mut DownloadScan::default(),
276 directory,
277 )
278 .await?;
279 let probe_range = match probe {
280 FetchedRange::Range { coverage, body } => {
281 drop(body);
282 coverage
283 }
284 FetchedRange::Status(status) => return storage_status(status),
285 };
286 let total = probe_range.total;
287 let start = match window {
288 Window::Tail(length) => total.saturating_sub(u64::from(length)),
289 Window::Offset { start, .. } => start,
290 };
291 if start >= total {
292 return Err(DownloadError::Incomplete);
293 }
294 let end = start
295 .checked_add(u64::from(length))
296 .ok_or(DownloadError::Incomplete)?
297 .min(total);
298 let coverage = Coverage {
299 start,
300 end_exclusive: end,
301 total,
302 };
303 let overlap = destination
304 .uri
305 .expose()
306 .as_str()
307 .len()
308 .saturating_sub(1)
309 .max(
310 self.credential
311 .as_ref()
312 .map_or(0, super::BoundCredential::echo_overlap),
313 );
314 if overlap > WINDOW_BYTES as usize {
315 return Err(DownloadError::Denied);
316 }
317 let mut cursor = start.saturating_sub(overlap as u64);
318 let checked_end = end.saturating_add(overlap as u64).min(total);
319 let mut scan = DownloadScan::default();
320 let mut output = directory
321 .allocate()
322 .await
323 .map_err(|error| DownloadError::from(self.asset_error(error)))?;
324 while cursor < checked_end {
325 let segment_end = cursor
326 .saturating_add(u64::from(WINDOW_BYTES))
327 .min(checked_end);
328 let checked = Coverage {
329 start: cursor,
330 end_exclusive: segment_end,
331 total,
332 };
333 match self
334 .fetch_storage(&mut destination, checked, &mut scan, directory)
335 .await?
336 {
337 FetchedRange::Status(status) => return storage_status(status),
338 FetchedRange::Range {
339 coverage: checked,
340 body,
341 } => {
342 let visible_start = start.max(checked.start);
343 let visible_end = end.min(checked.end_exclusive);
344 if visible_start < visible_end {
345 let offset = visible_start - checked.start;
346 let count = (visible_end - visible_start) as usize;
347 let bytes = super::asset::AssetReader::output(std::sync::Arc::new(body))
348 .read(move |file| {
349 super::read_decoded(
350 file,
351 super::Representation::Identity,
352 offset,
353 count,
354 )
355 .map_err(Into::into)
356 })
357 .await
358 .map_err(|error| DownloadError::from(self.asset_error(error)))?;
359 output = output
360 .write(bytes)
361 .await
362 .map_err(|error| DownloadError::from(self.asset_error(error)))?;
363 }
364 }
365 }
366 cursor = segment_end;
367 }
368 let body = output
369 .finish()
370 .await
371 .map_err(|error| DownloadError::from(self.asset_error(error)))?;
372 Ok(DownloadResponse::Storage {
373 status: 206,
374 coverage: Some(coverage),
375 body: Some(body),
376 })
377 }
378
379 async fn signed_api_request(&mut self, api_uri: String) -> Result<Response, DownloadError> {
380 let span = tracing::info_span!(
381 "http.request",
382 "url.full" = api_uri,
383 "http.request.method" = "GET",
384 "server.address" = tracing::field::Empty,
385 "http.response.status_code" = tracing::field::Empty,
386 "dekopon.http.request.accounted_bytes" = tracing::field::Empty,
387 "dekopon.http.response.accounted_bytes" = tracing::field::Empty,
388 "error.code" = tracing::field::Empty,
389 "error.message" = tracing::field::Empty,
390 "dekopon.http.byte_limit.key" = tracing::field::Empty,
391 "dekopon.http.byte_limit.bytes" = tracing::field::Empty,
392 outcome = tracing::field::Empty
393 );
394 let index = self.evidence.len();
395 let api = self
396 .send_with_metadata(
397 Request {
398 method: "GET".to_owned(),
399 uri: api_uri,
400 headers: vec![Header {
401 name: "user-agent".to_owned(),
402 value: b"dekopon".to_vec(),
403 }],
404 body: vec![],
405 },
406 super::ResponseMetadata::SignedDownload,
407 )
408 .instrument(span.clone())
409 .await;
410 self.record_request(&span, index, &api);
411 api.map_err(DownloadError::from)
412 }
413
414 async fn storage_destination(
415 &mut self,
416 uri: Url,
417 grant: HttpConstraints,
418 ceilings: super::HttpHostCeilings,
419 ) -> Result<Destination, DownloadError> {
420 #[cfg(test)]
421 if let Some(destination) = self.signed_download_destination.take() {
422 if destination.uri.expose() != &uri {
423 return Err(DownloadError::RedirectRefused);
424 }
425 return Ok(destination);
426 }
427 Destination::new(
428 uri,
429 grant,
430 ceilings,
431 self.deadline,
432 #[cfg(feature = "native-test")]
433 self.test_transport.clone(),
434 )
435 .await
436 }
437
438 async fn fetch_storage(
439 &mut self,
440 destination: &mut Destination,
441 expected: Coverage,
442 scan: &mut DownloadScan,
443 directory: &AssetDirectory,
444 ) -> Result<FetchedRange, DownloadError> {
445 let index = self.evidence.len();
446 let result = self
447 .fetch_storage_checked(destination, expected, scan, directory)
448 .await;
449 self.record_storage_request(&destination.span, index, &result);
450 result
451 }
452
453 async fn fetch_storage_checked(
454 &mut self,
455 destination: &mut Destination,
456 expected: Coverage,
457 scan: &mut DownloadScan,
458 directory: &AssetDirectory,
459 ) -> Result<FetchedRange, DownloadError> {
460 let response = self
461 .storage_get(destination, expected.start, expected.end_exclusive - 1)
462 .await?;
463 let status = response.status().as_u16();
464 if status != 206 {
465 return if (400..600).contains(&status) {
466 Ok(FetchedRange::Status(status))
467 } else {
468 Err(DownloadError::Incomplete)
469 };
470 }
471 let coverage = content_range(&response)?;
472 if coverage.start != expected.start
473 || coverage.end_exclusive != expected.end_exclusive
474 || (expected.total != 0 && coverage.total != expected.total)
475 {
476 return Err(DownloadError::Incomplete);
477 }
478 let body = self
479 .read_storage_checked(response, destination, coverage, scan, directory)
480 .instrument(destination.span.clone())
481 .await?;
482 Ok(FetchedRange::Range { coverage, body })
483 }
484
485 fn record_storage_request<T>(
486 &self,
487 span: &tracing::Span,
488 index: usize,
489 result: &Result<T, DownloadError>,
490 ) {
491 let evidence = self.evidence.get(index);
492 let failure = result.as_ref().err().copied();
493 let outcome = failure.map_or("succeeded", DownloadError::label);
494 span.record("outcome", outcome);
495 if let Some(evidence) = evidence {
496 span.record(
497 "dekopon.http.response.accounted_bytes",
498 evidence.response_bytes,
499 );
500 }
501 if let Some(error) = failure {
502 span.record("error.code", error.label());
503 }
504 let byte_limit = failure.and_then(DownloadError::byte_limit);
505 if let Some(exceeded) = byte_limit {
506 span.record("dekopon.http.byte_limit.key", exceeded.key.as_str());
507 span.record("dekopon.http.byte_limit.bytes", exceeded.limit);
508 }
509 span.in_scope(|| {
510 tracing::info!(target: "dekopon_http_host::audit", {
511 audit.event = "accounting.http.request",
512 "http.request.method" = evidence.map(|value| value.method.as_str()),
513 "server.address" = evidence.map(|value| value.authority.as_str()),
514 "http.response.status_code" = evidence.and_then(|value| value.status),
515 "dekopon.http.request.accounted_bytes" = evidence.map(|value| value.request_bytes),
516 "dekopon.http.response.accounted_bytes" = evidence.map(|value| value.response_bytes),
517 "error.code" = failure.map(DownloadError::label),
518 "error.message" = failure.map(tracing::field::display),
519 "dekopon.http.byte_limit.key" = byte_limit.map(|exceeded| exceeded.key.as_str()),
520 "dekopon.http.byte_limit.bytes" = byte_limit.map(|exceeded| exceeded.limit),
521 outcome,
522 }, "accounting.http.request")
523 });
524 }
525
526 async fn storage_get(
527 &mut self,
528 destination: &mut Destination,
529 start: u64,
530 end: u64,
531 ) -> Result<reqwest::Response, DownloadError> {
532 let span = tracing::info_span!(
533 "http.request",
534 "server.address" = destination.uri.expose().host_str(),
535 "http.request.method" = "GET",
536 "http.response.status_code" = tracing::field::Empty,
537 "dekopon.http.response.accounted_bytes" = tracing::field::Empty,
538 "error.code" = tracing::field::Empty,
539 "dekopon.http.byte_limit.key" = tracing::field::Empty,
540 "dekopon.http.byte_limit.bytes" = tracing::field::Empty,
541 outcome = tracing::field::Empty
542 );
543 destination.span = span.clone();
544 async {
545 let grant = self.grant.as_ref().ok_or(DownloadError::Denied)?;
546 if self.calls >= grant.max_requests {
547 return Err(DownloadError::RequestLimit);
548 }
549 self.calls += 1;
550
551 let range = format!("bytes={start}-{end}");
552 let request_bytes = destination
553 .request_bytes
554 .checked_add((range.len() + 9) as u64)
555 .ok_or(DownloadError::Denied)?;
556 if request_bytes
557 > self
558 .grant
559 .as_ref()
560 .ok_or(DownloadError::Denied)?
561 .max_request_bytes
562 {
563 return Err(DownloadError::Denied);
564 }
565 self.evidence.push(HttpCallEvidence {
566 method: "GET".to_owned(),
567 authority: destination.authority.clone(),
568 status: None,
569 request_bytes,
570 response_bytes: 0,
571 upstream_request_id: None,
572 vm_session: None,
573 credential_injected: false,
574 });
575 #[cfg(feature = "native-test")]
576 let scripted = self.test_transport.as_ref().map(|transport| {
577 let mut headers = destination.headers.clone();
578 headers.insert(
579 "range",
580 reqwest::header::HeaderValue::from_str(&range)
581 .map_err(|_error| DownloadError::Internal)?,
582 );
583 transport.guest(Request {
584 method: "GET".to_owned(),
585 uri: destination.uri.expose().as_str().to_owned(),
586 headers: headers
587 .iter()
588 .map(|(name, value)| Header {
589 name: name.to_string(),
590 value: value.as_bytes().to_vec(),
591 })
592 .collect(),
593 body: vec![],
594 });
595 transport
596 .response(&Method::GET, destination.uri.expose(), &headers, &[])
597 .map_err(DownloadError::from)
598 });
599 #[cfg(not(feature = "native-test"))]
600 let scripted: Option<Result<reqwest::Response, DownloadError>> = None;
601 let response = match scripted {
602 Some(response) => response?,
603 None => timeout_at(
604 self.deadline,
605 destination
606 .client
607 .request(Method::GET, destination.uri.expose().clone())
608 .headers(destination.headers.clone())
609 .header("range", range)
610 .send(),
611 )
612 .await
613 .map_err(|_cause| DownloadError::Timeout)?
614 .map_err(|_cause| DownloadError::Storage)?,
615 };
616 let status = response.status().as_u16();
617 tracing::Span::current().record("http.response.status_code", status);
618 if let Some(evidence) = self.evidence.last_mut() {
619 evidence.status = Some(status);
620 }
621 self.storage_head(&response)?;
622 if response.status().is_redirection() {
623 return Err(DownloadError::RedirectRefused);
624 }
625 Ok(response)
626 }
627 .instrument(span)
628 .await
629 }
630
631 fn storage_head(&mut self, response: &reqwest::Response) -> Result<(), DownloadError> {
632 let maximum = self
633 .grant
634 .as_ref()
635 .ok_or(DownloadError::Denied)?
636 .max_response_bytes;
637 let bytes = super::response_head_bytes(response.headers(), &self.ceilings, maximum)
638 .map_err(DownloadError::from)?;
639 if let Some(evidence) = self.evidence.last_mut() {
640 evidence.response_bytes = bytes;
641 }
642 Ok(())
643 }
644
645 #[cfg(test)]
646 async fn read_storage(
647 &mut self,
648 response: reqwest::Response,
649 destination: &Destination,
650 coverage: Coverage,
651 directory: &AssetDirectory,
652 ) -> Result<AssetFile, DownloadError> {
653 let result = self
654 .read_storage_checked(
655 response,
656 destination,
657 coverage,
658 &mut DownloadScan::default(),
659 directory,
660 )
661 .instrument(destination.span.clone())
662 .await;
663 destination
664 .span
665 .record("outcome", if result.is_ok() { "ok" } else { "error" });
666 if let Some(evidence) = self.evidence.last() {
667 destination.span.record(
668 "dekopon.http.response.accounted_bytes",
669 evidence.response_bytes,
670 );
671 }
672 if let Err(error) = &result {
673 destination
674 .span
675 .record("error.code", tracing::field::debug(error));
676 }
677 result
678 }
679
680 async fn read_storage_checked(
681 &mut self,
682 mut response: reqwest::Response,
683 destination: &Destination,
684 coverage: Coverage,
685 scan: &mut DownloadScan,
686 directory: &AssetDirectory,
687 ) -> Result<AssetFile, DownloadError> {
688 let maximum = self
689 .grant
690 .as_ref()
691 .ok_or(DownloadError::Denied)?
692 .max_response_bytes;
693 if response
694 .headers()
695 .get_all("content-encoding")
696 .iter()
697 .any(|value| !value.as_bytes().eq_ignore_ascii_case(b"identity"))
698 {
699 return Err(DownloadError::Incomplete);
700 }
701 let expected = coverage.end_exclusive - coverage.start;
702 if let Some(length) = response.content_length() {
703 if length > expected {
704 return Err(DownloadError::ResponseTooLarge(None));
705 }
706 if length != expected {
707 return Err(DownloadError::Incomplete);
708 }
709 }
710 if expected > u64::from(WINDOW_BYTES) {
711 return Err(DownloadError::ResponseTooLarge(None));
712 }
713 let mut spool = directory
714 .allocate()
715 .await
716 .map_err(|error| DownloadError::from(self.asset_error(error)))?;
717 let mut read = 0_u64;
718 let patterns = [
719 destination.uri.expose().as_str().as_bytes(),
720 destination
721 .uri
722 .expose()
723 .query()
724 .unwrap_or_default()
725 .as_bytes(),
726 ];
727 let overlap = patterns
728 .iter()
729 .map(|pattern| pattern.len())
730 .max()
731 .unwrap_or(0)
732 .saturating_sub(1);
733 while let Some(chunk) = timeout_at(self.deadline, response.chunk())
734 .await
735 .map_err(|_cause| DownloadError::Timeout)?
736 .map_err(|_cause| DownloadError::Incomplete)?
737 {
738 read = read
739 .checked_add(chunk.len() as u64)
740 .ok_or(DownloadError::ResponseTooLarge(None))?;
741 let evidence = self.evidence.last_mut().ok_or(DownloadError::Internal)?;
742 evidence.response_bytes = evidence
743 .response_bytes
744 .checked_add(chunk.len() as u64)
745 .ok_or(DownloadError::ResponseTooLarge(None))?;
746 if evidence.response_bytes > maximum {
747 return Err(DownloadError::ResponseTooLarge(Some(
748 super::ByteLimitExceeded {
749 key: super::ByteLimitKey::MaxResponseBytes,
750 limit: maximum,
751 observed: evidence.response_bytes,
752 },
753 )));
754 }
755 if read > expected {
756 return Err(DownloadError::ResponseTooLarge(None));
757 }
758 for bytes in chunk.chunks(super::CHUNK_BYTES) {
759 scan.location.extend_from_slice(bytes);
760 if patterns.iter().any(|pattern| {
761 !pattern.is_empty()
762 && scan
763 .location
764 .windows(pattern.len())
765 .any(|part| part == *pattern)
766 }) {
767 return Err(DownloadError::Denied);
768 }
769 let clean = scan.location.len().saturating_sub(overlap);
770 scan.location.drain(..clean);
771 if let Some(credential) = &self.credential {
772 let clean = credential
773 .scan_stream_chunk(&mut scan.credential, bytes, credential.echo_overlap())
774 .ok_or(DownloadError::Denied)?;
775 scan.credential.drain(..clean);
776 }
777 spool = spool
778 .write(bytes.to_vec())
779 .await
780 .map_err(|error| DownloadError::from(self.asset_error(error)))?;
781 }
782 }
783 if read != expected {
784 return Err(DownloadError::Incomplete);
785 }
786 spool
787 .finish()
788 .await
789 .map_err(|error| DownloadError::from(self.asset_error(error)))
790 }
791}
792
793pub(super) struct ApiRedactor {
794 matcher: aho_corasick::AhoCorasick,
795 pending: Vec<u8>,
796 overlap: usize,
797}
798
799impl ApiRedactor {
800 pub(super) fn new(headers: &mut [Header]) -> Result<Self, HttpError> {
801 let mut secrets = Vec::new();
802 for header in headers
803 .iter()
804 .filter(|header| header.name.eq_ignore_ascii_case("location"))
805 {
806 let (path_query, fragment) = split_secret_part(&header.value, b'#');
807 let (_, query) = split_secret_part(path_query, b'?');
808 for part in [query, fragment]
809 .into_iter()
810 .flatten()
811 .filter(|part| !part.is_empty())
812 {
813 for pair in part.split(|byte| *byte == b'&') {
814 let (key, value) = split_secret_part(pair, b'=');
815 let value = value.unwrap_or(pair);
816 if !value.is_empty() && (key.eq_ignore_ascii_case(b"sig") || value.len() >= 16)
817 {
818 secrets.push(value.to_vec());
819 secrets.push(percent_encoding::percent_decode(value).collect());
820 }
821 }
822 }
823 }
824 secrets.sort_by_key(|secret| std::cmp::Reverse(secret.len()));
825 secrets.dedup();
826 let overlap = secrets
827 .first()
828 .map_or(0, |secret| secret.len().saturating_sub(1));
829 let matcher = aho_corasick::AhoCorasick::builder()
830 .match_kind(aho_corasick::MatchKind::LeftmostLongest)
831 .build(&secrets)
832 .map_err(|_error| {
833 super::http_error(
834 ErrorCode::Internal,
835 "response redactor could not be constructed",
836 )
837 })?;
838 redact_api_locations(headers);
839 let replacements = vec![b"[redacted]"; secrets.len()];
840 for header in headers {
841 header.name =
842 String::from_utf8(matcher.replace_all_bytes(header.name.as_bytes(), &replacements))
843 .map_err(|_error| {
844 super::http_error(ErrorCode::Internal, "redacted header name is not UTF-8")
845 })?;
846 header.value = matcher.replace_all_bytes(&header.value, &replacements);
847 }
848 Ok(Self {
849 matcher,
850 pending: Vec::new(),
851 overlap,
852 })
853 }
854
855 pub(super) fn push(
856 &mut self,
857 bytes: &[u8],
858 output: &mut Vec<u8>,
859 maximum: u64,
860 ) -> Result<(), HttpError> {
861 self.pending.extend_from_slice(bytes);
862 if self.pending.len() < self.overlap + super::stream::CHUNK_BYTES {
863 return Ok(());
864 }
865 self.render(self.pending.len() - self.overlap, output, maximum)
866 }
867
868 pub(super) fn finish(&mut self, output: &mut Vec<u8>, maximum: u64) -> Result<(), HttpError> {
869 self.render(self.pending.len(), output, maximum)
870 }
871
872 fn render(
873 &mut self,
874 ready: usize,
875 output: &mut Vec<u8>,
876 maximum: u64,
877 ) -> Result<(), HttpError> {
878 let mut consumed = 0;
879 for found in self.matcher.find_iter(&self.pending) {
880 if found.start() >= ready {
881 break;
882 }
883 append_redacted(output, &self.pending[consumed..found.start()], maximum)?;
884 append_redacted(output, b"[redacted]", maximum)?;
885 consumed = found.end();
886 }
887 if consumed < ready {
888 append_redacted(output, &self.pending[consumed..ready], maximum)?;
889 consumed = ready;
890 }
891 self.pending.drain(..consumed);
892 Ok(())
893 }
894}
895
896fn split_secret_part(bytes: &[u8], separator: u8) -> (&[u8], Option<&[u8]>) {
897 match bytes.iter().position(|byte| *byte == separator) {
898 Some(index) => (&bytes[..index], Some(&bytes[index + 1..])),
899 None => (bytes, None),
900 }
901}
902
903fn append_redacted(output: &mut Vec<u8>, bytes: &[u8], maximum: u64) -> Result<(), HttpError> {
904 if (output.len() as u64).saturating_add(bytes.len() as u64) > maximum {
905 return Err(super::http_error(
906 ErrorCode::ResponseTooLarge,
907 "redacted response exceeds the authorized byte limit",
908 ));
909 }
910 output.extend_from_slice(bytes);
911 Ok(())
912}
913
914pub(super) fn redact_api_locations(headers: &mut [Header]) {
915 for header in headers {
916 if !header.name.eq_ignore_ascii_case("location") {
917 continue;
918 }
919 let Some(index) = header
920 .value
921 .iter()
922 .position(|byte| *byte == b'?' || *byte == b'#')
923 else {
924 continue;
925 };
926 let query = header.value.get(index) == Some(&b'?');
927 let fragment = header.value.contains(&b'#');
928 header.value.truncate(index);
929 if query {
930 header.value.extend_from_slice(b"?[redacted]");
931 }
932 if fragment {
933 header.value.extend_from_slice(b"#[redacted]");
934 }
935 }
936}
937
938fn storage_status(status: u16) -> Result<DownloadResponse, DownloadError> {
939 if (400..600).contains(&status) {
940 Ok(DownloadResponse::Storage {
941 status,
942 coverage: None,
943 body: None,
944 })
945 } else {
946 Err(DownloadError::Incomplete)
947 }
948}
949
950fn api_route(uri: &str) -> bool {
951 let Ok(url) = Url::parse(uri) else {
952 return false;
953 };
954 if url.scheme() != "https"
955 || !url.username().is_empty()
956 || url.password().is_some()
957 || url.query().is_some()
958 || url.fragment().is_some()
959 {
960 return false;
961 }
962 let segments = url.path().split('/').collect::<Vec<_>>();
963 let [
964 "",
965 "repos",
966 owner,
967 repository,
968 "actions",
969 "jobs",
970 job,
971 "logs",
972 ] = segments.as_slice()
973 else {
974 return false;
975 };
976 [owner, repository].iter().all(|value| {
977 !value.is_empty()
978 && value
979 .bytes()
980 .all(|byte| byte.is_ascii_alphanumeric() || b"-_.".contains(&byte))
981 }) && job.bytes().all(|byte| byte.is_ascii_digit())
982 && job.parse::<u64>().is_ok_and(|id| id > 0)
983}
984
985fn location(headers: &[Header]) -> Result<Url, DownloadError> {
986 let mut locations = headers
987 .iter()
988 .filter(|header| header.name.eq_ignore_ascii_case("location"));
989 let header = locations.next().ok_or(DownloadError::RedirectRefused)?;
990 if locations.next().is_some()
991 || header.value.len() > LOCATION_BYTES
992 || header
993 .value
994 .iter()
995 .any(|b| b.is_ascii_whitespace() || b.is_ascii_control())
996 {
997 return Err(DownloadError::RedirectRefused);
998 }
999 let value =
1000 std::str::from_utf8(&header.value).map_err(|_cause| DownloadError::RedirectRefused)?;
1001 let uri = Url::parse(value).map_err(|_cause| DownloadError::RedirectRefused)?;
1002 if uri.scheme() != "https"
1003 || uri.port_or_known_default() != Some(443)
1004 || !uri.username().is_empty()
1005 || uri.password().is_some()
1006 || uri.fragment().is_some()
1007 || value.contains(['\\', '%'])
1008 && value.split_once("://").is_some_and(|(_, rest)| {
1009 rest.split('/')
1010 .next()
1011 .is_some_and(|host| host.contains(['\\', '%']))
1012 })
1013 || !uri.host_str().is_some_and(storage_host)
1014 {
1015 return Err(DownloadError::RedirectRefused);
1016 }
1017 Ok(uri)
1018}
1019
1020fn storage_host(host: &str) -> bool {
1021 if let Some(label) = host
1022 .strip_suffix(".blob.core.windows.net")
1023 .and_then(|host| host.strip_prefix("productionresultssa"))
1024 {
1025 return (1..=5).contains(&label.len())
1026 && label
1027 .bytes()
1028 .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit());
1029 }
1030 if let Some(label) = host
1031 .strip_suffix(".actions.githubusercontent.com")
1032 .and_then(|host| host.strip_prefix("pipelines"))
1033 {
1034 return label.len() <= 54
1035 && label
1036 .bytes()
1037 .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'-')
1038 && !label.ends_with('-');
1039 }
1040 false
1041}
1042
1043fn content_range(response: &reqwest::Response) -> Result<Coverage, DownloadError> {
1044 let mut values = response.headers().get_all("content-range").iter();
1045 let value = values
1046 .next()
1047 .and_then(|value| value.to_str().ok())
1048 .ok_or(DownloadError::Incomplete)?;
1049 if values.next().is_some() {
1050 return Err(DownloadError::Incomplete);
1051 }
1052 let (range, total) = value
1053 .strip_prefix("bytes ")
1054 .and_then(|value| value.split_once('/'))
1055 .ok_or(DownloadError::Incomplete)?;
1056 let (start, end) = range.split_once('-').ok_or(DownloadError::Incomplete)?;
1057 let parse = |value: &str| {
1058 if !value.is_empty() && value.bytes().all(|b| b.is_ascii_digit()) {
1059 value.parse::<u64>().ok()
1060 } else {
1061 None
1062 }
1063 };
1064 let start = parse(start).ok_or(DownloadError::Incomplete)?;
1065 let end_exclusive = parse(end)
1066 .and_then(|end| end.checked_add(1))
1067 .ok_or(DownloadError::Incomplete)?;
1068 let total = parse(total).ok_or(DownloadError::Incomplete)?;
1069 if start >= end_exclusive || end_exclusive > total {
1070 return Err(DownloadError::Incomplete);
1071 }
1072 Ok(Coverage {
1073 start,
1074 end_exclusive,
1075 total,
1076 })
1077}
1078
1079#[cfg(test)]
1080mod tests {
1081 use super::*;
1082 use crate::{BoundCredential, HttpHostCeilings};
1083 use dekopon_core::Redacted;
1084 use dekopon_test_support::LoopbackServer;
1085 use std::time::Duration;
1086
1087 fn grant(authority: &str) -> HttpConstraints {
1088 HttpConstraints {
1089 allowed_hosts: vec![authority.to_owned()],
1090 allowed_methods: vec!["GET".to_owned()],
1091 max_requests: 3,
1092 max_request_bytes: 16384,
1093 max_response_bytes: 131072,
1094 allow_plaintext_loopback: true,
1095 propagate_trace: false,
1096 request_templates: vec![],
1097 signed_download: Some(SignedDownload::GithubActionsLogsV1),
1098 }
1099 }
1100
1101 async fn destination(server: &LoopbackServer, parent: &BufferedHttpClient) -> Destination {
1102 Destination::new(
1103 Url::parse(&format!("{}?sig=private-signed-query", server.url())).unwrap(),
1104 grant(server.authority()),
1105 HttpHostCeilings::default(),
1106 parent.deadline,
1107 #[cfg(feature = "native-test")]
1108 None,
1109 )
1110 .await
1111 .unwrap()
1112 }
1113
1114 #[test]
1115 fn native_locations_admit_only_the_two_bounded_host_families() {
1116 for (host, admitted) in [
1117 ("productionresultssa1.blob.core.windows.net", true),
1118 ("productionresultssa12345.blob.core.windows.net", true),
1119 ("productionresultssa123456.blob.core.windows.net", false),
1120 ("productionresultssa.blob.core.windows.net", false),
1121 ("pipelines.actions.githubusercontent.com", true),
1122 ("pipelines1.actions.githubusercontent.com.evil.test", false),
1123 ("evil.blob.core.windows.net", false),
1124 ("pipelines1.actions.githubusercontent.com.", false),
1125 ] {
1126 assert_eq!(storage_host(host), admitted, "{host}");
1127 }
1128 for value in [
1129 "http://productionresultssa1.blob.core.windows.net/log?sig=x".to_owned(),
1130 "https://127.0.0.1/log".to_owned(),
1131 "https://[::1]/log".to_owned(),
1132 "https://evil.test/log".to_owned(),
1133 "https://user@productionresultssa1.blob.core.windows.net/log".to_owned(),
1134 "https://productionresultssa1.blob.core.windows.net:444/log".to_owned(),
1135 format!(
1136 "https://productionresultssa1.blob.core.windows.net/{}",
1137 "x".repeat(8192)
1138 ),
1139 ] {
1140 assert_eq!(
1141 location(&[Header {
1142 name: "location".to_owned(),
1143 value: value.into_bytes()
1144 }]),
1145 Err(DownloadError::RedirectRefused)
1146 );
1147 }
1148 }
1149
1150 #[tokio::test]
1151 async fn native_storage_ranges_never_receive_the_parent_credential_and_preserve_full_windows() {
1152 let secret = "native-api-secret-with-sixteen-bytes";
1153 let api = LoopbackServer::once(
1154 b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok",
1155 );
1156 let credential = BoundCredential::bearer(
1157 "Bearer",
1158 Redacted::new(secret.to_owned()),
1159 vec![api.authority().to_owned()],
1160 )
1161 .unwrap();
1162 let mut parent = BufferedHttpClient::authorized_with_credential(
1163 grant(api.authority()),
1164 Some(credential),
1165 HttpHostCeilings::default(),
1166 Duration::from_secs(5),
1167 )
1168 .unwrap();
1169 parent
1170 .send(Request {
1171 method: "GET".to_owned(),
1172 uri: api.url(),
1173 headers: vec![],
1174 body: vec![],
1175 })
1176 .await
1177 .unwrap();
1178 assert!(api.request_text().contains(secret));
1179 api.join();
1180 let body = vec![b'x'; 65536];
1181 let mut tail = b"HTTP/1.1 206 Partial Content\r\nContent-Range: bytes 4464-69999/70000\r\nContent-Length: 65536\r\nX-Fixture: nonempty\r\nConnection: close\r\n\r\n".to_vec();
1182 tail.extend_from_slice(&body);
1183 let storage = LoopbackServer::sequence([
1184 b"HTTP/1.1 206 Partial Content\r\nContent-Range: bytes 0-0/70000\r\nContent-Length: 1\r\nConnection: close\r\n\r\nx".to_vec(), tail,
1185 ]);
1186 let root = tempfile::tempdir().unwrap();
1187 let directory = AssetDirectory::new(root.path().to_owned(), 131072);
1188 let mut target = destination(&storage, &parent).await;
1189 let deadline = parent.deadline;
1190 let probe = parent.storage_get(&mut target, 0, 0).await.unwrap();
1191 let coverage = content_range(&probe).unwrap();
1192 let probe = parent
1193 .read_storage(probe, &target, coverage, &directory)
1194 .await
1195 .unwrap();
1196 assert_eq!(probe.len(), 1);
1197 let response = parent.storage_get(&mut target, 4464, 69999).await.unwrap();
1198 let coverage = content_range(&response).unwrap();
1199 let body = parent
1200 .read_storage(response, &target, coverage, &directory)
1201 .await
1202 .unwrap();
1203 assert_eq!(body.len(), 65536);
1204 assert_eq!(parent.calls, 3);
1205 assert_eq!(parent.deadline, deadline);
1206 assert!(parent.evidence.last().unwrap().response_bytes > 65536);
1207 for expected in ["range: bytes=0-0", "range: bytes=4464-69999"] {
1208 let request = storage.request_text().to_ascii_lowercase();
1209 assert!(request.contains(expected));
1210 assert!(!request.contains("authorization"));
1211 assert!(!request.contains(secret));
1212 assert!(!request.contains("cookie:"));
1213 assert!(!request.contains("traceparent:"));
1214 }
1215 assert_eq!(
1216 parent.storage_get(&mut target, 0, 0).await.err(),
1217 Some(DownloadError::RequestLimit)
1218 );
1219 storage.join();
1220 }
1221
1222 #[tokio::test]
1223 async fn native_storage_refuses_second_hops_and_bounds_hostile_or_incomplete_bodies() {
1224 for (response, expected) in [
1225 (b"HTTP/1.1 302 Found\r\nLocation: https://evil.test/secret\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".to_vec(), DownloadError::RedirectRefused),
1226 (b"HTTP/1.1 206 Partial Content\r\nContent-Range: bytes 0-2/3\r\nContent-Length: 3\r\nConnection: close\r\n\r\nx".to_vec(), DownloadError::Incomplete),
1227 (b"HTTP/1.1 206 Partial Content\r\nContent-Range: bytes 0-2/3\r\nContent-Length: 4\r\nConnection: close\r\n\r\nxxxx".to_vec(), DownloadError::ResponseTooLarge(None)),
1228 (b"HTTP/1.1 206 Partial Content\r\nContent-Range: bytes 0-23/24\r\nContent-Length: 24\r\nConnection: close\r\n\r\nsig=private-signed-query!".to_vec(), DownloadError::Denied),
1229 ] {
1230 let server = LoopbackServer::once(&response);
1231 let mut parent = BufferedHttpClient::authorized(grant(server.authority()), HttpHostCeilings::default(), Duration::from_secs(5)).unwrap();
1232 let mut target = destination(&server, &parent).await;
1233 let root = tempfile::tempdir().unwrap();
1234 let directory = AssetDirectory::new(root.path().to_owned(), 65536);
1235 let result = match parent.storage_get(&mut target, 0, 2).await {
1236 Ok(response) => {
1237 let coverage = content_range(&response).unwrap();
1238 parent.read_storage(response, &target, coverage, &directory).await.map(|_| ())
1239 }
1240 Err(error) => Err(error),
1241 };
1242 assert_eq!(result, Err(expected));
1243 assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
1244 assert!(!server.request_text().contains("authorization"));
1245 server.join();
1246 }
1247 }
1248
1249 #[tokio::test]
1250 async fn a_storage_body_over_max_response_bytes_names_the_key() {
1251 let body = "x".repeat(200);
1252 let wire = format!(
1253 "HTTP/1.1 206 Partial Content\r\nContent-Range: bytes 0-199/200\r\nContent-Length: 200\r\nConnection: close\r\n\r\n{body}"
1254 );
1255 let server = LoopbackServer::once(wire.as_bytes());
1256 let mut limited = grant(server.authority());
1257 limited.max_response_bytes = 200;
1258 let mut parent = BufferedHttpClient::authorized(
1259 limited,
1260 HttpHostCeilings::default(),
1261 Duration::from_secs(5),
1262 )
1263 .unwrap();
1264 let mut target = destination(&server, &parent).await;
1265 let root = tempfile::tempdir().unwrap();
1266 let directory = AssetDirectory::new(root.path().to_owned(), 65536);
1267 let response = parent.storage_get(&mut target, 0, 199).await.unwrap();
1268 let coverage = content_range(&response).unwrap();
1269 let result = parent
1270 .read_storage(response, &target, coverage, &directory)
1271 .await
1272 .map(|_| ());
1273 assert!(matches!(
1274 result,
1275 Err(DownloadError::ResponseTooLarge(Some(super::super::ByteLimitExceeded {
1276 key: super::super::ByteLimitKey::MaxResponseBytes,
1277 limit: 200,
1278 observed,
1279 }))) if observed > 200
1280 ));
1281 server.join();
1282 }
1283
1284 #[test]
1285 fn native_api_outcomes_and_storage_failures_remain_distinct() {
1286 for status in [403, 404, 410, 500] {
1287 match storage_status(status).unwrap() {
1288 DownloadResponse::Storage {
1289 status: actual,
1290 coverage,
1291 body,
1292 } => {
1293 assert_eq!(actual, status);
1294 assert!(coverage.is_none());
1295 assert!(body.is_none());
1296 }
1297 DownloadResponse::Api(_) => panic!("storage status became an API response"),
1298 }
1299 }
1300 assert!(!api_route("https://api.github.com/user"));
1301 assert!(!api_route(
1302 "https://api.github.com/extra/repos/owner/repo/actions/jobs/1/logs"
1303 ));
1304 assert!(!api_route(
1305 "https://api.github.com/repos/owner/repo/actions/jobs/+1/logs"
1306 ));
1307 assert!(api_route(
1308 "https://api.github.com/repos/owner/repo/actions/jobs/1/logs"
1309 ));
1310 }
1311 async fn tls_api(
1312 response: Vec<u8>,
1313 ) -> (String, HttpHostCeilings, tokio::task::JoinHandle<Vec<u8>>) {
1314 use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
1315 let certified =
1316 rcgen::generate_simple_self_signed(vec!["api.fixture.test".to_owned()]).unwrap();
1317 let config = rustls::ServerConfig::builder_with_provider(std::sync::Arc::new(
1318 rustls::crypto::ring::default_provider(),
1319 ))
1320 .with_safe_default_protocol_versions()
1321 .unwrap()
1322 .with_no_client_auth()
1323 .with_single_cert(
1324 vec![certified.cert.der().clone()],
1325 rustls::pki_types::PrivatePkcs8KeyDer::from(certified.signing_key.serialize_der())
1326 .into(),
1327 )
1328 .unwrap();
1329 let acceptor = tokio_rustls::TlsAcceptor::from(std::sync::Arc::new(config));
1330 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
1331 let address = listener.local_addr().unwrap();
1332 let authority = format!("api.fixture.test:{}", address.port());
1333 let pin =
1334 crate::LoopbackHttpsPin::new(&authority, address, certified.cert.pem().into_bytes())
1335 .unwrap();
1336 let server = tokio::spawn(async move {
1337 let (stream, _) = listener.accept().await.unwrap();
1338 let mut tls = acceptor.accept(stream).await.unwrap();
1339 let mut request = Vec::new();
1340 loop {
1341 let mut chunk = [0; 1024];
1342 let count = tls.read(&mut chunk).await.unwrap();
1343 if count == 0 {
1344 break;
1345 }
1346 request.extend_from_slice(&chunk[..count]);
1347 if request.windows(4).any(|bytes| bytes == b"\r\n\r\n") {
1348 break;
1349 }
1350 assert!(request.len() < 16384);
1351 }
1352 tls.write_all(&response).await.unwrap();
1353 tls.shutdown().await.unwrap();
1354 request
1355 });
1356 (
1357 format!("https://{authority}/repos/owner/repo/actions/jobs/1/logs"),
1358 HttpHostCeilings {
1359 loopback_https_pin: Some(pin),
1360 ..HttpHostCeilings::default()
1361 },
1362 server,
1363 )
1364 }
1365
1366 #[tokio::test]
1367 async fn native_signed_download_rejects_locations_before_any_storage_request_and_keeps_api_statuses()
1368 {
1369 for value in [
1370 "http://productionresultssa1.blob.core.windows.net/log".to_owned(),
1371 "https://evil.test/log".to_owned(),
1372 "https://127.0.0.1/log".to_owned(),
1373 "https://[::1]/log".to_owned(),
1374 format!(
1375 "https://productionresultssa1.blob.core.windows.net/{}",
1376 "x".repeat(8192)
1377 ),
1378 ] {
1379 let response = format!(
1380 "HTTP/1.1 302 Found\r\nLocation: {value}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
1381 );
1382 let (uri, ceilings, server) = tls_api(response.into_bytes()).await;
1383 let authority = Url::parse(&uri).unwrap().authority().to_owned();
1384 let secret = "native-tls-api-secret-sixteen-bytes";
1385 let credential = BoundCredential::bearer(
1386 "Bearer",
1387 Redacted::new(secret.to_owned()),
1388 vec![authority.clone()],
1389 )
1390 .unwrap();
1391 let mut parent = BufferedHttpClient::authorized_with_credential(
1392 grant(&authority),
1393 Some(credential),
1394 ceilings,
1395 Duration::from_secs(5),
1396 )
1397 .unwrap();
1398 let root = tempfile::tempdir().unwrap();
1399 let result = parent
1400 .signed_download(
1401 uri,
1402 Window::Tail(65536),
1403 &AssetDirectory::new(root.path().to_owned(), 131072),
1404 )
1405 .await;
1406 assert_eq!(result.err(), Some(DownloadError::RedirectRefused));
1407 assert_eq!(
1408 parent.policy_violation().map(crate::PolicyViolation::label),
1409 Some("redirect-refused")
1410 );
1411 assert_eq!(parent.calls, 1);
1412 assert_eq!(parent.evidence.len(), 1);
1413 let request = String::from_utf8(server.await.unwrap()).unwrap();
1414 assert!(request.contains(secret));
1415 assert!(request.to_ascii_lowercase().contains("user-agent: dekopon"));
1416 assert!(request.starts_with("GET /repos/owner/repo/actions/jobs/1/logs HTTP/1.1"));
1417 }
1418 for status in [403, 404, 410] {
1419 let response = format!(
1420 "HTTP/1.1 {status} Fixture\r\nContent-Length: 3\r\nX-Fixture: safe\r\nConnection: close\r\n\r\nraw"
1421 );
1422 let (uri, ceilings, server) = tls_api(response.into_bytes()).await;
1423 let authority = Url::parse(&uri).unwrap().authority().to_owned();
1424 let credential = BoundCredential::bearer(
1425 "Bearer",
1426 Redacted::new("api-test-credential-sixteen-bytes".to_owned()),
1427 vec![authority.clone()],
1428 )
1429 .unwrap();
1430 let mut parent = BufferedHttpClient::authorized_with_credential(
1431 grant(&authority),
1432 Some(credential),
1433 ceilings,
1434 Duration::from_secs(5),
1435 )
1436 .unwrap();
1437 let root = tempfile::tempdir().unwrap();
1438 let response = parent
1439 .signed_download(
1440 uri,
1441 Window::Tail(65536),
1442 &AssetDirectory::new(root.path().to_owned(), 131072),
1443 )
1444 .await
1445 .unwrap();
1446 match response {
1447 DownloadResponse::Api(response) => {
1448 assert_eq!(response.status, status);
1449 assert_eq!(response.body, b"raw");
1450 }
1451 DownloadResponse::Storage { .. } => panic!("API status became a storage status"),
1452 }
1453 assert_eq!(parent.calls, 1);
1454 server.await.unwrap();
1455 }
1456 }
1457 #[tokio::test]
1458 async fn native_signed_storage_traces_exclude_signed_urls_and_keep_opaque_bytes() {
1459 use tracing::instrument::WithSubscriber as _;
1460 use tracing_subscriber::layer::SubscriberExt as _;
1461 let captured = dekopon_test_support::CaptureLayer::workspace();
1462 let subscriber = tracing_subscriber::registry().with(captured.clone());
1463 async {
1464 let response = b"HTTP/1.1 206 Partial Content\r\nContent-Range: bytes 0-3/4\r\nContent-Length: 4\r\nConnection: close\r\n\r\n\xff\x1b\0\n";
1465 let server = LoopbackServer::once(response);
1466 let mut parent = BufferedHttpClient::authorized(grant(server.authority()), HttpHostCeilings::default(), Duration::from_secs(5)).unwrap();
1467 let mut target = destination(&server, &parent).await;
1468 let root = tempfile::tempdir().unwrap();
1469 let response = parent.storage_get(&mut target, 0, 3).await.unwrap();
1470 let coverage = content_range(&response).unwrap();
1471 let body = parent.read_storage(response, &target, coverage, &AssetDirectory::new(root.path().to_owned(), 65536)).await.unwrap();
1472 let bytes = crate::read_decoded(body.file(), crate::Representation::Identity, 0, 4).unwrap();
1473 assert_eq!(bytes, b"\xff\x1b\0\n");
1474 assert!(server.request_text().contains("sig=private-signed-query"));
1475 server.join();
1476 }.with_subscriber(subscriber).await;
1477 let recorded = captured.text();
1478 assert!(recorded.contains("http.request"));
1479 assert!(recorded.contains("206"));
1480 assert!(!recorded.contains("private-signed-query"));
1481 assert!(!recorded.contains("?sig="));
1482 }
1483
1484 #[tokio::test]
1485 async fn native_signed_download_requires_its_separate_grant_before_api_egress() {
1486 let mut constraints = grant("api.github.com");
1487 constraints.signed_download = None;
1488 let mut parent = BufferedHttpClient::authorized(
1489 constraints,
1490 HttpHostCeilings::default(),
1491 Duration::from_secs(5),
1492 )
1493 .unwrap();
1494 let root = tempfile::tempdir().unwrap();
1495 let result = parent
1496 .signed_download(
1497 "https://api.github.com/repos/owner/repo/actions/jobs/1/logs".to_owned(),
1498 Window::Tail(65536),
1499 &AssetDirectory::new(root.path().to_owned(), 65536),
1500 )
1501 .await;
1502 assert_eq!(result.err(), Some(DownloadError::Denied));
1503 assert_eq!(parent.calls, 0);
1504 assert!(parent.evidence.is_empty());
1505 assert_eq!(
1506 parent.policy_violation(),
1507 Some(crate::PolicyViolation::Denied)
1508 );
1509 }
1510 fn authenticated_api(uri: &str, ceilings: HttpHostCeilings) -> BufferedHttpClient {
1511 let authority = Url::parse(uri).unwrap().authority().to_owned();
1512 let credential = BoundCredential::bearer(
1513 "Bearer",
1514 Redacted::new("api-credential-with-sixteen-bytes".to_owned()),
1515 vec![authority.clone()],
1516 )
1517 .unwrap();
1518 BufferedHttpClient::authorized_with_credential(
1519 grant(&authority),
1520 Some(credential),
1521 ceilings,
1522 Duration::from_secs(5),
1523 )
1524 .unwrap()
1525 }
1526
1527 #[tokio::test]
1528 async fn native_signed_api_requires_authentication_before_dispatch() {
1529 let (uri, ceilings, server) =
1530 tls_api(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".to_vec())
1531 .await;
1532 let authority = Url::parse(&uri).unwrap().authority().to_owned();
1533 let mut parent =
1534 BufferedHttpClient::authorized(grant(&authority), ceilings, Duration::from_secs(5))
1535 .unwrap();
1536 let root = tempfile::tempdir().unwrap();
1537 let result = parent
1538 .signed_download(
1539 uri,
1540 Window::Tail(64),
1541 &AssetDirectory::new(root.path().to_owned(), 131072),
1542 )
1543 .await;
1544 assert_eq!(result.err(), Some(DownloadError::Denied));
1545 assert_eq!(parent.calls, 0);
1546 assert!(parent.evidence.is_empty());
1547 server.abort();
1548 assert!(server.await.unwrap_err().is_cancelled());
1549 }
1550
1551 #[tokio::test]
1552 async fn native_signed_302_never_stores_reflected_request_ids_even_when_the_redirect_is_refused()
1553 {
1554 for length in [0, 1] {
1555 let response = format!(
1556 "HTTP/1.1 302 Found\r\nLocation: http://productionresultssa1.blob.core.windows.net/log?sig=private-signed-query\r\nx-github-request-id: sig=private-signed-query\r\nContent-Length: {length}\r\nConnection: close\r\n\r\n"
1557 );
1558 let (uri, ceilings, server) = tls_api(response.into_bytes()).await;
1559 let mut parent = authenticated_api(&uri, ceilings);
1560 let root = tempfile::tempdir().unwrap();
1561 assert!(
1562 parent
1563 .signed_download(
1564 uri,
1565 Window::Tail(64),
1566 &AssetDirectory::new(root.path().to_owned(), 131072)
1567 )
1568 .await
1569 .is_err()
1570 );
1571 assert_eq!(parent.evidence.len(), 1);
1572 assert_eq!(parent.evidence[0].upstream_request_id, None);
1573 assert!(
1574 !serde_json::to_string(&parent.evidence)
1575 .unwrap()
1576 .contains("private-signed-query")
1577 );
1578 server.await.unwrap();
1579 }
1580 }
1581
1582 #[tokio::test]
1583 async fn native_signed_api_redacts_non_302_locations_without_following_them() {
1584 let location = "https://productionresultssa1.blob.core.windows.net/log?sig=raw-api-location#private-fragment";
1585 for status in [301, 303, 307] {
1586 let response = format!(
1587 "HTTP/1.1 {status} Redirect\r\nLocation: {location}\r\nContent-Length: 3\r\nConnection: close\r\n\r\nraw"
1588 );
1589 let (uri, ceilings, server) = tls_api(response.into_bytes()).await;
1590 let mut parent = authenticated_api(&uri, ceilings);
1591 let root = tempfile::tempdir().unwrap();
1592 match parent
1593 .signed_download(
1594 uri,
1595 Window::Tail(64),
1596 &AssetDirectory::new(root.path().to_owned(), 131072),
1597 )
1598 .await
1599 .unwrap()
1600 {
1601 DownloadResponse::Api(response) => {
1602 assert_eq!(response.status, status);
1603 assert_eq!(response.body, b"raw");
1604 assert!(
1605 response
1606 .headers
1607 .iter()
1608 .any(|header| header.name == "location"
1609 && header.value == b"https://productionresultssa1.blob.core.windows.net/log?[redacted]#[redacted]")
1610 );
1611 }
1612 DownloadResponse::Storage { .. } => panic!("non-302 API response followed storage"),
1613 }
1614 assert_eq!(parent.calls, 1);
1615 assert_eq!(parent.policy_violation(), None);
1616 server.await.unwrap();
1617 }
1618 }
1619 #[test]
1620 fn signed_api_redaction_preserves_matches_across_every_chunk_boundary() {
1621 let source = b"before private-query-long private-query private-fragment after";
1622 for split in 0..=source.len() {
1623 let mut headers = vec![Header {
1624 name: "location".to_owned(),
1625 value: b"https://storage.test/log?sig=private-query&other=private-query-long#private-fragment".to_vec(),
1626 }];
1627 let mut redactor = ApiRedactor::new(&mut headers).unwrap();
1628 let mut output = Vec::new();
1629 let prefix = vec![b'.'; super::super::stream::CHUNK_BYTES - split];
1630 redactor.push(&prefix, &mut output, 131072).unwrap();
1631 redactor
1632 .push(&source[..split], &mut output, 131072)
1633 .unwrap();
1634 redactor
1635 .push(&source[split..], &mut output, 131072)
1636 .unwrap();
1637 redactor.finish(&mut output, 131072).unwrap();
1638 let mut expected = prefix;
1639 expected.extend_from_slice(b"before [redacted] [redacted] [redacted] after");
1640 assert_eq!(output, expected);
1641 assert!(redactor.pending.is_empty());
1642 }
1643 }
1644
1645 #[test]
1646 fn signed_api_redaction_bounds_substitution_expansion() {
1647 let mut headers = vec![Header {
1648 name: "location".to_owned(),
1649 value: b"https://storage.test/log?sig=x".to_vec(),
1650 }];
1651 let mut redactor = ApiRedactor::new(&mut headers).unwrap();
1652 let mut output = Vec::new();
1653 redactor.push(b"xxxx", &mut output, 16).unwrap();
1654 assert_eq!(
1655 redactor.finish(&mut output, 16).unwrap_err().code,
1656 ErrorCode::ResponseTooLarge
1657 );
1658 assert!(output.len() <= 16);
1659 }
1660
1661 async fn reflected_api(status: u16) -> (Response, Vec<HttpCallEvidence>) {
1662 let location = "https://productionresultssa1.blob.core.windows.net/log?sig=private-query&other=private-query-long#private-fragment";
1663 let body =
1664 format!("<a href=\"{location}\">download</a> private-query-long private-fragment");
1665 let wire = format!(
1666 "HTTP/1.1 {status} Redirect\r\nLocation: {location}\r\nx-reflection: private-query-long private-fragment\r\nprivate-fragment: safe\r\nx-github-request-id: private-query\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
1667 body.len()
1668 );
1669 let (uri, ceilings, server) = tls_api(wire.into_bytes()).await;
1670 let mut parent = authenticated_api(&uri, ceilings);
1671 let root = tempfile::tempdir().unwrap();
1672 let result = parent
1673 .signed_download(
1674 uri,
1675 Window::Tail(64),
1676 &AssetDirectory::new(root.path().to_owned(), 131072),
1677 )
1678 .await
1679 .unwrap();
1680 server.await.unwrap();
1681 assert_eq!(parent.calls, 1);
1682 match result {
1683 DownloadResponse::Api(response) => (response, parent.evidence),
1684 DownloadResponse::Storage { .. } => panic!("non-302 API response followed storage"),
1685 }
1686 }
1687
1688 #[tokio::test]
1689 async fn a_short_sas_parameter_is_not_scrubbed_from_a_redirect_body() {
1690 let body = format!("<html>{} reflected token</html>", "br br br ".repeat(64));
1691 let expected = body.replace("token", "[redacted]");
1692 let wire = format!(
1693 "HTTP/1.1 301 Redirect\r\nLocation: https://productionresultssa1.blob.core.windows.net/log?sp=r&sr=b&SiG=token\r\nx-brown-bird: br\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
1694 body.len()
1695 );
1696 let (uri, ceilings, server) = tls_api(wire.into_bytes()).await;
1697 let mut parent = authenticated_api(&uri, ceilings);
1698 parent.grant.as_mut().unwrap().max_response_bytes = 1024;
1699 let root = tempfile::tempdir().unwrap();
1700 let response = parent
1701 .signed_download(
1702 uri,
1703 Window::Tail(64),
1704 &AssetDirectory::new(root.path().to_owned(), 1024),
1705 )
1706 .await
1707 .unwrap();
1708 match response {
1709 DownloadResponse::Api(response) => {
1710 assert_eq!(response.status, 301);
1711 assert_eq!(response.body, expected.as_bytes());
1712 assert!(
1713 response
1714 .headers
1715 .iter()
1716 .any(|header| { header.name == "x-brown-bird" && header.value == b"br" })
1717 );
1718 assert!(response.headers.iter().any(|header| {
1719 header.name == "location"
1720 && header.value
1721 == b"https://productionresultssa1.blob.core.windows.net/log?[redacted]"
1722 }));
1723 }
1724 DownloadResponse::Storage { .. } => panic!("301 response followed storage"),
1725 }
1726 server.await.unwrap();
1727 }
1728
1729 #[tokio::test]
1730 async fn native_signed_redirect_body_substitutes_location_secrets_and_preserves_html() {
1731 for status in [301, 303, 307] {
1732 let (response, _) = reflected_api(status).await;
1733 assert_eq!(response.status, status);
1734 assert_eq!(response.body, b"<a href=\"https://productionresultssa1.blob.core.windows.net/log?sig=[redacted]&other=[redacted]#[redacted]\">download</a> [redacted] [redacted]");
1735 }
1736 }
1737
1738 #[tokio::test]
1739 async fn native_signed_redirect_sibling_headers_substitute_location_secrets_longest_first() {
1740 let (response, _) = reflected_api(303).await;
1741 let reflection = response
1742 .headers
1743 .iter()
1744 .find(|header| header.name == "x-reflection")
1745 .unwrap();
1746 assert_eq!(reflection.value, b"[redacted] [redacted]");
1747 assert!(
1748 response
1749 .headers
1750 .iter()
1751 .any(|header| header.name == "[redacted]" && header.value == b"safe")
1752 );
1753 let request_id = response
1754 .headers
1755 .iter()
1756 .find(|header| header.name == "x-github-request-id")
1757 .unwrap();
1758 assert_eq!(request_id.value, b"[redacted]");
1759 }
1760
1761 #[tokio::test]
1762 async fn native_signed_redirect_evidence_never_retains_response_request_ids() {
1763 for status in [200, 301, 303, 307, 403] {
1764 let (_, evidence) = reflected_api(status).await;
1765 assert_eq!(evidence.len(), 1);
1766 assert_eq!(evidence[0].upstream_request_id, None);
1767 assert!(
1768 !serde_json::to_string(&evidence)
1769 .unwrap()
1770 .contains("private-query")
1771 );
1772 }
1773 }
1774
1775 async fn fake_storage(
1776 data: Vec<u8>,
1777 count: usize,
1778 ) -> (Destination, tokio::task::JoinHandle<Vec<Vec<u8>>>) {
1779 use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
1780 let hostname = "productionresultssa1.blob.core.windows.net";
1781 let certified = rcgen::generate_simple_self_signed(vec![hostname.to_owned()]).unwrap();
1782 let config = rustls::ServerConfig::builder_with_provider(std::sync::Arc::new(
1783 rustls::crypto::ring::default_provider(),
1784 ))
1785 .with_safe_default_protocol_versions()
1786 .unwrap()
1787 .with_no_client_auth()
1788 .with_single_cert(
1789 vec![certified.cert.der().clone()],
1790 rustls::pki_types::PrivatePkcs8KeyDer::from(certified.signing_key.serialize_der())
1791 .into(),
1792 )
1793 .unwrap();
1794 let acceptor = tokio_rustls::TlsAcceptor::from(std::sync::Arc::new(config));
1795 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
1796 let address = listener.local_addr().unwrap();
1797 let client = reqwest::Client::builder()
1798 .no_proxy()
1799 .redirect(reqwest::redirect::Policy::none())
1800 .add_root_certificate(
1801 reqwest::Certificate::from_pem(certified.cert.pem().as_bytes()).unwrap(),
1802 )
1803 .resolve(hostname, address)
1804 .build()
1805 .unwrap();
1806 let server = tokio::spawn(async move {
1807 let mut requests = Vec::new();
1808 for _ in 0..count {
1809 let (stream, _) = listener.accept().await.unwrap();
1810 let mut tls = acceptor.accept(stream).await.unwrap();
1811 let mut request = Vec::new();
1812 loop {
1813 let mut bytes = [0; 1024];
1814 let length = tls.read(&mut bytes).await.unwrap();
1815 assert_ne!(length, 0);
1816 request.extend_from_slice(&bytes[..length]);
1817 if request.windows(4).any(|bytes| bytes == b"\r\n\r\n") {
1818 break;
1819 }
1820 }
1821 let text = String::from_utf8(request.clone())
1822 .unwrap()
1823 .to_ascii_lowercase();
1824 let range = text
1825 .lines()
1826 .find_map(|line| line.strip_prefix("range: bytes="))
1827 .unwrap();
1828 let (start, end) = range.split_once('-').unwrap();
1829 let start = start.parse::<usize>().unwrap();
1830 let end = end.parse::<usize>().unwrap();
1831 assert!(start <= end && end < data.len());
1832 let response = format!(
1833 "HTTP/1.1 206 Partial Content\r\nContent-Range: bytes {start}-{end}/{}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
1834 data.len(),
1835 end - start + 1
1836 );
1837 tls.write_all(response.as_bytes()).await.unwrap();
1838 tls.write_all(&data[start..=end]).await.unwrap();
1839 tls.shutdown().await.unwrap();
1840 requests.push(request);
1841 }
1842 requests
1843 });
1844 let uri = Url::parse(&format!("https://{hostname}/log?sig=private-signed-query")).unwrap();
1845 let mut headers = reqwest::header::HeaderMap::new();
1846 headers.insert(
1847 "accept-encoding",
1848 reqwest::header::HeaderValue::from_static("identity"),
1849 );
1850 headers.insert(
1851 "user-agent",
1852 reqwest::header::HeaderValue::from_static("dekopon"),
1853 );
1854 (
1855 Destination {
1856 uri: Redacted::new(uri),
1857 client,
1858 headers,
1859 authority: hostname.to_owned(),
1860 request_bytes: 256,
1861 span: tracing::Span::none(),
1862 },
1863 server,
1864 )
1865 }
1866
1867 #[tokio::test]
1868 async fn native_302_to_storage_preserves_credentials_secrecy_coverage_and_every_accounting_event()
1869 {
1870 use tracing::instrument::WithSubscriber as _;
1871 use tracing_subscriber::layer::SubscriberExt as _;
1872 let capture = dekopon_test_support::CaptureLayer::workspace();
1873 let subscriber = tracing_subscriber::registry().with(capture.clone());
1874 let evidence = async {
1875 let (destination, storage) = fake_storage(vec![b'x'; 70000], 3).await;
1876 let response = format!("HTTP/1.1 302 Found\r\nLocation: {}\r\nx-github-request-id: sig=private-signed-query\r\nContent-Length: 0\r\nConnection: close\r\n\r\n", destination.uri.expose());
1877 let (uri, ceilings, api) = tls_api(response.into_bytes()).await;
1878 let mut parent = authenticated_api(&uri, ceilings);
1879 parent.grant.as_mut().unwrap().max_requests = 8;
1880 parent.signed_download_destination = Some(destination);
1881 let root = tempfile::tempdir().unwrap();
1882 let result = parent.signed_download(uri, Window::Tail(65536), &AssetDirectory::new(root.path().to_owned(), 131072)).await.unwrap();
1883 match result {
1884 DownloadResponse::Storage { status, coverage, body } => {
1885 assert_eq!(status, 206);
1886 assert_eq!(coverage, Some(Coverage { start: 4464, end_exclusive: 70000, total: 70000 }));
1887 assert_eq!(body.unwrap().len(), 65536);
1888 }
1889 DownloadResponse::Api(_) => panic!("302 was not followed"),
1890 }
1891 let api_request = String::from_utf8(api.await.unwrap()).unwrap();
1892 assert!(api_request.contains("authorization: Bearer api-credential-with-sixteen-bytes"));
1893 let requests = storage.await.unwrap();
1894 assert_eq!(requests.len(), 3);
1895 for request in requests {
1896 let request = String::from_utf8(request).unwrap().to_ascii_lowercase();
1897 assert!(!request.contains("authorization:"));
1898 assert!(!request.contains("api-credential-with-sixteen-bytes"));
1899 assert!(!request.contains("traceparent:"));
1900 }
1901 assert_eq!(parent.calls, 4);
1902 parent.evidence
1903 }.with_subscriber(subscriber).await;
1904 let events = capture.events_where(
1905 "dekopon_http_host::audit",
1906 &[("audit.event", "accounting.http.request")],
1907 );
1908 assert_eq!(events.len(), 4);
1909 for (event, evidence) in events.iter().zip(&evidence) {
1910 assert_eq!(
1911 event
1912 .field("dekopon.http.response.accounted_bytes")
1913 .unwrap()
1914 .parse::<u64>()
1915 .unwrap(),
1916 evidence.response_bytes
1917 );
1918 }
1919 assert!(
1920 evidence
1921 .iter()
1922 .all(|call| call.upstream_request_id.is_none())
1923 );
1924 assert!(!capture.text().contains("private-signed-query"));
1925 assert!(
1926 !serde_json::to_string(&evidence)
1927 .unwrap()
1928 .contains("private-signed-query")
1929 );
1930 }
1931
1932 #[tokio::test]
1933 async fn a_signed_download_over_max_response_bytes_records_its_key_on_api_and_storage_requests()
1934 {
1935 use dekopon_test_support::{CaptureLayer, Record};
1936 use tracing::instrument::WithSubscriber as _;
1937 use tracing_subscriber::layer::SubscriberExt as _;
1938 let api_over = format!(
1939 "HTTP/1.1 200 OK\r\nContent-Length: 8192\r\nConnection: close\r\n\r\n{}",
1940 "x".repeat(8192)
1941 );
1942 for storage_over in [false, true] {
1943 let capture = CaptureLayer::workspace();
1944 let result = async {
1945 let (destination, _storage) = fake_storage(vec![b'x'; 70000], 2).await;
1946 let response = if storage_over {
1947 format!(
1948 "HTTP/1.1 302 Found\r\nLocation: {}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
1949 destination.uri.expose()
1950 )
1951 } else {
1952 api_over.clone()
1953 };
1954 let (uri, ceilings, _api) = tls_api(response.into_bytes()).await;
1955 let mut parent = authenticated_api(&uri, ceilings);
1956 parent.grant.as_mut().unwrap().max_response_bytes = 4096;
1957 parent.signed_download_destination = Some(destination);
1958 let root = tempfile::tempdir().unwrap();
1959 parent
1960 .signed_download(
1961 uri,
1962 Window::Tail(65536),
1963 &AssetDirectory::new(root.path().to_owned(), 131072),
1964 )
1965 .await
1966 .map(|_| ())
1967 }
1968 .with_subscriber(tracing_subscriber::registry().with(capture.clone()))
1969 .await;
1970 assert!(matches!(
1971 result,
1972 Err(DownloadError::ResponseTooLarge(Some(_)))
1973 ));
1974 let span_field = |name, value| {
1975 capture.records().iter().any(|record| {
1976 matches!(
1977 record,
1978 Record::Span {
1979 name: "http.request",
1980 ..
1981 }
1982 ) && record.field(name) == Some(value)
1983 })
1984 };
1985 assert!(span_field(
1986 "dekopon.http.byte_limit.key",
1987 "maxResponseBytes"
1988 ));
1989 assert!(span_field("dekopon.http.byte_limit.bytes", "4096"));
1990 assert_eq!(
1991 capture
1992 .events_where(
1993 "dekopon_http_host::audit",
1994 &[
1995 ("audit.event", "accounting.http.request"),
1996 ("dekopon.http.byte_limit.key", "maxResponseBytes"),
1997 ("dekopon.http.byte_limit.bytes", "4096"),
1998 ],
1999 )
2000 .len(),
2001 1
2002 );
2003 }
2004 }
2005
2006 #[tokio::test]
2007 async fn native_offset_reads_cannot_reconstruct_a_signed_query_from_two_fragments() {
2008 let query = b"sig=private-signed-query";
2009 for window in [
2010 Window::Offset {
2011 start: 0,
2012 length: 12,
2013 },
2014 Window::Offset {
2015 start: 12,
2016 length: 11,
2017 },
2018 ] {
2019 let (destination, storage) = fake_storage(query.to_vec(), 2).await;
2020 let response = format!(
2021 "HTTP/1.1 302 Found\r\nLocation: {}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
2022 destination.uri.expose()
2023 );
2024 let (uri, ceilings, api) = tls_api(response.into_bytes()).await;
2025 let mut parent = authenticated_api(&uri, ceilings);
2026 parent.grant.as_mut().unwrap().max_requests = 8;
2027 parent.signed_download_destination = Some(destination);
2028 let root = tempfile::tempdir().unwrap();
2029 let result = parent
2030 .signed_download(
2031 uri,
2032 window,
2033 &AssetDirectory::new(root.path().to_owned(), 131072),
2034 )
2035 .await;
2036 assert_eq!(result.err(), Some(DownloadError::Denied));
2037 assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
2038 assert_eq!(parent.calls, 3);
2039 api.await.unwrap();
2040 assert_eq!(storage.await.unwrap().len(), 2);
2041 }
2042 }
2043 #[tokio::test]
2044 async fn native_signed_windows_are_not_exposed_when_context_exhausts_the_request_budget() {
2045 let (destination, storage) = fake_storage(vec![b'x'; 70000], 1).await;
2046 let response = format!(
2047 "HTTP/1.1 302 Found\r\nLocation: {}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
2048 destination.uri.expose()
2049 );
2050 let (uri, ceilings, api) = tls_api(response.into_bytes()).await;
2051 let mut parent = authenticated_api(&uri, ceilings);
2052 parent.grant.as_mut().unwrap().max_requests = 2;
2053 parent.signed_download_destination = Some(destination);
2054 let root = tempfile::tempdir().unwrap();
2055 let result = parent
2056 .signed_download(
2057 uri,
2058 Window::Tail(65536),
2059 &AssetDirectory::new(root.path().to_owned(), 131072),
2060 )
2061 .await;
2062 assert_eq!(result.err(), Some(DownloadError::RequestLimit));
2063 assert_eq!(
2064 parent.policy_violation(),
2065 Some(crate::PolicyViolation::HostCallLimit)
2066 );
2067 assert_eq!(parent.calls, 2);
2068 assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
2069 api.await.unwrap();
2070 assert_eq!(storage.await.unwrap().len(), 1);
2071 }
2072}