mirror of
https://github.com/Ap0dexMe0/unixtract.git
synced 2026-07-16 05:04:22 +02:00
RESTRUCTURING 1
- change formats to have their own folders with mod + include files + anything they want - change format list to be defined in formats.rs instead of in each format - move utils to their respective formats - some minor code changes in some formats
This commit is contained in:
theubusu
@@ -0,0 +1,132 @@
|
||||
use crate::utils::common;
|
||||
use binrw::BinRead;
|
||||
use super::pana_dvd_crypto::{decrypt_data};
|
||||
use crate::utils::aes::{decrypt_aes128_cbc_nopad};
|
||||
|
||||
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 {
|
||||
let key_bytes = hex::decode(key_hex)?;
|
||||
let key_array: [u8; 8] = key_bytes.as_slice().try_into()?;
|
||||
let decrypted = decrypt_data(data, &key_array);
|
||||
|
||||
if decrypted[magic_offset..].starts_with(expected_magic) {
|
||||
return Ok(Some(key_array));
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
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, aes_iv_hex, cust_key_hex) in key_array {
|
||||
let aes_key: [u8; 16] = hex::decode(aes_key_hex)?.as_slice().try_into()?;
|
||||
let aes_iv: [u8; 16] = hex::decode(aes_iv_hex)?.as_slice().try_into()?;
|
||||
let aes_decrypted = decrypt_aes128_cbc_nopad(data, &aes_key, &aes_iv)?;
|
||||
|
||||
let key_bytes = hex::decode(cust_key_hex)?;
|
||||
let key_array: [u8; 8] = key_bytes.as_slice().try_into()?;
|
||||
let decrypted = decrypt_data(&aes_decrypted, &key_array);
|
||||
|
||||
if decrypted[magic_offset..].starts_with(expected_magic) {
|
||||
return Ok(Some((aes_key, aes_iv, key_array)));
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
pub static MAX_HEADER_SIZE: usize = 0x2000;
|
||||
|
||||
#[derive(BinRead)]
|
||||
pub struct AesHeaderFileEntry {
|
||||
pub offset: u32,
|
||||
pub size: u32,
|
||||
}
|
||||
|
||||
pub struct FileEntry {
|
||||
pub offset: u32,
|
||||
pub base_offset: u32,
|
||||
}
|
||||
|
||||
//checksums are mostly Adler32, but some very old files use Checksum32 instead.
|
||||
|
||||
#[derive(BinRead)]
|
||||
pub struct ModuleEntry {
|
||||
#[br(count = 4)] pub name_bytes: Vec<u8>,
|
||||
version_bytes: [u8; 4],
|
||||
_unk: u32,
|
||||
pub offset: u32,
|
||||
platform_bytes: [u8; 8],
|
||||
_unk1: u16,
|
||||
id_bytes: [u8; 6],
|
||||
pub size: u32,
|
||||
pub data_checksum: u32, //checksum of the entrys' DATA
|
||||
_unk2: u32,
|
||||
_entry_checksum: u32, //checksum of THIS header entry (all previous 44 bytes)
|
||||
}
|
||||
impl ModuleEntry {
|
||||
pub fn name(&self) -> String {
|
||||
common::string_from_bytes(&self.name_bytes)
|
||||
}
|
||||
pub fn version(&self) -> String {
|
||||
common::string_from_bytes(&self.version_bytes)
|
||||
}
|
||||
pub fn platform(&self) -> String {
|
||||
common::string_from_bytes(&self.platform_bytes)
|
||||
}
|
||||
pub fn id(&self) -> String {
|
||||
common::string_from_bytes(&self.id_bytes)
|
||||
}
|
||||
pub fn is_valid(&self) -> bool {
|
||||
self.name().is_ascii() && self.platform().is_ascii()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(BinRead)]
|
||||
pub struct MainListHeader {
|
||||
_checksum: u32, //checksum of the MAIN LIST
|
||||
_unk: u32, //seems to be always 1?
|
||||
pub list_size: u32,
|
||||
pub decompressed_part_size: u32,
|
||||
_unk2: u32,
|
||||
}
|
||||
impl MainListHeader {
|
||||
pub fn entry_count(&self) -> u32 {
|
||||
(&self.list_size - 20) / 8
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(BinRead)]
|
||||
pub struct MainListEntry {
|
||||
pub size: u32,
|
||||
pub checksum: u32, //checksum of this MAIN entrys' data
|
||||
}
|
||||
|
||||
pub const COMPRESSED_FILE_MAGIC: &[u8; 8] = b"EXTRHEAD";
|
||||
|
||||
#[derive(BinRead)]
|
||||
pub struct CompressedFileHeader {
|
||||
_header_string: [u8; 14], //EXTRHEADDRV \x01\x00
|
||||
pub compression_type_byte: u16,
|
||||
pub decompressed_size: u32,
|
||||
_destination_address: u32,
|
||||
pub compressed_size: u32,
|
||||
_unk: u32,
|
||||
_footer_offset: u32,
|
||||
_base_address: u32,
|
||||
_checksum: u32, //unknown type of checksum
|
||||
_checksum_flag: u8,
|
||||
_unused: [u8; 19],
|
||||
}
|
||||
impl CompressedFileHeader {
|
||||
pub fn compression_type(&self) -> &str {
|
||||
if self.compression_type_byte == 0 {
|
||||
return "Uncompressed"
|
||||
} else if self.compression_type_byte == 1 {
|
||||
return "GZIP"
|
||||
} else if self.compression_type_byte == 2 {
|
||||
return "LZSS"
|
||||
} else {
|
||||
return "Unknown"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
pub fn decompress_lzss(data: &[u8]) -> Vec<u8> {
|
||||
let mut window = [0u8; 0x1000];
|
||||
let mut dst = Vec::new();
|
||||
let mut src_i = 0;
|
||||
let mut win_pos = 0xFEE;
|
||||
let mut flags = 0u16;
|
||||
|
||||
while src_i < data.len() {
|
||||
flags >>= 1;
|
||||
if (flags & 0x100) == 0 {
|
||||
if src_i >= data.len() {
|
||||
break;
|
||||
}
|
||||
flags = data[src_i] as u16 | 0xFF00;
|
||||
src_i += 1;
|
||||
}
|
||||
|
||||
if (flags & 1) == 0 {
|
||||
// Backreference
|
||||
if src_i + 1 >= data.len() {
|
||||
break;
|
||||
}
|
||||
let b1 = data[src_i];
|
||||
let b2 = data[src_i + 1];
|
||||
src_i += 2;
|
||||
|
||||
let mut offset = (b1 as usize) | (((b2 & 0xF0) as usize) << 4);
|
||||
let length = ((b2 & 0x0F) as usize) + 3;
|
||||
|
||||
for _ in 0..length {
|
||||
let c = window[offset];
|
||||
dst.push(c);
|
||||
window[win_pos] = c;
|
||||
win_pos = (win_pos + 1) & 0xFFF;
|
||||
offset = (offset + 1) & 0xFFF;
|
||||
}
|
||||
} else {
|
||||
// Literal
|
||||
if src_i >= data.len() {
|
||||
break;
|
||||
}
|
||||
let c = data[src_i];
|
||||
src_i += 1;
|
||||
dst.push(c);
|
||||
window[win_pos] = c;
|
||||
win_pos = (win_pos + 1) & 0xFFF;
|
||||
}
|
||||
}
|
||||
|
||||
dst
|
||||
}
|
||||
@@ -0,0 +1,276 @@
|
||||
mod include;
|
||||
mod pana_dvd_crypto;
|
||||
mod lzss;
|
||||
use std::any::Any;
|
||||
use crate::AppContext;
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::fs::{self, OpenOptions};
|
||||
use std::io::{Write, Read, Cursor, Seek, SeekFrom};
|
||||
use binrw::BinReaderExt;
|
||||
|
||||
use crate::keys;
|
||||
use crate::utils::common;
|
||||
use crate::utils::aes::{decrypt_aes128_cbc_nopad};
|
||||
use crate::utils::compression::{decompress_gzip};
|
||||
use pana_dvd_crypto::{decrypt_data};
|
||||
use lzss::{decompress_lzss};
|
||||
use include::*;
|
||||
|
||||
pub struct PanaDvdContext {
|
||||
matching_key: [u8; 8],
|
||||
base_hdr_size: u32,
|
||||
is_aes: bool,
|
||||
aes_key: Option<[u8; 16]>,
|
||||
aes_iv: Option<[u8; 16]>
|
||||
}
|
||||
|
||||
pub fn is_pana_dvd_file(app_ctx: &AppContext) -> Result<Option<Box<dyn Any>>, Box<dyn std::error::Error>> {
|
||||
let file = match app_ctx.file() {Some(f) => f, None => return Ok(None)};
|
||||
let header = common::read_file(&file, 0, 64)?;
|
||||
if let Some(matching_key) = find_key(&keys::PANA_DVD_KEYONLY, &header, b"PROG", 0)? {
|
||||
Ok(Some(Box::new(PanaDvdContext {
|
||||
matching_key: matching_key,
|
||||
base_hdr_size: 0,
|
||||
is_aes: false,
|
||||
aes_key: None,
|
||||
aes_iv: None,
|
||||
})))
|
||||
} else if header.starts_with(b"PANASONIC\x00\x00\x00") && let Some(matching_key) = find_key(&keys::PANA_DVD_KEYONLY, &header, b"PROG", 48)? {
|
||||
Ok(Some(Box::new(PanaDvdContext {
|
||||
matching_key: matching_key,
|
||||
base_hdr_size: 48,
|
||||
is_aes: false,
|
||||
aes_key: None,
|
||||
aes_iv: None,
|
||||
})))
|
||||
} else if let Some((aes_key, aes_iv, matching_key)) = find_aes_key_pair(&keys::PANA_DVD_AESPAIR, &header, b"PANASONIC", 32)? {
|
||||
Ok(Some(Box::new(PanaDvdContext {
|
||||
matching_key: matching_key,
|
||||
base_hdr_size: 48,
|
||||
is_aes: true,
|
||||
aes_key: Some(aes_key),
|
||||
aes_iv: Some(aes_iv),
|
||||
})))
|
||||
} else {
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn extract_pana_dvd(app_ctx: &AppContext, ctx: Box<dyn Any>) -> Result<(), Box<dyn std::error::Error>> {
|
||||
let mut file = app_ctx.file().ok_or("Extractor expected file")?;
|
||||
let context = ctx.downcast::<PanaDvdContext>().expect("Missing context");
|
||||
|
||||
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.read_to_end(&mut data)?;
|
||||
let mut file_reader = Cursor::new(data);
|
||||
|
||||
let matching_key = context.matching_key;
|
||||
let mut file_entries: Vec<FileEntry> = Vec::new();
|
||||
|
||||
if context.is_aes {
|
||||
let (aes_key, aes_iv) = (context.aes_key.unwrap(), context.aes_iv.unwrap());
|
||||
println!("Using key: {} + AES key: {}, IV: {}", hex::encode_upper(matching_key), hex::encode_upper(aes_key), hex::encode_upper(aes_iv));
|
||||
println!("Decrypting AES...\n");
|
||||
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
|
||||
|
||||
//read file entries in extra header
|
||||
let file_table = common::read_exact(&mut file_reader, 48)?;
|
||||
let mut file_table_reader = Cursor::new(decrypt_data(&file_table, &matching_key));
|
||||
for _i in 0..4 {
|
||||
let file_entry: AesHeaderFileEntry = file_table_reader.read_le()?;
|
||||
if file_entry.size == 0 && file_entry.offset == 0 {
|
||||
break
|
||||
}
|
||||
if !file_entries.iter().any(|f| f.offset == file_entry.offset ){
|
||||
file_entries.push(FileEntry { offset: file_entry.offset, base_offset: context.base_hdr_size });
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
println!("Using key: {}", hex::encode_upper(matching_key));
|
||||
file_entries.push(FileEntry { offset: 0, base_offset: context.base_hdr_size });
|
||||
}
|
||||
|
||||
if file_entries.len() == 1 {
|
||||
//only one file, standard extraction
|
||||
println!("File contains no extra sub-files...\n");
|
||||
extract_file(&mut file_reader, file_entries[0].offset as u64, file_entries[0].base_offset as u64, matching_key, &app_ctx.output_dir)?;
|
||||
} 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, &app_ctx.output_dir.join(format!("file_{}", 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: &PathBuf) -> Result<(), Box<dyn std::error::Error>> {
|
||||
file_reader.seek(SeekFrom::Start(offset + base_offset))?;
|
||||
|
||||
let enc_header = common::read_exact(file_reader, MAX_HEADER_SIZE)?;
|
||||
let mut hdr_reader = Cursor::new(decrypt_data(&enc_header, &key));
|
||||
let mut modules: Vec<ModuleEntry> = Vec::new();
|
||||
|
||||
for i in 0..100 {
|
||||
let mut entry: ModuleEntry = hdr_reader.read_le()?;
|
||||
if !entry.is_valid() {break};
|
||||
println!("Module {} - Name: {}, Version: {}, Platform: {}, ID: {}, Offset: {}, Size: {}",
|
||||
i + 1, entry.name(), entry.version(), entry.platform(), entry.id(), entry.offset, entry.size);
|
||||
if modules.iter().any(|m| m.offset == entry.offset ){
|
||||
println!("- Duplicate module, skipping!");
|
||||
continue
|
||||
}
|
||||
|
||||
//prevent collision of modules with the same name
|
||||
if modules.iter().any(|m| m.name() == entry.name() ){
|
||||
entry.name_bytes = format!("{}({})", entry.name(), i + 1).as_bytes().to_vec();
|
||||
}
|
||||
|
||||
modules.push(entry);
|
||||
}
|
||||
|
||||
let mut mod_i = 0;
|
||||
for module in &modules {
|
||||
mod_i += 1;
|
||||
println!("\n({}/{}) - {}, Offset: {}, Size: {}, Checksum: {:#010x}",
|
||||
mod_i, modules.len(), module.name(), module.offset, module.size, module.data_checksum);
|
||||
|
||||
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 mut dec_data = decrypt_data(&data, &key);
|
||||
|
||||
if module.name().starts_with("DRV") {
|
||||
println!("- Extracting DRIVE firmware...");
|
||||
dec_data = extract_drv(dec_data, &key)?;
|
||||
}
|
||||
|
||||
fs::create_dir_all(&output_folder)?;
|
||||
let mut out_file = OpenOptions::new().write(true).create(true).open(output_path)?;
|
||||
out_file.write_all(&dec_data)?;
|
||||
|
||||
println!("-- Saved file!");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
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()?;
|
||||
if main_list_hdr.entry_count() > 200 {
|
||||
println!("Unsupported MAIN data, skipping!");
|
||||
return Ok(())
|
||||
}
|
||||
|
||||
println!("MAIN - Entry count: {}, Decompressed part size: {}", main_list_hdr.entry_count(), main_list_hdr.decompressed_part_size);
|
||||
let mut main_entries: Vec<MainListEntry> = Vec::new();
|
||||
for i in 0..main_list_hdr.entry_count() {
|
||||
let main_entry: MainListEntry = file_reader.read_le()?;
|
||||
println!("- Entry {}/{} - Size: {}, Checksum: {:#010x}",
|
||||
i + 1, main_list_hdr.entry_count(), main_entry.size, main_entry.checksum);
|
||||
main_entries.push(main_entry);
|
||||
}
|
||||
|
||||
let mut maine_i = 0;
|
||||
for entry in &main_entries {
|
||||
maine_i += 1;
|
||||
let mut data = common::read_exact(file_reader, entry.size as usize)?;
|
||||
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
|
||||
let first_decrypted = decrypt_data(&data[..decrypt_size], &key);
|
||||
data[..decrypt_size].copy_from_slice(&first_decrypted);
|
||||
|
||||
let last_decrypted = decrypt_data(&data[entry.size as usize - decrypt_size..], &key);
|
||||
data[entry.size as usize - decrypt_size..].copy_from_slice(&last_decrypted);
|
||||
//
|
||||
} else {
|
||||
let decrypted = decrypt_data(&data, &key);
|
||||
data.copy_from_slice(&decrypted);
|
||||
}
|
||||
|
||||
print!("\nMAIN ({}/{}) - ", maine_i, main_entries.len());
|
||||
let decompressed_data = decompress_data(&data)?;
|
||||
|
||||
let mut out_file = OpenOptions::new().append(true).create(true).open(&output_path)?;
|
||||
out_file.write_all(&decompressed_data)?;
|
||||
|
||||
println!("-- Saved to MAIN!");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn decompress_data(data: &[u8]) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
|
||||
let mut data_reader = Cursor::new(data);
|
||||
let header: CompressedFileHeader = data_reader.read_le()?;
|
||||
println!("Compressed size: {}, Decompressed size: {}, Compression type: {}({})",
|
||||
header.compressed_size, header.decompressed_size, header.compression_type_byte, header.compression_type());
|
||||
|
||||
let compressed_data = common::read_exact(&mut data_reader, header.compressed_size as usize)?;
|
||||
let decompressed_data;
|
||||
|
||||
if header.compression_type_byte == 1 { //gzip + optionally lzss
|
||||
println!("- Decompressing GZIP...");
|
||||
let decompressed_gzip = decompress_gzip(&compressed_data)?;
|
||||
|
||||
// the decompressed data can have another header
|
||||
if decompressed_gzip.starts_with(COMPRESSED_FILE_MAGIC) {
|
||||
decompressed_data = decompress_data(&decompressed_gzip)?;
|
||||
} else {
|
||||
decompressed_data = decompressed_gzip;
|
||||
}
|
||||
} else if header.compression_type_byte == 2 { //only lzss
|
||||
println!("- Decompressing LZSS...");
|
||||
decompressed_data = decompress_lzss(&compressed_data);
|
||||
if decompressed_data.len() != header.decompressed_size as usize {
|
||||
return Err("Decompressed size does not match size in header, decompression failed!".into());
|
||||
}
|
||||
} else if header.compression_type_byte == 0 { //no compression. havent encountered one yet
|
||||
decompressed_data = compressed_data;
|
||||
|
||||
} else {
|
||||
println!("- Unknown compression method!");
|
||||
decompressed_data = compressed_data;
|
||||
}
|
||||
|
||||
Ok(decompressed_data)
|
||||
}
|
||||
|
||||
fn extract_drv(mut data: Vec<u8>, key: &[u8; 8]) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
|
||||
let data_size = data.len();
|
||||
let decrypt_size: usize = 10240;
|
||||
let header_size = 0x20;
|
||||
|
||||
//decrypt first and last 10240b (execpt last 48b)
|
||||
let first_decrypted = decrypt_data(&data[..decrypt_size], &key);
|
||||
data[..decrypt_size].copy_from_slice(&first_decrypted);
|
||||
|
||||
let last_decrypted = decrypt_data(&data[data_size as usize - decrypt_size - 48..data_size - 48], &key);
|
||||
data[data_size as usize - decrypt_size - 48..data_size - 48].copy_from_slice(&last_decrypted);
|
||||
|
||||
//can be compressed
|
||||
if data[header_size..].starts_with(COMPRESSED_FILE_MAGIC) {
|
||||
let decompressed = decompress_data(&data[header_size..])?;
|
||||
data.truncate(header_size);
|
||||
data.extend_from_slice(&decompressed);
|
||||
}
|
||||
|
||||
Ok(data)
|
||||
}
|
||||
@@ -0,0 +1,167 @@
|
||||
//libfmupre.so
|
||||
//DAT_29f06d60
|
||||
const SBOX: [u8; 256] = [
|
||||
0x00,0x01,0xbb,0x9c,0x3f,0x5e,0xc7,0x3e,0x36,0xa4,0x92,0x93,0x38,0x9b,0x8d,0x1a,
|
||||
0x3c,0x84,0xf7,0x2a,0xcb,0x3d,0x70,0xad,0x30,0xa2,0xc1,0x95,0x03,0x39,0xa5,0x0e,
|
||||
0xe6,0xfb,0x09,0x1e,0xb9,0xc4,0x24,0x57,0x5f,0xc3,0x5d,0xfa,0x60,0x56,0xfd,0xed,
|
||||
0x81,0xf3,0x4a,0xff,0x85,0xdb,0xcd,0xa0,0xd0,0x9d,0x8b,0x26,0x4c,0x50,0x0c,0x1d,
|
||||
0x7d,0x77,0xde,0x7a,0x0a,0x0b,0x73,0xe1,0x54,0x76,0xe8,0xc2,0x28,0x05,0x98,0x99,
|
||||
0x29,0x4b,0xee,0x87,0x42,0x59,0x65,0xb8,0x1f,0xdf,0x23,0x58,0x63,0x69,0x1c,0x79,
|
||||
0x64,0xc5,0x6f,0x13,0x3b,0xce,0x08,0xa7,0xb2,0x12,0x20,0x7f,0xe2,0x89,0x21,0x2b,
|
||||
0x41,0x49,0x7c,0x82,0xbe,0xf2,0x43,0x8e,0x86,0x02,0x9e,0xd8,0x67,0x8f,0xa3,0xe7,
|
||||
0xbc,0xf8,0x66,0x22,0x4d,0xe5,0xba,0xd2,0xda,0xea,0x61,0x25,0xb0,0xc0,0x7b,0xa6,
|
||||
0x48,0x96,0xdd,0xdc,0x71,0x90,0x55,0x5b,0x4f,0x4e,0x6d,0xd1,0x11,0x34,0xaa,0x1b,
|
||||
0xf4,0x17,0x80,0xb7,0xcc,0x8c,0xd9,0x37,0x8a,0x2c,0x94,0x16,0x72,0x40,0xef,0x9a,
|
||||
0xc8,0x47,0xf6,0xfc,0x2e,0xb3,0x2f,0xbd,0xcf,0xa9,0x15,0x10,0x18,0xec,0x6a,0x6e,
|
||||
0xc9,0x91,0x53,0x78,0xa8,0x3a,0xaf,0x0d,0xe0,0x97,0x32,0x51,0xb1,0xf5,0x27,0x2d,
|
||||
0x35,0x88,0x14,0xe3,0xfe,0x06,0xd7,0xd6,0xab,0xa1,0xd5,0xe4,0x45,0x44,0x9f,0x0f,
|
||||
0x5a,0x83,0xeb,0xca,0x07,0x04,0xb4,0xb6,0x52,0xae,0xd4,0x33,0x31,0x75,0xd3,0x6c,
|
||||
0x62,0xbf,0x6b,0xf9,0xac,0x46,0xf0,0x5c,0x19,0x7e,0x68,0xb5,0xf1,0x74,0xc6,0xe9,
|
||||
];
|
||||
|
||||
//FUN_29f05520
|
||||
fn round_function(state: &mut [u8; 4], a5: &[u8; 4]) {
|
||||
let v5 = a5[1] ^ state[1];
|
||||
let v6 = a5[2] ^ state[2];
|
||||
let v7 = state[3] ^ a5[3];
|
||||
|
||||
let v8 = ((v5 >> 7) | (v5 << 1)) & 0xFF;
|
||||
let v9 = ((v6 >> 5) | (v6 << 3)) & 0xFF;
|
||||
let v10 = a5[0] ^ state[0];
|
||||
let v11 = ((v7 >> 2) | (v7 << 6)) & 0xFF;
|
||||
let v12 = v10 ^ v9 ^ v8;
|
||||
|
||||
let temp_v7 = v10 >> 1;
|
||||
let temp_v10 = ((v10 << 7) | (v11 >> 1)) & 0xFF;
|
||||
|
||||
let new_a4 = ((v9 >> 1) | (v11 << 7)) & 0xFF;
|
||||
let v13 = SBOX[(v11 ^ v12) as usize];
|
||||
let new_a3 = ((v8 >> 1) | (v9 << 7)) & 0xFF;
|
||||
let new_a2 = (temp_v7 | (v8 << 7)) & 0xFF;
|
||||
let new_result = temp_v10 & 0xFF;
|
||||
|
||||
let a4_final = new_a4.wrapping_add(v13);
|
||||
let a3_final = new_a3.wrapping_add(((v13 >> 7) | (v13 << 1)) & 0xFF);
|
||||
let a2_final = new_a2.wrapping_add(((v13 >> 6) | (v13 << 2)) & 0xFF);
|
||||
let result_final = new_result.wrapping_add(((v13 >> 5) | (v13 << 3)) & 0xFF);
|
||||
|
||||
state[0] = result_final;
|
||||
state[1] = a2_final;
|
||||
state[2] = a3_final;
|
||||
state[3] = a4_final;
|
||||
}
|
||||
|
||||
//FUN_29f055dc
|
||||
fn key_schedule(xored_key: &[u8; 8], out: &mut [u8; 32]) {
|
||||
//in original function 2 keys were XORed together to make the actual key (that the round keys are derived from)
|
||||
// why? i dont know (obfuscation?) but i use the XORed key here directly
|
||||
let mut v26 = [0u8; 8];
|
||||
for i in 0..7 {
|
||||
v26[i] = xored_key[i];
|
||||
}
|
||||
let v12 = xored_key[7];
|
||||
v26[1] ^= v12;
|
||||
v26[4] ^= v12;
|
||||
|
||||
for i in 0..7 {
|
||||
out[i] = v26[i];
|
||||
}
|
||||
for i in 7..32 {
|
||||
out[i] = 0;
|
||||
}
|
||||
|
||||
let mut v22: [u8; 4] = [53, 125, 251, 154];
|
||||
|
||||
for v16 in 0..16 {
|
||||
let v17 = 4 * (v16 & 7);
|
||||
let mut state: [u8; 4] = out[v17..v17 + 4].try_into().unwrap();
|
||||
round_function(&mut state, &v22);
|
||||
out[v17..v17 + 4].copy_from_slice(&state);
|
||||
v22.copy_from_slice(&state);
|
||||
}
|
||||
}
|
||||
|
||||
//FUN_29f056b0
|
||||
fn decrypt_block(a1: &[u8; 32], a2: &mut [u8; 8]) {
|
||||
let mut v6 = a2[0];
|
||||
let mut v7 = a2[1];
|
||||
let mut v5 = a2[2];
|
||||
let mut v4 = a2[3];
|
||||
|
||||
let mut v24 = v6;
|
||||
let mut v25 = v7;
|
||||
let mut v26 = v5;
|
||||
let mut v27 = v4;
|
||||
|
||||
let mut v10 = a2[4];
|
||||
let mut v11 = a2[5];
|
||||
let mut v12 = a2[6];
|
||||
let mut v13 = a2[7];
|
||||
|
||||
let mut v15: u8 = 0;
|
||||
let mut v16: u8 = 0;
|
||||
let mut v17: u8 = 0;
|
||||
let mut v18: u8 = 0;
|
||||
|
||||
for v2 in (0..16).rev() {
|
||||
let v14 = (v2 & 7) as usize;
|
||||
let subkey: [u8; 4] = a1[4 * v14..4 * v14 + 4].try_into().unwrap();
|
||||
let mut st = [v24, v25, v26, v27];
|
||||
round_function(&mut st, &subkey);
|
||||
v24 = st[0];
|
||||
v25 = st[1];
|
||||
v26 = st[2];
|
||||
v27 = st[3];
|
||||
|
||||
v15 = v10 ^ v24;
|
||||
v16 = v11 ^ v25;
|
||||
v17 = v12 ^ v26;
|
||||
v18 = v13 ^ v27;
|
||||
|
||||
v24 ^= v10;
|
||||
v25 ^= v11;
|
||||
v26 ^= v12;
|
||||
v27 ^= v13;
|
||||
|
||||
v10 = v6;
|
||||
v11 = v7;
|
||||
v12 = v5;
|
||||
v13 = v4;
|
||||
|
||||
if v2 == 0 {
|
||||
break;
|
||||
}
|
||||
|
||||
v6 = v15;
|
||||
v7 = v16;
|
||||
v5 = v17;
|
||||
v4 = v18;
|
||||
}
|
||||
|
||||
a2[0] = v6;
|
||||
a2[1] = v7;
|
||||
a2[2] = v5;
|
||||
a2[3] = v4;
|
||||
a2[4] = v15;
|
||||
a2[5] = v16;
|
||||
a2[6] = v17;
|
||||
a2[7] = v18;
|
||||
}
|
||||
|
||||
fn decrypt_data_inplace(data: &mut [u8], key: &[u8; 8]) {
|
||||
let mut subkeys = [0u8; 32];
|
||||
key_schedule(key, &mut subkeys);
|
||||
for chunk in data.chunks_mut(8) {
|
||||
if chunk.len() == 8 {
|
||||
let mut block: [u8; 8] = chunk.try_into().unwrap();
|
||||
decrypt_block(&subkeys, &mut block);
|
||||
chunk.copy_from_slice(&block);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn decrypt_data(data: &[u8], key: &[u8; 8]) -> Vec<u8> {
|
||||
let mut buf = data.to_vec();
|
||||
decrypt_data_inplace(&mut buf, key);
|
||||
buf
|
||||
}
|
||||
Reference in New Issue
Block a user