aboutsummaryrefslogtreecommitdiff
path: root/crates/rsli
diff options
context:
space:
mode:
Diffstat (limited to 'crates/rsli')
-rw-r--r--crates/rsli/Cargo.toml8
-rw-r--r--crates/rsli/README.md58
-rw-r--r--crates/rsli/src/compress/deflate.rs14
-rw-r--r--crates/rsli/src/compress/lzh.rs298
-rw-r--r--crates/rsli/src/compress/lzss.rs79
-rw-r--r--crates/rsli/src/compress/mod.rs9
-rw-r--r--crates/rsli/src/compress/xor.rs29
-rw-r--r--crates/rsli/src/error.rs140
-rw-r--r--crates/rsli/src/lib.rs411
-rw-r--r--crates/rsli/src/parse.rs267
-rw-r--r--crates/rsli/src/tests.rs1337
11 files changed, 2650 insertions, 0 deletions
diff --git a/crates/rsli/Cargo.toml b/crates/rsli/Cargo.toml
new file mode 100644
index 0000000..faad224
--- /dev/null
+++ b/crates/rsli/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "rsli"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+common = { path = "../common" }
+flate2 = { version = "1", default-features = false, features = ["rust_backend"] }
diff --git a/crates/rsli/README.md b/crates/rsli/README.md
new file mode 100644
index 0000000..27816d6
--- /dev/null
+++ b/crates/rsli/README.md
@@ -0,0 +1,58 @@
+# rsli
+
+Rust-библиотека для чтения архивов формата **RsLi**.
+
+## Что умеет
+
+- Открытие библиотеки из файла (`open_path`, `open_path_with`).
+- Дешифрование таблицы записей (XOR stream cipher).
+- Поддержка AO-трейлера и media overlay (`allow_ao_trailer`).
+- Поддержка quirk для Deflate `EOF+1` (`allow_deflate_eof_plus_one`).
+- Поиск по имени (`find`, c приведением запроса к uppercase).
+- Загрузка данных:
+- `load`, `load_into`, `load_packed`, `unpack`, `load_fast`.
+
+## Поддерживаемые методы упаковки
+
+- `0x000` None
+- `0x020` XorOnly
+- `0x040` Lzss
+- `0x060` XorLzss
+- `0x080` LzssHuffman
+- `0x0A0` XorLzssHuffman
+- `0x100` Deflate
+
+## Модель ошибок
+
+Типизированные ошибки без паник в production-коде (`InvalidMagic`, `UnsupportedVersion`, `EntryTableOutOfBounds`, `PackedSizePastEof`, `DeflateEofPlusOneQuirkRejected`, `UnsupportedMethod`, и др.).
+
+## Покрытие тестами
+
+### Реальные файлы
+
+- Рекурсивный прогон по `testdata/rsli/**`.
+- Сейчас в наборе: **2 архива**.
+- На реальных данных подтверждены и проходят byte-to-byte проверки методы:
+- `0x040` (LZSS)
+- `0x100` (Deflate)
+- Для каждого архива проверяется:
+- `load`/`load_into`/`load_packed`/`unpack`/`load_fast`;
+- `find`;
+- пересборка и сравнение **byte-to-byte**.
+
+### Синтетические тесты
+
+Из-за отсутствия реальных файлов для части методов добавлены синтетические архивы и тесты:
+
+- Методы:
+- `0x000`, `0x020`, `0x060`, `0x080`, `0x0A0`.
+- Спецкейсы формата:
+ - AO trailer + overlay;
+ - Deflate `EOF+1` (оба режима: accepted/rejected);
+- некорректные заголовки/таблицы/смещения/методы.
+
+## Быстрый запуск тестов
+
+```bash
+cargo test -p rsli -- --nocapture
+```
diff --git a/crates/rsli/src/compress/deflate.rs b/crates/rsli/src/compress/deflate.rs
new file mode 100644
index 0000000..6b8ea73
--- /dev/null
+++ b/crates/rsli/src/compress/deflate.rs
@@ -0,0 +1,14 @@
+use crate::error::Error;
+use crate::Result;
+use flate2::read::DeflateDecoder;
+use std::io::Read;
+
+/// Decode raw Deflate (RFC 1951) payload.
+pub fn decode_deflate(packed: &[u8]) -> Result<Vec<u8>> {
+ let mut out = Vec::new();
+ let mut decoder = DeflateDecoder::new(packed);
+ decoder
+ .read_to_end(&mut out)
+ .map_err(|_| Error::DecompressionFailed("deflate"))?;
+ Ok(out)
+}
diff --git a/crates/rsli/src/compress/lzh.rs b/crates/rsli/src/compress/lzh.rs
new file mode 100644
index 0000000..07dc0c5
--- /dev/null
+++ b/crates/rsli/src/compress/lzh.rs
@@ -0,0 +1,298 @@
+use super::xor::XorState;
+use crate::error::Error;
+use crate::Result;
+
+pub(crate) const LZH_N: usize = 4096;
+pub(crate) const LZH_F: usize = 60;
+pub(crate) const LZH_THRESHOLD: usize = 2;
+pub(crate) const LZH_N_CHAR: usize = 256 - LZH_THRESHOLD + LZH_F;
+pub(crate) const LZH_T: usize = LZH_N_CHAR * 2 - 1;
+pub(crate) const LZH_R: usize = LZH_T - 1;
+pub(crate) const LZH_MAX_FREQ: u16 = 0x8000;
+
+/// LZSS-Huffman decompression with optional on-the-fly XOR decryption.
+pub fn lzss_huffman_decompress(
+ data: &[u8],
+ expected_size: usize,
+ xor_key: Option<u16>,
+) -> Result<Vec<u8>> {
+ let mut decoder = LzhDecoder::new(data, xor_key);
+ decoder.decode(expected_size)
+}
+
+struct LzhDecoder<'a> {
+ bit_reader: BitReader<'a>,
+ text: [u8; LZH_N],
+ freq: [u16; LZH_T + 1],
+ parent: [usize; LZH_T + LZH_N_CHAR],
+ son: [usize; LZH_T],
+ d_code: [u8; 256],
+ d_len: [u8; 256],
+ ring_pos: usize,
+}
+
+impl<'a> LzhDecoder<'a> {
+ fn new(data: &'a [u8], xor_key: Option<u16>) -> Self {
+ let mut decoder = Self {
+ bit_reader: BitReader::new(data, xor_key),
+ text: [0x20u8; LZH_N],
+ freq: [0u16; LZH_T + 1],
+ parent: [0usize; LZH_T + LZH_N_CHAR],
+ son: [0usize; LZH_T],
+ d_code: [0u8; 256],
+ d_len: [0u8; 256],
+ ring_pos: LZH_N - LZH_F,
+ };
+ decoder.init_tables();
+ decoder.start_huff();
+ decoder
+ }
+
+ fn decode(&mut self, expected_size: usize) -> Result<Vec<u8>> {
+ let mut out = Vec::with_capacity(expected_size);
+
+ while out.len() < expected_size {
+ let c = self.decode_char()?;
+ if c < 256 {
+ let byte = c as u8;
+ out.push(byte);
+ self.text[self.ring_pos] = byte;
+ self.ring_pos = (self.ring_pos + 1) & (LZH_N - 1);
+ } else {
+ let mut offset = self.decode_position()?;
+ offset = (self.ring_pos.wrapping_sub(offset).wrapping_sub(1)) & (LZH_N - 1);
+ let mut length = c.saturating_sub(253);
+
+ while length > 0 && out.len() < expected_size {
+ let byte = self.text[offset];
+ out.push(byte);
+ self.text[self.ring_pos] = byte;
+ self.ring_pos = (self.ring_pos + 1) & (LZH_N - 1);
+ offset = (offset + 1) & (LZH_N - 1);
+ length -= 1;
+ }
+ }
+ }
+
+ if out.len() != expected_size {
+ return Err(Error::DecompressionFailed("lzss-huffman"));
+ }
+ Ok(out)
+ }
+
+ fn init_tables(&mut self) {
+ let d_code_group_counts = [1usize, 3, 8, 12, 24, 16];
+ let d_len_group_counts = [32usize, 48, 64, 48, 48, 16];
+
+ let mut group_index = 0u8;
+ let mut idx = 0usize;
+ let mut run = 32usize;
+ for count in d_code_group_counts {
+ for _ in 0..count {
+ for _ in 0..run {
+ self.d_code[idx] = group_index;
+ idx += 1;
+ }
+ group_index = group_index.wrapping_add(1);
+ }
+ run >>= 1;
+ }
+
+ let mut len = 3u8;
+ idx = 0;
+ for count in d_len_group_counts {
+ for _ in 0..count {
+ self.d_len[idx] = len;
+ idx += 1;
+ }
+ len = len.saturating_add(1);
+ }
+ }
+
+ fn start_huff(&mut self) {
+ for i in 0..LZH_N_CHAR {
+ self.freq[i] = 1;
+ self.son[i] = i + LZH_T;
+ self.parent[i + LZH_T] = i;
+ }
+
+ let mut i = 0usize;
+ let mut j = LZH_N_CHAR;
+ while j <= LZH_R {
+ self.freq[j] = self.freq[i].saturating_add(self.freq[i + 1]);
+ self.son[j] = i;
+ self.parent[i] = j;
+ self.parent[i + 1] = j;
+ i += 2;
+ j += 1;
+ }
+
+ self.freq[LZH_T] = u16::MAX;
+ self.parent[LZH_R] = 0;
+ }
+
+ fn decode_char(&mut self) -> Result<usize> {
+ let mut node = self.son[LZH_R];
+ while node < LZH_T {
+ let bit = usize::from(self.bit_reader.read_bit()?);
+ node = self.son[node + bit];
+ }
+
+ let c = node - LZH_T;
+ self.update(c);
+ Ok(c)
+ }
+
+ fn decode_position(&mut self) -> Result<usize> {
+ let i = self.bit_reader.read_bits(8)? as usize;
+ let mut c = usize::from(self.d_code[i]) << 6;
+ let mut j = usize::from(self.d_len[i]).saturating_sub(2);
+
+ while j > 0 {
+ j -= 1;
+ c |= usize::from(self.bit_reader.read_bit()?) << j;
+ }
+
+ Ok(c | (i & 0x3F))
+ }
+
+ fn update(&mut self, c: usize) {
+ if self.freq[LZH_R] == LZH_MAX_FREQ {
+ self.reconstruct();
+ }
+
+ let mut current = self.parent[c + LZH_T];
+ loop {
+ self.freq[current] = self.freq[current].saturating_add(1);
+ let freq = self.freq[current];
+
+ if current + 1 < self.freq.len() && freq > self.freq[current + 1] {
+ let mut swap_idx = current + 1;
+ while swap_idx + 1 < self.freq.len() && freq > self.freq[swap_idx + 1] {
+ swap_idx += 1;
+ }
+
+ self.freq.swap(current, swap_idx);
+
+ let left = self.son[current];
+ let right = self.son[swap_idx];
+ self.son[current] = right;
+ self.son[swap_idx] = left;
+
+ self.parent[left] = swap_idx;
+ if left < LZH_T {
+ self.parent[left + 1] = swap_idx;
+ }
+
+ self.parent[right] = current;
+ if right < LZH_T {
+ self.parent[right + 1] = current;
+ }
+
+ current = swap_idx;
+ }
+
+ current = self.parent[current];
+ if current == 0 {
+ break;
+ }
+ }
+ }
+
+ fn reconstruct(&mut self) {
+ let mut j = 0usize;
+ for i in 0..LZH_T {
+ if self.son[i] >= LZH_T {
+ self.freq[j] = (self.freq[i].saturating_add(1)) / 2;
+ self.son[j] = self.son[i];
+ j += 1;
+ }
+ }
+
+ let mut i = 0usize;
+ let mut current = LZH_N_CHAR;
+ while current < LZH_T {
+ let sum = self.freq[i].saturating_add(self.freq[i + 1]);
+ self.freq[current] = sum;
+
+ let mut insert_at = current;
+ while insert_at > 0 && sum < self.freq[insert_at - 1] {
+ insert_at -= 1;
+ }
+
+ for move_idx in (insert_at..current).rev() {
+ self.freq[move_idx + 1] = self.freq[move_idx];
+ self.son[move_idx + 1] = self.son[move_idx];
+ }
+
+ self.freq[insert_at] = sum;
+ self.son[insert_at] = i;
+
+ i += 2;
+ current += 1;
+ }
+
+ for idx in 0..LZH_T {
+ let node = self.son[idx];
+ self.parent[node] = idx;
+ if node < LZH_T {
+ self.parent[node + 1] = idx;
+ }
+ }
+
+ self.freq[LZH_T] = u16::MAX;
+ self.parent[LZH_R] = 0;
+ }
+}
+
+struct BitReader<'a> {
+ data: &'a [u8],
+ byte_pos: usize,
+ bit_mask: u8,
+ current_byte: u8,
+ xor_state: Option<XorState>,
+}
+
+impl<'a> BitReader<'a> {
+ fn new(data: &'a [u8], xor_key: Option<u16>) -> Self {
+ Self {
+ data,
+ byte_pos: 0,
+ bit_mask: 0x80,
+ current_byte: 0,
+ xor_state: xor_key.map(XorState::new),
+ }
+ }
+
+ fn read_bit(&mut self) -> Result<u8> {
+ if self.bit_mask == 0x80 {
+ let Some(mut byte) = self.data.get(self.byte_pos).copied() else {
+ return Err(Error::DecompressionFailed("lzss-huffman: unexpected EOF"));
+ };
+ if let Some(state) = &mut self.xor_state {
+ byte = state.decrypt_byte(byte);
+ }
+ self.current_byte = byte;
+ }
+
+ let bit = if (self.current_byte & self.bit_mask) != 0 {
+ 1
+ } else {
+ 0
+ };
+ self.bit_mask >>= 1;
+ if self.bit_mask == 0 {
+ self.bit_mask = 0x80;
+ self.byte_pos = self.byte_pos.saturating_add(1);
+ }
+ Ok(bit)
+ }
+
+ fn read_bits(&mut self, bits: usize) -> Result<u32> {
+ let mut value = 0u32;
+ for _ in 0..bits {
+ value = (value << 1) | u32::from(self.read_bit()?);
+ }
+ Ok(value)
+ }
+}
diff --git a/crates/rsli/src/compress/lzss.rs b/crates/rsli/src/compress/lzss.rs
new file mode 100644
index 0000000..d30345c
--- /dev/null
+++ b/crates/rsli/src/compress/lzss.rs
@@ -0,0 +1,79 @@
+use super::xor::XorState;
+use crate::error::Error;
+use crate::Result;
+
+/// Simple LZSS decompression with optional on-the-fly XOR decryption
+pub fn lzss_decompress_simple(
+ data: &[u8],
+ expected_size: usize,
+ xor_key: Option<u16>,
+) -> Result<Vec<u8>> {
+ let mut ring = [0x20u8; 0x1000];
+ let mut ring_pos = 0xFEEusize;
+ let mut out = Vec::with_capacity(expected_size);
+ let mut in_pos = 0usize;
+
+ let mut control = 0u8;
+ let mut bits_left = 0u8;
+
+ // XOR state for on-the-fly decryption
+ let mut xor_state = xor_key.map(XorState::new);
+
+ // Helper to read byte with optional XOR decryption
+ let read_byte = |pos: usize, state: &mut Option<XorState>| -> Option<u8> {
+ let encrypted = data.get(pos).copied()?;
+ Some(if let Some(ref mut s) = state {
+ s.decrypt_byte(encrypted)
+ } else {
+ encrypted
+ })
+ };
+
+ while out.len() < expected_size {
+ if bits_left == 0 {
+ let byte = read_byte(in_pos, &mut xor_state)
+ .ok_or(Error::DecompressionFailed("lzss-simple: unexpected EOF"))?;
+ control = byte;
+ in_pos += 1;
+ bits_left = 8;
+ }
+
+ if (control & 1) != 0 {
+ let byte = read_byte(in_pos, &mut xor_state)
+ .ok_or(Error::DecompressionFailed("lzss-simple: unexpected EOF"))?;
+ in_pos += 1;
+
+ out.push(byte);
+ ring[ring_pos] = byte;
+ ring_pos = (ring_pos + 1) & 0x0FFF;
+ } else {
+ let low = read_byte(in_pos, &mut xor_state)
+ .ok_or(Error::DecompressionFailed("lzss-simple: unexpected EOF"))?;
+ let high = read_byte(in_pos + 1, &mut xor_state)
+ .ok_or(Error::DecompressionFailed("lzss-simple: unexpected EOF"))?;
+ in_pos += 2;
+
+ let offset = usize::from(low) | (usize::from(high & 0xF0) << 4);
+ let length = usize::from((high & 0x0F) + 3);
+
+ for step in 0..length {
+ let byte = ring[(offset + step) & 0x0FFF];
+ out.push(byte);
+ ring[ring_pos] = byte;
+ ring_pos = (ring_pos + 1) & 0x0FFF;
+ if out.len() >= expected_size {
+ break;
+ }
+ }
+ }
+
+ control >>= 1;
+ bits_left -= 1;
+ }
+
+ if out.len() != expected_size {
+ return Err(Error::DecompressionFailed("lzss-simple"));
+ }
+
+ Ok(out)
+}
diff --git a/crates/rsli/src/compress/mod.rs b/crates/rsli/src/compress/mod.rs
new file mode 100644
index 0000000..bd23143
--- /dev/null
+++ b/crates/rsli/src/compress/mod.rs
@@ -0,0 +1,9 @@
+pub mod deflate;
+pub mod lzh;
+pub mod lzss;
+pub mod xor;
+
+pub use deflate::decode_deflate;
+pub use lzh::lzss_huffman_decompress;
+pub use lzss::lzss_decompress_simple;
+pub use xor::{xor_stream, XorState};
diff --git a/crates/rsli/src/compress/xor.rs b/crates/rsli/src/compress/xor.rs
new file mode 100644
index 0000000..c4c3d7d
--- /dev/null
+++ b/crates/rsli/src/compress/xor.rs
@@ -0,0 +1,29 @@
+/// XOR cipher state for RsLi format
+pub struct XorState {
+ lo: u8,
+ hi: u8,
+}
+
+impl XorState {
+ /// Create new XOR state from 16-bit key
+ pub fn new(key16: u16) -> Self {
+ Self {
+ lo: (key16 & 0xFF) as u8,
+ hi: ((key16 >> 8) & 0xFF) as u8,
+ }
+ }
+
+ /// Decrypt a single byte and update state
+ pub fn decrypt_byte(&mut self, encrypted: u8) -> u8 {
+ self.lo = self.hi ^ self.lo.wrapping_shl(1);
+ let decrypted = encrypted ^ self.lo;
+ self.hi = self.lo ^ (self.hi >> 1);
+ decrypted
+ }
+}
+
+/// Decrypt entire buffer with XOR stream cipher
+pub fn xor_stream(data: &[u8], key16: u16) -> Vec<u8> {
+ let mut state = XorState::new(key16);
+ data.iter().map(|&b| state.decrypt_byte(b)).collect()
+}
diff --git a/crates/rsli/src/error.rs b/crates/rsli/src/error.rs
new file mode 100644
index 0000000..5a36101
--- /dev/null
+++ b/crates/rsli/src/error.rs
@@ -0,0 +1,140 @@
+use core::fmt;
+
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum Error {
+ Io(std::io::Error),
+
+ InvalidMagic {
+ got: [u8; 2],
+ },
+ UnsupportedVersion {
+ got: u8,
+ },
+ InvalidEntryCount {
+ got: i16,
+ },
+ TooManyEntries {
+ got: usize,
+ },
+
+ EntryTableOutOfBounds {
+ table_offset: u64,
+ table_len: u64,
+ file_len: u64,
+ },
+ EntryTableDecryptFailed,
+ CorruptEntryTable(&'static str),
+
+ EntryIdOutOfRange {
+ id: u32,
+ entry_count: u32,
+ },
+ EntryDataOutOfBounds {
+ id: u32,
+ offset: u64,
+ size: u32,
+ file_len: u64,
+ },
+
+ AoTrailerInvalid,
+ MediaOverlayOutOfBounds {
+ overlay: u32,
+ file_len: u64,
+ },
+
+ UnsupportedMethod {
+ raw: u32,
+ },
+ PackedSizePastEof {
+ id: u32,
+ offset: u64,
+ packed_size: u32,
+ file_len: u64,
+ },
+ DeflateEofPlusOneQuirkRejected {
+ id: u32,
+ },
+
+ DecompressionFailed(&'static str),
+ OutputSizeMismatch {
+ expected: u32,
+ got: u32,
+ },
+
+ IntegerOverflow,
+}
+
+impl From<std::io::Error> for Error {
+ fn from(value: std::io::Error) -> Self {
+ Self::Io(value)
+ }
+}
+
+impl fmt::Display for Error {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Error::Io(e) => write!(f, "I/O error: {e}"),
+ Error::InvalidMagic { got } => write!(f, "invalid RsLi magic: {got:02X?}"),
+ Error::UnsupportedVersion { got } => write!(f, "unsupported RsLi version: {got:#x}"),
+ Error::InvalidEntryCount { got } => write!(f, "invalid entry_count: {got}"),
+ Error::TooManyEntries { got } => write!(f, "too many entries: {got} exceeds u32::MAX"),
+ Error::EntryTableOutOfBounds {
+ table_offset,
+ table_len,
+ file_len,
+ } => write!(
+ f,
+ "entry table out of bounds: off={table_offset}, len={table_len}, file={file_len}"
+ ),
+ Error::EntryTableDecryptFailed => write!(f, "failed to decrypt entry table"),
+ Error::CorruptEntryTable(s) => write!(f, "corrupt entry table: {s}"),
+ Error::EntryIdOutOfRange { id, entry_count } => {
+ write!(f, "entry id out of range: id={id}, count={entry_count}")
+ }
+ Error::EntryDataOutOfBounds {
+ id,
+ offset,
+ size,
+ file_len,
+ } => write!(
+ f,
+ "entry data out of bounds: id={id}, off={offset}, size={size}, file={file_len}"
+ ),
+ Error::AoTrailerInvalid => write!(f, "invalid AO trailer"),
+ Error::MediaOverlayOutOfBounds { overlay, file_len } => {
+ write!(
+ f,
+ "media overlay out of bounds: overlay={overlay}, file={file_len}"
+ )
+ }
+ Error::UnsupportedMethod { raw } => write!(f, "unsupported packing method: {raw:#x}"),
+ Error::PackedSizePastEof {
+ id,
+ offset,
+ packed_size,
+ file_len,
+ } => write!(
+ f,
+ "packed range past EOF: id={id}, off={offset}, size={packed_size}, file={file_len}"
+ ),
+ Error::DeflateEofPlusOneQuirkRejected { id } => {
+ write!(f, "deflate EOF+1 quirk rejected for entry {id}")
+ }
+ Error::DecompressionFailed(s) => write!(f, "decompression failed: {s}"),
+ Error::OutputSizeMismatch { expected, got } => {
+ write!(f, "output size mismatch: expected={expected}, got={got}")
+ }
+ Error::IntegerOverflow => write!(f, "integer overflow"),
+ }
+ }
+}
+
+impl std::error::Error for Error {
+ fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+ match self {
+ Self::Io(err) => Some(err),
+ _ => None,
+ }
+ }
+}
diff --git a/crates/rsli/src/lib.rs b/crates/rsli/src/lib.rs
new file mode 100644
index 0000000..ef29f41
--- /dev/null
+++ b/crates/rsli/src/lib.rs
@@ -0,0 +1,411 @@
+pub mod compress;
+pub mod error;
+pub mod parse;
+
+use crate::compress::{
+ decode_deflate, lzss_decompress_simple, lzss_huffman_decompress, xor_stream,
+};
+use crate::error::Error;
+use crate::parse::{c_name_bytes, cmp_c_string, parse_library};
+use common::{OutputBuffer, ResourceData};
+use std::cmp::Ordering;
+use std::fs;
+use std::path::Path;
+use std::sync::Arc;
+
+pub type Result<T> = core::result::Result<T, Error>;
+
+#[derive(Clone, Debug)]
+pub struct OpenOptions {
+ pub allow_ao_trailer: bool,
+ pub allow_deflate_eof_plus_one: bool,
+}
+
+impl Default for OpenOptions {
+ fn default() -> Self {
+ Self {
+ allow_ao_trailer: true,
+ allow_deflate_eof_plus_one: true,
+ }
+ }
+}
+
+#[derive(Debug)]
+pub struct Library {
+ bytes: Arc<[u8]>,
+ entries: Vec<EntryRecord>,
+ #[cfg(test)]
+ pub(crate) header_raw: [u8; 32],
+ #[cfg(test)]
+ pub(crate) table_plain_original: Vec<u8>,
+ #[cfg(test)]
+ pub(crate) xor_seed: u32,
+ #[cfg(test)]
+ pub(crate) source_size: usize,
+ #[cfg(test)]
+ pub(crate) trailer_raw: Option<[u8; 6]>,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EntryId(pub u32);
+
+#[derive(Clone, Debug)]
+pub struct EntryMeta {
+ pub name: String,
+ pub flags: i32,
+ pub method: PackMethod,
+ pub data_offset: u64,
+ pub packed_size: u32,
+ pub unpacked_size: u32,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum PackMethod {
+ None,
+ XorOnly,
+ Lzss,
+ XorLzss,
+ LzssHuffman,
+ XorLzssHuffman,
+ Deflate,
+ Unknown(u32),
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct EntryRef<'a> {
+ pub id: EntryId,
+ pub meta: &'a EntryMeta,
+}
+
+pub struct PackedResource {
+ pub meta: EntryMeta,
+ pub packed: Vec<u8>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct EntryRecord {
+ pub(crate) meta: EntryMeta,
+ pub(crate) name_raw: [u8; 12],
+ pub(crate) sort_to_original: i16,
+ pub(crate) key16: u16,
+ #[cfg(test)]
+ pub(crate) data_offset_raw: u32,
+ pub(crate) packed_size_declared: u32,
+ pub(crate) packed_size_available: usize,
+ pub(crate) effective_offset: usize,
+}
+
+impl Library {
+ pub fn open_path(path: impl AsRef<Path>) -> Result<Self> {
+ Self::open_path_with(path, OpenOptions::default())
+ }
+
+ pub fn open_path_with(path: impl AsRef<Path>, opts: OpenOptions) -> Result<Self> {
+ let bytes = fs::read(path.as_ref())?;
+ let arc: Arc<[u8]> = Arc::from(bytes.into_boxed_slice());
+ parse_library(arc, opts)
+ }
+
+ pub fn entry_count(&self) -> usize {
+ self.entries.len()
+ }
+
+ pub fn entries(&self) -> impl Iterator<Item = EntryRef<'_>> {
+ self.entries
+ .iter()
+ .enumerate()
+ .map(|(idx, entry)| EntryRef {
+ id: EntryId(u32::try_from(idx).expect("entry count validated at parse")),
+ meta: &entry.meta,
+ })
+ }
+
+ pub fn find(&self, name: &str) -> Option<EntryId> {
+ if self.entries.is_empty() {
+ return None;
+ }
+
+ const MAX_INLINE_NAME: usize = 12;
+
+ // Fast path: use stack allocation for short ASCII names (95% of cases)
+ if name.len() <= MAX_INLINE_NAME && name.is_ascii() {
+ let mut buf = [0u8; MAX_INLINE_NAME];
+ for (i, &b) in name.as_bytes().iter().enumerate() {
+ buf[i] = b.to_ascii_uppercase();
+ }
+ return self.find_impl(&buf[..name.len()]);
+ }
+
+ // Slow path: heap allocation for long or non-ASCII names
+ let query = name.to_ascii_uppercase();
+ self.find_impl(query.as_bytes())
+ }
+
+ fn find_impl(&self, query_bytes: &[u8]) -> Option<EntryId> {
+ // Binary search
+ let mut low = 0usize;
+ let mut high = self.entries.len();
+ while low < high {
+ let mid = low + (high - low) / 2;
+ let idx = self.entries[mid].sort_to_original;
+ if idx < 0 {
+ break;
+ }
+ let idx = usize::try_from(idx).ok()?;
+ if idx >= self.entries.len() {
+ break;
+ }
+
+ let cmp = cmp_c_string(query_bytes, c_name_bytes(&self.entries[idx].name_raw));
+ match cmp {
+ Ordering::Less => high = mid,
+ Ordering::Greater => low = mid + 1,
+ Ordering::Equal => {
+ return Some(EntryId(
+ u32::try_from(idx).expect("entry count validated at parse"),
+ ))
+ }
+ }
+ }
+
+ // Linear fallback search
+ self.entries.iter().enumerate().find_map(|(idx, entry)| {
+ if cmp_c_string(query_bytes, c_name_bytes(&entry.name_raw)) == Ordering::Equal {
+ Some(EntryId(
+ u32::try_from(idx).expect("entry count validated at parse"),
+ ))
+ } else {
+ None
+ }
+ })
+ }
+
+ pub fn get(&self, id: EntryId) -> Option<EntryRef<'_>> {
+ let idx = usize::try_from(id.0).ok()?;
+ let entry = self.entries.get(idx)?;
+ Some(EntryRef {
+ id,
+ meta: &entry.meta,
+ })
+ }
+
+ pub fn load(&self, id: EntryId) -> Result<Vec<u8>> {
+ let entry = self.entry_by_id(id)?;
+ let packed = self.packed_slice(id, entry)?;
+ decode_payload(
+ packed,
+ entry.meta.method,
+ entry.key16,
+ entry.meta.unpacked_size,
+ )
+ }
+
+ pub fn load_into(&self, id: EntryId, out: &mut dyn OutputBuffer) -> Result<usize> {
+ let decoded = self.load(id)?;
+ out.write_exact(&decoded)?;
+ Ok(decoded.len())
+ }
+
+ pub fn load_packed(&self, id: EntryId) -> Result<PackedResource> {
+ let entry = self.entry_by_id(id)?;
+ let packed = self.packed_slice(id, entry)?.to_vec();
+ Ok(PackedResource {
+ meta: entry.meta.clone(),
+ packed,
+ })
+ }
+
+ pub fn unpack(&self, packed: &PackedResource) -> Result<Vec<u8>> {
+ let key16 = self.resolve_key_for_meta(&packed.meta).unwrap_or(0);
+
+ let method = packed.meta.method;
+ if needs_xor_key(method) && self.resolve_key_for_meta(&packed.meta).is_none() {
+ return Err(Error::CorruptEntryTable(
+ "cannot resolve XOR key for packed resource",
+ ));
+ }
+
+ decode_payload(&packed.packed, method, key16, packed.meta.unpacked_size)
+ }
+
+ pub fn load_fast(&self, id: EntryId) -> Result<ResourceData<'_>> {
+ let entry = self.entry_by_id(id)?;
+ if entry.meta.method == PackMethod::None {
+ let packed = self.packed_slice(id, entry)?;
+ let size =
+ usize::try_from(entry.meta.unpacked_size).map_err(|_| Error::IntegerOverflow)?;
+ if packed.len() < size {
+ return Err(Error::OutputSizeMismatch {
+ expected: entry.meta.unpacked_size,
+ got: u32::try_from(packed.len()).unwrap_or(u32::MAX),
+ });
+ }
+ return Ok(ResourceData::Borrowed(&packed[..size]));
+ }
+ Ok(ResourceData::Owned(self.load(id)?))
+ }
+
+ fn entry_by_id(&self, id: EntryId) -> Result<&EntryRecord> {
+ let idx = usize::try_from(id.0).map_err(|_| Error::IntegerOverflow)?;
+ self.entries
+ .get(idx)
+ .ok_or_else(|| Error::EntryIdOutOfRange {
+ id: id.0,
+ entry_count: self.entries.len().try_into().unwrap_or(u32::MAX),
+ })
+ }
+
+ fn packed_slice<'a>(&'a self, id: EntryId, entry: &EntryRecord) -> Result<&'a [u8]> {
+ let start = entry.effective_offset;
+ let end = start
+ .checked_add(entry.packed_size_available)
+ .ok_or(Error::IntegerOverflow)?;
+ self.bytes
+ .get(start..end)
+ .ok_or(Error::EntryDataOutOfBounds {
+ id: id.0,
+ offset: u64::try_from(start).unwrap_or(u64::MAX),
+ size: entry.packed_size_declared,
+ file_len: u64::try_from(self.bytes.len()).unwrap_or(u64::MAX),
+ })
+ }
+
+ fn resolve_key_for_meta(&self, meta: &EntryMeta) -> Option<u16> {
+ self.entries
+ .iter()
+ .find(|entry| {
+ entry.meta.name == meta.name
+ && entry.meta.flags == meta.flags
+ && entry.meta.data_offset == meta.data_offset
+ && entry.meta.packed_size == meta.packed_size
+ && entry.meta.unpacked_size == meta.unpacked_size
+ && entry.meta.method == meta.method
+ })
+ .map(|entry| entry.key16)
+ }
+
+ #[cfg(test)]
+ pub(crate) fn rebuild_from_parsed_metadata(&self) -> Result<Vec<u8>> {
+ let trailer_len = usize::from(self.trailer_raw.is_some()) * 6;
+ let pre_trailer_size = self
+ .source_size
+ .checked_sub(trailer_len)
+ .ok_or(Error::IntegerOverflow)?;
+
+ let count = self.entries.len();
+ let table_len = count.checked_mul(32).ok_or(Error::IntegerOverflow)?;
+ let table_end = 32usize
+ .checked_add(table_len)
+ .ok_or(Error::IntegerOverflow)?;
+ if pre_trailer_size < table_end {
+ return Err(Error::EntryTableOutOfBounds {
+ table_offset: 32,
+ table_len: u64::try_from(table_len).map_err(|_| Error::IntegerOverflow)?,
+ file_len: u64::try_from(pre_trailer_size).map_err(|_| Error::IntegerOverflow)?,
+ });
+ }
+
+ let mut out = vec![0u8; pre_trailer_size];
+ out[0..32].copy_from_slice(&self.header_raw);
+ let encrypted_table =
+ xor_stream(&self.table_plain_original, (self.xor_seed & 0xFFFF) as u16);
+ out[32..table_end].copy_from_slice(&encrypted_table);
+
+ let mut occupied = vec![false; pre_trailer_size];
+ for byte in occupied.iter_mut().take(table_end) {
+ *byte = true;
+ }
+
+ for (idx, entry) in self.entries.iter().enumerate() {
+ let packed = self
+ .load_packed(EntryId(
+ u32::try_from(idx).expect("entry count validated at parse"),
+ ))?
+ .packed;
+ let start =
+ usize::try_from(entry.data_offset_raw).map_err(|_| Error::IntegerOverflow)?;
+ for (offset, byte) in packed.iter().copied().enumerate() {
+ let pos = start.checked_add(offset).ok_or(Error::IntegerOverflow)?;
+ if pos >= out.len() {
+ return Err(Error::PackedSizePastEof {
+ id: u32::try_from(idx).expect("entry count validated at parse"),
+ offset: u64::from(entry.data_offset_raw),
+ packed_size: entry.packed_size_declared,
+ file_len: u64::try_from(out.len()).map_err(|_| Error::IntegerOverflow)?,
+ });
+ }
+ if occupied[pos] && out[pos] != byte {
+ return Err(Error::CorruptEntryTable("packed payload overlap conflict"));
+ }
+ out[pos] = byte;
+ occupied[pos] = true;
+ }
+ }
+
+ if let Some(trailer) = self.trailer_raw {
+ out.extend_from_slice(&trailer);
+ }
+ Ok(out)
+ }
+}
+
+fn decode_payload(
+ packed: &[u8],
+ method: PackMethod,
+ key16: u16,
+ unpacked_size: u32,
+) -> Result<Vec<u8>> {
+ let expected = usize::try_from(unpacked_size).map_err(|_| Error::IntegerOverflow)?;
+
+ let out = match method {
+ PackMethod::None => {
+ if packed.len() < expected {
+ return Err(Error::OutputSizeMismatch {
+ expected: unpacked_size,
+ got: u32::try_from(packed.len()).unwrap_or(u32::MAX),
+ });
+ }
+ packed[..expected].to_vec()
+ }
+ PackMethod::XorOnly => {
+ if packed.len() < expected {
+ return Err(Error::OutputSizeMismatch {
+ expected: unpacked_size,
+ got: u32::try_from(packed.len()).unwrap_or(u32::MAX),
+ });
+ }
+ xor_stream(&packed[..expected], key16)
+ }
+ PackMethod::Lzss => lzss_decompress_simple(packed, expected, None)?,
+ PackMethod::XorLzss => {
+ // Optimized: XOR on-the-fly during decompression instead of creating temp buffer
+ lzss_decompress_simple(packed, expected, Some(key16))?
+ }
+ PackMethod::LzssHuffman => lzss_huffman_decompress(packed, expected, None)?,
+ PackMethod::XorLzssHuffman => {
+ // Optimized: XOR on-the-fly during decompression
+ lzss_huffman_decompress(packed, expected, Some(key16))?
+ }
+ PackMethod::Deflate => decode_deflate(packed)?,
+ PackMethod::Unknown(raw) => return Err(Error::UnsupportedMethod { raw }),
+ };
+
+ if out.len() != expected {
+ return Err(Error::OutputSizeMismatch {
+ expected: unpacked_size,
+ got: u32::try_from(out.len()).unwrap_or(u32::MAX),
+ });
+ }
+
+ Ok(out)
+}
+
+fn needs_xor_key(method: PackMethod) -> bool {
+ matches!(
+ method,
+ PackMethod::XorOnly | PackMethod::XorLzss | PackMethod::XorLzssHuffman
+ )
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/rsli/src/parse.rs b/crates/rsli/src/parse.rs
new file mode 100644
index 0000000..9a916dc
--- /dev/null
+++ b/crates/rsli/src/parse.rs
@@ -0,0 +1,267 @@
+use crate::compress::xor::xor_stream;
+use crate::error::Error;
+use crate::{EntryMeta, EntryRecord, Library, OpenOptions, PackMethod, Result};
+use std::cmp::Ordering;
+use std::sync::Arc;
+
+pub fn parse_library(bytes: Arc<[u8]>, opts: OpenOptions) -> Result<Library> {
+ if bytes.len() < 32 {
+ return Err(Error::EntryTableOutOfBounds {
+ table_offset: 32,
+ table_len: 0,
+ file_len: u64::try_from(bytes.len()).map_err(|_| Error::IntegerOverflow)?,
+ });
+ }
+
+ let mut header_raw = [0u8; 32];
+ header_raw.copy_from_slice(&bytes[0..32]);
+
+ if &bytes[0..2] != b"NL" {
+ let mut got = [0u8; 2];
+ got.copy_from_slice(&bytes[0..2]);
+ return Err(Error::InvalidMagic { got });
+ }
+ if bytes[3] != 0x01 {
+ return Err(Error::UnsupportedVersion { got: bytes[3] });
+ }
+
+ let entry_count = i16::from_le_bytes([bytes[4], bytes[5]]);
+ if entry_count < 0 {
+ return Err(Error::InvalidEntryCount { got: entry_count });
+ }
+ let count = usize::try_from(entry_count).map_err(|_| Error::IntegerOverflow)?;
+
+ // Validate entry_count fits in u32 (required for EntryId)
+ if count > u32::MAX as usize {
+ return Err(Error::TooManyEntries { got: count });
+ }
+
+ let xor_seed = u32::from_le_bytes([bytes[20], bytes[21], bytes[22], bytes[23]]);
+
+ let table_len = count.checked_mul(32).ok_or(Error::IntegerOverflow)?;
+ let table_offset = 32usize;
+ let table_end = table_offset
+ .checked_add(table_len)
+ .ok_or(Error::IntegerOverflow)?;
+ if table_end > bytes.len() {
+ return Err(Error::EntryTableOutOfBounds {
+ table_offset: u64::try_from(table_offset).map_err(|_| Error::IntegerOverflow)?,
+ table_len: u64::try_from(table_len).map_err(|_| Error::IntegerOverflow)?,
+ file_len: u64::try_from(bytes.len()).map_err(|_| Error::IntegerOverflow)?,
+ });
+ }
+
+ let table_enc = &bytes[table_offset..table_end];
+ let table_plain_original = xor_stream(table_enc, (xor_seed & 0xFFFF) as u16);
+ if table_plain_original.len() != table_len {
+ return Err(Error::EntryTableDecryptFailed);
+ }
+
+ let (overlay, trailer_raw) = parse_ao_trailer(&bytes, opts.allow_ao_trailer)?;
+ #[cfg(not(test))]
+ let _ = trailer_raw;
+
+ let mut entries = Vec::with_capacity(count);
+ for idx in 0..count {
+ let row = &table_plain_original[idx * 32..(idx + 1) * 32];
+
+ let mut name_raw = [0u8; 12];
+ name_raw.copy_from_slice(&row[0..12]);
+
+ let flags_signed = i16::from_le_bytes([row[16], row[17]]);
+ let sort_to_original = i16::from_le_bytes([row[18], row[19]]);
+ let unpacked_size = u32::from_le_bytes([row[20], row[21], row[22], row[23]]);
+ let data_offset_raw = u32::from_le_bytes([row[24], row[25], row[26], row[27]]);
+ let packed_size_declared = u32::from_le_bytes([row[28], row[29], row[30], row[31]]);
+
+ let method_raw = (flags_signed as u16 as u32) & 0x1E0;
+ let method = parse_method(method_raw);
+
+ let effective_offset_u64 = u64::from(data_offset_raw)
+ .checked_add(u64::from(overlay))
+ .ok_or(Error::IntegerOverflow)?;
+ let effective_offset =
+ usize::try_from(effective_offset_u64).map_err(|_| Error::IntegerOverflow)?;
+
+ let packed_size_usize =
+ usize::try_from(packed_size_declared).map_err(|_| Error::IntegerOverflow)?;
+ let mut packed_size_available = packed_size_usize;
+
+ let end = effective_offset_u64
+ .checked_add(u64::from(packed_size_declared))
+ .ok_or(Error::IntegerOverflow)?;
+ let file_len_u64 = u64::try_from(bytes.len()).map_err(|_| Error::IntegerOverflow)?;
+
+ if end > file_len_u64 {
+ if method_raw == 0x100 && end == file_len_u64 + 1 {
+ if opts.allow_deflate_eof_plus_one {
+ packed_size_available = packed_size_available
+ .checked_sub(1)
+ .ok_or(Error::IntegerOverflow)?;
+ } else {
+ return Err(Error::DeflateEofPlusOneQuirkRejected {
+ id: u32::try_from(idx).expect("entry count validated at parse"),
+ });
+ }
+ } else {
+ return Err(Error::PackedSizePastEof {
+ id: u32::try_from(idx).expect("entry count validated at parse"),
+ offset: effective_offset_u64,
+ packed_size: packed_size_declared,
+ file_len: file_len_u64,
+ });
+ }
+ }
+
+ let available_end = effective_offset
+ .checked_add(packed_size_available)
+ .ok_or(Error::IntegerOverflow)?;
+ if available_end > bytes.len() {
+ return Err(Error::EntryDataOutOfBounds {
+ id: u32::try_from(idx).expect("entry count validated at parse"),
+ offset: effective_offset_u64,
+ size: packed_size_declared,
+ file_len: file_len_u64,
+ });
+ }
+
+ let name = decode_name(c_name_bytes(&name_raw));
+
+ entries.push(EntryRecord {
+ meta: EntryMeta {
+ name,
+ flags: i32::from(flags_signed),
+ method,
+ data_offset: effective_offset_u64,
+ packed_size: packed_size_declared,
+ unpacked_size,
+ },
+ name_raw,
+ sort_to_original,
+ key16: sort_to_original as u16,
+ #[cfg(test)]
+ data_offset_raw,
+ packed_size_declared,
+ packed_size_available,
+ effective_offset,
+ });
+ }
+
+ let presorted_flag = u16::from_le_bytes([bytes[14], bytes[15]]);
+ if presorted_flag == 0xABBA {
+ let mut seen = vec![false; count];
+ for entry in &entries {
+ let idx = i32::from(entry.sort_to_original);
+ if idx < 0 {
+ return Err(Error::CorruptEntryTable(
+ "sort_to_original is not a valid permutation index",
+ ));
+ }
+ let idx = usize::try_from(idx).map_err(|_| Error::IntegerOverflow)?;
+ if idx >= count {
+ return Err(Error::CorruptEntryTable(
+ "sort_to_original is not a valid permutation index",
+ ));
+ }
+ if seen[idx] {
+ return Err(Error::CorruptEntryTable(
+ "sort_to_original is not a permutation",
+ ));
+ }
+ seen[idx] = true;
+ }
+ if seen.iter().any(|value| !*value) {
+ return Err(Error::CorruptEntryTable(
+ "sort_to_original is not a permutation",
+ ));
+ }
+ } else {
+ let mut sorted: Vec<usize> = (0..count).collect();
+ sorted.sort_by(|a, b| {
+ cmp_c_string(
+ c_name_bytes(&entries[*a].name_raw),
+ c_name_bytes(&entries[*b].name_raw),
+ )
+ });
+ for (idx, entry) in entries.iter_mut().enumerate() {
+ entry.sort_to_original =
+ i16::try_from(sorted[idx]).map_err(|_| Error::IntegerOverflow)?;
+ entry.key16 = entry.sort_to_original as u16;
+ }
+ }
+
+ #[cfg(test)]
+ let source_size = bytes.len();
+
+ Ok(Library {
+ bytes,
+ entries,
+ #[cfg(test)]
+ header_raw,
+ #[cfg(test)]
+ table_plain_original,
+ #[cfg(test)]
+ xor_seed,
+ #[cfg(test)]
+ source_size,
+ #[cfg(test)]
+ trailer_raw,
+ })
+}
+
+fn parse_ao_trailer(bytes: &[u8], allow: bool) -> Result<(u32, Option<[u8; 6]>)> {
+ if !allow || bytes.len() < 6 {
+ return Ok((0, None));
+ }
+
+ if &bytes[bytes.len() - 6..bytes.len() - 4] != b"AO" {
+ return Ok((0, None));
+ }
+
+ let mut trailer = [0u8; 6];
+ trailer.copy_from_slice(&bytes[bytes.len() - 6..]);
+ let overlay = u32::from_le_bytes([trailer[2], trailer[3], trailer[4], trailer[5]]);
+
+ if u64::from(overlay) > u64::try_from(bytes.len()).map_err(|_| Error::IntegerOverflow)? {
+ return Err(Error::MediaOverlayOutOfBounds {
+ overlay,
+ file_len: u64::try_from(bytes.len()).map_err(|_| Error::IntegerOverflow)?,
+ });
+ }
+
+ Ok((overlay, Some(trailer)))
+}
+
+pub fn parse_method(raw: u32) -> PackMethod {
+ match raw {
+ 0x000 => PackMethod::None,
+ 0x020 => PackMethod::XorOnly,
+ 0x040 => PackMethod::Lzss,
+ 0x060 => PackMethod::XorLzss,
+ 0x080 => PackMethod::LzssHuffman,
+ 0x0A0 => PackMethod::XorLzssHuffman,
+ 0x100 => PackMethod::Deflate,
+ other => PackMethod::Unknown(other),
+ }
+}
+
+fn decode_name(name: &[u8]) -> String {
+ name.iter().map(|b| char::from(*b)).collect()
+}
+
+pub fn c_name_bytes(raw: &[u8; 12]) -> &[u8] {
+ let len = raw.iter().position(|&b| b == 0).unwrap_or(raw.len());
+ &raw[..len]
+}
+
+pub fn cmp_c_string(a: &[u8], b: &[u8]) -> Ordering {
+ let min_len = a.len().min(b.len());
+ let mut idx = 0usize;
+ while idx < min_len {
+ if a[idx] != b[idx] {
+ return a[idx].cmp(&b[idx]);
+ }
+ idx += 1;
+ }
+ a.len().cmp(&b.len())
+}
diff --git a/crates/rsli/src/tests.rs b/crates/rsli/src/tests.rs
new file mode 100644
index 0000000..07807d3
--- /dev/null
+++ b/crates/rsli/src/tests.rs
@@ -0,0 +1,1337 @@
+use super::*;
+use crate::compress::lzh::{LZH_MAX_FREQ, LZH_N_CHAR, LZH_R, LZH_T};
+use crate::compress::xor::xor_stream;
+use flate2::write::DeflateEncoder;
+use flate2::write::ZlibEncoder;
+use flate2::Compression;
+use std::any::Any;
+use std::fs;
+use std::io::Write as _;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::path::PathBuf;
+
+#[derive(Clone, Debug)]
+struct SyntheticRsliEntry {
+ name: String,
+ method_raw: u16,
+ plain: Vec<u8>,
+ declared_packed_size: Option<u32>,
+}
+
+#[derive(Clone, Debug)]
+struct RsliBuildOptions {
+ seed: u32,
+ presorted: bool,
+ overlay: u32,
+ add_ao_trailer: bool,
+}
+
+impl Default for RsliBuildOptions {
+ fn default() -> Self {
+ Self {
+ seed: 0x1234_5678,
+ presorted: true,
+ overlay: 0,
+ add_ao_trailer: false,
+ }
+ }
+}
+
+fn collect_files_recursive(root: &Path, out: &mut Vec<PathBuf>) {
+ let Ok(entries) = fs::read_dir(root) else {
+ return;
+ };
+ for entry in entries.flatten() {
+ let path = entry.path();
+ if path.is_dir() {
+ collect_files_recursive(&path, out);
+ } else if path.is_file() {
+ out.push(path);
+ }
+ }
+}
+
+fn rsli_test_files() -> Vec<PathBuf> {
+ let root = Path::new(env!("CARGO_MANIFEST_DIR"))
+ .join("..")
+ .join("..")
+ .join("testdata")
+ .join("rsli");
+ let mut files = Vec::new();
+ collect_files_recursive(&root, &mut files);
+ files.sort();
+ files
+ .into_iter()
+ .filter(|path| {
+ fs::read(path)
+ .map(|data| data.get(0..4) == Some(b"NL\0\x01"))
+ .unwrap_or(false)
+ })
+ .collect()
+}
+
+fn panic_message(payload: Box<dyn Any + Send>) -> String {
+ let any = payload.as_ref();
+ if let Some(message) = any.downcast_ref::<String>() {
+ return message.clone();
+ }
+ if let Some(message) = any.downcast_ref::<&str>() {
+ return (*message).to_string();
+ }
+ String::from("panic without message")
+}
+
+fn write_temp_file(prefix: &str, bytes: &[u8]) -> PathBuf {
+ let mut path = std::env::temp_dir();
+ path.push(format!(
+ "{}-{}-{}.bin",
+ prefix,
+ std::process::id(),
+ std::time::SystemTime::now()
+ .duration_since(std::time::UNIX_EPOCH)
+ .map(|d| d.as_nanos())
+ .unwrap_or(0)
+ ));
+ fs::write(&path, bytes).expect("failed to write temp archive");
+ path
+}
+
+fn deflate_raw(data: &[u8]) -> Vec<u8> {
+ let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default());
+ encoder
+ .write_all(data)
+ .expect("deflate encoder write failed");
+ encoder.finish().expect("deflate encoder finish failed")
+}
+
+fn deflate_zlib(data: &[u8]) -> Vec<u8> {
+ let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
+ encoder.write_all(data).expect("zlib encoder write failed");
+ encoder.finish().expect("zlib encoder finish failed")
+}
+
+fn lzss_pack_literals(data: &[u8]) -> Vec<u8> {
+ let mut out = Vec::new();
+ for chunk in data.chunks(8) {
+ let mask = if chunk.len() == 8 {
+ 0xFF
+ } else {
+ (1u16
+ .checked_shl(u32::try_from(chunk.len()).expect("chunk len overflow"))
+ .expect("shift overflow")
+ - 1) as u8
+ };
+ out.push(mask);
+ out.extend_from_slice(chunk);
+ }
+ out
+}
+
+struct BitWriter {
+ bytes: Vec<u8>,
+ current: u8,
+ mask: u8,
+}
+
+impl BitWriter {
+ fn new() -> Self {
+ Self {
+ bytes: Vec::new(),
+ current: 0,
+ mask: 0x80,
+ }
+ }
+
+ fn write_bit(&mut self, bit: u8) {
+ if bit != 0 {
+ self.current |= self.mask;
+ }
+ self.mask >>= 1;
+ if self.mask == 0 {
+ self.bytes.push(self.current);
+ self.current = 0;
+ self.mask = 0x80;
+ }
+ }
+
+ fn finish(mut self) -> Vec<u8> {
+ if self.mask != 0x80 {
+ self.bytes.push(self.current);
+ }
+ self.bytes
+ }
+}
+
+struct LzhLiteralModel {
+ freq: [u16; LZH_T + 1],
+ parent: [usize; LZH_T + LZH_N_CHAR],
+ son: [usize; LZH_T + 1],
+}
+
+impl LzhLiteralModel {
+ fn new() -> Self {
+ let mut model = Self {
+ freq: [0; LZH_T + 1],
+ parent: [0; LZH_T + LZH_N_CHAR],
+ son: [0; LZH_T + 1],
+ };
+ model.start_huff();
+ model
+ }
+
+ fn encode_literal(&mut self, literal: u8, writer: &mut BitWriter) {
+ let target = usize::from(literal) + LZH_T;
+ let mut path = Vec::new();
+ let mut visited = [false; LZH_T + 1];
+ let found = self.find_path(self.son[LZH_R], target, &mut path, &mut visited);
+ assert!(found, "failed to encode literal {literal}");
+ for bit in path {
+ writer.write_bit(bit);
+ }
+
+ self.update(usize::from(literal));
+ }
+
+ fn find_path(
+ &self,
+ node: usize,
+ target: usize,
+ path: &mut Vec<u8>,
+ visited: &mut [bool; LZH_T + 1],
+ ) -> bool {
+ if node == target {
+ return true;
+ }
+ if node >= LZH_T {
+ return false;
+ }
+ if visited[node] {
+ return false;
+ }
+ visited[node] = true;
+
+ for bit in [0u8, 1u8] {
+ let child = self.son[node + usize::from(bit)];
+ path.push(bit);
+ if self.find_path(child, target, path, visited) {
+ visited[node] = false;
+ return true;
+ }
+ path.pop();
+ }
+
+ visited[node] = false;
+ false
+ }
+
+ fn start_huff(&mut self) {
+ for i in 0..LZH_N_CHAR {
+ self.freq[i] = 1;
+ self.son[i] = i + LZH_T;
+ self.parent[i + LZH_T] = i;
+ }
+
+ let mut i = 0usize;
+ let mut j = LZH_N_CHAR;
+ while j <= LZH_R {
+ self.freq[j] = self.freq[i].saturating_add(self.freq[i + 1]);
+ self.son[j] = i;
+ self.parent[i] = j;
+ self.parent[i + 1] = j;
+ i += 2;
+ j += 1;
+ }
+
+ self.freq[LZH_T] = u16::MAX;
+ self.parent[LZH_R] = 0;
+ }
+
+ fn update(&mut self, c: usize) {
+ if self.freq[LZH_R] == LZH_MAX_FREQ {
+ self.reconstruct();
+ }
+
+ let mut current = self.parent[c + LZH_T];
+ loop {
+ self.freq[current] = self.freq[current].saturating_add(1);
+ let freq = self.freq[current];
+
+ if current + 1 < self.freq.len() && freq > self.freq[current + 1] {
+ let mut swap_idx = current + 1;
+ while swap_idx + 1 < self.freq.len() && freq > self.freq[swap_idx + 1] {
+ swap_idx += 1;
+ }
+
+ self.freq.swap(current, swap_idx);
+
+ let left = self.son[current];
+ let right = self.son[swap_idx];
+ self.son[current] = right;
+ self.son[swap_idx] = left;
+
+ self.parent[left] = swap_idx;
+ if left < LZH_T {
+ self.parent[left + 1] = swap_idx;
+ }
+
+ self.parent[right] = current;
+ if right < LZH_T {
+ self.parent[right + 1] = current;
+ }
+
+ current = swap_idx;
+ }
+
+ current = self.parent[current];
+ if current == 0 {
+ break;
+ }
+ }
+ }
+
+ fn reconstruct(&mut self) {
+ let mut j = 0usize;
+ for i in 0..LZH_T {
+ if self.son[i] >= LZH_T {
+ self.freq[j] = self.freq[i].div_ceil(2);
+ self.son[j] = self.son[i];
+ j += 1;
+ }
+ }
+
+ let mut i = 0usize;
+ let mut current = LZH_N_CHAR;
+ while current < LZH_T {
+ let sum = self.freq[i].saturating_add(self.freq[i + 1]);
+ self.freq[current] = sum;
+
+ let mut insert_at = current;
+ while insert_at > 0 && sum < self.freq[insert_at - 1] {
+ insert_at -= 1;
+ }
+
+ for move_idx in (insert_at..current).rev() {
+ self.freq[move_idx + 1] = self.freq[move_idx];
+ self.son[move_idx + 1] = self.son[move_idx];
+ }
+
+ self.freq[insert_at] = sum;
+ self.son[insert_at] = i;
+ i += 2;
+ current += 1;
+ }
+
+ for idx in 0..LZH_T {
+ let node = self.son[idx];
+ self.parent[node] = idx;
+ if node < LZH_T {
+ self.parent[node + 1] = idx;
+ }
+ }
+
+ self.freq[LZH_T] = u16::MAX;
+ self.parent[LZH_R] = 0;
+ }
+}
+
+fn lzh_pack_literals(data: &[u8]) -> Vec<u8> {
+ let mut writer = BitWriter::new();
+ let mut model = LzhLiteralModel::new();
+ for byte in data {
+ model.encode_literal(*byte, &mut writer);
+ }
+ writer.finish()
+}
+
+fn packed_for_method(method_raw: u16, plain: &[u8], key16: u16) -> Vec<u8> {
+ match (u32::from(method_raw)) & 0x1E0 {
+ 0x000 => plain.to_vec(),
+ 0x020 => xor_stream(plain, key16),
+ 0x040 => lzss_pack_literals(plain),
+ 0x060 => xor_stream(&lzss_pack_literals(plain), key16),
+ 0x080 => lzh_pack_literals(plain),
+ 0x0A0 => xor_stream(&lzh_pack_literals(plain), key16),
+ 0x100 => deflate_raw(plain),
+ _ => plain.to_vec(),
+ }
+}
+
+fn build_rsli_bytes(entries: &[SyntheticRsliEntry], opts: &RsliBuildOptions) -> Vec<u8> {
+ let count = entries.len();
+ let mut rows_plain = vec![0u8; count * 32];
+ let table_end = 32 + rows_plain.len();
+
+ let mut sort_lookup: Vec<usize> = (0..count).collect();
+ sort_lookup.sort_by(|a, b| entries[*a].name.as_bytes().cmp(entries[*b].name.as_bytes()));
+
+ let mut packed_blobs = Vec::with_capacity(count);
+ for index in 0..count {
+ let key16 = u16::try_from(sort_lookup[index]).expect("sort index overflow");
+ let packed = packed_for_method(entries[index].method_raw, &entries[index].plain, key16);
+ packed_blobs.push(packed);
+ }
+
+ let overlay = usize::try_from(opts.overlay).expect("overlay overflow");
+ let mut cursor = table_end + overlay;
+ let mut output = vec![0u8; cursor];
+
+ let mut data_offsets = Vec::with_capacity(count);
+ for (index, packed) in packed_blobs.iter().enumerate() {
+ let raw_offset = cursor
+ .checked_sub(overlay)
+ .expect("overlay larger than cursor");
+ data_offsets.push(raw_offset);
+
+ let end = cursor.checked_add(packed.len()).expect("cursor overflow");
+ if output.len() < end {
+ output.resize(end, 0);
+ }
+ output[cursor..end].copy_from_slice(packed);
+ cursor = end;
+
+ let base = index * 32;
+ let mut name_raw = [0u8; 12];
+ let uppercase = entries[index].name.to_ascii_uppercase();
+ let name_bytes = uppercase.as_bytes();
+ assert!(name_bytes.len() <= 12, "name too long in synthetic fixture");
+ name_raw[..name_bytes.len()].copy_from_slice(name_bytes);
+
+ rows_plain[base..base + 12].copy_from_slice(&name_raw);
+
+ let sort_field: i16 = if opts.presorted {
+ i16::try_from(sort_lookup[index]).expect("sort field overflow")
+ } else {
+ 0
+ };
+
+ let packed_size = entries[index]
+ .declared_packed_size
+ .unwrap_or_else(|| u32::try_from(packed.len()).expect("packed size overflow"));
+
+ rows_plain[base + 16..base + 18].copy_from_slice(&entries[index].method_raw.to_le_bytes());
+ rows_plain[base + 18..base + 20].copy_from_slice(&sort_field.to_le_bytes());
+ rows_plain[base + 20..base + 24].copy_from_slice(
+ &u32::try_from(entries[index].plain.len())
+ .expect("unpacked size overflow")
+ .to_le_bytes(),
+ );
+ rows_plain[base + 24..base + 28].copy_from_slice(
+ &u32::try_from(data_offsets[index])
+ .expect("data offset overflow")
+ .to_le_bytes(),
+ );
+ rows_plain[base + 28..base + 32].copy_from_slice(&packed_size.to_le_bytes());
+ }
+
+ if output.len() < table_end {
+ output.resize(table_end, 0);
+ }
+
+ output[0..2].copy_from_slice(b"NL");
+ output[2] = 0;
+ output[3] = 1;
+ output[4..6].copy_from_slice(
+ &i16::try_from(count)
+ .expect("entry count overflow")
+ .to_le_bytes(),
+ );
+
+ let presorted_flag = if opts.presorted { 0xABBA_u16 } else { 0_u16 };
+ output[14..16].copy_from_slice(&presorted_flag.to_le_bytes());
+ output[20..24].copy_from_slice(&opts.seed.to_le_bytes());
+
+ let encrypted_table = xor_stream(&rows_plain, (opts.seed & 0xFFFF) as u16);
+ output[32..table_end].copy_from_slice(&encrypted_table);
+
+ if opts.add_ao_trailer {
+ output.extend_from_slice(b"AO");
+ output.extend_from_slice(&opts.overlay.to_le_bytes());
+ }
+
+ output
+}
+
+fn read_u32_le(bytes: &[u8], offset: usize) -> u32 {
+ let slice = bytes
+ .get(offset..offset + 4)
+ .expect("u32 read out of bounds in test");
+ let arr: [u8; 4] = slice.try_into().expect("u32 conversion failed in test");
+ u32::from_le_bytes(arr)
+}
+
+#[test]
+fn rsli_read_unpack_and_repack_all_files() {
+ let files = rsli_test_files();
+ if files.is_empty() {
+ eprintln!(
+ "skipping rsli_read_unpack_and_repack_all_files: no RsLi archives in testdata/rsli"
+ );
+ return;
+ }
+
+ let checked = files.len();
+ let mut success = 0usize;
+ let mut failures = Vec::new();
+
+ for path in files {
+ let display_path = path.display().to_string();
+ let result = catch_unwind(AssertUnwindSafe(|| {
+ let original = fs::read(&path).expect("failed to read archive");
+ let library = Library::open_path(&path)
+ .unwrap_or_else(|err| panic!("failed to open {}: {err}", path.display()));
+
+ let count = library.entry_count();
+ assert_eq!(
+ count,
+ library.entries().count(),
+ "entry count mismatch: {}",
+ path.display()
+ );
+
+ for idx in 0..count {
+ let id = EntryId(idx as u32);
+ let meta_ref = library
+ .get(id)
+ .unwrap_or_else(|| panic!("missing entry #{idx} in {}", path.display()));
+
+ let loaded = library.load(id).unwrap_or_else(|err| {
+ panic!("load failed for {} entry #{idx}: {err}", path.display())
+ });
+
+ let packed = library.load_packed(id).unwrap_or_else(|err| {
+ panic!(
+ "load_packed failed for {} entry #{idx}: {err}",
+ path.display()
+ )
+ });
+ let unpacked = library.unpack(&packed).unwrap_or_else(|err| {
+ panic!("unpack failed for {} entry #{idx}: {err}", path.display())
+ });
+ assert_eq!(
+ loaded,
+ unpacked,
+ "load != unpack in {} entry #{idx}",
+ path.display()
+ );
+
+ let mut out = Vec::new();
+ let written = library.load_into(id, &mut out).unwrap_or_else(|err| {
+ panic!(
+ "load_into failed for {} entry #{idx}: {err}",
+ path.display()
+ )
+ });
+ assert_eq!(
+ written,
+ loaded.len(),
+ "load_into size mismatch in {} entry #{idx}",
+ path.display()
+ );
+ assert_eq!(
+ out,
+ loaded,
+ "load_into payload mismatch in {} entry #{idx}",
+ path.display()
+ );
+
+ let fast = library.load_fast(id).unwrap_or_else(|err| {
+ panic!(
+ "load_fast failed for {} entry #{idx}: {err}",
+ path.display()
+ )
+ });
+ assert_eq!(
+ fast.as_slice(),
+ loaded.as_slice(),
+ "load_fast mismatch in {} entry #{idx}",
+ path.display()
+ );
+
+ let found = library.find(&meta_ref.meta.name).unwrap_or_else(|| {
+ panic!(
+ "find failed for '{}' in {}",
+ meta_ref.meta.name,
+ path.display()
+ )
+ });
+ let found_meta = library.get(found).expect("find returned invalid entry id");
+ assert_eq!(
+ found_meta.meta.name,
+ meta_ref.meta.name,
+ "find returned a different entry in {}",
+ path.display()
+ );
+ }
+
+ let rebuilt = library
+ .rebuild_from_parsed_metadata()
+ .unwrap_or_else(|err| panic!("rebuild failed for {}: {err}", path.display()));
+ assert_eq!(
+ rebuilt,
+ original,
+ "byte-to-byte roundtrip mismatch for {}",
+ path.display()
+ );
+ }));
+
+ match result {
+ Ok(()) => success += 1,
+ Err(payload) => failures.push(format!("{}: {}", display_path, panic_message(payload))),
+ }
+ }
+
+ let failed = failures.len();
+ eprintln!(
+ "RsLi summary: checked={}, success={}, failed={}",
+ checked, success, failed
+ );
+ if !failures.is_empty() {
+ panic!(
+ "RsLi validation failed.\nsummary: checked={}, success={}, failed={}\n{}",
+ checked,
+ success,
+ failed,
+ failures.join("\n")
+ );
+ }
+}
+
+#[test]
+fn rsli_docs_structural_invariants_all_files() {
+ let files = rsli_test_files();
+ if files.is_empty() {
+ eprintln!(
+ "skipping rsli_docs_structural_invariants_all_files: no RsLi archives in testdata/rsli"
+ );
+ return;
+ }
+
+ let mut deflate_eof_plus_one_quirks = Vec::new();
+
+ for path in files {
+ let bytes = fs::read(&path).unwrap_or_else(|err| {
+ panic!("failed to read {}: {err}", path.display());
+ });
+
+ assert!(
+ bytes.len() >= 32,
+ "RsLi header too short in {}",
+ path.display()
+ );
+ assert_eq!(&bytes[0..2], b"NL", "bad magic in {}", path.display());
+ assert_eq!(
+ bytes[2],
+ 0,
+ "reserved header byte must be zero in {}",
+ path.display()
+ );
+ assert_eq!(bytes[3], 1, "bad version in {}", path.display());
+
+ let entry_count = i16::from_le_bytes([bytes[4], bytes[5]]);
+ assert!(
+ entry_count >= 0,
+ "negative entry_count={} in {}",
+ entry_count,
+ path.display()
+ );
+ let count = usize::try_from(entry_count).expect("entry_count overflow");
+ let table_size = count.checked_mul(32).expect("table_size overflow");
+ let table_end = 32usize.checked_add(table_size).expect("table_end overflow");
+ assert!(
+ table_end <= bytes.len(),
+ "table out of bounds in {}",
+ path.display()
+ );
+
+ let seed = read_u32_le(&bytes, 20);
+ let table_plain = xor_stream(&bytes[32..table_end], (seed & 0xFFFF) as u16);
+ assert_eq!(
+ table_plain.len(),
+ table_size,
+ "decrypted table size mismatch in {}",
+ path.display()
+ );
+
+ let mut overlay = 0u32;
+ if bytes.len() >= 6 && &bytes[bytes.len() - 6..bytes.len() - 4] == b"AO" {
+ overlay = read_u32_le(&bytes, bytes.len() - 4);
+ assert!(
+ usize::try_from(overlay).expect("overlay overflow") <= bytes.len(),
+ "overlay beyond EOF in {}",
+ path.display()
+ );
+ }
+
+ let presorted_flag = u16::from_le_bytes([bytes[14], bytes[15]]);
+ let mut sort_values = Vec::with_capacity(count);
+
+ for index in 0..count {
+ let base = index * 32;
+ let row = &table_plain[base..base + 32];
+ let flags_signed = i16::from_le_bytes([row[16], row[17]]);
+ let sort_to_original = i16::from_le_bytes([row[18], row[19]]);
+ let data_offset = u64::from(read_u32_le(row, 24));
+ let packed_size = u64::from(read_u32_le(row, 28));
+
+ let method = (flags_signed as u16 as u32) & 0x1E0;
+ let effective_offset = data_offset + u64::from(overlay);
+ let end = effective_offset + packed_size;
+ let file_len = u64::try_from(bytes.len()).expect("file size overflow");
+
+ if end > file_len {
+ assert!(
+ method == 0x100 && end == file_len + 1,
+ "packed range out of bounds in {} entry #{index}: method=0x{method:03X}, range=[{effective_offset}, {end}), file={file_len}",
+ path.display()
+ );
+ deflate_eof_plus_one_quirks.push((path.display().to_string(), index));
+ }
+
+ sort_values.push(sort_to_original);
+ }
+
+ if presorted_flag == 0xABBA {
+ let mut sorted = sort_values;
+ sorted.sort_unstable();
+ let expected: Vec<i16> = (0..count)
+ .map(|idx| i16::try_from(idx).expect("too many entries for i16"))
+ .collect();
+ assert_eq!(
+ sorted,
+ expected,
+ "sort_to_original is not a permutation in {}",
+ path.display()
+ );
+ }
+ }
+
+ if !deflate_eof_plus_one_quirks.is_empty() {
+ assert!(
+ deflate_eof_plus_one_quirks
+ .iter()
+ .all(|(file, idx)| file.ends_with("sprites.lib") && *idx == 23),
+ "unexpected deflate EOF+1 quirks: {:?}",
+ deflate_eof_plus_one_quirks
+ );
+ }
+}
+
+#[test]
+fn rsli_synthetic_all_methods_roundtrip() {
+ let entries = vec![
+ SyntheticRsliEntry {
+ name: "M_NONE".to_string(),
+ method_raw: 0x000,
+ plain: b"plain-data".to_vec(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "M_XOR".to_string(),
+ method_raw: 0x020,
+ plain: b"xor-only".to_vec(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "M_LZSS".to_string(),
+ method_raw: 0x040,
+ plain: b"lzss literals payload".to_vec(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "M_XLZS".to_string(),
+ method_raw: 0x060,
+ plain: b"xor lzss payload".to_vec(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "M_LZHU".to_string(),
+ method_raw: 0x080,
+ plain: b"huffman literals payload".to_vec(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "M_XLZH".to_string(),
+ method_raw: 0x0A0,
+ plain: b"xor huffman payload".to_vec(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "M_DEFL".to_string(),
+ method_raw: 0x100,
+ plain: b"deflate payload with repetition repetition repetition".to_vec(),
+ declared_packed_size: None,
+ },
+ ];
+
+ let bytes = build_rsli_bytes(
+ &entries,
+ &RsliBuildOptions {
+ seed: 0xA1B2_C3D4,
+ presorted: false,
+ overlay: 0,
+ add_ao_trailer: false,
+ },
+ );
+ let path = write_temp_file("rsli-all-methods", &bytes);
+
+ let library = Library::open_path(&path).expect("open synthetic rsli failed");
+ assert_eq!(library.entry_count(), entries.len());
+
+ for entry in &entries {
+ let id = library
+ .find(&entry.name)
+ .unwrap_or_else(|| panic!("find failed for {}", entry.name));
+ let loaded = library
+ .load(id)
+ .unwrap_or_else(|err| panic!("load failed for {}: {err}", entry.name));
+ assert_eq!(
+ loaded, entry.plain,
+ "decoded payload mismatch for {}",
+ entry.name
+ );
+
+ let packed = library
+ .load_packed(id)
+ .unwrap_or_else(|err| panic!("load_packed failed for {}: {err}", entry.name));
+ let unpacked = library
+ .unpack(&packed)
+ .unwrap_or_else(|err| panic!("unpack failed for {}: {err}", entry.name));
+ assert_eq!(unpacked, entry.plain, "unpack mismatch for {}", entry.name);
+ }
+
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_empty_archive_roundtrip() {
+ let bytes = build_rsli_bytes(&[], &RsliBuildOptions::default());
+ let path = write_temp_file("rsli-empty", &bytes);
+
+ let library = Library::open_path(&path).expect("open empty rsli failed");
+ assert_eq!(library.entry_count(), 0);
+ assert_eq!(library.find("ANYTHING"), None);
+
+ let rebuilt = library
+ .rebuild_from_parsed_metadata()
+ .expect("rebuild empty rsli failed");
+ assert_eq!(rebuilt, bytes, "empty rsli roundtrip mismatch");
+
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_max_name_length_without_nul_roundtrip() {
+ let max_name = "NAME12345678";
+ assert_eq!(max_name.len(), 12);
+
+ let bytes = build_rsli_bytes(
+ &[SyntheticRsliEntry {
+ name: max_name.to_string(),
+ method_raw: 0x000,
+ plain: b"payload".to_vec(),
+ declared_packed_size: None,
+ }],
+ &RsliBuildOptions::default(),
+ );
+ let path = write_temp_file("rsli-max-name", &bytes);
+
+ let library = Library::open_path(&path).expect("open max-name rsli failed");
+ assert_eq!(library.entry_count(), 1);
+ assert_eq!(library.find(max_name), Some(EntryId(0)));
+ assert_eq!(
+ library.find(&max_name.to_ascii_lowercase()),
+ Some(EntryId(0))
+ );
+ assert_eq!(
+ library.entries[0]
+ .name_raw
+ .iter()
+ .position(|byte| *byte == 0),
+ None,
+ "name_raw must occupy full 12 bytes without NUL"
+ );
+
+ let entry = library.get(EntryId(0)).expect("missing entry");
+ assert_eq!(entry.meta.name, max_name);
+ assert_eq!(
+ library.load(EntryId(0)).expect("load failed"),
+ b"payload",
+ "payload mismatch"
+ );
+
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_lzss_large_payload_over_4k_roundtrip() {
+ let plain: Vec<u8> = (0..10_000u32).map(|v| (v % 251) as u8).collect();
+ let entries = vec![
+ SyntheticRsliEntry {
+ name: "LZSS4K".to_string(),
+ method_raw: 0x040,
+ plain: plain.clone(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "XLZS4K".to_string(),
+ method_raw: 0x060,
+ plain: plain.clone(),
+ declared_packed_size: None,
+ },
+ ];
+ let bytes = build_rsli_bytes(&entries, &RsliBuildOptions::default());
+ let path = write_temp_file("rsli-lzss-4k", &bytes);
+
+ let library = Library::open_path(&path).expect("open large-lzss rsli failed");
+ assert_eq!(library.entry_count(), entries.len());
+
+ for entry in &entries {
+ let id = library
+ .find(&entry.name)
+ .unwrap_or_else(|| panic!("find failed for {}", entry.name));
+ let loaded = library
+ .load(id)
+ .unwrap_or_else(|err| panic!("load failed for {}: {err}", entry.name));
+ assert_eq!(loaded, plain, "payload mismatch for {}", entry.name);
+ }
+
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_find_falls_back_when_sort_table_corrupted_in_memory() {
+ let entries = vec![
+ SyntheticRsliEntry {
+ name: "AAA".to_string(),
+ method_raw: 0x000,
+ plain: b"a".to_vec(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "BBB".to_string(),
+ method_raw: 0x000,
+ plain: b"b".to_vec(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "CCC".to_string(),
+ method_raw: 0x000,
+ plain: b"c".to_vec(),
+ declared_packed_size: None,
+ },
+ ];
+ let bytes = build_rsli_bytes(
+ &entries,
+ &RsliBuildOptions {
+ presorted: true,
+ ..RsliBuildOptions::default()
+ },
+ );
+ let path = write_temp_file("rsli-find-fallback", &bytes);
+
+ let mut library = Library::open_path(&path).expect("open synthetic rsli failed");
+ library.entries[1].sort_to_original = -1;
+
+ assert_eq!(library.find("AAA"), Some(EntryId(0)));
+ assert_eq!(library.find("bbb"), Some(EntryId(1)));
+ assert_eq!(library.find("CcC"), Some(EntryId(2)));
+ assert_eq!(library.find("missing"), None);
+
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_deflate_method_rejects_zlib_wrapped_stream() {
+ let plain = b"payload".to_vec();
+ let zlib_payload = deflate_zlib(&plain);
+ let entries = vec![SyntheticRsliEntry {
+ name: "ZLIB".to_string(),
+ method_raw: 0x100,
+ plain,
+ declared_packed_size: Some(
+ u32::try_from(zlib_payload.len()).expect("zlib payload size overflow"),
+ ),
+ }];
+ let mut bytes = build_rsli_bytes(
+ &entries,
+ &RsliBuildOptions {
+ presorted: true,
+ ..RsliBuildOptions::default()
+ },
+ );
+
+ let table_end = 32 + entries.len() * 32;
+ let data_offset = table_end;
+ let data_end = data_offset + zlib_payload.len();
+ if bytes.len() < data_end {
+ bytes.resize(data_end, 0);
+ }
+ bytes[data_offset..data_end].copy_from_slice(&zlib_payload);
+
+ let path = write_temp_file("rsli-zlib-reject", &bytes);
+ let library = Library::open_path(&path).expect("open zlib-wrapped rsli failed");
+ match library.load(EntryId(0)) {
+ Err(Error::DecompressionFailed(reason)) => {
+ assert_eq!(reason, "deflate");
+ }
+ other => panic!("expected deflate decompression error, got {other:?}"),
+ }
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_lzss_huffman_reports_unexpected_eof() {
+ let entries = vec![SyntheticRsliEntry {
+ name: "TRUNC".to_string(),
+ method_raw: 0x080,
+ plain: b"this payload is long enough".to_vec(),
+ declared_packed_size: None,
+ }];
+ let mut bytes = build_rsli_bytes(
+ &entries,
+ &RsliBuildOptions {
+ presorted: true,
+ ..RsliBuildOptions::default()
+ },
+ );
+
+ let seed = read_u32_le(&bytes, 20);
+ let mut table_plain = xor_stream(&bytes[32..64], (seed & 0xFFFF) as u16);
+ let original_packed_size = u32::from_le_bytes([
+ table_plain[28],
+ table_plain[29],
+ table_plain[30],
+ table_plain[31],
+ ]);
+ assert!(
+ original_packed_size > 4,
+ "packed payload too small for truncation"
+ );
+ let truncated_size = original_packed_size - 3;
+ table_plain[28..32].copy_from_slice(&truncated_size.to_le_bytes());
+ let encrypted_table = xor_stream(&table_plain, (seed & 0xFFFF) as u16);
+ bytes[32..64].copy_from_slice(&encrypted_table);
+
+ let path = write_temp_file("rsli-lzh-truncated", &bytes);
+ let library = Library::open_path(&path).expect("open truncated lzh rsli failed");
+ match library.load(EntryId(0)) {
+ Err(Error::DecompressionFailed(reason)) => {
+ assert_eq!(reason, "lzss-huffman: unexpected EOF");
+ }
+ other => panic!("expected lzss-huffman EOF error, got {other:?}"),
+ }
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_presorted_flag_requires_permutation() {
+ let entries = vec![
+ SyntheticRsliEntry {
+ name: "AAA".to_string(),
+ method_raw: 0x000,
+ plain: b"a".to_vec(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "BBB".to_string(),
+ method_raw: 0x000,
+ plain: b"b".to_vec(),
+ declared_packed_size: None,
+ },
+ ];
+ let mut bytes = build_rsli_bytes(
+ &entries,
+ &RsliBuildOptions {
+ presorted: true,
+ ..RsliBuildOptions::default()
+ },
+ );
+
+ let seed = read_u32_le(&bytes, 20);
+ let mut table_plain = xor_stream(&bytes[32..32 + entries.len() * 32], (seed & 0xFFFF) as u16);
+
+ // Corrupt sort_to_original: duplicate index 0, so the table is not a permutation.
+ table_plain[18..20].copy_from_slice(&0i16.to_le_bytes());
+ table_plain[50..52].copy_from_slice(&0i16.to_le_bytes());
+
+ let table_encrypted = xor_stream(&table_plain, (seed & 0xFFFF) as u16);
+ bytes[32..32 + table_encrypted.len()].copy_from_slice(&table_encrypted);
+
+ let path = write_temp_file("rsli-bad-presorted-perm", &bytes);
+ match Library::open_path(&path) {
+ Err(Error::CorruptEntryTable(message)) => {
+ assert!(
+ message.contains("permutation"),
+ "unexpected error message: {message}"
+ );
+ }
+ other => panic!("expected CorruptEntryTable for invalid permutation, got {other:?}"),
+ }
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_load_reports_correct_entry_id_on_range_failure() {
+ let entries = vec![
+ SyntheticRsliEntry {
+ name: "ONE".to_string(),
+ method_raw: 0x000,
+ plain: b"one".to_vec(),
+ declared_packed_size: None,
+ },
+ SyntheticRsliEntry {
+ name: "TWO".to_string(),
+ method_raw: 0x000,
+ plain: b"two".to_vec(),
+ declared_packed_size: None,
+ },
+ ];
+ let bytes = build_rsli_bytes(
+ &entries,
+ &RsliBuildOptions {
+ presorted: true,
+ ..RsliBuildOptions::default()
+ },
+ );
+ let path = write_temp_file("rsli-entry-id-error", &bytes);
+
+ let mut library = Library::open_path(&path).expect("open synthetic rsli failed");
+ library.entries[1].packed_size_available = usize::MAX;
+
+ match library.load(EntryId(1)) {
+ Err(Error::IntegerOverflow) => {}
+ other => panic!("expected IntegerOverflow, got {other:?}"),
+ }
+
+ library.entries[1].packed_size_available = library.bytes.len();
+ match library.load(EntryId(1)) {
+ Err(Error::EntryDataOutOfBounds { id, .. }) => assert_eq!(id, 1),
+ other => panic!("expected EntryDataOutOfBounds with id=1, got {other:?}"),
+ }
+
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_xorlzss_huffman_on_the_fly_roundtrip() {
+ let plain: Vec<u8> = (0..512u16).map(|i| b'A' + (i % 26) as u8).collect();
+ let entries = vec![SyntheticRsliEntry {
+ name: "XLZH_ONFLY".to_string(),
+ method_raw: 0x0A0,
+ plain: plain.clone(),
+ declared_packed_size: None,
+ }];
+
+ let bytes = build_rsli_bytes(
+ &entries,
+ &RsliBuildOptions {
+ seed: 0x0BAD_C0DE,
+ presorted: true,
+ overlay: 0,
+ add_ao_trailer: false,
+ },
+ );
+ let path = write_temp_file("rsli-xorlzh-onfly", &bytes);
+
+ let library = Library::open_path(&path).expect("open synthetic XLZH archive failed");
+ let id = library
+ .find("XLZH_ONFLY")
+ .expect("find XLZH_ONFLY entry failed");
+
+ let loaded = library.load(id).expect("load XLZH_ONFLY failed");
+ assert_eq!(loaded, plain);
+
+ let packed = library
+ .load_packed(id)
+ .expect("load_packed XLZH_ONFLY failed");
+ let unpacked = library.unpack(&packed).expect("unpack XLZH_ONFLY failed");
+ assert_eq!(unpacked, loaded);
+
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_synthetic_overlay_and_ao_trailer() {
+ let entries = vec![SyntheticRsliEntry {
+ name: "OVERLAY".to_string(),
+ method_raw: 0x040,
+ plain: b"overlay-data".to_vec(),
+ declared_packed_size: None,
+ }];
+
+ let bytes = build_rsli_bytes(
+ &entries,
+ &RsliBuildOptions {
+ seed: 0x4433_2211,
+ presorted: true,
+ overlay: 128,
+ add_ao_trailer: true,
+ },
+ );
+ let path = write_temp_file("rsli-overlay", &bytes);
+
+ let library = Library::open_path_with(
+ &path,
+ OpenOptions {
+ allow_ao_trailer: true,
+ allow_deflate_eof_plus_one: true,
+ },
+ )
+ .expect("open with AO trailer enabled failed");
+
+ let id = library.find("OVERLAY").expect("find overlay entry failed");
+ let payload = library.load(id).expect("load overlay entry failed");
+ assert_eq!(payload, b"overlay-data");
+
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_deflate_eof_plus_one_quirk() {
+ let plain = b"quirk deflate payload".to_vec();
+ let packed = deflate_raw(&plain);
+ let declared = u32::try_from(packed.len() + 1).expect("declared size overflow");
+
+ let entries = vec![SyntheticRsliEntry {
+ name: "QUIRK".to_string(),
+ method_raw: 0x100,
+ plain,
+ declared_packed_size: Some(declared),
+ }];
+ let bytes = build_rsli_bytes(&entries, &RsliBuildOptions::default());
+ let path = write_temp_file("rsli-deflate-quirk", &bytes);
+
+ let lib_ok = Library::open_path_with(
+ &path,
+ OpenOptions {
+ allow_ao_trailer: true,
+ allow_deflate_eof_plus_one: true,
+ },
+ )
+ .expect("open with EOF+1 quirk enabled failed");
+ let loaded = lib_ok
+ .load(lib_ok.find("QUIRK").expect("find quirk entry failed"))
+ .expect("load quirk entry failed");
+ assert_eq!(loaded, b"quirk deflate payload");
+
+ match Library::open_path_with(
+ &path,
+ OpenOptions {
+ allow_ao_trailer: true,
+ allow_deflate_eof_plus_one: false,
+ },
+ ) {
+ Err(Error::DeflateEofPlusOneQuirkRejected { id }) => assert_eq!(id, 0),
+ other => panic!("expected DeflateEofPlusOneQuirkRejected, got {other:?}"),
+ }
+
+ let _ = fs::remove_file(&path);
+}
+
+#[test]
+fn rsli_validation_error_cases() {
+ let valid = build_rsli_bytes(
+ &[SyntheticRsliEntry {
+ name: "BASE".to_string(),
+ method_raw: 0x000,
+ plain: b"abc".to_vec(),
+ declared_packed_size: None,
+ }],
+ &RsliBuildOptions::default(),
+ );
+
+ let mut bad_magic = valid.clone();
+ bad_magic[0..2].copy_from_slice(b"XX");
+ let path = write_temp_file("rsli-bad-magic", &bad_magic);
+ match Library::open_path(&path) {
+ Err(Error::InvalidMagic { .. }) => {}
+ other => panic!("expected InvalidMagic, got {other:?}"),
+ }
+ let _ = fs::remove_file(&path);
+
+ let mut bad_version = valid.clone();
+ bad_version[3] = 2;
+ let path = write_temp_file("rsli-bad-version", &bad_version);
+ match Library::open_path(&path) {
+ Err(Error::UnsupportedVersion { got }) => assert_eq!(got, 2),
+ other => panic!("expected UnsupportedVersion, got {other:?}"),
+ }
+ let _ = fs::remove_file(&path);
+
+ let mut bad_count = valid.clone();
+ bad_count[4..6].copy_from_slice(&(-1_i16).to_le_bytes());
+ let path = write_temp_file("rsli-bad-count", &bad_count);
+ match Library::open_path(&path) {
+ Err(Error::InvalidEntryCount { got }) => assert_eq!(got, -1),
+ other => panic!("expected InvalidEntryCount, got {other:?}"),
+ }
+ let _ = fs::remove_file(&path);
+
+ let mut bad_table = valid.clone();
+ bad_table[4..6].copy_from_slice(&100_i16.to_le_bytes());
+ let path = write_temp_file("rsli-bad-table", &bad_table);
+ match Library::open_path(&path) {
+ Err(Error::EntryTableOutOfBounds { .. }) => {}
+ other => panic!("expected EntryTableOutOfBounds, got {other:?}"),
+ }
+ let _ = fs::remove_file(&path);
+
+ let mut unknown_method = build_rsli_bytes(
+ &[SyntheticRsliEntry {
+ name: "UNK".to_string(),
+ method_raw: 0x120,
+ plain: b"x".to_vec(),
+ declared_packed_size: None,
+ }],
+ &RsliBuildOptions::default(),
+ );
+ // Force truly unknown method by writing 0x1C0 mask bits.
+ let row = 32;
+ unknown_method[row + 16..row + 18].copy_from_slice(&(0x1C0_u16).to_le_bytes());
+ // Re-encrypt table with the same seed.
+ let seed = u32::from_le_bytes([
+ unknown_method[20],
+ unknown_method[21],
+ unknown_method[22],
+ unknown_method[23],
+ ]);
+ let mut plain_row = vec![0u8; 32];
+ plain_row.copy_from_slice(&unknown_method[32..64]);
+ plain_row = xor_stream(&plain_row, (seed & 0xFFFF) as u16);
+ plain_row[16..18].copy_from_slice(&(0x1C0_u16).to_le_bytes());
+ let encrypted_row = xor_stream(&plain_row, (seed & 0xFFFF) as u16);
+ unknown_method[32..64].copy_from_slice(&encrypted_row);
+
+ let path = write_temp_file("rsli-unknown-method", &unknown_method);
+ let lib = Library::open_path(&path).expect("open archive with unknown method failed");
+ match lib.load(EntryId(0)) {
+ Err(Error::UnsupportedMethod { raw }) => assert_eq!(raw, 0x1C0),
+ other => panic!("expected UnsupportedMethod, got {other:?}"),
+ }
+ let _ = fs::remove_file(&path);
+
+ let mut bad_packed = valid.clone();
+ bad_packed[32 + 28..32 + 32].copy_from_slice(&0xFFFF_FFF0_u32.to_le_bytes());
+ let path = write_temp_file("rsli-bad-packed", &bad_packed);
+ match Library::open_path(&path) {
+ Err(Error::PackedSizePastEof { .. }) => {}
+ other => panic!("expected PackedSizePastEof, got {other:?}"),
+ }
+ let _ = fs::remove_file(&path);
+
+ let mut with_bad_overlay = valid;
+ with_bad_overlay.extend_from_slice(b"AO");
+ with_bad_overlay.extend_from_slice(&0xFFFF_FFFF_u32.to_le_bytes());
+ let path = write_temp_file("rsli-bad-overlay", &with_bad_overlay);
+ match Library::open_path_with(
+ &path,
+ OpenOptions {
+ allow_ao_trailer: true,
+ allow_deflate_eof_plus_one: true,
+ },
+ ) {
+ Err(Error::MediaOverlayOutOfBounds { .. }) => {}
+ other => panic!("expected MediaOverlayOutOfBounds, got {other:?}"),
+ }
+ let _ = fs::remove_file(&path);
+}
Copyright © 2026 Valentin A. Popov. All Rights Reverse Engineered.