payload_dumper 0.7.6

A fast and efficient Android OTA payload dumper written in Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use crate::http::HttpReader;
use crate::payload::payload_dumper::AsyncPayloadRead;
use crate::zip::zip::ZipParser;
use anyhow::Result;
use async_trait::async_trait;
use futures::StreamExt;
use std::pin::Pin;
use tokio::io::AsyncRead;

/// async payload reader for remote ZIP files
pub struct RemoteAsyncZipPayloadReader {
    http_reader: HttpReader,
    payload_offset: u64,
    payload_size: u64,
}

impl RemoteAsyncZipPayloadReader {
    pub async fn new(url: String, user_agent: Option<&str>) -> Result<Self> {
        let http_reader = HttpReader::new(url, user_agent).await?;

        // find payload.bin in ZIP
        let entry = ZipParser::find_payload_entry(&http_reader).await?;
        let payload_offset = ZipParser::get_data_offset(&http_reader, &entry).await?;
        ZipParser::verify_payload_magic(&http_reader, payload_offset).await?;

        Ok(Self {
            http_reader,
            payload_offset,
            payload_size: entry.uncompressed_size,
        })
    }
}

#[async_trait]
impl AsyncPayloadRead for RemoteAsyncZipPayloadReader {
    async fn stream_from(
        &self,
        offset: u64,
        length: u64,
    ) -> Result<Pin<Box<dyn AsyncRead + Send>>> {
        let absolute_offset = self.payload_offset + offset;

        if absolute_offset + length > self.payload_offset + self.payload_size {
            return Err(anyhow::anyhow!(
                "Read request exceeds payload bounds: offset={}, length={}, payload_size={}",
                offset,
                length,
                self.payload_size
            ));
        }

        // create a new HTTP client for streaming
        let client = reqwest::Client::builder()
            .timeout(std::time::Duration::from_secs(600))
            .pool_max_idle_per_host(10)
            .build()?;

        let end = absolute_offset + length - 1;
        let range = format!("bytes={}-{}", absolute_offset, end);

        let response = client
            .get(&self.http_reader.url)
            .header(reqwest::header::RANGE, range)
            .send()
            .await?;

        if !response.status().is_success() && response.status().as_u16() != 206 {
            return Err(anyhow::anyhow!(
                "Range request failed: {}",
                response.status()
            ));
        }

        // convert response to AsyncRead stream
        let stream = response.bytes_stream();
        let reader = tokio_util::io::StreamReader::new(
            stream.map(|result| result.map_err(std::io::Error::other)),
        );

        Ok(Box::pin(reader))
    }
}