JObfuscator — Obfuscation et protection du code source Java

JObfuscator est un obfuscateur de code source pour le langage de programmation Java. Il peut protéger votre code source Java et vos algorithmes contre le piratage, le cracking, le reverse engineering, la décompilation et le vol de technologie.

JObfuscator utilise une variété de techniques d'obfuscation pour protéger et dissimuler la véritable fonctionnalité de votre code source Java.

Il renomme toutes les variables et méthodes, obfusque le flux du code en le rendant non linéaire, et chiffre toutes les chaînes de caractères grâce à notre moteur polymorphe de pointe string encryption.

Plus de détails techniques, téléchargements et documentation disponibles sur :

https://www.pelock.com/products/jobfuscator

Il est disponible pour Windows et Linux (nécessite Mono) :

https://www.pelock.com/products/jobfuscator/download

Plusieurs API de programmation disponibles :

https://www.pelock.com/products/jobfuscator/api

Une interface d'obfuscation en ligne :

https://www.pelock.com/jobfuscator/

La décompilation Java est un problème majeur

Les applications écrites en Java et compilées aux formats JAR, WAR ou CLASS sont vulnérables à la décompilation.

Il existe un certain nombre de décompilateurs capables de recréer presque entièrement le code compilé en code source Java.

Le problème est que le code Java compilé est écrit sous forme de bytecode pour la JVM (par opposition au code natif du processeur comme x86 ou x86-64).

En plus d'être parfaitement documenté, cette forme de code permet une reproduction très précise des instructions d'origine en code source Java de haut niveau.

Que peuvent faire les décompilateurs Java ?

Regardez cet exemple :

Ceci est du code Java décompilé ! Tous les noms de variables, de propriétés et de méthodes sont lisibles. Vous pouvez même naviguer facilement dans tout le projet décompilé, en passant d'une classe à une autre.

Êtes-vous surpris ? Cela pourrait être votre logiciel analysé par la concurrence, des hackers, des crackers ou n'importe qui d'autre.

Vol de technologie et de propriété intellectuelle (PI)

Que pourraient-ils en faire ? La plupart du temps, le logiciel ou ses algorithmes sont volés ou répliqués dans des produits concurrents.

Dans d'autres cas, le logiciel est cracké, les vérifications de licence clairement visibles dans le code source décompilé sont patchées, ou même le logiciel cracké entier est recompilé et publié sur des sites pirates.

Obfuscation du code source Java

L'obfuscation est le processus de transformation du code source Java en une version protégée de lui-même.

La fonctionnalité reste inchangée, tout fonctionne de la même manière, mais le code source et le bytecode final compilé sont protégés contre l'analyse par reverse engineering, même après la décompilation.

Exemple de code source Java avant obfuscation```java

import java.util.; import java.lang.; import java.io.*;

// // you must include a custom annotation // to enable the entire class or a single // method obfuscation // @Obfuscate class Ideone { //@Obfuscate public static double calculateSD(double numArray[]) { double sum = 0.0, standardDeviation = 0.0; int length = numArray.length;

    for(double num : numArray) {
        sum += num;
    }

    double mean = sum/length;

    for(double num: numArray) {
        standardDeviation += Math.pow(num - mean, 2);
    }

    return Math.sqrt(standardDeviation/length);
}

//
// selective obfuscation strategies
// can be applied for the entire
// class or a single method (by
// default all obfuscation strategies
// are enabled when you use @Obfuscate
// annotation alone)
//
//@Obfuscate(
//  array_int_crypt = true,
//  array_char_crypt = true,
//  array_double_crypt = true,
//  array_string_crypt = true,
//  split_strings = true,
//  crypt_strings = true,
//  rename_methods = false,
//  shuffle_methods = true,
//  ints_math_crypt = true,
//  dbls_math_crypt = true,
//  rename_variables = true,
//  mix_code_flow = true,
//  string_char_vault = true,
//  ints_from_double_math = true,
//  opaque_mixer_chain = true,
//  complexify_booleans = true,
//  try_finally_noise = true,
//  ints_to_arrays = true,
//  dbls_to_arrays = true
// )
public static void main(String[] args) {

    double[] numArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    double SD = calculateSD(numArray);

    System.out.format("Standard Deviation = %.6f", SD);
}

}

### Le même code source Java après l'obfuscation```java
////////////////////////////////////////////////////////////////////////////////
//
// An output from JObfuscator v1.30 - Bartosz Wójcik
//
// Website   : https://www.pelock.com/products/jobfuscator
// Version   : v1.30
// Params    : /MixCodeFlow /RenMethods /RenVars /ShuffleMethods /ArrayIntCrypt
//             /ArrayDoubleCrypt /ArrayCharCrypt /ArrayStringCrypt
//             /IntsMathCrypt /DblsMathCrypt /StringSplit /CryptStr
//             /StringCharVault /IntsFromDoubleMath /OpaqueMixerChain
//             /ComplexifyBooleans /TryFinallyNoise /IntsToArray /DblsToArray
// New lines : Windows (CRLF - \r\n)
// Date      : 12.05.2026
//
////////////////////////////////////////////////////////////////////////////////

import java.util.*;
import java.lang.*;
import java.io.*;
import java.lang.Math.*;

class Ideone {