unegg 0.1.0

EGG archive extractor
Documentation 
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

use std::io::{Read, Write};

use crate::crypto::Decryptor;
use crate::error::{EggError, EggResult};

const BUF_SIZE: usize = 8192;

pub fn extract_bzip2<R: Read, W: Write>(
    reader: &mut R,
    writer: &mut W,
    compressed_size: u64,
    crypto: Option<&mut dyn Decryptor>,
) -> EggResult<u32> {
    // Bzip2 needs the whole compressed stream. If encrypted, decrypt first.
    let bounded = reader.take(compressed_size);
    let source: Box<dyn Read> = if let Some(c) = crypto {
        Box::new(DecryptingReader::new(bounded, c))
    } else {
        Box::new(bounded)
    };

    let mut decoder = bzip2::read::BzDecoder::new(source);

    let mut hasher = crc32fast::Hasher::new();
    let mut buf = [0u8; BUF_SIZE];

    loop {
        let n = decoder
            .read(&mut buf)
            .map_err(|e| EggError::Bzip2Failed(e.to_string()))?;
        if n == 0 {
            break;
        }
        hasher.update(&buf[..n]);
        writer.write_all(&buf[..n])?;
    }

    Ok(hasher.finalize())
}

/// Adapter that decrypts data on the fly as it's read.
struct DecryptingReader<'a, R: Read> {
    inner: R,
    crypto: &'a mut dyn Decryptor,
}

impl<'a, R: Read> DecryptingReader<'a, R> {
    fn new(inner: R, crypto: &'a mut dyn Decryptor) -> Self {
        Self { inner, crypto }
    }
}

impl<R: Read> Read for DecryptingReader<'_, R> {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        let n = self.inner.read(buf)?;
        if n > 0 {
            self.crypto.decrypt(&mut buf[..n]);
        }
        Ok(n)
    }
}