use std::cmp::Ordering;
use md5::{Digest, Md5};
pub(crate) const MAGIC: [u8; 8] = *b"PAR2\0PKT";
pub const HEADER_LEN: usize = 64;
pub const TYPE_MAIN: [u8; 16] = *b"PAR 2.0\0Main\0\0\0\0";
pub const TYPE_FILE_DESC: [u8; 16] = *b"PAR 2.0\0FileDesc";
pub const TYPE_IFSC: [u8; 16] = *b"PAR 2.0\0IFSC\0\0\0\0";
pub const TYPE_RECOVERY: [u8; 16] = *b"PAR 2.0\0RecvSlic";
pub const TYPE_CREATOR: [u8; 16] = *b"PAR 2.0\0Creator\0";
pub const TYPE_UNICODE_FILENAME: [u8; 16] = *b"PAR 2.0\0UniFileN";
#[derive(Debug, Clone, Copy)]
pub struct SliceChecksum {
pub md5: [u8; 16],
pub crc32: u32,
}
pub fn md5(data: &[u8]) -> [u8; 16] {
let mut hasher = Md5::new();
hasher.update(data);
let mut out = [0u8; 16];
out.copy_from_slice(&hasher.finalize());
out
}
fn pad_to_4(mut bytes: Vec<u8>) -> Vec<u8> {
while !bytes.len().is_multiple_of(4) {
bytes.push(0);
}
bytes
}
pub fn serialize_packet(
recovery_set_id: &[u8; 16],
packet_type: &[u8; 16],
body: &[u8],
) -> Vec<u8> {
assert!(
body.len().is_multiple_of(4),
"PAR2 packet body must be a multiple of 4 bytes"
);
let total = HEADER_LEN + body.len();
let mut packet = Vec::with_capacity(total);
packet.extend_from_slice(&MAGIC); packet.extend_from_slice(&(total as u64).to_le_bytes()); packet.extend_from_slice(&[0u8; 16]); packet.extend_from_slice(recovery_set_id); packet.extend_from_slice(packet_type); packet.extend_from_slice(body);
let hash = md5(&packet[32..]);
packet[16..32].copy_from_slice(&hash);
packet
}
pub fn serialize_recovery_packets(
recovery_set_id: &[u8; 16],
slices: &[crate::encoder::RecoverySlice],
) -> Vec<Vec<u8>> {
use md5_many::{Md5Many, Md5State};
let many = Md5Many::new();
let mut out_packets = Vec::with_capacity(slices.len());
for slice in slices {
let body_len = 4 + slice.data.len();
let total = HEADER_LEN + body_len;
let mut packet = Vec::with_capacity(total);
packet.extend_from_slice(&MAGIC); packet.extend_from_slice(&(total as u64).to_le_bytes()); packet.extend_from_slice(&[0u8; 16]); packet.extend_from_slice(recovery_set_id); packet.extend_from_slice(&TYPE_RECOVERY); packet.extend_from_slice(&slice.exponent.to_le_bytes()); packet.extend_from_slice(&slice.data); out_packets.push(packet);
}
let lanes = many.lanes();
for chunk in out_packets.chunks_mut(lanes) {
let mut states = vec![Md5State::new(); chunk.len()];
let mut inputs = Vec::with_capacity(chunk.len());
for p in chunk.iter() {
inputs.push(&p[32..]);
}
many.update_many(&mut states, &inputs);
let mut hashes = vec![[0u8; 16]; chunk.len()];
many.finalize_many(&states, &mut hashes);
for (i, hash) in hashes.into_iter().enumerate() {
chunk[i][16..32].copy_from_slice(&hash);
}
}
out_packets
}
pub fn cmp_file_id(a: &[u8; 16], b: &[u8; 16]) -> Ordering {
a.iter().rev().cmp(b.iter().rev())
}
pub fn main_body(slice_size: u64, recovery_file_ids: &[[u8; 16]]) -> Vec<u8> {
let mut sorted = recovery_file_ids.to_vec();
sorted.sort_unstable_by(cmp_file_id);
let mut body = Vec::with_capacity(12 + 16 * sorted.len());
body.extend_from_slice(&slice_size.to_le_bytes());
body.extend_from_slice(&(sorted.len() as u32).to_le_bytes());
for id in &sorted {
body.extend_from_slice(id);
}
body
}
pub fn recovery_set_id(main_body: &[u8]) -> [u8; 16] {
md5(main_body)
}
pub fn compute_file_id(md5_16k: &[u8; 16], file_length: u64, name: &str) -> [u8; 16] {
let mut input = Vec::with_capacity(24 + name.len());
input.extend_from_slice(md5_16k);
input.extend_from_slice(&file_length.to_le_bytes());
input.extend_from_slice(name.as_bytes());
md5(&input)
}
pub fn file_description_body(
file_id: &[u8; 16],
md5_full: &[u8; 16],
md5_16k: &[u8; 16],
file_length: u64,
name: &str,
) -> Vec<u8> {
let mut body = Vec::with_capacity(56 + name.len() + 3);
body.extend_from_slice(file_id);
body.extend_from_slice(md5_full);
body.extend_from_slice(md5_16k);
body.extend_from_slice(&file_length.to_le_bytes());
body.extend_from_slice(name.as_bytes());
pad_to_4(body)
}
pub fn unicode_filename_body(file_id: &[u8; 16], name: &str) -> Vec<u8> {
let mut body = Vec::with_capacity(16 + 2 * name.len() + 2);
body.extend_from_slice(file_id);
for unit in name.encode_utf16() {
body.extend_from_slice(&unit.to_le_bytes());
}
pad_to_4(body)
}
pub fn serialize_file_description(
recovery_set_id: &[u8; 16],
file_id: &[u8; 16],
md5_full: &[u8; 16],
md5_16k: &[u8; 16],
file_length: u64,
name: &str,
) -> Vec<u8> {
let mut packets = serialize_packet(
recovery_set_id,
&TYPE_FILE_DESC,
&file_description_body(file_id, md5_full, md5_16k, file_length, name),
);
if !name.is_ascii() {
packets.extend(serialize_packet(
recovery_set_id,
&TYPE_UNICODE_FILENAME,
&unicode_filename_body(file_id, name),
));
}
packets
}
pub fn ifsc_body(file_id: &[u8; 16], slices: &[SliceChecksum]) -> Vec<u8> {
let mut body = Vec::with_capacity(16 + 20 * slices.len());
body.extend_from_slice(file_id);
for slice in slices {
body.extend_from_slice(&slice.md5);
body.extend_from_slice(&slice.crc32.to_le_bytes());
}
body
}
pub fn recovery_body(exponent: u32, data: &[u8]) -> Vec<u8> {
assert!(
data.len().is_multiple_of(4),
"recovery slice data must be a multiple of 4 bytes"
);
let mut body = Vec::with_capacity(4 + data.len());
body.extend_from_slice(&exponent.to_le_bytes());
body.extend_from_slice(data);
body
}
pub fn creator_body(creator: &str) -> Vec<u8> {
pad_to_4(creator.as_bytes().to_vec())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn md5_known_vectors() {
assert_eq!(
md5(b""),
[
0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04, 0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8,
0x42, 0x7e
]
);
assert_eq!(
md5(b"abc"),
[
0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0, 0xd6, 0x96, 0x3f, 0x7d, 0x28, 0xe1,
0x7f, 0x72
]
);
}
#[test]
fn all_type_tags_are_16_bytes() {
for tag in [
TYPE_MAIN,
TYPE_FILE_DESC,
TYPE_IFSC,
TYPE_RECOVERY,
TYPE_CREATOR,
TYPE_UNICODE_FILENAME,
] {
assert_eq!(tag.len(), 16);
assert!(tag.starts_with(b"PAR 2.0\0"));
}
}
#[test]
fn serialized_packet_has_correct_header() {
let rsid = [0x11u8; 16];
let body = b"abcd1234"; let packet = serialize_packet(&rsid, &TYPE_CREATOR, body);
assert_eq!(&packet[0..8], b"PAR2\0PKT");
assert_eq!(
u64::from_le_bytes(packet[8..16].try_into().unwrap()),
(HEADER_LEN + body.len()) as u64
);
assert_eq!(&packet[32..48], &rsid);
assert_eq!(&packet[48..64], &TYPE_CREATOR);
assert_eq!(&packet[64..], body);
assert_eq!(&packet[16..32], &md5(&packet[32..]));
assert!(packet.len().is_multiple_of(4));
}
#[test]
fn main_body_sorts_file_ids_and_recovery_set_id_is_its_md5() {
let ids = [[0x03u8; 16], [0x01u8; 16], [0x02u8; 16]];
let body = main_body(768_000, &ids);
assert_eq!(u64::from_le_bytes(body[0..8].try_into().unwrap()), 768_000);
assert_eq!(u32::from_le_bytes(body[8..12].try_into().unwrap()), 3);
assert_eq!(&body[12..28], &[0x01u8; 16]);
assert_eq!(&body[28..44], &[0x02u8; 16]);
assert_eq!(&body[44..60], &[0x03u8; 16]);
assert_eq!(recovery_set_id(&body), md5(&body));
}
#[test]
fn file_ids_sort_as_little_endian_integers() {
let mut low = [0u8; 16];
low[0] = 0xFF;
let mut high = [0u8; 16];
high[15] = 0x01;
assert_eq!(cmp_file_id(&low, &high), Ordering::Less);
assert_eq!(cmp_file_id(&high, &low), Ordering::Greater);
assert_eq!(cmp_file_id(&low, &low), Ordering::Equal);
let body = main_body(16_384, &[high, low]);
assert_eq!(&body[12..28], &low);
assert_eq!(&body[28..44], &high);
}
#[test]
fn file_id_is_md5_of_hash_length_and_name() {
let md5_16k = [0xABu8; 16];
let id = compute_file_id(&md5_16k, 1234, "movie.mkv");
let mut expected_input = Vec::new();
expected_input.extend_from_slice(&md5_16k);
expected_input.extend_from_slice(&1234u64.to_le_bytes());
expected_input.extend_from_slice(b"movie.mkv");
assert_eq!(id, md5(&expected_input));
}
#[test]
fn file_description_body_layout_and_padding() {
let body = file_description_body(&[1; 16], &[2; 16], &[3; 16], 5000, "ab");
assert_eq!(&body[0..16], &[1u8; 16]);
assert_eq!(&body[16..32], &[2u8; 16]);
assert_eq!(&body[32..48], &[3u8; 16]);
assert_eq!(u64::from_le_bytes(body[48..56].try_into().unwrap()), 5000);
assert_eq!(&body[56..58], b"ab");
assert!(body.len().is_multiple_of(4)); assert_eq!(body.len(), 60);
}
#[test]
fn unicode_filename_body_is_padded_utf16le() {
let body = unicode_filename_body(&[1; 16], "é");
assert_eq!(&body[0..16], &[1u8; 16]);
assert_eq!(&body[16..], &[0xE9, 0x00, 0x00, 0x00]);
let body = unicode_filename_body(&[1; 16], "çã");
assert_eq!(&body[16..], &[0xE7, 0x00, 0xE3, 0x00]);
let body = unicode_filename_body(&[1; 16], "\u{1F600}");
assert_eq!(&body[16..], &[0x3D, 0xD8, 0x00, 0xDE]);
}
#[test]
fn file_description_adds_unicode_packet_only_for_non_ascii_names() {
let ascii = serialize_file_description(&[0; 16], &[1; 16], &[2; 16], &[3; 16], 9, "a.bin");
assert_eq!(ascii.len(), HEADER_LEN + 56 + 8);
assert_eq!(&ascii[48..64], &TYPE_FILE_DESC);
let name = "Ação.bin";
let both = serialize_file_description(&[0; 16], &[1; 16], &[2; 16], &[3; 16], 9, name);
let desc_len = u64::from_le_bytes(both[8..16].try_into().unwrap()) as usize;
assert_eq!(&both[48..64], &TYPE_FILE_DESC);
assert_eq!(
&both[HEADER_LEN + 56..HEADER_LEN + 56 + name.len()],
name.as_bytes(),
"FileDesc keeps the UTF-8 name"
);
let uni = &both[desc_len..];
assert_eq!(&uni[48..64], &TYPE_UNICODE_FILENAME);
assert_eq!(&uni[HEADER_LEN..HEADER_LEN + 16], &[1u8; 16]);
assert_eq!(
&uni[HEADER_LEN + 16..],
&unicode_filename_body(&[1; 16], name)[16..]
);
}
#[test]
fn ifsc_body_packs_20_bytes_per_slice() {
let slices = [
SliceChecksum {
md5: [9; 16],
crc32: 0x1122_3344,
},
SliceChecksum {
md5: [8; 16],
crc32: 0xAABB_CCDD,
},
];
let body = ifsc_body(&[7; 16], &slices);
assert_eq!(body.len(), 16 + 20 * 2);
assert_eq!(&body[0..16], &[7u8; 16]);
assert_eq!(&body[16..32], &[9u8; 16]);
assert_eq!(
u32::from_le_bytes(body[32..36].try_into().unwrap()),
0x1122_3344
);
}
#[test]
fn recovery_body_prefixes_the_exponent() {
let data = vec![0u8; 8];
let body = recovery_body(42, &data);
assert_eq!(u32::from_le_bytes(body[0..4].try_into().unwrap()), 42);
assert_eq!(body.len(), 12);
}
#[test]
fn creator_body_is_padded() {
assert_eq!(creator_body("pesto"), b"pesto\0\0\0");
}
}