Skip to main content

dekopon_http_host/
signed_download.rs

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}