JObfuscator — Ofuscação e Proteção de Código-Fonte Java

JObfuscator é um ofuscador de código-fonte para a linguagem de programação Java. Ele pode proteger seu código-fonte Java e seus algoritmos contra hacking, cracking, engenharia reversa, descompilação e roubo de tecnologia.

O JObfuscator emprega uma variedade de técnicas de ofuscação para proteger e ocultar a verdadeira funcionalidade do seu código-fonte Java.

Ele renomeia todas as variáveis e métodos, ofusca o fluxo do código tornando-o não linear e criptografa todas as strings com nosso motor de criptografia de strings polimórfico de ponta.

Mais detalhes técnicos, downloads e documentação disponíveis em:

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

Está disponível para Windows e Linux (requer Mono):

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

Várias APIs de programação disponíveis:

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

Uma interface de ofuscação online:

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

A descompilação Java é um problema enorme

Aplicações escritas em Java e compiladas para os formatos JAR, WAR ou CLASS são vulneráveis à descompilação.

Existem vários descompiladores que podem recriar quase completamente o código compilado de volta ao código-fonte Java.

O problema é que o código Java compilado é escrito como um chamado bytecode para a JVM (em oposição ao código nativo da CPU, como x86 ou x86-64).

Além de ser perfeitamente documentado, essa forma de código permite uma reprodução muito precisa das instruções originais em código-fonte Java de alto nível.

O que os descompiladores Java podem fazer?

Dê uma olhada neste exemplo:

Este é um código Java descompilado! Todos os nomes de variáveis, propriedades e métodos estão legíveis. Você pode até navegar facilmente por todo o projeto descompilado, saltando de uma classe para outra.

Está surpreso? Poderia ser o seu software analisado pela concorrência, hackers, crackers ou qualquer outra pessoa.

Roubo de Tecnologia e Propriedade Intelectual (PI)

O que eles poderiam fazer com isso? Na maioria das vezes, o software ou seus algoritmos são roubados ou replicados em produtos concorrentes.

Em outros casos, o software é crackeado, verificações de licença claramente visíveis no código-fonte descompilado são corrigidas ou até mesmo todo o software crackeado é recompilado e publicado em sites de pirataria.

Ofuscação de código-fonte Java

A ofuscação é o processo de transformar o código-fonte Java em uma versão protegida de si mesmo.

A funcionalidade permanece inalterada, tudo funciona da mesma forma, mas o código-fonte e o bytecode final compilado são protegidos contra análises de engenharia reversa, mesmo após a descompilação.

Exemplo de código-fonte Java antes da ofuscação```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);
}

}

### O mesmo código-fonte Java após a ofuscação```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 {