Showing posts with label java obfuscator. Show all posts
Showing posts with label java obfuscator. Show all posts

Wednesday, June 10, 2026

Java Obfuscator for Maven

JObfuscator is a modern Java obfuscator. It operates at the source code level & employs a range of obfuscation techniques to protect the code against decompilation, reverse engineering, and LLM analysis.

Java Obfuscator

How to use Java obfuscator?

The easiest way to use JObfuscator is via Maven pre-compiler plugin. Follow the steps to add JObfuscator to your Maven build workflow:

Step 1 - integrate into your Maven workflow

Add the plugin, annotation library and its settings to your application pom.xml, minimal configuration:


<?
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><!-- YOU-API-HERE or leave empty for DEMO VERSION --></jobfuscator.apiKey>
    <jobfuscator.version><!-- e.g. 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>


Step 2 - prepare your source codes

Annotate your sources to enable obfuscation in the build process:

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(
    //  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);
    }
}
And that's all! Just build your project like you did before. The obfuscation process is automated and fully invisible to you.

For more obfuscation features of the Maven plugin please refer to the official JObfuscator Maven Compiler documentation.

Wednesday, May 13, 2026

JObfuscator - Java Source Code Obfuscator

JObfuscator is a Java source code obfuscator. Obfuscate your Java source code & algorithms to protect it against reverse engineering analysis, LLMs, cracking and decompilation.

 JObfuscator has been updated with major changes

  • Online interface - https://www.pelock.com/jobfuscator/
  • Desktop & CLI - https://www.pelock.com/products/jobfuscator/download
  • SDK packages - https://www.pelock.com/products/jobfuscator/api
Desktop app window

JObfuscator Java Source Code Obfuscator


Engine history

v1.30 - 14.05.2026

  • A new obfuscation strategy. Encrypt all double values using floating point math functions from the java.lang.Math.* class.
  • A new obfuscation strategy. Rebuild string literals as runtime-created String objects from hidden char arrays.
  • A new obfuscation strategy. Represent selected integer values through equivalent double math expressions.
  • A new obfuscation strategy. Inject opaque mixer chains and unreachable guards to increase the amount of code decompilers have to analyze.
  • A new obfuscation strategy. Replace plain true and false literals with equivalent runtime expressions.
  • A new obfuscation strategy. Wrap selected safe statements in noisy try/finally blocks while preserving program behavior.
  • A new obfuscation strategy. Encrypt int array contents and decode them at runtime.
  • A new obfuscation strategy. Encrypt double arrays by hiding their values as encoded bit patterns.
  • A new obfuscation strategy. Encrypt char arrays and restore the original characters through generated decoder code.
  • A new obfuscation strategy. Encrypt String array elements and rebuild them while the program runs.
  • A new obfuscation strategy. Split eligible string literals into nested .concat(...) chains so decompilers face more tokens and local data-flow steps; it runs before polymorphic string encryption when both are enabled.
  • Updated the StringEncrypt engine with support for nested polymorphic loops in string encryption.
  • Updated the engine parser configuration to support Java 21 source code constructs.


Client history

v1.3 - 14.05.2026

  • Windows and Linux clients updated with all the new obfuscation strategies
  • Windows client runs the obfuscation process in background now
  • Drag & drop support added for faster Java file opening
  • Command line version supports wildcards now and can process many files at once
  • All the SDK packages updated

Tuesday, September 13, 2022

Java Source Code Obfuscator - JObfuscator

Obfuscate your Java source code & algorithms to protect it against reverse engineering analysis, cracking, and decompilation.

JObfuscator is a Java source code obfuscator to protect your work at the source code level. After compilation of the protected and obfuscated code - it will be extremely hard to reverse engineer the compiled bytecode, forget about Java decompilers!

Java Obfuscator - JObfuscator

Changes:

v1.10 - 09.08.2022
  • Fixed an error in the order of variable declarations when using obfuscation to change the linear path of code execution (thank you Yi Wu)
  • Automatically adding special annotation for IntelliJ IDE @SuppressWarnings(InstanceVariableMayNotBeInitialized) for the non-linear code path obfuscation

v1.09 - 06.02.2022
  • Fixed bug in annotation handling that caused string encryption obfuscation to work incorrectly
v1.08 - 19.10.2021
  • Fixed renaming methods within the same class
v1.07 - 17.08.2021
  • Improved integer to arrays obfuscation by generating multidimensional arrays e.g. int[][] var_3035 = { { 65535 }, { 01, 02, 0b0 } };
  • Improved doubles to arrays obfuscation by generating multidimensional arrays e.g. double[][][] O_ZzBf7_4tcNvh_c = { { { 2.8 } }, { { 1.3 } }, { { 0.06, 3.7, 65535.8 } } };

Saturday, July 31, 2021

Best Java Obfuscator?

Our Java Obfuscator - JObfuscator has been updated to include new Java obfuscation strategies.

Best Java Obfuscator - JObfuscator

Obfuscation engine history

v1.03 - 31.07.2021
  • Some integers were not extracted correctly for the integers to arrays obfuscation strategy
  • Multilevel obfuscation of extracted integers into the arrays (into a random number of double and integer arrays)
v1.02 - 30.07.2021
  • An integers to arrays obfuscation strategy, converts the integer values into double values to avoid deobfuscation by popular Java decompilers e.g. double[] var_2597 = new double[]{13.898355719807563D, 65535.73657403742D, ... };
v1.01 - 28.07.2021
  • A new obfuscation strategy. For each method, extract all possible integers from the code and store them in an array. It makes the analysis harder because it requires an indexed table lookup for every numeric value.

Client history


v1.01 - 28.07.2021
  • All clients (Windows, Linux) and SDKs (PHP & Python) updated to include the new obfuscation strategy /IntsToArrays

PowerShell Obfuscator & Virtualizer - How to Protect PowerShell Scripts

Looking for a PowerShell obfuscator that can protect .ps1 source without turning your automation into a maintenance nightmare? In this pos...