Pembatas

Node.js CI

Deobfuscate Javascript dan rekonstruksi string. Sederhanakan logika yang rumit jika memungkinkan sambil tetap mematuhi batasan cakupan.

Cobalah secara online @ restringer.tech.

Untuk komentar dan saran, jangan ragu untuk membuka terbitan atau temukan saya di Twitter - @ctrl__esc

Daftar isi

Instalasi
- npm
- Kloning Repo
Penggunaan
- Penggunaan Baris Perintah
- Gunakan sebagai Modul
Buat Deobfuscator Kustom
- Kode Boilerplate untuk Memulai dari Awal
Baca selengkapnya

Instalasi

npm

npm install -g restringer

Kloning Repo

Membutuhkan Node 16 atau lebih baru.

git clone [email protected]:PerimeterX/restringer.git
cd restringer
npm install

Penggunaan

restringer.js menggunakan metode deobfuscation umum yang merekonstruksi dan memulihkan string yang dikaburkan dan menyederhanakan logika redundan yang dimaksudkan hanya untuk membebani. REstringer menggunakan Obfuscation Detector untuk mengidentifikasi jenis kebingungan tertentu yang memerlukan penerapan metode deobfuscation tertentu untuk menghindari mekanisme anti-debugging atau jebakan kode lain yang mencegah deobfuscating skrip.

Penggunaan Baris Perintah

 Usage: restringer input_filename [-h] [-c] [-q | -v] [-m M] [-o [output_filename]]

positional arguments:
	input_filename                  The obfuscated JS file

optional arguments:
	-h, --help                      Show this help message and exit.
	-c, --clean                     Remove dead nodes from script after deobfuscation is complete (unsafe).
	-q, --quiet                     Suppress output to stdout. Output result only to stdout if the -o option is not set.
									Does not go with the -v option.
	-m, --max-iterations M          Run at most M iterations
	-v, --verbose                   Show more debug messages while deobfuscating. Does not go with the -q option.
	-o, --output [output_filename]  Write deobfuscated script to output_filename. 
									<input_filename>-deob.js is used if no filename is provided.

Contoh:

Cetak skrip yang tidak dikaburkan ke stdout.
```
 restringer [target-file.js]
```
Simpan skrip yang tidak dikaburkan ke output.js.
```
 restringer [target-file.js] -o output.js
```
Deobfuscate dan cetak info debug.
```
 restringer [target-file.js] -v
```
Deobfuscate tanpa mencetak apa pun kecuali output yang dideobfuscate.
```
 restringer [target-file.js] -q
```

Gunakan sebagai Modul

 import { REstringer } from 'restringer' ;

const restringer = new REstringer ( '"RE" + "stringer"' ) ;
if ( restringer . deobfuscate ( ) ) {
  console . log ( restringer . script ) ;
} else {
  console . log ( 'Nothing was deobfuscated :/' ) ;
}
// Output: 'REstringer';

Buat Deobfuscator Khusus

REstringer sangat termodulasi. Ini memperlihatkan modul yang memungkinkan pembuatan deobfuscator khusus yang dapat memecahkan masalah tertentu.

Struktur dasar deobfuscator tersebut akan berupa serangkaian modul deobfuscation (baik aman atau tidak aman), dijalankan melalui fungsi utilitas applyIteratively flAST.

Modul yang tidak aman menjalankan kode melalui eval (menggunakan terisolasi-vm agar aman) sedangkan modul yang aman tidak.

 import { applyIteratively } from 'flast' ;
import { safe , unsafe } from 'restringer' ;
const { normalizeComputed } = safe ;
const { resolveDefiniteBinaryExpressions , resolveLocalCalls } = unsafe ;
let script = 'obfuscated JS here' ;
const deobModules = [
  resolveDefiniteBinaryExpressions ,
  resolveLocalCalls ,
  normalizeComputed ,
] ;
script = applyIteratively ( script , deobModules ) ;
console . log ( script ) ; // Deobfuscated script

Dengan argumen fungsi candidateFilter tambahan, dimungkinkan untuk mempersempit node yang ditargetkan:

 import { unsafe } from 'restringer' ;
const { resolveLocalCalls } = unsafe ;
import { applyIteratively } from 'flast' ;
let script = 'obfuscated JS here' ;

// It's better to define a function with a meaningful name that can show up in the log 
function resolveLocalCallsInGlobalScope ( arb ) {
  return resolveLocalCalls ( arb , n => n . parentNode ?. type === 'Program' ) ;
}
script = applyIteratively ( script , [ resolveLocalCallsInGlobalScope ] ) ;
console . log ( script ) ; // Deobfuscated script

Anda juga dapat menyesuaikan metode deobfuscation apa pun saat masih menggunakan REstringer tanpa menjalankan loop sendiri:

 import fs from 'node:fs' ;
import { REstringer } from 'restringer' ;

const inputFilename = process . argv [ 2 ] ;
const code = fs . readFileSync ( inputFilename , 'utf-8' ) ;
const res = new REstringer ( code ) ;

// res.logger.setLogLevelDebug();
res . detectObfuscationType = false ;  // Skip obfuscation type detection, including any pre and post processors

const targetFunc = res . unsafeMethods . find ( m => m . name === 'resolveLocalCalls' ) ;
let changes = 0 ;		// Resolve only the first 5 calls
res . safeMethods [ res . unsafeMethods . indexOf ( targetFunc ) ] = function customResolveLocalCalls ( n ) { return targetFunc ( n , ( ) => changes ++ < 5 ) }

res . deobfuscate ( ) ;

if ( res . script !== code ) {
  console . log ( '[+] Deob successful' ) ;
  fs . writeFileSync ( ` ${ inputFilename } -deob.js` , res . script , 'utf-8' ) ;
} else console . log ( '[-] Nothing deobfuscated :/' ) ;

Kode boilerplate untuk memulai dari awal

 import { applyIteratively , logger } from 'flast' ;
// Optional loading from file
// import fs from 'node:fs';
// const inputFilename = process.argv[2] || 'target.js';
// const code = fs.readFileSync(inputFilename, 'utf-8');
const code = `(function() {
  function createMessage() {return 'Hello' + ' ' + 'there!';}
  function print(msg) {console.log(msg);}
  print(createMessage());
})();` ;

logger . setLogLevelDebug ( ) ;

/**
 * Replace specific strings with other strings
 * @param {Arborist} arb
 * @return {Arborist}
 */
function replaceSpecificLiterals ( arb ) {
	const replacements = {
        'Hello' : 'General' ,
        'there!' : 'Kenobi!' ,
    } ;
    // Iterate over only the relevant nodes by targeting specific types using the typeMap property on the root node
	const relevantNodes = [
		... ( arb . ast [ 0 ] . typeMap . Literal || [ ] ) ,
        // ...(arb.ast.typeMap.TemplateLiteral || []), // unnecessary for this example, but this is how to add more types
    ] ;
    for ( const n of relevantNodes ) {
        if ( replacements [ n . value ] ) {
          // dynamically define a replacement node by creating an object with a type and value properties
          // markNode(n) would delete the node, while markNode(n, {...}) would replace the node with the supplied node.
          arb . markNode ( n , { type : 'Literal' , value : replacements [ n . value ] } ) ;
        }
    }
  return arb ;
}

let script = code ;

script = applyIteratively ( script , [
  replaceSpecificLiterals ,
] ) ;

if ( code !== script ) {
  console . log ( script ) ;
  // fs.writeFileSync(inputFilename + '-deob.js', script, 'utf-8');
} else console . log ( `No changes` ) ;