リストリンガー

Node.js CI

JavaScript の難読化を解除し、文字列を再構築します。スコープの制限を守りながら、可能な限り煩雑なロジックを簡素化します。

オンライン @restringer.tech でお試しください。

コメントや提案が必要な場合は、お気軽に問題を開くか、Twitter (@ctrl__esc) で私を見つけてください。

インストール

npm

npm install -g restringer

リポジトリのクローンを作成する

ノード 16 以降が必要です。

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

使用法

restringer.js は、難読化された文字列を再構築して復元する汎用の難読化解除メソッドを使用し、邪魔になるだけの冗長なロジックを簡素化します。 REstringer は、難読化検出機能を使用して、スクリプトの難読化解除を妨げるデバッグ対策メカニズムやその他のコードトラップを回避するために、特定の難読化解除メソッドを適用する必要がある特定の種類の難読化を識別します。

コマンドラインの使用法

 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.

例:

難読化を解除したスクリプトを標準出力に出力します。
```
 restringer [target-file.js]
```
難読化を解除したスクリプトをoutput.jsに保存します。
```
 restringer [target-file.js] -o output.js
```
難読化を解除してデバッグ情報を出力します。
```
 restringer [target-file.js] -v
```
難読化解除された出力以外は何も出力せずに難読化を解除します。
```
 restringer [target-file.js] -q
```

モジュールとして使用する

 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';

カスタムの難読化解除ツールを作成する

REstringer は高度にモジュール化されています。特定の問題を解決できるカスタムの難読化解除ツールを作成できるモジュールを公開します。

このような難読化解除ツールの基本構造は、flAST の applyIteratively ユーティリティ関数を介して実行される難読化解除モジュール (安全または安全でない) の配列になります。

安全でないモジュールはevalを通じてコードを実行しますが (安全側になるように孤立した VM を使用します)、安全なモジュールは実行しません。

 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

追加のcandidateFilter関数引数を使用すると、対象のノードを絞り込むことができます。

 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

自分でループを実行せずに REstringer を使用しながら難読化解除メソッドをカスタマイズすることもできます。

 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 :/' ) ;

ゼロから始めるための定型コード

 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` ) ;