grf-file-extractor 1.0.35

package/lib/cps.js

@@ -0,0 +1,72 @@
+// CPS (cps.dll / Fury.dll) decryption support
+// Extracts the RC4 S-box from a cps.dll and provides decryption for GRF entries
+
+var fs = require('fs')
+
+// Load encryption key from a CPS DLL or a raw S-box hex file
+function loadKey(path) {
+	var data = fs.readFileSync(path)
+
+	// If the file is small and looks like a hex dump (text file), parse as raw S-box
+	var text = data.toString('utf8').trim()
+	var hexMatch = text.match(/^(?:SBOX:)?([0-9a-fA-F]{512})$/)
+	if (hexMatch) {
+		return new Uint8Array(Buffer.from(hexMatch[1], 'hex'))
+	}
+
+	// Otherwise treat as a DLL: search for UTF-16LE L"NUMBER" marker
+	var pattern = [0x4E, 0x00, 0x55, 0x00, 0x4D, 0x00, 0x42, 0x00, 0x45, 0x00, 0x52, 0x00]
+	var offset = -1
+
+	for (var i = 0; i < data.length - pattern.length; i++) {
+		var match = true
+		for (var j = 0; j < pattern.length; j++) {
+			if (data[i + j] !== pattern[j]) { match = false; break }
+		}
+		if (match) { offset = i; break }
+	}
+
+	if (offset === -1) {
+		throw new Error('CPS: Could not find encryption key in ' + path)
+	}
+
+	// Key is after L"NUMBER\0" (14 bytes) + 4 byte header
+	var keyStart = offset + 14 + 4
+	var key = data.slice(keyStart, keyStart + 260)
+
+	if (key.length < 260) {
+		throw new Error('CPS: Not enough key data in ' + path)
+	}
+
+	// Build S-box using the DLL's key scheduling algorithm
+	var a = (key[3] << 24) | (key[2] << 16) | (key[1] << 8) | key[0]
+	var sbox = new Uint8Array(256)
+	for (var i = 0; i < 256; i++) {
+		sbox[i] = ((a & 0xFF) ^ key[i + 4]) & 0xFF
+		a = Math.imul(a, 0x2F)
+	}
+
+	return sbox
+}
+
+// RC4 decrypt a buffer in-place using the S-box
+// initialI is typically the entry's real_size (decompressed size)
+function decrypt(buffer, sbox, initialI) {
+	var S = new Uint8Array(sbox) // working copy
+	var i = initialI & 0xFF
+	var j = 0
+
+	for (var k = 0; k < buffer.length; k++) {
+		i = (i + 1) & 0xFF
+		j = (j + S[i]) & 0xFF
+		var tmp = S[i]; S[i] = S[j]; S[j] = tmp
+		buffer[k] ^= S[(S[i] + S[j]) & 0xFF]
+	}
+
+	return buffer
+}
+
+module.exports = {
+	loadKey: loadKey,
+	decrypt: decrypt
+}

package/lib/extractor.js

@@ -0,0 +1,258 @@
+// Grf full extraction
+var GRF = require('./Loaders/GameFile.js')
+var Inflate = require('./Utils/Inflate.js')
+var GameFileDecrypt = require('./Loaders/GameFileDecrypt.js')
+var EventEmitter = require('events').EventEmitter
+var Cluster = require('cluster')
+var Os = require('os')
+var Fs = require('fs')
+var Util = require('util')
+var Zlib = require('zlib')
+var Cps = require('./cps.js')
+var fs = require('fs')
+
+// Constructor
+var Extractor = function Constructor(grf, options) {
+	this._progress = 0
+	this.grf = grf
+	this.concurrency = options.concurrency || 100
+	this.output_dir = options.output || ''
+	this.cpsSbox = options.cpsSbox || null
+	this.mkdirPaths = [] // List of paths already created
+
+	// Start at next tick, give time for event listener to bind
+	process.nextTick(extractStart.bind(this))
+
+	return this
+}
+
+// Event emmiter
+Util.inherits(Extractor, EventEmitter);
+
+// Start the extraction
+function extractStart() {
+	var numCpus = Os.cpus().length
+	var cluster = Cluster
+	var grf = this.grf
+	var concurrency = this.concurrency
+	var extract_folder = (this.output_dir ? this.output_dir.replace(/\/?$/, '/') : '') // Add trailling slash to folder, if specified
+	var self = this
+
+	// The master only spawn workers to work on the GRF
+	// And receives progress updates
+	if(cluster.isMaster) {
+		// Fork some workers
+		for(var i = 0; i < numCpus; i++) {
+			cluster.fork()
+		}
+
+		// Workers online
+		var workers = []
+
+		// Separate the entries table into the number of workers
+		var entries_slices = [{
+			start: 0,
+			end: 0,
+		}]
+		var last = 0
+		var chunk_size = Math.floor(grf.entries.length / numCpus)
+		
+		for(var i = 0; i < numCpus; i++) {
+			next = last + chunk_size 
+
+			// If last iteration, set this slice to the rest of the entries array
+			if(i == numCpus - 1) {
+				next = grf.entries.length
+			}
+
+			entries_slices[i] = {
+				start: last,
+				end: next,
+			}
+
+			last = next
+		}
+
+		// A worker is online, send it work :)
+		cluster.on('online', function(worker) {
+			var worker_id = workers.length
+
+			// Send a slice of the entries table to this worker to process
+			var slice = entries_slices[ worker_id ]
+			worker.send(slice)
+
+			grf.debug("Sending to worker #%d slice %d to %d.", worker_id, slice.start, slice.end)
+
+			// Worker is reporting its progress
+			worker.on('message', function(msg) {
+				if(msg.cmd == 'progress') {
+					self._progress++	
+				}
+			})
+
+			// Register worker
+			workers.push(worker)	
+		})
+		
+		self.emit('start')
+
+		return
+	}
+
+	// Else is, worker
+	// Wait for the master to send us the go signal 
+	process.on('message', function(msg) {
+		// Receive a slice to work on
+		var entries = grf.entries.slice(msg.start, msg.end)	
+		var next = 0
+		
+		grf.debug("Worker received slice from %d to %d to work on.", msg.start, msg.end)
+		grf.debug('Worker extracting', entries.length, 'files.')
+
+		// Launch # concurrent extractors
+		for(var i = 0; i < concurrency; i++){
+			extract_next()
+		}
+
+		function extract_next() {
+			if(next >= entries.length) {
+				return 
+			}
+
+			var i = next++
+			var entry = entries[i]
+			var buffer = Buffer.alloc(entry.length_aligned);
+			var file = entry.filename.replace( /\\/g, '/') // Replace windows back slash \ to unix forward slash
+			var fullpath = extract_folder + file
+
+			if(entry.type & GRF.FILELIST_TYPE_FILE) {
+				// Read entry from .grf file
+				Fs.read(grf.file.fd, buffer, 0, entry.length_aligned, entry.offset + GRF.struct_header.size, function(err, bytesRead, buffer){
+					if(err) {
+						console.error("Error reading %s: %s", file, err.message)
+						finish()
+						return
+					}
+
+					// Write entry to file
+					self.writeEntry(entry, fullpath, buffer, finish)	
+				})
+			}
+			// Directory?
+			else {
+				self.makeDir(fullpath, finish)
+			}
+	
+			// Extract next
+			function finish() {
+				// Notify master of progress
+				process.send({cmd: 'progress'})
+				extract_next()
+			}
+		}
+	})
+
+	// Avoid workers crashing because of excpections
+	process.on('uncaughtException', function(err) {
+		console.error(err)	
+	})
+}
+
+// Progress
+Extractor.prototype.progress = function progress() {
+	return this._progress
+}
+
+// Make a directory
+Extractor.prototype.makeDir = function mkDir(path, callback) {					
+	// Create directoy
+	if(typeof this.mkdirPaths[path] === 'undefined') {
+		var self = this
+
+		fs.mkdir(path, { recursive: true }, function (err) {
+			if(err) {
+				console.error("Error creating directory %s: %s", path, err.message)
+			}
+
+			// Add to created paths hashtable
+			self.mkdirPaths[path] = true
+
+			callback()
+		})
+
+		return
+	}
+
+	// Directoy already exixsts
+	callback()
+}	
+
+// Write entry buffer to a file
+Extractor.prototype.writeEntry = function writeEntry(entry, path, buffer, callback) {
+	// Decode buffer if needed
+	if (entry.type & GRF.FILELIST_TYPE_ENCRYPT_MIXED) {
+		var data = new Uint8Array(buffer)
+		GameFileDecrypt.decodeFull( data, entry.length_aligned, entry.pack_size)
+		buffer = Buffer.from(data)
+	}
+	else if (entry.type & GRF.FILELIST_TYPE_ENCRYPT_HEADER) {
+		var data = new Uint8Array(buffer)
+		GameFileDecrypt.decodeHeader( data, entry.length_aligned )
+		buffer = Buffer.from(data)
+	}
+
+	var self = this
+
+	function writeInflated(buf) {
+		var folder = path.substring(0, path.lastIndexOf("/"))
+		self.makeDir(folder, function() {
+			self.writeFile(path, buf, callback)
+		})
+	}
+
+	if (self.cpsSbox) {
+		// CPS encrypted GRF: RC4 decrypt a copy, then inflate
+		var decrypted = Buffer.from(buffer)
+		Cps.decrypt(decrypted, self.cpsSbox, entry.real_size)
+
+		Zlib.inflate(decrypted, function(err, buf) {
+			if(!err) {
+				writeInflated(buf)
+				return
+			}
+
+			// Fallback: try without CPS decryption (some files may be unencrypted)
+			Zlib.inflate(buffer, function(err2, buf2) {
+				if(!err2) {
+					writeInflated(buf2)
+					return
+				}
+				console.error("Error decompressing %s: %s", path, err.message2)
+				callback()
+			})
+		})
+	} else {
+		Zlib.inflate(buffer, function(err, buf) {
+			if(err) {
+				console.error("Error decompressing %s: %s", path, err.message)
+				callback()
+				return
+			}
+			writeInflated(buf)
+		})
+	}
+}
+
+// Write buffer to file
+Extractor.prototype.writeFile = function writeFile(path, buffer, callback) {
+	Fs.writeFile(path, buffer, function (err) {
+		if (err) {
+			console.error("Error writing %s: %s", path, err.message)
+		}
+
+		callback()
+	})					
+}
+
+// Exports
+module.exports = Extractor

package/lib/grf.js

@@ -0,0 +1,41 @@
+// This librarie extends default roBrowser software
+// It extends roBrowser default GRF loader
+// Giving it a set a new set of API's and replacing some performance critical functions
+var Grf = module.exports = require('./Loaders/GameFile.js')
+var Extractor = require('./extractor')
+
+// Should we print debug messages?
+Grf.prototype.printDebug = false
+
+// Search for a pattern on the .grf file
+// @param regexp: A regular expression instance
+Grf.prototype.searchPattern = function search(regexp, callback) {
+	var matches = []
+
+	for(var i in this.entries) {
+		var entry = this.entries[i]
+		var filename = entry.filename
+
+		if(regexp.test(filename)) {
+			matches.push(entry)
+		}
+	}
+
+	callback(matches)
+}
+
+// Extract all files from the .grf to a folder
+// @param options {
+// 		output: output directory
+// 		concurrency: concurrency rate
+// }
+Grf.prototype.extract = function(options) {
+	return new Extractor(this, options)
+}
+
+// Print a debug message if verbosity is set
+Grf.prototype.debug = function debug() {
+	if(this.printDebug) {
+		console.log.apply(this, arguments)
+	}
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "grf-file-extractor",
+  "version": "1.0.35",
+  "description": "A command line GRF extractor, used to manage Ragnarok's .grf files.",
+  "main": "index.js",
+  "bin": {
+    "grf-file-extractor": "./index.js"
+  },
+  "scripts": {
+    "test": "npm test",
+    "build": "tsup src/index.ts --format cjs,esm --dts"
+  },
+  "keywords": [
+    "ragnarok",
+    "grf",
+    "robrowser",
+    "extractor"
+  ],
+  "author": "ayenpanda",
+  "license": "MIT",
+  "engines": {
+    "node": ">=10.12.0"
+  }
+}

package/profile.js

@@ -0,0 +1,17 @@
+// Profiler
+var cluster = require('cluster')
+var agent = require('webkit-devtools-agent');
+
+if(cluster.isMaster) {
+	agent.start()
+}
+else {
+	var id = cluster.worker.id
+	agent.start({
+		port: 9999 + id,
+		ipc_port: 3333 + id,
+	})
+	console.log("Worker #%d inspector on port %d.", id, 9999 + id)
+}
+
+require('./index.js')

package/src/index.ts

@@ -0,0 +1,3 @@
+export function sayHello(name: string = 'world'): string {
+  return `Hello, ${name}!`;
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "noImplicitAny": true,
+    "module": "commonjs",
+    "target": "ES2022",
+    "outDir": "dist",
+    "declaration": true,
+    "esModuleInterop": true,
+    "strictNullChecks": true,
+    "moduleResolution": "node",
+    "isolatedModules": true,
+    "noEmit": true,
+    "ignoreDeprecations": "6.0"
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup';
+ 
+export default defineConfig({
+    format: ['cjs', 'esm'],
+    entry: ['./src/index.ts'],
+    dts: true,
+    shims: true,
+    skipNodeModulesBundle: true,
+    clean: true,
+});