add invincible_image extractor, update sddl_sec extractor, fix for mtk upgrade loader

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;
 

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<Aes128>;
+
+use crate::common;
+
+#[derive(BinRead)]
+struct Header {
+    #[br(count = 16)] _magic_bytes: Vec<u8>,
+    #[br(count = 4)] file_version: Vec<u8>,
+    _unk1: u32,
+    #[br(count = 16)] ver1_bytes: Vec<u8>,
+    #[br(count = 16)] ver2_bytes: Vec<u8>,
+    _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<u8>,
+    #[br(count = 16)] ver4_bytes: Vec<u8>,
+    #[br(count = 11)] _unk6: Vec<u8>,
+    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<u8>,
+    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<Vec<u8>, Box<dyn std::error::Error>> {
+    let mut data = encrypted_data.to_vec();
+    let decryptor = Aes128CbcDec::new(key.into(), iv.into());
+
+    let decrypted = decryptor
+        .decrypt_padded_mut::<NoPadding>(&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<dyn std::error::Error>> {
+    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<Entry> = 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(())
+}

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

src/formats/sddl_sec.rs

@@ -155,25 +155,22 @@ pub fn extract_sddl_sec(file: &File, output_folder: &str) -> Result<(), Box<dyn
             let source_offset = u32::from_be_bytes([0x00, out_data[6], out_data[7], out_data[8]]);
 
             let path: PathBuf; 
-            let msg: &str;
+            let msg: String;
+
+            let source_name = filename.split(".").next().unwrap();
 
-            if filename.starts_with("PEAKS.F") {
             if source_offset == 270 {   //unique for 2014-2018 files
                 let embedded_file_name_string = String::from_utf8_lossy(&out_data[14..270]);
                 let embedded_file_name = embedded_file_name_string.split("\0").next().unwrap();
                 println!("--- Embedded file: {}", embedded_file_name);
     
-                    let folder_path = Path::new(&output_folder).join("PEAKS");
+                let folder_path = Path::new(&output_folder).join(source_name);
                 fs::create_dir_all(&folder_path)?;
                 path = Path::new(&folder_path).join(embedded_file_name);
-                    msg = "to PEAKS";
+                msg = format!("to {}", source_name);
             } else {
-                    path = Path::new(&output_folder).join("PEAKS.bin");
-                    msg = "to PEAKS.bin";
-                }            
-            } else {
-                path = Path::new(&output_folder).join(filename);
-                msg = "file";
+                path = Path::new(&output_folder).join(format!("{}.bin", source_name));
+                msg = format!("to {}.bin", source_name);
             }
 
             fs::create_dir_all(&output_folder)?;

src/main.rs

@@ -52,6 +52,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             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)?;