JObfuscator — Offuscamento e protezione del codice sorgente Java

JObfuscator è un offuscatore di codice sorgente per il linguaggio di programmazione Java. Può proteggere il tuo codice sorgente Java e i tuoi algoritmi da hacking, cracking, reverse engineering, decompilazione e furto di tecnologia.

JObfuscator impiega una varietà di tecniche di offuscamento per proteggere e nascondere la reale funzionalità del tuo codice sorgente Java.

Rinomina tutte le variabili e i metodi, offusca il flusso del codice rendendolo non lineare e crittografa tutte le stringhe con il nostro motore polimorfico all'avanguardia di crittografia delle stringhe.

Maggiori dettagli tecnici, download e documentazione disponibili su:

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

È disponibile per Windows e Linux (richiede Mono):

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

Sono disponibili molteplici API di programmazione:

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

Un'interfaccia di offuscamento online:

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

La decompilazione Java è un problema enorme

Le applicazioni scritte in Java e compilate nei formati JAR, WAR o CLASS sono vulnerabili alla decompilazione.

Esistono numerosi decompilatori in grado di ricreare quasi completamente il codice compilato nel codice sorgente Java originale.

Il problema è che il codice Java compilato è scritto come cosiddetto bytecode per la JVM (a differenza del codice nativo della CPU come x86 o x86-64).

Oltre a essere perfettamente documentato, questa forma di codice consente una riproduzione molto accurata delle istruzioni originali in codice sorgente Java di alto livello.

Cosa possono fare i decompilatori Java?

Dai un'occhiata a questo esempio:

Questo è codice Java decompilato! Tutti i nomi di variabili, proprietà e metodi sono leggibili. Puoi persino navigare facilmente nell'intero progetto decompilato, passando da una classe all'altra.

Sei sorpreso? Potrebbe essere il tuo software analizzato dalla concorrenza, da hacker, cracker o chiunque altro.

Furto di tecnologia e proprietà intellettuale (IP)

Cosa potrebbero farci? Nella maggior parte dei casi, il software o i suoi algoritmi vengono rubati o replicati in prodotti concorrenti.

In altri casi, il software viene craccato, i controlli di licenza chiaramente visibili nel codice sorgente decompilato vengono patchati o persino l'intero software craccato viene ricompilato e pubblicato su siti pirata.

Offuscamento del codice sorgente Java

L'offuscamento è il processo di trasformazione del codice sorgente Java in una versione protetta di se stesso.

La funzionalità rimane invariata, tutto funziona allo stesso modo, ma il codice sorgente e il bytecode finale compilato sono protetti dall'analisi di reverse engineering, anche dopo la decompilazione.

Esempio di codice sorgente Java prima dell'offuscamento```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);
}

}

### Lo stesso codice sorgente Java dopo l'offuscamento```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 {