thegame_1980/unixtract
1
0
Fork 0
mirror of https://github.com/Ap0dexMe0/unixtract.git synced 2026-07-15 21:00:03 +02:00
Code Issues Packages Projects Releases Wiki Activity

pana_dvd: major restructure and various improvements:

Browse Source 
- add missing IV to aes key
- support multiple subfiles in some firmwares
- fix decompression error in some older firmwares
- generally make it less bad
This commit is contained in:
theubusu
2026-01-30 18:23:34 +01:00
parent 07e75f26ca
commit 48f8868d71
2 changed files with 119 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/formats/pana_dvd.rs
+116 -86
View File
@@ -1,8 +1,7 @@
use std::fs::File; use std::fs::File;
use std::path::Path; use std::path::{Path, PathBuf};
use std::fs::{self, OpenOptions}; use std::fs::{self, OpenOptions};
use std::io::{Write, Read, Cursor, Seek, SeekFrom}; use std::io::{Write, Read, Cursor, Seek, SeekFrom};
use simd_adler32::adler32;
use binrw::{BinRead, BinReaderExt}; use binrw::{BinRead, BinReaderExt};
use crate::keys; use crate::keys;
@@ -12,6 +11,19 @@ use crate::utils::aes::{decrypt_aes128_cbc_nopad};
use crate::utils::compression::{decompress_gzip}; use crate::utils::compression::{decompress_gzip};
use crate::utils::lzss::{decompress_lzss}; use crate::utils::lzss::{decompress_lzss};
#[derive(BinRead)]
struct AesHeaderFileEntry {
offset: u32,
size: u32,
}
struct FileEntry {
offset: u32,
base_offset: u32,
}
//checksums are mostly Adler32, but some very old files use Checksum32 instead.
#[derive(BinRead)] #[derive(BinRead)]
struct ModuleEntry { struct ModuleEntry {
#[br(count = 4)] name_bytes: Vec<u8>, #[br(count = 4)] name_bytes: Vec<u8>,
@@ -22,9 +34,9 @@ struct ModuleEntry {
_unk1: u16, _unk1: u16,
#[br(count = 6)] id_bytes: Vec<u8>, #[br(count = 6)] id_bytes: Vec<u8>,
size: u32, size: u32,
data_checksum: u32, data_checksum: u32, //checksum of the entrys' DATA
_unk2: u32, _unk2: u32,
_entry_checksum: u32, _entry_checksum: u32, //checksum of THIS header entry (all previous 44 bytes)
} }
impl ModuleEntry { impl ModuleEntry {
fn name(&self) -> String { fn name(&self) -> String {
@@ -46,10 +58,11 @@ impl ModuleEntry {
#[derive(BinRead)] #[derive(BinRead)]
struct MainListHeader { struct MainListHeader {
_checksum: u32, _checksum: u32, //checksum of the MAIN LIST
_unk: u32, _unk: u32, //seems to be always 1?
list_size: u32, list_size: u32,
_unk2: u64, decompressed_part_size: u32,
_unk2: u32,
} }
impl MainListHeader { impl MainListHeader {
fn entry_count(&self) -> u32 { fn entry_count(&self) -> u32 {
@@ -60,12 +73,12 @@ impl MainListHeader {
#[derive(BinRead)] #[derive(BinRead)]
struct MainListEntry { struct MainListEntry {
size: u32, size: u32,
checksum: u32, checksum: u32, //checksum of this MAIN entrys' data
} }
#[derive(BinRead)] #[derive(BinRead)]
struct MainEntryHeader { struct MainEntryHeader {
#[br(count = 14)] _header_string: Vec<u8>, //EXTRHEADDRV #[br(count = 14)] _header_string: Vec<u8>, //EXTRHEADDRV \x01\x00
compression_type_byte: u16, compression_type_byte: u16,
decompressed_size: u32, decompressed_size: u32,
_destination_address: u32, _destination_address: u32,
@@ -73,7 +86,7 @@ struct MainEntryHeader {
_unk: u32, _unk: u32,
_footer_offset: u32, _footer_offset: u32,
_base_address: u32, _base_address: u32,
_checksum: u32, _checksum: u32, //unknown type of checksum
_checksum_flag: u8, _checksum_flag: u8,
#[br(count = 19)] _unused: Vec<u8>, #[br(count = 19)] _unused: Vec<u8>,
} }
@@ -91,43 +104,41 @@ impl MainEntryHeader {
} }
} }
pub fn find_key<'a>(key_array: &'a [&'a str], data: &[u8], expected_magic: &[u8]) -> Result<Option<[u8; 8]>, Box<dyn std::error::Error>> { pub fn find_key<'a>(key_array: &'a [&'a str], data: &[u8], expected_magic: &[u8], magic_offset: usize) -> Result<Option<[u8; 8]>, Box<dyn std::error::Error>> {
for key_hex in key_array { for key_hex in key_array {
let key_bytes = hex::decode(key_hex)?; let key_bytes = hex::decode(key_hex)?;
let key_array: [u8; 8] = key_bytes.as_slice().try_into()?; let key_array: [u8; 8] = key_bytes.as_slice().try_into()?;
let decrypted = decrypt_data(data, &key_array); let decrypted = decrypt_data(data, &key_array);
if decrypted.starts_with(expected_magic) { if decrypted[magic_offset..].starts_with(expected_magic) {
return Ok(Some(key_array)); return Ok(Some(key_array));
} }
} }
Ok(None) Ok(None)
} }
pub fn find_aes_key_pair<'a>(key_array: &'a [(&'a str, &'a str)], data: &[u8], expected_magic: &[u8], magic_offset: usize) -> Result<Option<([u8; 16], [u8; 8])>, Box<dyn std::error::Error>> { pub fn find_aes_key_pair<'a>(key_array: &'a [(&'a str, &'a str, &'a str)], data: &[u8], expected_magic: &[u8], magic_offset: usize) -> Result<Option<([u8; 16], [u8; 16], [u8; 8])>, Box<dyn std::error::Error>> {
for (aes_key_hex, cust_key_hex) in key_array { for (aes_key_hex, aes_iv_hex, cust_key_hex) in key_array {
let aes_key_bytes = hex::decode(aes_key_hex)?; let aes_key: [u8; 16] = hex::decode(aes_key_hex)?.as_slice().try_into()?;
let aes_key_array: [u8; 16] = aes_key_bytes.as_slice().try_into()?; let aes_iv: [u8; 16] = hex::decode(aes_iv_hex)?.as_slice().try_into()?;
let iv: [u8; 16] = [0x00; 16]; let aes_decrypted = decrypt_aes128_cbc_nopad(data, &aes_key, &aes_iv)?;
let aes_decrypted = decrypt_aes128_cbc_nopad(data, &aes_key_array, &iv)?;
let key_bytes = hex::decode(cust_key_hex)?; let key_bytes = hex::decode(cust_key_hex)?;
let key_array: [u8; 8] = key_bytes.as_slice().try_into()?; let key_array: [u8; 8] = key_bytes.as_slice().try_into()?;
let decrypted = decrypt_data(&aes_decrypted, &key_array); let decrypted = decrypt_data(&aes_decrypted, &key_array);
if decrypted[magic_offset..].starts_with(expected_magic) { if decrypted[magic_offset..].starts_with(expected_magic) {
return Ok(Some((aes_key_array, key_array))); return Ok(Some((aes_key, aes_iv, key_array)));
} }
} }
Ok(None) Ok(None)
} }
pub fn is_pana_dvd_file(mut file: &File) -> bool { pub fn is_pana_dvd_file(file: &File) -> bool {
let header = common::read_file(&file, 0, 64).expect("Failed to read from file."); let header = common::read_file(&file, 0, 64).expect("Failed to read from file.");
if header.starts_with(b"PANASONIC\x00\x00\x00") { if header.starts_with(b"PANASONIC\x00\x00\x00") {
file.seek(std::io::SeekFrom::Start(48)).expect("Failed to seek"); //skip rest of header
true true
} else if find_key(&keys::PANA_DVD_KEYONLY, &header, b"PROG").expect("Failed to decrypt header.").is_some() { } else if find_key(&keys::PANA_DVD_KEYONLY, &header, b"PROG", 0).expect("Failed to decrypt header.").is_some() {
true true
} else if find_aes_key_pair(&keys::PANA_DVD_AESPAIR, &header, b"PANASONIC", 32).expect("Failed to decrypt header.").is_some() { } else if find_aes_key_pair(&keys::PANA_DVD_AESPAIR, &header, b"PANASONIC", 32).expect("Failed to decrypt header.").is_some() {
true true
@@ -137,45 +148,74 @@ pub fn is_pana_dvd_file(mut file: &File) -> bool {
} }
pub fn extract_pana_dvd(mut file: &File, output_folder: &str) -> Result<(), Box<dyn std::error::Error>> { pub fn extract_pana_dvd(mut file: &File, output_folder: &str) -> Result<(), Box<dyn std::error::Error>> {
let init_pos = file.stream_position()?; let mut data = Vec::new(); // we need to load the entire file into memory so we can swap it with AES decrypted data if its AES encrypted
file.seek(SeekFrom::Start(0))?;
let mut data = Vec::new(); // we need to load the entire file into a cursor so we can swap it with AES decrypted data if its AES encrypted because im not making temp files
file.read_to_end(&mut data)?; file.read_to_end(&mut data)?;
let mut file_reader = Cursor::new(data); let mut file_reader = Cursor::new(data);
file_reader.seek(SeekFrom::Start(init_pos))?; let enc_header_s = common::read_exact(&mut file_reader, 64)?;
let enc_header = common::read_exact(&mut file_reader, 8192)?;
let matching_key; let matching_key;
let header; let mut file_entries: Vec<FileEntry> = Vec::new();
// find the key, knowing that the first entry is always "PROG"
if let Some(key_array) = find_key(&keys::PANA_DVD_KEYONLY, &enc_header, b"PROG")? { // (custom enc) find the key, knowing that the first entry is always "PROG" (offset 0)
if let Some(key_array) = find_key(&keys::PANA_DVD_KEYONLY, &enc_header_s, b"PROG", 0)? {
println!("Found valid key: {}\n", hex::encode_upper(key_array)); println!("Found valid key: {}\n", hex::encode_upper(key_array));
matching_key = Some(key_array); matching_key = Some(key_array);
header = decrypt_data(&enc_header, &key_array); file_entries.push(FileEntry { offset: 0, base_offset: 0 })
} else if let Some((aes_key_array, key_array)) = find_aes_key_pair(&keys::PANA_DVD_AESPAIR, &enc_header, b"PROG", 96)? { // (custom enc) find the key, knowing that the first entry is always "PROG" (offset 48)
println!("Found AES key pair: aes={} cust={}", hex::encode_upper(aes_key_array), hex::encode_upper(key_array)); } else if let Some(key_array) = find_key(&keys::PANA_DVD_KEYONLY, &enc_header_s, b"PROG", 48)? {
println!("Found valid key: {}\n", hex::encode_upper(key_array));
matching_key = Some(key_array);
file_entries.push(FileEntry { offset: 0, base_offset: 48 })
// (aes) find the key using PANASONIC magic
} else if let Some((aes_key, aes_iv, key_array)) = find_aes_key_pair(&keys::PANA_DVD_AESPAIR, &enc_header_s, b"PANASONIC", 32)? {
println!("Found AES key pair: aes={} iv={} cust={}", hex::encode_upper(aes_key), hex::encode_upper(aes_iv), hex::encode_upper(key_array));
matching_key = Some(key_array); matching_key = Some(key_array);
let iv: [u8; 16] = [0x00; 16];
println!("Decrypting AES...\n"); println!("Decrypting AES...\n");
let aes_decrypted = decrypt_aes128_cbc_nopad(&file_reader.get_ref()[48..], &aes_key_array, &iv)?; let aes_decrypted = decrypt_aes128_cbc_nopad(&file_reader.get_ref(), &aes_key, &aes_iv)?;
file_reader = Cursor::new(aes_decrypted); //set the file reader to use AES decrypted stream file_reader = Cursor::new(aes_decrypted); //set the file reader to use AES decrypted stream
file_reader.seek(SeekFrom::Start(48))?; //read file entries in extra header
let enc_header = common::read_exact(&mut file_reader, 8192)?; let file_table = common::read_exact(&mut file_reader, 48)?;
header = decrypt_data(&enc_header, &key_array); let mut file_table_reader = Cursor::new(decrypt_data(&file_table, &key_array));
for _i in 0..4 {
let file_entry: AesHeaderFileEntry = file_table_reader.read_le()?;
if file_entry.size == 0 && file_entry.offset == 0 {
break
}
file_entries.push(FileEntry { offset: file_entry.offset, base_offset: 48 });
}
} else { } else {
println!("No valid key found!\n"); println!("\nNo valid key found!");
return Ok(()); return Ok(());
} }
let matching_key_array = matching_key.as_ref().unwrap(); let matching_key_array = matching_key.unwrap();
let mut hdr_reader = Cursor::new(header); if file_entries.len() == 1 {
//only one file, standard extraction
println!("File contains no extra sub-files...");
extract_file(&mut file_reader, file_entries[0].offset as u64, file_entries[0].base_offset as u64, matching_key_array, output_folder)?;
} else {
println!("File contains {} sub-files...", file_entries.len());
for (i, file_entry ) in file_entries.iter().enumerate() {
println!("\nExtracting file {}/{} - Offset: {}, base: {}", i + 1, file_entries.len(), file_entry.offset, file_entry.base_offset);
extract_file(&mut file_reader, file_entry.offset as u64, file_entry.base_offset as u64, matching_key_array, &format!("{}/file_{}", output_folder, i + 1))?;
}
}
println!("\nExtraction finished!");
Ok(())
}
fn extract_file(file_reader: &mut Cursor<Vec<u8>>, offset: u64, base_offset: u64, key: [u8; 8], output_folder: &str) -> Result<(), Box<dyn std::error::Error>> {
file_reader.seek(SeekFrom::Start(offset + base_offset))?;
let enc_header = common::read_exact(file_reader, 8192)?;
let mut hdr_reader = Cursor::new(decrypt_data(&enc_header, &key));
let mut modules: Vec<ModuleEntry> = Vec::new(); let mut modules: Vec<ModuleEntry> = Vec::new();
for i in 0..100 { for i in 0..100 {
@@ -191,31 +231,26 @@ pub fn extract_pana_dvd(mut file: &File, output_folder: &str) -> Result<(), Box<
} }
let mut mod_i = 0; let mut mod_i = 0;
let mut main_offset: Option<u32> = None;
for module in &modules { for module in &modules {
mod_i += 1; mod_i += 1;
println!("\n({}/{}) - {}, Offset: {}, Size: {}, Expected checksum: {:#010x}", println!("\n({}/{}) - {}, Offset: {}, Size: {}, Checksum: {:#010x}",
mod_i, modules.len(), module.name(), module.offset, module.size, module.data_checksum); mod_i, modules.len(), module.name(), module.offset, module.size, module.data_checksum);
file_reader.seek(SeekFrom::Start(module.offset as u64))?;
let data = common::read_exact(&mut file_reader, module.size as usize)?;
let checksum = adler32(&data.as_slice());
if module.name() == "MAIN" {
if checksum == module.data_checksum {
main_offset = Some(module.offset);
println!("- Valid MAIN data found - will extract later...");
continue
} else {
println!("- WARNING: Invalid/unsupported MAIN data!")
}
}
println!("- Decrypting...");
let dec_data = decrypt_data(&data, &matching_key_array);
let output_path = Path::new(&output_folder).join(format!("{}.bin", module.name())); let output_path = Path::new(&output_folder).join(format!("{}.bin", module.name()));
let rel_offset: u64 = offset + module.offset as u64;
file_reader.seek(SeekFrom::Start(rel_offset))?;
if module.name() == "MAIN" {
println!("Extracting MAIN...");
extract_main(file_reader, key, output_path)?;
continue
}
let data = common::read_exact(file_reader, module.size as usize)?;
println!("- Decrypting...");
let dec_data = decrypt_data(&data, &key);
fs::create_dir_all(&output_folder)?; fs::create_dir_all(&output_folder)?;
let mut out_file = OpenOptions::new().write(true).create(true).open(output_path)?; let mut out_file = OpenOptions::new().write(true).create(true).open(output_path)?;
out_file.write_all(&dec_data)?; out_file.write_all(&dec_data)?;
@@ -223,17 +258,13 @@ pub fn extract_pana_dvd(mut file: &File, output_folder: &str) -> Result<(), Box<
println!("-- Saved file!"); println!("-- Saved file!");
} }
if !main_offset.is_some() { Ok(())
println!("\nExtraction finished!"); }
return Ok(())
}
println!("\nExtracting MAIN section...");
let main_offset_unwrap = main_offset.unwrap();
file_reader.seek(SeekFrom::Start(main_offset_unwrap as u64))?;
fn extract_main(file_reader: &mut Cursor<Vec<u8>>, key: [u8; 8], output_path: PathBuf) -> Result<(), Box<dyn std::error::Error>> {
let main_list_hdr: MainListHeader = file_reader.read_le()?; let main_list_hdr: MainListHeader = file_reader.read_le()?;
println!("MAIN entry count: {}", main_list_hdr.entry_count()); println!("MAIN - Entry count: {}, Decompressed part size: {}", main_list_hdr.entry_count(), main_list_hdr.decompressed_part_size);
assert!(main_list_hdr.entry_count() < 200, "Unreasonable MAIN entry count!");
let mut main_entries: Vec<MainListEntry> = Vec::new(); let mut main_entries: Vec<MainListEntry> = Vec::new();
for i in 0..main_list_hdr.entry_count() { for i in 0..main_list_hdr.entry_count() {
@@ -246,21 +277,21 @@ pub fn extract_pana_dvd(mut file: &File, output_folder: &str) -> Result<(), Box<
let mut maine_i = 0; let mut maine_i = 0;
for entry in &main_entries { for entry in &main_entries {
maine_i += 1; maine_i += 1;
let mut data = common::read_exact(&mut file_reader, entry.size as usize)?; let mut data = common::read_exact(file_reader, entry.size as usize)?;
if entry.size > 5120 { let decrypt_size: usize = if main_list_hdr.decompressed_part_size == 0x2000000 {10240} /* old type */ else {5120};
if entry.size > decrypt_size as u32 {
//decrypt first and last 5kb //decrypt first and last 5kb
let first_decrypted = decrypt_data(&data[..5120], &matching_key_array); let first_decrypted = decrypt_data(&data[..decrypt_size], &key);
data[..5120].copy_from_slice(&first_decrypted); data[..decrypt_size].copy_from_slice(&first_decrypted);
let last_decrypted = decrypt_data(&data[entry.size as usize - 5120..], &matching_key_array); let last_decrypted = decrypt_data(&data[entry.size as usize - decrypt_size..], &key);
data[entry.size as usize - 5120..].copy_from_slice(&last_decrypted); data[entry.size as usize - decrypt_size..].copy_from_slice(&last_decrypted);
// //
} else { } else {
let decrypted = decrypt_data(&data, &matching_key_array); let decrypted = decrypt_data(&data, &key);
data.copy_from_slice(&decrypted); data.copy_from_slice(&decrypted);
} }
let mut data_reader = Cursor::new(data); let mut data_reader = Cursor::new(data);
let header: MainEntryHeader = data_reader.read_le()?; let header: MainEntryHeader = data_reader.read_le()?;
println!("\nMAIN ({}/{}) - Compressed size: {}, Decompressed size: {}, Compression type: {}({})", println!("\nMAIN ({}/{}) - Compressed size: {}, Decompressed size: {}, Compression type: {}({})",
@@ -278,26 +309,25 @@ pub fn extract_pana_dvd(mut file: &File, output_folder: &str) -> Result<(), Box<
let compressed_lzss = common::read_exact(&mut decompressed_gzip_reader, header.compressed_size as usize)?; let compressed_lzss = common::read_exact(&mut decompressed_gzip_reader, header.compressed_size as usize)?;
decompressed_data = decompress_lzss(&compressed_lzss); decompressed_data = decompress_lzss(&compressed_lzss);
assert!(decompressed_data.len() == header.decompressed_size as usize, "Decompressed size does not match size in header, decompression failed!"); assert!(decompressed_data.len() == header.decompressed_size as usize, "Decompressed size does not match size in header, decompression failed!");
} else if header.compression_type_byte == 2 { //only lzss } else if header.compression_type_byte == 2 { //only lzss
println!("- Decompressing LZSS..."); println!("- Decompressing LZSS...");
decompressed_data = decompress_lzss(&compressed_data); decompressed_data = decompress_lzss(&compressed_data);
assert!(decompressed_data.len() == header.decompressed_size as usize, "Decompressed size does not match size in header, decompression failed!"); assert!(decompressed_data.len() == header.decompressed_size as usize, "Decompressed size does not match size in header, decompression failed!");
} else if header.compression_type_byte == 0 { //no compression. havent encountered one yet } else if header.compression_type_byte == 0 { //no compression. havent encountered one yet
decompressed_data = compressed_data; decompressed_data = compressed_data;
} else { } else {
println!("- Unknown compression method!"); println!("- Unknown compression method!");
decompressed_data = compressed_data; decompressed_data = compressed_data;
} }
let output_path = Path::new(&output_folder).join("MAIN.bin"); let mut out_file = OpenOptions::new().append(true).create(true).open(&output_path)?;
fs::create_dir_all(&output_folder)?;
let mut out_file = OpenOptions::new().append(true).create(true).open(output_path)?;
out_file.write_all(&decompressed_data)?; out_file.write_all(&decompressed_data)?;
println!("- Saved to MAIN!"); println!("-- Saved to MAIN!");
} }
println!("\nExtraction finished!");
Ok(()) Ok(())
} }
src/keys.rs
+3 -3
View File
@@ -63,9 +63,9 @@ pub static PANA_DVD_KEYONLY: &[&str] = &[
("08E03D859AF9F3EE"), //B3A25A0B9D864F08 # 87 firmwares, ..-~2011 ("08E03D859AF9F3EE"), //B3A25A0B9D864F08 # 87 firmwares, ..-~2011
]; ];
//pana dvd keys (PANAEUSB pair (AES + cust)) //pana dvd keys (PANAEUSB pair - AES key, AES IV, cust)
pub static PANA_DVD_AESPAIR: &[(&str, &str)] = &[ pub static PANA_DVD_AESPAIR: &[(&str, &str, &str)] = &[
("62A39E1C5594AE09244EB326EF7938FA", "06C943F3B997F7E0"), //# 9 firmwares, ~2018 ("62A39E1C5594AE09244EB326EF7938FA", "46D03C52B1A398FA03276FDE7CC4EA26", "06C943F3B997F7E0"), //# 9 firmwares, ~2018
]; ];
//mtk pkg custom keys //mtk pkg custom keys