bzimage 0.1.0

A create for handling bzimage format, such as Linux kernel images.
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use bzimage::{BzImageHeader, MAGIC, VERSION};
use flate2::write::GzEncoder;
use flate2::Compression;
use sha2::{Digest, Sha256};
use std::io::{Cursor, Seek, SeekFrom, Write, Read};

#[test]
fn round_trip_write_read_validate_decompress() {
    // prepare payload
    let payload = b"hello daemonizer world".to_vec();
    let uncompressed_size = payload.len() as u64;

    // compress
    let mut enc = GzEncoder::new(Vec::new(), Compression::best());
    enc.write_all(&payload).unwrap();
    let compressed = enc.finish().unwrap();
    let compressed_size = compressed.len() as u64;

    // compute checksum
    let mut hasher = Sha256::new();
    hasher.update(&compressed);
    let checksum: [u8; 32] = hasher.finalize().into();

    // build header (endian-typed fields)
    let header = BzImageHeader {
        magic: *MAGIC,
        version: VERSION.into(),
        reserved1: 0u32.into(),
        uncompressed_size: (uncompressed_size).into(),
        compressed_size: (compressed_size).into(),
        checksum,
        reserved2: 0u32.into(),
    };

    // write header + compressed data into cursor
    let mut cur = Cursor::new(Vec::new());
    header.write_to(&mut cur).unwrap();
    cur.write_all(&compressed).unwrap();

    // rewind and read
    cur.seek(SeekFrom::Start(0)).unwrap();
    let read_header = BzImageHeader::read_from(&mut cur).unwrap();

    // validate magic & sizes via safe copies and endian conversion
    assert_eq!(&read_header.magic_copy(), MAGIC);
    // Copy endian-typed fields out of the packed struct safely.
    let uncompressed_field: simple_endian::u64le = unsafe {
        std::ptr::read_unaligned(std::ptr::addr_of!(read_header.uncompressed_size))
    };
    let compressed_field: simple_endian::u64le = unsafe {
        std::ptr::read_unaligned(std::ptr::addr_of!(read_header.compressed_size))
    };
    let un: u64 = uncompressed_field.into();
    let comp: u64 = compressed_field.into();
    assert_eq!(un, uncompressed_size);
    assert_eq!(comp, compressed_size);

    // read compressed bytes
    let mut compressed_read = Vec::new();
    cur.read_to_end(&mut compressed_read).unwrap();
    assert_eq!(compressed_read.len(), compressed_size as usize);

    // checksum
    assert!(read_header.validate_checksum(&compressed_read));

    // decompression via helper
    let decompressed = BzImageHeader::decompress_data(&compressed_read).unwrap();
    assert_eq!(decompressed, payload);
}

#[test]
fn invalid_magic_fails() {
    use std::io::Write;
    let mut cur = Cursor::new(Vec::new());
    cur.write_all(b"BAD!").unwrap();
    // pad out to header size
    cur.write_all(&vec![0u8; 60]).unwrap();
    cur.seek(SeekFrom::Start(0)).unwrap();
    let res = BzImageHeader::read_from(&mut cur);
    assert!(res.is_err());
}

#[test]
fn checksum_mismatch_detected() {
    // create a correct header but corrupt compressed data
    let payload = b"somedata".to_vec();
    let mut enc = GzEncoder::new(Vec::new(), Compression::best());
    enc.write_all(&payload).unwrap();
    let compressed = enc.finish().unwrap();

    let mut hasher = Sha256::new();
    hasher.update(&compressed);
    let checksum: [u8; 32] = hasher.finalize().into();

    let header = BzImageHeader {
        magic: *MAGIC,
        version: VERSION.into(),
        reserved1: 0u32.into(),
        uncompressed_size: (payload.len() as u64).into(),
        compressed_size: (compressed.len() as u64).into(),
        checksum,
        reserved2: 0u32.into(),
    };

    // write header + corrupted compressed data
    let mut cur = Cursor::new(Vec::new());
    header.write_to(&mut cur).unwrap();
    let mut corrupted = compressed.clone();
    if !corrupted.is_empty() { corrupted[0] ^= 0xff; }
    cur.write_all(&corrupted).unwrap();
    cur.seek(SeekFrom::Start(0)).unwrap();

    let read_header = BzImageHeader::read_from(&mut cur).unwrap();
    // read compressed bytes
    let mut compressed_read = Vec::new();
    cur.read_to_end(&mut compressed_read).unwrap();

    assert!(!read_header.validate_checksum(&compressed_read));
}

#[test]
fn header_write_size() {
    // ensure write_to writes exactly HEADER_SIZE bytes
    let header = BzImageHeader {
        magic: *MAGIC,
        version: VERSION.into(),
        reserved1: 0u32.into(),
        uncompressed_size: 0u64.into(),
        compressed_size: 0u64.into(),
        checksum: [0u8; 32],
        reserved2: 0u32.into(),
    };

    let mut cur = Cursor::new(Vec::new());
    header.write_to(&mut cur).unwrap();
    assert_eq!(cur.get_ref().len(), bzimage::HEADER_SIZE);
}

#[test]
fn truncated_header_fails() {
    // provide only the magic and partial header and ensure read_from errors
    let mut buf = Vec::new();
    buf.extend_from_slice(MAGIC);
    buf.extend_from_slice(&[0u8; 10]);
    let mut cur = Cursor::new(buf);
    let r = BzImageHeader::read_from(&mut cur);
    assert!(r.is_err());
}