Initial commit

Author: savannstm

.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "rpgmad-lib"
+version = "1.0.1"
+edition = "2021"
+
+[features]
+rayon = ["dep:rayon"]
+
+[dependencies]
+rayon = { version = "1.10.0", optional = true }

LICENSE.md

@@ -0,0 +1,14 @@
+        DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+Copyright (C) 2024 Pavlov Danil <[email protected]>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. You just DO WHAT THE FUCK YOU WANT TO.

README.md

@@ -0,0 +1,18 @@
+# rpgm-archive-decrypter-lib
+
+A decrypter implementation for [rpgm-archive-decrypter](https://github.com/savannstm/rpgm-archive-decrypter).
+Not intended for use in other applications; but can be.
+
+## Quick example
+
+```rust
+let archive_bytes = std::fs::read("C:/Documents/Game/Game.rgssad");
+let mut decrypter = rpgmad_lib::Decrypter::new();
+
+// Writes decrypted game files to "C:/Documents/Game"
+decrypter.decrypt("C:/Documents/Game", false).unwrap()
+```
+
+## License
+
+Project is licensed under WTFPL.

src/lib.rs

@@ -0,0 +1,274 @@
+//!A decrypter implementation for rpgm-archive-decrypter. Not intended for use in other applications; but can be.
+
+#[cfg(feature = "rayon")]
+use rayon::prelude::*;
+#[cfg(feature = "rayon")]
+use std::sync::{Arc, Mutex};
+use std::{
+    cell::UnsafeCell,
+    fs::{create_dir_all, write},
+    path::{Path, PathBuf},
+};
+
+#[derive(PartialEq)]
+enum Engine {
+    Older,
+    VXAce,
+}
+
+enum SeekFrom {
+    Start,
+    Current,
+}
+
+impl std::fmt::Display for Engine {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let variant_name: &str = match self {
+            Engine::Older => "XP/VX",
+            Engine::VXAce => "VXAce",
+        };
+
+        write!(f, "{}", variant_name)
+    }
+}
+
+struct VecWalker {
+    data: Vec<u8>,
+    pos: usize,
+    len: usize,
+}
+
+impl VecWalker {
+    pub fn new(data: Vec<u8>) -> Self {
+        let len: usize = data.len();
+        VecWalker { data, pos: 0, len }
+    }
+
+    pub fn advance(&mut self, bytes: usize) -> &[u8] {
+        self.pos += bytes;
+        &self.data[self.pos - bytes..self.pos]
+    }
+
+    pub fn read_chunk(&mut self) -> [u8; 4] {
+        let chunk: &[u8] = self.advance(4);
+        unsafe { *(chunk.as_ptr() as *const [u8; 4]) }
+    }
+
+    pub fn read_byte(&mut self) -> u8 {
+        self.pos += 1;
+        self.data[self.pos - 1]
+    }
+
+    pub fn seek(&mut self, offset: usize, seek_from: SeekFrom) {
+        self.pos = match seek_from {
+            SeekFrom::Start => offset,
+            SeekFrom::Current => self.pos + offset,
+        };
+    }
+}
+
+struct Archive {
+    filename: String,
+    size: i32,
+    offset: usize,
+    key: u32,
+}
+
+pub struct Decrypter {
+    walker: UnsafeCell<VecWalker>,
+    key: u32,
+    engine: Engine,
+}
+
+impl Decrypter {
+    /// Creates a new decrypter for specified archive binary data.
+    pub fn new(bytes: Vec<u8>) -> Self {
+        Self {
+            walker: UnsafeCell::new(VecWalker::new(bytes)),
+            key: 0xDEADCAFE,
+            engine: Engine::Older,
+        }
+    }
+
+    /// Extracts archive to `output_path`. Does nothing if extracted files already exist and `force` is set to `false`.
+    pub fn extract<P: AsRef<Path>>(&mut self, output_path: P, force: bool) -> Result<(), &str> {
+        let walker: &mut VecWalker = unsafe { &mut *self.walker.get() };
+
+        let version: u8 = {
+            let header: &[u8] = walker.advance(6);
+
+            if header != b"RGSSAD" {
+                return Err("Unknown archive header. Expected: RGSSAD.");
+            }
+
+            walker.seek(1, SeekFrom::Current);
+            walker.read_byte()
+        };
+
+        self.engine = if version == 1 {
+            Engine::Older
+        } else if version == 3 {
+            Engine::VXAce
+        } else {
+            return Err("Unknown archive game engine. Archive is possibly corrupted.");
+        };
+
+        let archives: Vec<Archive> = self.read_archive();
+
+        #[cfg(feature = "rayon")]
+        let arc: Arc<Mutex<&mut VecWalker>> = Arc::new(Mutex::new(walker));
+
+        #[cfg(feature = "rayon")]
+        let archives = archives.into_par_iter();
+
+        #[cfg(not(feature = "rayon"))]
+        let archives = archives.into_iter();
+
+        let output_path: &Path = output_path.as_ref();
+
+        archives.for_each(|archive: Archive| {
+            let output_path: PathBuf = output_path.join(archive.filename);
+
+            if output_path.exists() && !force {
+                println!("Output files already exist. Use --force to forcefully overwrite them.");
+                return;
+            }
+
+            #[cfg(feature = "rayon")]
+            let mut walker = arc.lock().unwrap();
+
+            walker.seek(archive.offset, SeekFrom::Start);
+            let data: Vec<u8> = Vec::from(walker.advance(archive.size as usize));
+
+            #[cfg(feature = "rayon")]
+            drop(walker);
+
+            let parent_directory: &Path = unsafe { output_path.parent().unwrap_unchecked() };
+
+            if !parent_directory.exists() {
+                create_dir_all(parent_directory).unwrap();
+            }
+
+            let decrypted: Vec<u8> = Self::decrypt_archive(&data, archive.key);
+            write(output_path, decrypted).unwrap();
+        });
+
+        Ok(())
+    }
+
+    fn decrypt_archive(data: &[u8], mut key: u32) -> Vec<u8> {
+        let mut decrypted: Vec<u8> = Vec::with_capacity(data.len());
+
+        let mut key_bytes: [u8; 4] = key.to_le_bytes();
+        let mut j: usize = 0;
+
+        for item in data {
+            if j == 4 {
+                j = 0;
+                key = key.wrapping_mul(7).wrapping_add(3);
+                key_bytes = key.to_le_bytes();
+            }
+
+            decrypted.push(item ^ key_bytes[j]);
+            j += 1;
+        }
+
+        decrypted
+    }
+
+    fn decrypt_integer(&mut self, value: i32) -> i32 {
+        let result: i32 = value ^ self.key as i32;
+
+        if self.engine == Engine::Older {
+            self.key = self.key.wrapping_mul(7).wrapping_add(3);
+        }
+
+        result
+    }
+
+    fn decrypt_filename(&mut self, filename: &[u8]) -> String {
+        let mut decrypted: Vec<u8> = Vec::with_capacity(filename.len());
+
+        if self.engine == Engine::VXAce {
+            let key_bytes: [u8; 4] = self.key.to_le_bytes();
+            let mut j: usize = 0;
+
+            for item in filename {
+                if j == 4 {
+                    j = 0;
+                }
+
+                decrypted.push(item ^ key_bytes[j]);
+                j += 1;
+            }
+        } else {
+            for item in filename {
+                decrypted.push(item ^ (self.key & 0xff) as u8);
+                self.key = self.key.wrapping_mul(7).wrapping_add(3);
+            }
+        }
+
+        String::from_utf8(decrypted).unwrap()
+    }
+
+    fn read_archive(&mut self) -> Vec<Archive> {
+        let walker: &mut VecWalker = unsafe { &mut *self.walker.get() };
+
+        if self.engine == Engine::VXAce {
+            // 0xDEADCAFE key is not ever used and overwritten.
+            self.key = u32::from_le_bytes(walker.read_chunk())
+                .wrapping_mul(9)
+                .wrapping_add(3);
+        }
+
+        let mut archives: Vec<Archive> = Vec::with_capacity(1024);
+
+        loop {
+            let (filename, size, offset, key) = if self.engine == Engine::VXAce {
+                let offset: usize =
+                    self.decrypt_integer(i32::from_le_bytes(walker.read_chunk())) as usize;
+
+                let size: i32 = self.decrypt_integer(i32::from_le_bytes(walker.read_chunk()));
+
+                let key: u32 = self.decrypt_integer(i32::from_le_bytes(walker.read_chunk())) as u32;
+
+                let length: i32 = self.decrypt_integer(i32::from_le_bytes(walker.read_chunk()));
+
+                if offset == 0 {
+                    break;
+                }
+
+                let filename: String = self.decrypt_filename(walker.advance(length as usize));
+
+                (filename, size, offset, key)
+            } else {
+                let length: i32 = self.decrypt_integer(i32::from_le_bytes(walker.read_chunk()));
+
+                let filename: String = self.decrypt_filename(walker.advance(length as usize));
+
+                let size: i32 = self.decrypt_integer(i32::from_le_bytes(walker.read_chunk()));
+
+                let offset: usize = walker.pos;
+
+                let key: u32 = self.key;
+
+                walker.seek(size as usize, SeekFrom::Current);
+
+                if walker.pos == walker.len {
+                    break;
+                }
+
+                (filename, size, offset, key)
+            };
+
+            archives.push(Archive {
+                filename,
+                size,
+                offset,
+                key,
+            });
+        }
+
+        archives
+    }
+}