use std::io::{Read, Seek, SeekFrom};
use tar::{EntryType, Header};
use super::ArchiveError;
const BLOCK: usize = 512;
const CKSUM_FIELD: std::ops::Range<usize> = 148..156;
pub(super) struct PaxRecord {
pub key: Vec<u8>,
pub value: Vec<u8>,
}
pub(super) struct Member {
pub header: Header,
pub path: Vec<u8>,
pub link: Option<Vec<u8>>,
pub records: Vec<PaxRecord>,
pub body: MemberBody,
}
pub(super) enum MemberBody {
Bytes(Vec<u8>),
Range {
offset: u64,
len: u64,
},
}
impl Member {
fn record(&self, key: &[u8]) -> Option<&[u8]> {
self.records
.iter()
.rev()
.find(|r| r.key == key)
.map(|r| r.value.as_slice())
}
}
pub(super) fn read_members<R: Read>(reader: R) -> Result<Vec<Member>, ArchiveError> {
read_members_with(reader, |r, size| Ok(MemberBody::Bytes(read_body(r, size)?)))
}
pub(super) fn read_members_seeking<R: Read + Seek>(
mut reader: R,
) -> Result<Vec<Member>, ArchiveError> {
let end = reader.seek(SeekFrom::End(0))?;
reader.seek(SeekFrom::Start(0))?;
read_members_with(reader, move |r, size| {
let offset = r.stream_position()?;
let next = size
.checked_next_multiple_of(BLOCK as u64)
.and_then(|padded| offset.checked_add(padded))
.filter(|&next| next <= end)
.ok_or(ArchiveError::Malformed {
reason: "archive ends inside a member body",
})?;
r.seek(SeekFrom::Start(next))?;
Ok(MemberBody::Range { offset, len: size })
})
}
fn read_members_with<R: Read>(
mut reader: R,
mut take_body: impl FnMut(&mut R, u64) -> Result<MemberBody, ArchiveError>,
) -> Result<Vec<Member>, ArchiveError> {
let mut members = Vec::new();
let mut records: Vec<PaxRecord> = Vec::new();
let mut long_path: Option<Vec<u8>> = None;
let mut long_link: Option<Vec<u8>> = None;
let mut first_block = true;
while let Some(block) = read_block(&mut reader)? {
if block.iter().all(|&b| b == 0) {
break;
}
if let Err(e) = verify_cksum(&block) {
if first_block && let Some(format) = compression(&block) {
return Err(ArchiveError::Compressed { format });
}
return Err(e);
}
first_block = false;
let header = Header::from_byte_slice(&block);
let stored = header.entry_size().map_err(|_| ArchiveError::Malformed {
reason: "unreadable member size",
})?;
match header.entry_type() {
EntryType::XHeader => {
records = parse_records(&read_body(&mut reader, stored)?)?;
}
EntryType::GNULongName => {
long_path = Some(trim_nul(read_body(&mut reader, stored)?));
}
EntryType::GNULongLink => {
long_link = Some(trim_nul(read_body(&mut reader, stored)?));
}
EntryType::XGlobalHeader => {
for record in parse_records(&read_body(&mut reader, stored)?)? {
if applies_per_member(&record.key) {
return Err(ArchiveError::Malformed {
reason: "a PAX global header sets a default this parser would \
otherwise read per member, and archive-wide defaults \
are not applied",
});
}
}
}
t if t.as_byte() == b'V' => {
read_body(&mut reader, stored)?;
}
_ => {
let mut member = Member {
header: header.clone(),
path: Vec::new(),
link: None,
records: std::mem::take(&mut records),
body: MemberBody::Bytes(Vec::new()),
};
member.path = match long_path.take() {
Some(p) => p,
None => match member.record(b"path") {
Some(v) => v.to_vec(),
None => header.path_bytes().into_owned(),
},
};
member.link = match long_link.take() {
Some(l) => Some(l),
None => match member.record(b"linkpath") {
Some(v) => Some(v.to_vec()),
None => header.link_name_bytes().map(std::borrow::Cow::into_owned),
},
};
if header.entry_type() == EntryType::GNUSparse {
return Err(ArchiveError::Bad {
path: member.path,
reason: "old-GNU sparse files are not supported",
});
}
let size = match member.record(b"size") {
Some(v) => parse_decimal(v).ok_or(ArchiveError::Malformed {
reason: "invalid PAX size record",
})?,
None => stored,
};
member.body = take_body(&mut reader, size)?;
members.push(member);
}
}
}
Ok(members)
}
fn read_block<R: Read>(reader: &mut R) -> Result<Option<[u8; BLOCK]>, ArchiveError> {
let mut block = [0u8; BLOCK];
let mut filled = 0;
while filled < BLOCK {
match reader.read(&mut block[filled..])? {
0 => break,
n => filled += n,
}
}
match filled {
0 => Ok(None),
BLOCK => Ok(Some(block)),
_ => Err(compression(&block[..filled]).map_or(
ArchiveError::Malformed {
reason: "archive ends inside a block",
},
|format| ArchiveError::Compressed { format },
)),
}
}
fn compression(head: &[u8]) -> Option<&'static str> {
const MAGIC: &[(&[u8], &str)] = &[
(&[0x1f, 0x8b], "gzip"),
(&[0x28, 0xb5, 0x2f, 0xfd], "zstd"),
(&[0xfd, b'7', b'z', b'X', b'Z', 0x00], "xz"),
(b"BZh", "bzip2"),
(&[0x04, 0x22, 0x4d, 0x18], "lz4"),
(&[0x5d, 0x00, 0x00], "lzma"),
(b"\x89LZO", "lzop"),
(&[0x1f, 0x9d], "compress"),
];
MAGIC
.iter()
.find(|(magic, _)| head.starts_with(magic))
.map(|&(_, format)| format)
}
fn read_body<R: Read>(reader: &mut R, size: u64) -> Result<Vec<u8>, ArchiveError> {
let mut data = Vec::new();
reader.by_ref().take(size).read_to_end(&mut data)?;
if data.len() as u64 != size {
return Err(ArchiveError::Malformed {
reason: "archive ends inside a member body",
});
}
let mut padding = (BLOCK - (data.len() % BLOCK)) % BLOCK;
let mut sink = [0u8; BLOCK];
while padding > 0 {
match reader.read(&mut sink[..padding])? {
0 => {
return Err(ArchiveError::Malformed {
reason: "archive ends inside a member body",
});
}
n => padding -= n,
}
}
Ok(data)
}
fn verify_cksum(block: &[u8; BLOCK]) -> Result<(), ArchiveError> {
let declared = Header::from_byte_slice(block)
.cksum()
.map_err(|_| ArchiveError::Malformed {
reason: "unreadable header checksum",
})?;
let sum: u32 = block[..CKSUM_FIELD.start]
.iter()
.chain(&block[CKSUM_FIELD.end..])
.map(|&b| u32::from(b))
.sum::<u32>()
+ (CKSUM_FIELD.len() as u32) * u32::from(b' ');
if sum != declared {
return Err(ArchiveError::Malformed {
reason: "header checksum mismatch",
});
}
Ok(())
}
fn applies_per_member(key: &[u8]) -> bool {
matches!(
key,
b"path" | b"linkpath" | b"size" | b"uid" | b"gid" | b"atime" | b"ctime" | b"mtime"
) || key.starts_with(b"SCHILY.")
|| key.starts_with(b"LIBARCHIVE.xattr.")
|| key.starts_with(b"GNU.sparse.")
}
fn parse_records(body: &[u8]) -> Result<Vec<PaxRecord>, ArchiveError> {
let malformed = || ArchiveError::Malformed {
reason: "malformed PAX extended header",
};
let mut records = Vec::new();
let mut rest = body;
while !rest.is_empty() {
if rest.iter().all(|&b| b == 0) {
break;
}
let space = rest.iter().position(|&b| b == b' ').ok_or_else(malformed)?;
let len = parse_decimal(&rest[..space]).ok_or_else(malformed)?;
let len = usize::try_from(len)
.ok()
.filter(|&l| l <= rest.len())
.ok_or_else(malformed)?;
if len < space + 5 {
return Err(malformed());
}
let record = &rest[..len];
if record[len - 1] != b'\n' {
return Err(malformed());
}
let pair = &record[space + 1..len - 1];
let equals = pair.iter().position(|&b| b == b'=').ok_or_else(malformed)?;
if equals == 0 {
return Err(malformed());
}
records.push(PaxRecord {
key: pair[..equals].to_vec(),
value: pair[equals + 1..].to_vec(),
});
rest = &rest[len..];
}
Ok(records)
}
fn parse_decimal(text: &[u8]) -> Option<u64> {
if text.is_empty() || !text.iter().all(u8::is_ascii_digit) {
return None;
}
std::str::from_utf8(text).ok()?.parse().ok()
}
fn trim_nul(mut body: Vec<u8>) -> Vec<u8> {
if body.last() == Some(&0) {
body.pop();
}
body
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn records_are_delimited_by_length_not_newline() {
let value = b"\x02\x00\x00\x00\x01\x00\x06\x00\x0a\x00\x00\x00";
let key = b"SCHILY.xattr.system.posix_acl_access";
let payload_len = key.len() + 1 + value.len() + 1;
let len = payload_len + 2 + 1;
let mut body = format!("{len} ").into_bytes();
body.extend_from_slice(key);
body.push(b'=');
body.extend_from_slice(value);
body.push(b'\n');
let records = parse_records(&body).unwrap();
assert_eq!(records.len(), 1);
assert_eq!(records[0].key, key);
assert_eq!(records[0].value, value);
}
#[test]
fn records_reject_a_length_that_does_not_delimit() {
assert!(parse_records(b"99 mtime=1\n").is_err());
assert!(parse_records(b"3 a\n").is_err());
assert!(parse_records(b"11 mtime=1 ").is_err());
assert!(parse_records(b"9 =value\n").is_err());
assert!(parse_records(b"11 mtime=1\n\0\0\0").unwrap().len() == 1);
}
#[test]
fn a_body_shorter_than_its_header_claims_is_malformed() {
let mut stream = vec![0u8; BLOCK];
assert!(matches!(
read_body(&mut &stream[..], 4096),
Err(ArchiveError::Malformed { .. })
));
stream.truncate(BLOCK - 1);
assert!(matches!(
read_block(&mut &stream[..]),
Err(ArchiveError::Malformed { .. })
));
assert!(read_block(&mut &[][..]).unwrap().is_none());
}
fn pax_sized_archive(size: &str) -> Vec<u8> {
let payload = format!("size={size}\n");
let mut len = payload.len() + 2;
while format!("{len} ").len() + payload.len() != len {
len += 1;
}
let records = format!("{len} {payload}");
let mut out = Vec::new();
let mut push_block = |bytes: &[u8]| {
out.extend_from_slice(bytes);
out.resize(out.len().next_multiple_of(BLOCK), 0);
};
let mut x = Header::new_gnu();
x.set_entry_type(EntryType::XHeader);
x.set_size(records.len() as u64);
x.set_cksum();
push_block(x.as_bytes());
push_block(records.as_bytes());
let mut h = Header::new_gnu();
h.set_entry_type(EntryType::Regular);
h.set_size(0);
h.set_path("big").unwrap();
h.set_cksum();
push_block(h.as_bytes());
out.resize(out.len() + 2 * BLOCK, 0);
out
}
#[test]
fn a_pax_size_no_offset_can_hold_is_malformed() {
let cases = [
(u64::MAX, "the round-up"),
(u64::MAX - 510, "the round-up"),
(u64::MAX - 511, "the sum with the offset"),
(u64::MAX - 1000, "the sum with the offset"),
(u64::MAX / 2 + 1, "the bound against the archive's length"),
];
for (size, step) in cases {
let archive = pax_sized_archive(&size.to_string());
assert!(
matches!(
read_members_seeking(std::io::Cursor::new(&archive)),
Err(ArchiveError::Malformed { .. })
),
"size {size} framed successfully; {step} did not refuse it"
);
assert!(
matches!(
read_members(&archive[..]),
Err(ArchiveError::Malformed { .. })
),
"size {size} read successfully"
);
}
}
#[test]
fn the_seeking_parser_records_a_body_the_archive_holds() {
let mut archive = pax_sized_archive("512");
archive.splice(3 * BLOCK..3 * BLOCK, [0xab; BLOCK]);
let members = read_members_seeking(std::io::Cursor::new(&archive)).unwrap();
assert_eq!(members.len(), 1);
assert!(matches!(
members[0].body,
MemberBody::Range {
offset: 1536,
len: 512
}
));
let mut archive = pax_sized_archive("8");
archive.splice(3 * BLOCK..3 * BLOCK, [0xcd; BLOCK]);
let members = read_members_seeking(std::io::Cursor::new(&archive)).unwrap();
assert!(matches!(
members[0].body,
MemberBody::Range {
offset: 1536,
len: 8
}
));
}
}