Restringeur

Node.js CI

Désobstruez Javascript et reconstruisez les chaînes. Simplifiez la logique lourde lorsque cela est possible tout en respectant les limites de la portée.

Essayez-le en ligne @ restringer.tech.

Pour des commentaires et des suggestions, n'hésitez pas à ouvrir un numéro ou à me retrouver sur Twitter - @ctrl__esc

Table des matières

Installation
- npm
- Cloner le dépôt
Usage
- Utilisation de la ligne de commande
- Utiliser comme module
Créer des désobfuscateurs personnalisés
- Code passe-partout pour repartir de zéro
En savoir plus

Installation

npm

npm install -g restringer

Cloner le dépôt

Nécessite le nœud 16 ou une version plus récente.

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

Usage

Le restringer.js utilise des méthodes génériques de désobfuscation qui reconstruisent et restaurent les chaînes obscurcies et simplifient la logique redondante destinée uniquement à encombrer. REstringer utilise le détecteur d'obfuscation pour identifier les types spécifiques d'obscurcissement pour lesquels il est nécessaire d'appliquer des méthodes de désobscurcissement spécifiques afin de contourner les mécanismes anti-débogage ou d'autres pièges de code empêchant la désobscurcissement du script.

Utilisation de la ligne de commande

 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.

Exemples :

Imprimez le script désobfusqué sur la sortie standard.
```
 restringer [target-file.js]
```
Enregistrez le script désobfusqué dans output.js.
```
 restringer [target-file.js] -o output.js
```
Désobscurcir et imprimer les informations de débogage.
```
 restringer [target-file.js] -v
```
Désobfusquer sans rien imprimer d'autre que la sortie désobfusquée.
```
 restringer [target-file.js] -q
```

Utiliser comme module

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

Créer des désobfuscateurs personnalisés

REstringer est hautement modularisé. Il expose des modules qui permettent de créer des désobscurcisseurs personnalisés capables de résoudre des problèmes spécifiques.

La structure de base d'un tel désobfuscateur serait un ensemble de modules de désobscurcissement (sûrs ou non sécurisés), exécutés via la fonction utilitaire applyIteratively de flAST.

Les modules non sécurisés exécutent le code via eval (en utilisant isolated-vm pour être du côté de la sécurité), contrairement aux modules sûrs.

 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

Avec l'argument supplémentaire de la fonction candidateFilter , il est possible d'affiner les nœuds ciblés :

 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

Vous pouvez également personnaliser n'importe quelle méthode de désobscurcissement tout en utilisant REstringer sans exécuter la boucle vous-même :

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

Code passe-partout pour repartir de zéro

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