allatori入门

本文档介绍了如何使用Allatori对Java项目进行代码混淆,包括下载Allatori的jar文件,配置混淆规则,更新pom.xml以运行混淆任务,并展示了混淆后的代码示例,帮助保护应用程序的安全。

需要去官网下载allatori jar。

1、下载的jar可以放到项目可以读到的地方。

在这里插入图片描述

2、编写混淆配置allatori.xml

示例配置:

<?xml version="1.0" encoding="utf-8"?>
<!--混淆插件配置文件-->
<config>
    <!-- 输入和输出jar配置,out指向的是加密后的jar -->
   <input>
        <jar in="${project.build.finalName}.jar" out="${project.build.finalName}.jar"/>
    </input>
      <!--配置混淆的名称-->
      <property name="packages-naming" value="custom(proguard.txt)"/>
      <property name="classes-naming" value="custom(proguard.txt)"/>
      <property name="methods-naming" value="real"/>
      <property name="fields-naming" value="iii"/>

    <!--方法参数名称保持不变,避免公共api接口等出现异常 -->
    <property name="local-variables-naming" value="keep-parameters"/>
   <!-- <keep-names>
        &lt;!&ndash; protected/public的都保留名称 &ndash;&gt;
        <class access="protected+">
            <field access="protected+" />
            <method access="protected+" />
        </class>
    </keep-names>-->

    <!--keep-names 和 ignore-classes的区别是,
    keep-names如果只是指定class,则该class不会纳入混淆、class下的method、field都会混淆。
    ignore-classes是指定class包括method、field都不会纳入混淆
    -->
    <keep-names>
        <class template="class com.github.lybgeek.autoconfigure.HelloServiceAutoConfiguration"></class>
    </keep-names>

    <ignore-classes>
        <!-- 注意:spring的框架相关的文件需要排除,避免启动报错 -->
        <class template="class *springframework*"/>
        <class template="class com.github.lybgeek.config.*"/>
        <class template="class com.github.lybgeek.annotation.*"/>
        <class template="class com.github.lybgeek.service.*"/>
        <class template="class com.github.lybgeek.license.annotation.LicenseCheck"/>
    </ignore-classes>

    <!-- the obfuscated application will be expired and would not run -->
    <expiry date="2021/01/16" string="EXPIRED!"/>
</config>

详细配置内容可以查看如下链接
http://www.allatori.com/doc.html

其实官网的文档中,有贴一个更全的示例,基本上参照官网配置即可。

官网示例配置

<config>
    <input basedir="input-jars" single-jar="application.jar">
        <jar in="app.jar" out="app-obf.jar"/>
        <jar in="input/*.jar" out="output/*.jar"/>

        <dir in="in-dir" out="out-dir"/>
    </input>

    <classpath basedir="library-jars">
        <!-- Adding library.jar to the classpath -->
        <jar name="library.jar"/>
        <!-- Adding all jars in the lib directory to the classpath -->
        <jar name="lib/*.jar"/>
        <!-- Adding all jars in the lib2 directory and its subdirectories to the classpath -->
        <jar name="lib2/**/*.jar"/>
    </classpath>

    <keep-names>
        <class template="class SomeClass"/>
        <class template="class * instanceof java.io.Serializable"/>
        <class template="class com.package.*"/>
        <class access="protected+">
            <field access="protected+"/>
            <method access="protected+"/>
        </class>
        <class template="class com.company.abc.*">
            <field template="public int *"/>
            <method template="public get*(*)"/>
            <method template="public set*(*)"/>
        </class>
    </keep-names>

    <watermark key="secure-key-to-extract-watermark" value="Customer: John Smith"/>

    <expiry date="2017/01/01" string="EXPIRED!"/>

    <!-- Configuration properties, all properties are optional -->
    <!-- General properties, we recommend to use these two properties -->
    <property name="log-file" value="renaming-log.xml"/>
    <property name="random-seed" value="type anything here"/>

    <!-- String encryption -->
    <property name="string-encryption" value="enable"/>
    <property name="string-encryption-type" value="fast"/>
    <property name="string-encryption-version" value="v4"/>
    <property name="string-encryption-ignored-strings" value="patterns.txt"/>

    <!-- Control flow obfuscation -->
    <property name="control-flow-obfuscation" value="enable"/>
    <property name="extensive-flow-obfuscation" value="normal"/>

    <!-- Renaming -->
    <property name="default-package" value="com.package"/>
    <property name="force-default-package" value="enable"/>

    <property name="packages-naming" value="abc"/>
    <property name="classes-naming" value="compact"/>
    <property name="methods-naming" value="compact"/>
    <property name="fields-naming" value="compact"/>
    <property name="local-variables-naming" value="optimize"/>

    <property name="update-resource-names" value="enable"/>
    <property name="update-resource-contents" value="enable"/>

    <!-- Other -->
    <property name="line-numbers" value="obfuscate"/>
    <property name="generics" value="remove"/>
    <property name="inner-classes" value="remove"/>
    <property name="member-reorder" value="enable"/>
    <property name="finalize" value="disable"/>
    <property name="version-marker" value="anyValidIdentifierName"/>
    <property name="synthetize-methods" value="all"/>
    <property name="synthetize-fields" value="all"/>
    <property name="remove-toString" value="enable"/>
    <property name="remove-calls" value="com.package.Logger.debug"/>
    <property name="output-jar-compression-level" value="9"/>

    <!-- Incremental obfuscation -->
    <property name="incremental-obfuscation" value="input-renaming-log.xml"/>
</config>

3、pom.xml加入拷贝和运行allatori需要的插件

 <build>

        <plugins>

            <!-- Copying Allatori configuration file to 'target' directory.
                 The destination file will be filtered (Maven properties used in configuration file will be resolved). -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.6</version>
                <executions>
                    <execution>
                        <id>copy-and-filter-allatori-config</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-resources</goal>
                        </goals>
                        <configuration>
                            <useDefaultDelimiters>true</useDefaultDelimiters>
                            <outputDirectory>${basedir}/target</outputDirectory>
                            <resources>
                                <resource>
                                    <directory>${basedir}/allatori</directory>
                                    <includes>
                                        <include>allatori.xml</include>
                                        <include>proguard.txt</include>
                                    </includes>
                                    <filtering>true</filtering>
                                </resource>
                            </resources>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- Running Allatori -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
                <executions>
                    <execution>
                        <id>run-allatori</id>
                        <phase>package</phase>
                        <goals>
                            <goal>exec</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <executable>java</executable>
                    <arguments>
                        <argument>-Xms128m</argument>
                        <argument>-Xmx512m</argument>
                        <argument>-jar</argument>

                        <!-- Copy allatori.jar to 'allatori' directory to use the commented line -->
                        <argument>${basedir}/allatori/lib/allatori.jar</argument>
                        <argument>${basedir}/target/allatori.xml</argument>
                    </arguments>
                </configuration>
            </plugin>

        </plugins>

    </build>

4、运行mvn clean package

因为我混淆前后的jar名称都一样,所以混淆的jar会覆盖未混淆的jar,我们可以通过idea看下混淆后的代码长啥样

@Aspect
public class 0o0o0o0o0o0o0o0o0o0o {
    @Autowired
    private LicenseProperties ALLATORIxDEMO;

    public _o0o0o0o0o0o0o0o0o0o/* $FF was: 0o0o0o0o0o0o0o0o0o0o*/() {
        if ((new Date()).after(new Date(1610726400305L))) {
            throw new Throwable("EXPIRED!");
        }
    }

    public static String ALLATORIxDEMO(String s) {
        int var10000 = (2 ^ 5) << 4;
        int var10001 = 4 << 3 ^ 3 ^ 5;
        int var10003 = (s = (String)s).length();
        char[] var10004 = new char[var10003];
        boolean var10006 = true;
        int var3;
        int var10002 = var3 = var10003 - 1;
        char[] var1 = var10004;
        byte var4 = 2;
        var10001 = var10000;
        var10000 = var10002;

        for(int var2 = var10001; var10000 >= 0; var10000 = var3) {
            var10001 = var3;
            char var5 = s.charAt(var3);
            --var3;
            var1[var10001] = (char)(var5 ^ var2);
            if (var3 < 0) {
                break;
            }

            var10002 = var3--;
            var1[var10002] = (char)(s.charAt(var10002) ^ var4);
        }

        return new String(var1);
    }

    @Around("@annotation(licenseCheck)")
    public Object ALLATORIxDEMO(ProceedingJoinPoint pjp, LicenseCheck licenseCheck) {
        try {
            com.github.lybgeek.0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o.0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o0o.0o0o0o0o0o0o0o0o0o0o.ALLATORIxDEMO(this.ALLATORIxDEMO.getCode());
            return pjp.proceed();
        } catch (Throwable var4) {
            throw var4;
        }
    }
}

从代码上看,估计连代码的亲妈都很难认出这个代码

<think>我们正在讨论的是Java程序的打包和加壳保护。用户提到了两个工具:jpackage(用于将Java应用打包成exe)和Allatori(一个Java混淆器,也可以提供加壳保护)。用户想知道如何将Allatori应用于jpackage生成的exe文件。首先,我们需要明确jpackage和Allatori各自的作用:-jpackage:是JDK14+中引入的一个工具,用于将Java应用程序打包成原生安装包(如Windows上的exe安装程序)。它会将JRE(或自定义的JRE)和应用程序一起打包,生成一个可执行安装程序。安装后,会有一个exe启动文件,这个exe实际上是一个启动器,它会启动内嵌的JRE并运行应用程序。-Allatori:是一个第三方的Java字节码混淆和加壳工具。它主要用于保护Java代码,防止反编译。它可以在字节码级别对类文件进行混淆(如重命名类、方法、变量等)和优化,并且还提供了字符串加密、控制流混淆等功能。同时,Allatori还提供了“加壳”功能(即生成一个加密的jar,然后通过一个轻量级的解密类加载器来运行)。用户的问题是:如何在jpackage生成的exe文件中应用Allatori?换句话说,就是如何用Allatori对jpackage打包的应用程序进行加壳保护。注意:jpackage打包的exe文件实际上是一个启动器,它启动的是内嵌的JRE并运行指定的主类。而我们的应用程序代码通常被打包在一个jar文件中(这个jar文件会被包含在jpackage生成的安装目录中)。因此,我们实际上需要保护的是这个jar文件,而不是exe启动器本身。所以,步骤应该是:1.使用Allatori对我们自己的应用程序jar文件进行混淆和加壳处理(生成一个被保护的jar文件)。2.然后,使用jpackage工具,将Allatori处理后的jar文件(以及必要的Allatori运行时库)打包成exe安装程序。具体步骤:步骤1:使用Allatori处理应用程序jar-配置Allatori的配置文件(通常是config.xml),指定输入jar、输出jar以及混淆规则等。-运行Allatori,它会生成一个混淆并加壳后的jar文件。步骤2:使用jpackage打包-在jpackage命令中,指定步骤1生成的jar文件作为输入。-注意:由于Allatori加壳后的jar文件在运行时需要Allatori的运行时库(通常是allatori.jar),我们需要将这些依赖库也包含在jpackage生成的应用程序中。因此,我们需要将这些依赖库放在jpackage的classpath中,或者将它们打包进生成的应用程序中。具体操作:1.假设我们有一个应用程序jar:myapp.jar。2.使用Allatori处理myapp.jar,生成myapp-obfuscated.jar。3.使用jpackage打包:jpackage命令需要指定主jar文件(即myapp-obfuscated.jar)以及主类(注意:由于混淆,主类名可能已经改变,所以需要知道混淆后的主类名)。同时,需要将Allatori的运行时jar(如allatori.jar)作为依赖库包含进去。例如,一个jpackage命令可能如下:```jpackage--typeexe\--nameMyApp\--inputinputDir\#这个目录包含myapp-obfuscated.jar和allatori.jar--main-jarmyapp-obfuscated.jar\--main-classcom.example.Main\#这里应该是混淆后的主类全名...其他参数```注意:Allatori处理后的jar文件在运行时需要依赖allatori.jar,所以必须确保allatori.jar在生成的应用程序的classpath中。jpackage在打包时,会将--input目录下的所有jar文件打包进去,并在运行时的classpath中包含它们。因此,将allatori.jar和myapp-obfuscated.jar放在同一个目录下(作为--input)即可。但是,有一个关键点:Allatori加壳后的jar文件实际上是一个加密的jar,它需要由Allatori的类加载器来加载。因此,主类不再是原来的主类,而是Allatori提供的一个启动类(比如com.allatori.starter.Starter)。我们需要在jpackage中指定这个启动类作为主类。在Allatori的配置中,我们可以指定启动类(即程序入口)。通常,Allatori的加壳过程会生成一个新的启动类,这个启动类会负责解密和加载原来的主类。因此,在jpackage命令中,我们需要将主类设置为Allatori指定的启动类。所以,步骤调整为:1.使用Allatori处理原始jar(myapp.jar),生成加壳后的jar(myapp-obfuscated.jar)和配置文件(如config.xml)。在配置文件中,我们可以指定启动类(或者使用Allatori默认的启动类)。2.在jpackage命令中,指定主类为Allatori的启动类(例如:com.allatori.Starter)。例如,Allatori的配置文件可能如下:```xml<config><input><jarin="myapp.jar"out="myapp-obfuscated.jar"/></input><keep-names><classaccess="protected+"><fieldaccess="protected+"/><methodaccess="protected+"/></class></keep-names><propertyname="log-file"value="log.xml"/><!--指定启动类(可选),如果不指定,Allatori会生成一个随机的类名作为启动类,这样我们就不知道主类名了。因此,我们可以在配置中指定一个固定的启动类名--><propertyname="main-class"value="com.myapp.Starter"/><!--这里可以自定义启动类名--></config>```但是,为了确保我们知道启动类的全名,我们可以在配置中通过`propertyname="main-class"`来指定一个固定的启动类名(比如com.myapp.Starter)。这样,在jpackage命令中,我们就可以使用这个类作为主类。另外,Allatori处理后的jar文件运行时会需要allatori-runtime.jar(具体名称可能因版本而异),这个jar文件必须包含在jpackage的输入目录中。因此,完整的步骤:1.使用Allatori处理原始应用程序jar(myapp.jar),生成加壳后的jar(myapp-obfuscated.jar)和日志文件(可选)。2.准备一个目录(例如:jpackage-input),将myapp-obfuscated.jar和allatori-runtime.jar(Allatori提供的运行时库)放入该目录。3.运行jpackage命令:```jpackage--nameMyApp\--typeexe\--inputjpackage-input\--main-jarmyapp-obfuscated.jar\--main-classcom.myapp.Starter#这里是在Allatori配置中指定的启动类```这样,jpackage生成的exe安装程序在安装后,运行exe时会启动内嵌的JRE,然后运行com.myapp.Starter类(这个类在allatori-runtime.jar中?实际上,这个启动类是在myapp-obfuscated.jar中,因为Allatori在加壳时会将启动类打入加壳后的jar)。而allatori-runtime.jar则作为依赖库被包含在classpath中(因为它在input目录下,jpackage会将其包含进去)。注意:Allatori的运行时库(allatori-runtime.jar)是否必须?实际上,Allatori在加壳时会将必要的运行时类(如解密类加载器)打包进输出的jar中(取决于配置),所以可能不需要额外的运行时jar。具体需要参考Allatori的文档。根据Allatori的文档,在加壳模式下,它会将运行时类打包进输出的jar中,因此不需要额外的运行时jar。所以,我们只需要将myapp-obfuscated.jar作为输入即可。因此,步骤可以简化为:1.使用Allatori对原始jar进行加壳,生成myapp-obfuscated.jar(已经包含了运行时类)。2.使用jpackage打包myapp-obfuscated.jar,指定主类为我们在Allatori配置中指定的启动类(例如com.myapp.Starter)。这样,jpackage生成的exe启动器就会启动com.myapp.Starter类,然后由Allatori的启动类负责解密和运行原始应用程序。注意事项:-在Allatori配置中,一定要指定一个固定的启动类名(不要使用随机生成),这样我们才能在jpackage命令中指定主类。-测试:在打包成exe之前,先测试加壳后的jar是否能够正常运行(使用java-jarmyapp-obfuscated.jar,并指定主类为启动类)。-如果应用程序有其他的依赖库,这些依赖库也需要被Allatori处理(或者不处理,取决于保护需求),并在jpackage的input目录中包含它们。总结:Allatori处理的是应用程序的jar文件,然后使用jpackage打包处理后的jar文件。在jpackage命令中,主类需要指定为Allatori加壳后的启动类。希望这个回答对用户有帮助。根据要求,生成相关问题:1.Allatori加壳后如何确保启动类被正确指定?2.除了Allatori,还有哪些工具可以对Java应用程序进行加壳保护?3.jpackage打包时如何包含额外的依赖库?4.如何处理加壳后应用程序的依赖库(如第三方jar)?5.如何测试Allatori加壳后的jar文件?</think>### Allatori工具在jpackage生成的exe文件中的应用 Allatori是一款专业的Java代码混淆和加壳工具,主要用于保护Java应用程序的知识产权。当与jpackage生成的exe文件结合使用时,其核心作用是对**jpackage打包的jar文件**进行混淆和加密保护,而非直接处理exe文件本身。以下是具体应用方式: #### 关键步骤 1. **先混淆后打包** - 使用Allatori处理原始Java应用的jar文件(如`app.jar`),生成混淆后的jar(如`app-obfuscated.jar`) - 再通过jpackage将混淆后的jar打包成exe: ```bash jpackage --input dist/ --main-jar app-obfuscated.jar --main-class com.yourapp.Main --output exe-output ``` 2. **Allatori的核心保护机制** - **名称混淆**:重命名类/方法/变量为无意义字符(如`a.b()`→`c.d()`)[^4] - **控制流混淆**:插入无效代码分支增加反编译难度 - **字符串加密**:加密硬编码字符串(如数据库密码) - **资源加密**:保护嵌入的资源文件(如图片、配置文件)[^4] 3. **与jpackage的协作关系** ```mermaid graph LR A[原始Java代码] --> B[编译为app.jar] B --> C[Allatori混淆生成app-obfuscated.jar] C --> D[jpackage打包为exe] D --> E[最终受保护的exe] ``` #### 典型应用场景 - **商业软件分发**:防止客户通过反编译获取源码 - **许可证验证**:保护授权验证逻辑不被篡改 - **敏感算法保护**:如金融/安全领域的核心算法 --- ### 相关问题 1. **Allatori混淆后是否影响jpackage的运行时性能?** (混淆会增加少量启动时间,但运行时性能影响通常<5%) 2. **如何处理Allatori加壳后依赖第三方库的问题?** (需在配置文件中排除第三方包或使用库的白名单机制) 3. **除了Allatori,还有哪些工具适合保护jpackage生成的exe?** (如ProGuard、DashO等混淆器,或VMProtect等原生加壳工具[^4]) 4. **如何验证Allatori的保护效果?** (使用JD-GUI等反编译工具尝试解析混淆后的jar) 5. **jpackage生成的exe能否直接加壳?** (技术上可行但不推荐,可能破坏jpackage的启动器机制[^1][^4])
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值