From 87a87cd2bca4847ff4e129139bbaa355b2d663b2 Mon Sep 17 00:00:00 2001 From: theubusu <80545678+theubusu@users.noreply.github.com> Date: Tue, 28 Oct 2025 17:58:59 +0100 Subject: [PATCH] add invincible_image extractor, update sddl_sec extractor, fix for mtk upgrade loader --- src/formats.rs | 1 + src/formats/invincible_image.rs | 143 ++++++++++++++++++++++++++++++ src/formats/mtk_upgrade_loader.rs | 2 +- src/formats/sddl_sec.rs | 29 +++--- src/main.rs | 4 + 5 files changed, 162 insertions(+), 17 deletions(-) create mode 100644 src/formats/invincible_image.rs diff --git a/src/formats.rs b/src/formats.rs index 2ae6cc6..2aa60cd 100644 --- a/src/formats.rs +++ b/src/formats.rs @@ -5,6 +5,7 @@ pub mod pfl_upg; pub mod sddl_sec; pub mod novatek; pub mod ruf; +pub mod invincible_image; pub mod pup; diff --git a/src/formats/invincible_image.rs b/src/formats/invincible_image.rs new file mode 100644 index 0000000..248eaec --- /dev/null +++ b/src/formats/invincible_image.rs @@ -0,0 +1,143 @@ +use std::path::{Path}; +use std::fs::{self, File, OpenOptions}; +use std::io::{Write, Read, Seek, SeekFrom, Cursor}; +use binrw::{BinRead, BinReaderExt}; +use aes::Aes128; +use cbc::{Decryptor, cipher::{block_padding::NoPadding, BlockDecryptMut, KeyIvInit}}; +type Aes128CbcDec = Decryptor; + +use crate::common; + +#[derive(BinRead)] +struct Header { + #[br(count = 16)] _magic_bytes: Vec, + #[br(count = 4)] file_version: Vec, + _unk1: u32, + #[br(count = 16)] ver1_bytes: Vec, + #[br(count = 16)] ver2_bytes: Vec, + _unk2: u16, + _type: u8, + keep_size: u32, + _unk3: u8, + data_start_offset: u32, + data_size: u32, + _data_size_2: u32, + skip_size: u32, + _unk4: u16, + _encryption_method: u8, // 0x01 - AES128, 0x02 - AES256 + _hash_type: u8, // 0x01 - MD5, 0x02 - SHA1 + #[br(count = 16)] ver3_bytes: Vec, + #[br(count = 16)] ver4_bytes: Vec, + #[br(count = 11)] _unk6: Vec, + payload_count: u8, +} +impl Header { + fn ver1(&self) -> String { + common::string_from_bytes(&self.ver1_bytes).replace('\n', "") + } + fn ver2(&self) -> String { + common::string_from_bytes(&self.ver2_bytes).replace('\n', "") + } + fn ver3(&self) -> String { + common::string_from_bytes(&self.ver3_bytes).replace('\n', "") + } + fn ver4(&self) -> String { + common::string_from_bytes(&self.ver4_bytes).replace('\n', "") + } +} + +#[derive(BinRead)] +struct Entry { + #[br(count = 16)] name_bytes: Vec, + start_offset: u32, + size: u32, +} +impl Entry { + fn name(&self) -> String { + common::string_from_bytes(&self.name_bytes) + } +} + +pub fn is_invincible_image_file(file: &File) -> bool { + let header = common::read_file(&file, 0, 16).expect("Failed to read from file."); + if header == b"INVINCIBLE_IMAGE" { + true + } else { + false + } +} + +fn decrypt_aes_nopad(encrypted_data: &[u8], key: &[u8; 16], iv: &[u8; 16]) -> Result, Box> { + let mut data = encrypted_data.to_vec(); + let decryptor = Aes128CbcDec::new(key.into(), iv.into()); + + let decrypted = decryptor + .decrypt_padded_mut::(&mut data) + .map_err(|e| format!("UnpadError: {:?}", e))?; + + Ok(decrypted.to_vec()) +} + +pub fn extract_invincible_image(mut file: &File, output_folder: &str) -> Result<(), Box> { + let header: Header = file.read_le()?; + + println!("\nFile info:\nFile Version: {}.{}\nVersion(1): {}\nVersion(2): {}\nVersion(3): {}\nVersion(4): {}\nData size: {}\nData start offset: {}\nKeep data size: {}\nSkip data size: {}\n\nPayload Count: {}", + header.file_version[0], header.file_version[1], header.ver1(), header.ver2(), header.ver3(), header.ver4(), header.data_size, header.data_start_offset, header.keep_size, header.skip_size, header.payload_count); + + let mut entries: Vec = Vec::new(); + + for i in 0..header.payload_count { + let entry: Entry = file.read_le()?; + println!("{}. {}, Start offset: {}, Size: {}", + i + 1, entry.name(), entry.start_offset, entry.size); + entries.push(entry); + } + + if header.file_version[0] != 3 { + println!("\nSorry, this version of the file is not supported!"); + return Ok(()) + } + + let mut encrypted_data = Vec::new(); + let mut buffer = vec![0u8; header.keep_size as usize]; + + file.seek(SeekFrom::Start(header.data_start_offset.into()))?; + + loop { + let bytes_read = file.read(&mut buffer)?; + if bytes_read == 0 { + break; // EOF + } + encrypted_data.extend_from_slice(&buffer[..bytes_read]); + file.seek(SeekFrom::Current(header.skip_size.into()))?; + } + + let key = b"\x32\xe5\x26\x1e\x22\x67\x5e\x93\x20\xcf\x35\x91\x7c\x63\x7a\x36"; + let iv = b"\xe3\x9f\x36\x39\x56\x9a\x6b\x8d\x3f\x2e\xc9\x44\xd9\xbc\xec\x43"; + + println!("\nDecrypting data..."); + let decrypted_data = decrypt_aes_nopad(&encrypted_data, &key, &iv)?; + + let mut data_reader = Cursor::new(decrypted_data); + + let mut i = 1; + for entry in entries { + println!("\nExtracting {}/{} - {}", i, header.payload_count, entry.name()); + let data = common::read_exact(&mut data_reader, entry.size as usize)?; + + let output_path = Path::new(&output_folder).join(entry.name() + ".bin"); + + fs::create_dir_all(&output_folder)?; + let mut out_file = OpenOptions::new() + .write(true) + .create(true) + .open(output_path)?; + + out_file.write_all(&data)?; + + println!("- Saved file!"); + i += 1; + } + + Ok(()) +} \ No newline at end of file diff --git a/src/formats/mtk_upgrade_loader.rs b/src/formats/mtk_upgrade_loader.rs index 032c676..20d49bf 100644 --- a/src/formats/mtk_upgrade_loader.rs +++ b/src/formats/mtk_upgrade_loader.rs @@ -7,7 +7,7 @@ use crate::common; pub fn is_mtk_upgrade_loader_file(file: &File) -> bool { let header = common::read_file(&file, 152, 4).expect("Failed to read from file."); - if header == b"cfig" { //cfig is always(?) the first partition in upgrade_loader + if header == b"cfig" || header == b"load" { //cfig or load is always(?) the first partition in upgrade_loader true } else { false diff --git a/src/formats/sddl_sec.rs b/src/formats/sddl_sec.rs index 47d33eb..84fe2b5 100644 --- a/src/formats/sddl_sec.rs +++ b/src/formats/sddl_sec.rs @@ -155,25 +155,22 @@ pub fn extract_sddl_sec(file: &File, output_folder: &str) -> Result<(), Box Result<(), Box> { println!("SDDL.SEC file detected!"); formats::sddl_sec::extract_sddl_sec(&file, &output_path)?; } + if formats::invincible_image::is_invincible_image_file(&file) { + println!("INVINCIBLE_IMAGE file detected!"); + formats::invincible_image::extract_invincible_image(&file, &output_path)?; + } else if formats::msd10::is_msd10_file(&file) { println!("MSD10 file detected!"); formats::msd10::extract_msd10(&file, &output_path)?;