JObfuscator to mój obfuscator kodów źródłowych Javy. Największym minusem tego projektu zawsze było to, że wymagało używania zewnętrznych aplikacji, narzędzia online lub API do zabezpieczania kodów źródłowych. Do dzisiaj.

Nie było to najwygodniejsze rozwiązanie. Przyznaję bez bicia.

Myślałem o tym problemie od dawna i najlepszym rozwiązaniem, jakie mi wpadło do głowy, była wtyczka dla systemu Maven. Maven to standardowe narzędzie do budowy aplikacji bazujących na języku Java.

Automatyczna obfuskacja

I tak powstała wtyczka JObfuscator Maven Plugin.

Wtyczka JObfuscatora działa na zasadzie przedwstępnego kompilatora.

Kod źródłowy przed kompilacją poddawany jest automatycznej obfuskacji i dopiero te pliki wysyłane są do kompilatora javac.

Jak z tego skorzystać? Najpierw musisz mieć projekt kompatybilny z systemem Maven i odpowiednio zmodyfikować plik konfiguracyjny pom.xml, który definiuje wszystkie zależności i ustawienia.

Taka minimalna konfiguracja może wyglądać następująco:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.release>11</maven.compiler.release>
    <jobfuscator.apiKey><!-- TWOJ-KLUCZ-API lub pozostaw puste dla WERSJI DEMO --></jobfuscator.apiKey>
    <jobfuscator.version><!-- np. 1.0.3 --></jobfuscator.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>com.pelock</groupId>
      <artifactId>jobfuscator-annotations</artifactId>
      <version>${jobfuscator.version}</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>com.pelock</groupId>
        <artifactId>jobfuscator-maven-plugin</artifactId>
        <version>${jobfuscator.version}</version>
        <executions>
          <execution>
            <goals>
              <goal>obfuscate-sources</goal>
            </goals>
            <phase>generate-sources</phase>
          </execution>
        </executions>
        <configuration>
          <apiKey>${jobfuscator.apiKey}</apiKey>
          <enableCompression>true</enableCompression>
          <mixCodeFlow>true</mixCodeFlow>
          <renameVariables>true</renameVariables>
          <renameMethods>true</renameMethods>
          <shuffleMethods>true</shuffleMethods>
          <intsMathCrypt>true</intsMathCrypt>
          <cryptStrings>true</cryptStrings>
          <stringSplit>true</stringSplit>
          <intsToArrays>true</intsToArrays>
          <dblsToArrays>true</dblsToArrays>
          <dblsMathCrypt>true</dblsMathCrypt>
          <stringCharVault>true</stringCharVault>
          <intsFromDoubleMath>true</intsFromDoubleMath>
          <opaqueMixerChain>true</opaqueMixerChain>
          <complexifyBooleans>true</complexifyBooleans>
          <tryFinallyNoise>true</tryFinallyNoise>
          <selfCheck>true</selfCheck>
          <arrayIntCrypt>true</arrayIntCrypt>
          <arrayCharCrypt>true</arrayCharCrypt>
          <arrayDoubleCrypt>true</arrayDoubleCrypt>
          <arrayStringCrypt>true</arrayStringCrypt>
          <selfCheck>true</selfCheck>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.13.0</version>
        <configuration>
          <release>${maven.compiler.release}</release>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Modyfikacja źródeł

Do poprawnej obfuskacji potrzebne jest oznaczenie (tzw. annotation) na poziomie klasy czy metody, że w ogóle chcemy dokonać obfuskacji, dzięki czemu można dokładnie kontrolować co ma być poddane obfuskacji, z jakimi parametrami, a co ma być pominięte.

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

//
// MUSISZ dodać adnotację @Obfuscate do
// kodu, aby włączyć obfuskację na poziomie
// całej klasy lub pojedynczej metody
//
@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);
    }

    //
    // poszczególne strategie obfuskacji
    // mogą być włączane lub wyłączane
    // na poziomie całej klasy lub
    // pojedyncznej metody (domyślnie
    // wszystkie strategie obfuskacyjne
    // są włączone jeśli użyta jest
    // sama adnotacja @Obfuscate bez
    // wyszczególnionych strategii)
    //
    //@Obfuscate(
    //  ints_math_crypt = true,
    //  dbls_math_crypt = true,
    //  string_split = true,
    //  crypt_strings = true,
    //  string_char_vault = true,
    //  rename_methods = false,
    //  rename_variables = true,
    //  shuffle_methods = true,
    //  array_int_crypt = true,
    //  array_double_crypt = true,
    //  array_char_crypt = true,
    //  array_string_crypt = true,
    //  mix_code_flow = 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,
    //  self_check = 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);
    }
}

I tyle! Potem normalnie budujesz przez Mavena, a proces obfuskacji jest automatyczny.

Darmowy klucz aktywacyjny do potestowania F4FA-DCDD-58A7-9FE1

PS. A, zapomniałem dodać o nowej strategii obfuskacyjnej bazującej na refleksji w runtime i sprawdzaniu poprawności metod, pól i typów, tak żeby nie za łatwo dało się zdeobfuskować finalny kod.