精华内容
下载资源
问答
  • java maven 混淆打包

    千次阅读 2018-06-30 14:37:50
    <plugin> <groupId>com.github.wvengen&...proguard-maven-plugin</artifactId> <executions> <execution> &lt
    <plugin>
        <groupId>com.github.wvengen</groupId>
        <artifactId>proguard-maven-plugin</artifactId>
        <executions>
            <execution>
                <!-- 混淆时刻,这里是打包的时候混淆-->
                <phase>package</phase>
                <goals>
                    <!-- 使用插件的什么功能,当然是混淆-->
                    <goal>proguard</goal>
                </goals>
            </execution>
        </executions>
        <configuration>
            <!-- 是否将生成的PG文件安装部署-->
            <attach>true</attach>
            <!-- 是否混淆-->
            <obfuscate>true</obfuscate>
            <!-- 指定生成文件分类 -->
            <attachArtifactClassifier>pg</attachArtifactClassifier>
            <options>
                <!-- JDK目标版本1.8-->
                <option>-target 1.8</option>
                <!-- 不做收缩(删除注释、未被引用代码)-->
                <option>-dontshrink</option>
                <!-- 不做优化(变更代码实现逻辑)-->
                <option>-dontoptimize</option>
                <!-- 不路过非公用类文件及成员-->
                <option>-dontskipnonpubliclibraryclasses</option>
                <option>-dontskipnonpubliclibraryclassmembers</option>
                <!--不用大小写混合类名机制-->
                <option>-dontusemixedcaseclassnames</option>
    
                <!-- 优化时允许访问并修改有修饰符的类和类的成员 -->
                <option>-allowaccessmodification</option>
                <!-- 确定统一的混淆类的成员名称来增加混淆-->
                <option>-useuniqueclassmembernames</option>
                <!-- 不混淆所有包名-->
                <!--<option>-keeppackagenames</option>-->
    
                <!-- 需要保持的属性:异常,注解等-->
                <option>-keepattributes Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LocalVariable*Table,*Annotation*,Synthetic,EnclosingMethod</option>
                <!-- 不混淆所有的set/get方法-->
                <option>-keepclassmembers public class * {void set*(***);*** get*();}</option>
    
                <!--不混淆包下的所有类名,且类中的方法也不混淆-->
                <!--<option>-keep class com.xxx.xxx.bboss.SystemConfig { <methods> }</option>
                   <option>-keep class com.xxx.xxx.framework.** { *; }</option>
                   <option>-keep class com.xxx.xxx.xxx.controller.** { <methods> }</option>
                   <option>-keep class com.xxx.xxx.xxx.dao.** { <methods> }</option>
                   <option>-keep class com.xxx.xxx.xxx.exception { <methods> }</option>
                   <option>-keep class com.xxx.xxx.xxx.model.** { <methods> }</option>-->
                <option>-keep class cn.edu.buaa.sigpt.IntersectionAnalysisMain { * ;}</option>
                <option>-keep class cn.edu.buaa.pojo.OutOverCarData { * ;}</option>
            </options>
            <!--class 混淆后输出的jar包-->
            <outjar>classes-autotest.jar</outjar>
            <!-- 添加依赖,这里你可以按你的需要修改,这里测试只需要一个JRE的Runtime包就行了-->
            <libs>
                <lib>${java.home}/lib/rt.jar</lib>
            </libs>
            <!-- 对什么东西进行加载,这里仅有classes成功,毕竟你也不可能对配置文件及JSP混淆吧-->
            <injar>classes</injar>
            <!-- 输出目录-->
            <outputDirectory>${project.build.directory}</outputDirectory>
        </configuration>
    </plugin>
    展开全文
  • @ ProGuard+Maven混淆Java代码 ProGuard+Maven混淆Java代码 maven的pom.xml写如下代码 导入ProGuard的依赖 打包成功 maven的pom.xml写如下代码 // An highlighted block <!-- ProGuard混淆插件--> <plugin...

    ProGuard+Maven混淆Java代码

    maven的pom.xml写如下代码
    导入ProGuard的依赖
    打包成功

    maven的pom.xml写如下代码

    // An highlighted block
    <!-- ProGuard混淆插件-->
                <plugin>
                    <groupId>com.github.wvengen</groupId>
                    <artifactId>proguard-maven-plugin</artifactId>
                    <version>2.0.11</version>
                    <executions>
                        <execution>
                            <!-- 混淆时刻,这里是打包的时候混淆-->
                            <phase>package</phase>
                            <goals>
                                <!-- 使用插件的什么功能,当然是混淆-->
                                <goal>proguard</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <!-- 是否将生成的PG文件安装部署-->
                        <attach>true</attach>
                        <!-- 是否混淆-->
                        <obfuscate>true</obfuscate>
                        <!-- 指定生成文件分类 -->
                        <attachArtifactClassifier>pg</attachArtifactClassifier>
                        <options>
                            <!-- JDK目标版本1.8-->
                            <option>-target 1.8</option>
                            <!-- 不做收缩(删除注释、未被引用代码)-->
                            <option>-dontshrink</option>
                            <!-- 不做优化(变更代码实现逻辑)-->
                            <option>-dontoptimize</option>
                            <!-- 不路过非公用类文件及成员-->
                            <option>-dontskipnonpubliclibraryclasses</option>
                            <option>-dontskipnonpubliclibraryclassmembers</option>
                            <!-- 优化时允许访问并修改有修饰符的类和类的成员 -->
                            <option>-allowaccessmodification</option>
                            <!-- 确定统一的混淆类的成员名称来增加混淆-->
                            <option>-useuniqueclassmembernames</option>
                            <!-- 不混淆所有包名,本人测试混淆后WEB项目问题实在太多,毕竟Spring配置中有大量固定写法的包名-->
                            <option>-keeppackagenames</option>
                            <!-- 不混淆所有特殊的类-->
                            <option>-keepattributes
                                Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,LocalVariable*Table,*Annotation*,Synthetic,EnclosingMethod
                            </option>
                            <!--不用大小写混合类名机制-->
                            <option>-dontusemixedcaseclassnames</option>
                            <!-- 不混淆所有的set/get方法,毕竟项目中使用的部分第三方框架(例如Shiro)会用到大量的set/get映射-->
                            <option>-keepclassmembers public class * {void set*(***);*** get*();}</option>
    
                            <!-- 不混淆common包下的所有类名-->
                            <option>-keep class com.deceen.common.**</option>
                            <option>-keep class com.deceen.other.**</option>
                            <option>-keep class com.deceen.*.controller.** {*;}</option>
                            <option>-keep class com.deceen.*.service.**</option>
                            <option>-keep class com.deceen.*.model.*.** {*;}</option>
                            <option>-keep class com.deceen.*.dao.**</option>
                            <option>-keep interface * extends * { *; }</option>
                            <option>-keepclassmembers class * {
                                @org.springframework.beans.factory.annotation.Autowired *;
                                @org.springframework.beans.factory.annotation.Value *;
                                }
                            </option>
                            <option>-dontwarn</option>
                        </options>
                        <outjar>${project.build.finalName}-pg.jar</outjar>
                        <!-- 添加依赖,这里你可以按你的需要修改,这里测试只需要一个JRE的Runtime包就行了 -->
                        <libs>
                            <lib>${java.home}/lib/rt.jar</lib>
                            <lib>${java.home}/lib/jce.jar</lib>
                        </libs>
                        <!-- 加载文件的过滤器,就是你的工程目录了-->
                        <!--<inFilter>com/deceen/ **</inFilter>-->
                        <!-- 对什么东西进行加载,这里仅有classes成功,毕竟你也不可能对配置文件及JSP混淆吧-->
                        <injar>classes</injar>
                        <!-- 输出目录-->
                        <outputDirectory>${project.build.directory}</outputDirectory>
                    </configuration>
                    <dependencies>
                        <!-- https://mvnrepository.com/artifact/net.sf.proguard/proguard-base -->
                        <dependency>
                            <groupId>net.sf.proguard</groupId>
                            <artifactId>proguard-base</artifactId>
                            <version>6.1.1</version>
                        </dependency>
                    </dependencies>
                </plugin>
    

    注意:根据JDK的版本选择proguard版本,我jdk版本是1.8,用的6.1.1(目前最新版本)

    导入ProGuard的依赖

    如果maven导入不进proguard的dependency最新版本,可以去 maven官网: 下载proguard的jar包,然后用
    mvn install:install-file -Dfile=jar的目录路径 -DgroupId=net.sf.proguard -DartifactId=proguard-base -Dversion=6.1.1 -Dpackaging=jar -DgeneratePom=true
    再将生成的文件放入maven仓库中就可以自动导入进去了。

    打包成功

    在这里插入图片描述
    在项目的target目录下就会生成三个这样的文件:
    •classes-pg.jar 混淆后的classes文件,里面包含完整的项目结构
    •proguard_map.txt 混淆内容的映射
    •proguard_seed.txt 参与混淆的类

    混淆完成后,将classes-pg.jar解压到应用服务器覆盖原有的classes文件,通常目录为
    •X:\jetty9 或 tomcat7\webapps\myProject\WEB-INF\classes

    展开全文
  • maven混淆Java代码

    2019-10-02 21:05:55
    Maven 环境下使用 proguard-maven-plugin 插件混淆你的源码 时间2014-08-20 15:23:56 肖国颖的个人页面 原文 http://my.oschina.net/noahxiao/blog/304746 主题 Maven 一、场景介绍 两个工程 Project1,...

    Maven 环境下使用 proguard-maven-plugin 插件混淆你的源码

    一、场景介绍

    两个工程 Project1,Project2(将被混淆的工程)。Project1 将通过 Maven 依赖配置的方式引用混淆后的 Project2。后面我会详细介绍 pom.xml 的配置。

    二、Maven 配置

    1、Project1 的 pom.xml

    该 pom.xml 比较简单主要通过 classifier 来判断是否使用混淆的 Jar(Project2)

    <?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>org.noahx.proguard.example</groupId>
      <artifactId>project1</artifactId>
      <version>1.0-SNAPSHOT</version>
    
      <dependencies>
        <dependency>
          <groupId>org.noahx.proguard.example</groupId>
          <artifactId>project2</artifactId>
          <classifier>pg</classifier> <!--如果不想依赖混淆的包,请注释掉该行-->
          <version>1.0-SNAPSHOT</version>
        </dependency>
      </dependencies>
    
    </project>

    2、Project2 的 pom.xml

    pom.xml 中配置的 proguard-maven-plugin 来做混淆,详细说明见注释。

    <?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>org.noahx.proguard.example</groupId>
      <artifactId>project2</artifactId>
      <version>1.0-SNAPSHOT</version>
    
    
      <build>
        <plugins>
    
          <plugin>
            <groupId>com.github.wvengen</groupId>
            <artifactId>proguard-maven-plugin</artifactId>
            <version>2.0.7</version>
            <executions>
              <execution>
                <phase>package</phase>
                <goals>
                  <goal>proguard</goal>
                </goals>
              </execution>
            </executions>
            <configuration>
              <attach>true</attach>
              <attachArtifactClassifier>pg</attachArtifactClassifier>
              <!-- attach 的作用是在 install 与 deploy 时将生成的 pg 文件也安装与部署 -->
              <options> <!-- 详细配置方式参考 ProGuard 官方文档 -->
                <!--<option>-dontobfuscate</option>-->
                <option>-ignorewarnings</option> <!--忽略所有告警-->
                <option>-dontshrink</option>   <!--不做 shrink -->
                <option>-dontoptimize</option> <!--不做 optimize -->
                <option>-dontskipnonpubliclibraryclasses</option>
                <option>-dontskipnonpubliclibraryclassmembers</option>
    
                <option>-repackageclasses org.noahx.proguard.example.project2.pg</option>
                <!--平行包结构(重构包层次),所有混淆的类放在 pg 包下-->
    
                <!-- 以下为 Keep,哪些内容保持不变,因为有一些内容混淆后(a,b,c)导致反射或按类名字符串相关的操作失效 -->
    
                <option>-keep class **.package-info</option>
                <!--保持包注解类-->
    
                <option>-keepattributes Signature</option>
                <!--JAXB NEED,具体原因不明,不加会导致 JAXB 出异常,如果不使用 JAXB 根据需要修改-->
                <!-- Jaxb requires generics to be available to perform xml parsing and without this option ProGuard was not retaining that information after obfuscation. That was causing the exception above. -->
    
                <option>-keepattributes SourceFile,LineNumberTable,*Annotation*</option>
                <!--保持源码名与行号(异常时有明确的栈信息),注解(默认会过滤掉所有注解,会影响框架的注解)-->
    
                <option>-keepclassmembers enum org.noahx.proguard.example.project2.** { *;}</option>
                <!--保持枚举中的名子,确保枚举 valueOf 可以使用-->
    
                <option>-keep class org.noahx.proguard.example.project2.bean.** { *;}</option>
                <!--保持 Bean 类,(由于很多框架会对 Bean 中的内容做反射处理,请根据自己的业务调整) -->
    
                <option>-keep class org.noahx.proguard.example.project2.Project2 { public void init(); public void
                  destroy(); }
                </option>
                <!-- 保持对外的接口性质类对外的类名与方法名不变 -->
    
              </options>
              <outjar>${project.build.finalName}-pg</outjar>
              <libs>
                <lib>${java.home}/lib/rt.jar</lib>
              </libs>
    
            </configuration>
          </plugin>
    
         </plugins>
      </build>
    
    </project>

    三、Java 混淆前后内容比较

    这里只比较 Project2 类的不同。其它类的比较,请大家使用 jd-gui 等反编译工具进行比较。

    1、混淆前的 Project2 类

    package org.noahx.proguard.example.project2;
    
    import org.noahx.proguard.example.project2.dao.TestDao;
    import org.noahx.proguard.example.project2.impl.User;
    
    /**
     * Created by noah on 8/20/14.
     */
    public class Project2 {
    
      public void init() {
        test1();
        test2();
      }
    
      private void test1() {
        Status on = Status.valueOf("On");
        switch (on) {
          case On: {
    
          }
          break;
          case Off: {
    
          }
          break;
        }
      }
    
      private void test2() {
        TestDao testDao=new TestDao();
        User user=new User();
        user.setUserid("abc");
        user.setPassword("pwd");
        user.setDescription("des");
        testDao.save(user);
    
      }
    
      private void test3() {
      }
    
      private void test4() {
      }
    
      private void throwException() {
        throw new RuntimeException("hello");
      }
    
      public void destroy() {
        test3();
        test4();
        throwException();
      }
    }

    2、混淆后的 Project2 类

    所有没有指定 keep 的内容都变为了 a,b,c...,增大了阅读难度。

    package org.noahx.proguard.example.project2;
    
    import org.noahx.proguard.example.project2.pg.a;
    
    public class Project2
    {
      public void init()
      {
        b();
        c();
      }
    
      private void b() {
        b localb = b.valueOf("On");
        switch (a.a[localb.ordinal()])
        {
        case 1:
          break;
        case 2:
        }
      }
    
      private void c()
      {
        a locala = new a();
        org.noahx.proguard.example.project2.pg.b localb = new org.noahx.proguard.example.project2.pg.b();
        localb.a("abc");
        localb.b("pwd");
        localb.c("des");
        locala.a(localb);
      }
    
      private void d()
      {
      }
    
      private void e() {
      }
    
      public void a() {
        throw new RuntimeException("hello");
      }
    
      public void destroy() {
        d();
        e();
        a();
      }
    }

    四、类路径中资源加载问题

    使用 ProGuard 产生的 Jar 包,会发生无法定位 Jar 中资源的问题。原因不详,我没有太深入研究。

    使用 [类名].class.getResource (),Thread.currentThread().getContextClassLoader().getResource(),不论是否以“/”开头都返回 null。没有混淆的 Jar 是没有这个问题的。

    我使用了一种直接读取 Jar 中内容的方式来解决。

    final File jarFile = new File([类名].class.getProtectionDomain().getCodeSource().getLocation().getPath()); //定位类所在的 Jar 文件
          if(jarFile.isFile()) {
            final JarFile jar = new JarFile(jarFile);
            Enumeration<JarEntry> entries = jar.entries();
            while (entries.hasMoreElements()) {
              JarEntry entry = entries.nextElement();
              if (entry.getName().startsWith("org/noahx")) {
                InputStream entryInputStream = jarFile.getInputStream(entry);  //遍历包中的内容来获得资源
              }
            }
            jar.close();
          }

    五、总结

    使用 proguard-maven-plugin 插件,既保持了 Maven 的依赖模式,又满足了我的混淆需求。其它详细的参数配置,大家可以参考官方文档。

    ProGuard 满足了我的需求。至于是好是坏,希望大家不要围绕这点做没有必要的争论,谢谢。

    转载于:https://www.cnblogs.com/yanduanduan/p/5340060.html

    展开全文
  • Java+IDEA+Maven混淆打包

    2019-07-15 15:33:10
    IDEA中使用maven打jar包,然后使用工具混淆代码,亲测有效
  • Java+IDEA+maven混淆打包

    2019-03-15 15:25:16
    IDEA中使用maven打jar包,然后使用工具混淆代码,亲测有效
  • ProGuard+Maven混淆代码maven的pom.xml写如下代码导入ProGuard的依赖打包成功 maven的pom.xml写如下代码 // An highlighted block <!-- ProGuard混淆插件--> <plugin> <groupId>...

    maven的pom.xml写如下代码

    // An highlighted block
    <!-- ProGuard混淆插件-->
                <plugin>
                    <groupId>com.github.wvengen</groupId>
                    <artifactId>proguard-maven-plugin</artifactId>
                    <version>2.0.11</version>
                    <executions>
                        <execution>
                            <!-- 混淆时刻,这里是打包的时候混淆-->
                            <phase>package</phase>
                            <goals>
                                <!-- 使用插件的什么功能,当然是混淆-->
                                <goal>proguard</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <!-- 是否将生成的PG文件安装部署-->
                        <attach>true</attach>
                        <!-- 是否混淆-->
                        <obfuscate>true</obfuscate>
                        <!-- 指定生成文件分类 -->
                        <attachArtifactClassifier>pg</attachArtifactClassifier>
                        <options>
                            <!-- JDK目标版本1.8-->
                            <option>-target 1.8</option>
                            <!-- 不做收缩(删除注释、未被引用代码)-->
                            <option>-dontshrink</option>
                            <!-- 不做优化(变更代码实现逻辑)-->
                            <option>-dontoptimize</option>
                            <!-- 不路过非公用类文件及成员-->
                            <option>-dontskipnonpubliclibraryclasses</option>
                            <option>-dontskipnonpubliclibraryclassmembers</option>
                            <!-- 优化时允许访问并修改有修饰符的类和类的成员 -->
                            <option>-allowaccessmodification</option>
                            <!-- 确定统一的混淆类的成员名称来增加混淆-->
                            <option>-useuniqueclassmembernames</option>
                            <!-- 不混淆所有包名,本人测试混淆后WEB项目问题实在太多,毕竟Spring配置中有大量固定写法的包名-->
                            <option>-keeppackagenames</option>
                            <!-- 不混淆所有特殊的类-->
                            <option>-keepattributes
                                Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,LocalVariable*Table,*Annotation*,Synthetic,EnclosingMethod
                            </option>
                            <!--不用大小写混合类名机制-->
                            <option>-dontusemixedcaseclassnames</option>
                            <!-- 不混淆所有的set/get方法,毕竟项目中使用的部分第三方框架(例如Shiro)会用到大量的set/get映射-->
                            <option>-keepclassmembers public class * {void set*(***);*** get*();}</option>
    
                            <!-- 不混淆common包下的所有类名-->
                            <option>-keep class com.deceen.common.**</option>
                            <option>-keep class com.deceen.other.**</option>
                            <option>-keep class com.deceen.*.controller.** {*;}</option>
                            <option>-keep class com.deceen.*.service.**</option>
                            <option>-keep class com.deceen.*.model.*.** {*;}</option>
                            <option>-keep class com.deceen.*.dao.**</option>
                            <option>-keep interface * extends * { *; }</option>
                            <option>-keepclassmembers class * {
                                @org.springframework.beans.factory.annotation.Autowired *;
                                @org.springframework.beans.factory.annotation.Value *;
                                }
                            </option>
                            <option>-dontwarn</option>
                        </options>
                        <outjar>${project.build.finalName}-pg.jar</outjar>
                        <!-- 添加依赖,这里你可以按你的需要修改,这里测试只需要一个JRE的Runtime包就行了 -->
                        <libs>
                            <lib>${java.home}/lib/rt.jar</lib>
                            <lib>${java.home}/lib/jce.jar</lib>
                        </libs>
                        <!-- 加载文件的过滤器,就是你的工程目录了-->
                        <!--<inFilter>com/deceen/ **</inFilter>-->
                        <!-- 对什么东西进行加载,这里仅有classes成功,毕竟你也不可能对配置文件及JSP混淆吧-->
                        <injar>classes</injar>
                        <!-- 输出目录-->
                        <outputDirectory>${project.build.directory}</outputDirectory>
                    </configuration>
                    <dependencies>
                        <!-- https://mvnrepository.com/artifact/net.sf.proguard/proguard-base -->
                        <dependency>
                            <groupId>net.sf.proguard</groupId>
                            <artifactId>proguard-base</artifactId>
                            <version>6.1.1</version>
                        </dependency>
                    </dependencies>
                </plugin>
    

    注意:根据JDK的版本选择proguard版本,我jdk版本是1.8,用的6.1.1(目前最新版本)

    导入ProGuard的依赖

    如果maven导入不进proguard的dependency最新版本,可以去 maven官网: 下载proguard的jar包,然后用
    mvn install:install-file -Dfile=jar的目录路径 -DgroupId=net.sf.proguard -DartifactId=proguard-base -Dversion=6.1.1 -Dpackaging=jar -DgeneratePom=true
    再将生成的文件放入maven仓库中就可以自动导入进去了。

    打包成功

    在这里插入图片描述
    在项目的target目录下就会生成三个这样的文件:

    • classes-pg.jar 混淆后的classes文件,里面包含完整的项目结构
    • proguard_map.txt 混淆内容的映射
    • proguard_seed.txt 参与混淆的类

    混淆完成后,将classes-pg.jar解压到应用服务器覆盖原有的classes文件,通常目录为

    • X:\jetty9 或 tomcat7\webapps\myProject\WEB-INF\classes

    完整版请看这

    展开全文
  • -- 不混淆测试包下的所有类名,且类中的方法也不混淆,但是属性混淆 --> <!-- <option>-keep class com.jikexueyuancrm.test.** { <methods>; --> <!-- }</option> --> <!-- 以下因为大部分...
  • <artifactId>proguard-maven-plugin <version>2.0.11 <!-- 混淆时刻,这里是打包的时候混淆--> <phase>package <!-- 使用插件的什么功能,当然是混淆--> <goal>proguard <!-- 是否将生成的PG...
  • -- 使用4.8版本来混淆 --> <groupId>net.sf.proguard</groupId> <artifactId>proguard <version>4.4 <scope>runtime </plugin> </plugins> ok版本 <project xmlns="http://maven....
  • allatori第二代Java代码混淆Maven打包配置,依赖库,以及配置文件。示例运行,可行。
  • java代码可以反编译,因此有时候要保护自己的知识产权还真得费点心思,一般来说有三个思路:  1、将class文件加密,这个是最安全的,但也费事儿,因为要重写classloader来解密class文件;  2、使用花指令,使得...
  • 该插件使您可以使用ProGuard开源混淆器来混淆Maven工件,ProGuard开源混淆器是一种非常强大且完善的Java混淆器。 也可以在SourceForge的http://proguard.sourceforge.net/上找到ProGuard。 可以从您的POM使用此插件...
  • 由于公司要求,需要将入库版本的代码进行混淆,因此进行了这一项毫无意义的工作,多方调查后,终于成功实现混淆。下面我将介绍下我是如何将poguard嵌入maven工程中,进行打包的。 使用方法,将proguard.cfg文件放置...
  • -- ProGuard混淆插件--&gt; &lt;plugin&gt; &lt;groupId&gt;com.github.wvengen&lt;/groupId&gt; &lt;artifactId&gt;proguard-maven-plugin&lt;/artifactId&gt; .....
  • Maven打包对java代码进行混淆处理

    千次阅读 2015-04-13 18:36:46
    java打包编辑进行混淆防止反编译 实现: &lt;plugin&gt; &lt;groupId&gt;com.github.wvengen&lt;/groupId&gt; &lt;artifactId&gt;proguard-maven-plugin&lt;/...
  • Java代码混淆技术选型

    2019-11-16 11:35:27
    Java代码混淆技术选型代码混淆简介常见的Java代码混淆技术简介java混淆java加密保护提前编译技术(AOT)使用JNI方式保护用加密锁硬件保护总结ProGuard使用说明Proguard简介Proguard-maven-plugin配置项目的pom文件中...
  • proguard-java代码混淆

    2021-03-10 00:13:38
    proguard-java代码混淆前言pom文件配置总结 前言 许多场景需要对java代码混淆加密,防止被人反编译知道查看道源码,现在有好多代码混淆工具。 现在业内好多代码混淆工具都是需要进行下载,通过工具进行混淆,对于...
  • JAVA混淆

    2021-05-10 15:23:02
    jar包混淆 添加依赖 在完成项目的pom文件下的下添加proGuard混淆插件依赖,直接复制粘贴过去下载依赖即可 <...proguard-maven-plugin</artifactId> <version>2.3.1</version&
  • Allatori是第二代 Java 混淆器,可为您的知识产权提供全方位的保护。 尽管大多数第二代混淆器都提供了值得保护的级别,但我们已经在Allatori中开发了许多附加功能,以使对代码进行逆向工程几乎不可能。 Allatori...
  • java代码混淆

    千次阅读 2018-07-18 14:56:34
    使用maven 1. pom.xml中配置 &lt;!-- ProGuard混淆插件--&gt;  &lt;plugin&gt;  &lt;groupId&gt;com.github.wvengen&lt;/groupId&gt;  &lt;artifactId&gt;pr...
  • 一款上手即用的Java代码混淆工具

    千次阅读 2020-05-05 12:20:50
    基于Allatori的Java代码混淆 maven插件工具 项目地址:github Java代码很容易进行反编译,如果有人想要研究你的项目,随便反编译一下就看得清清楚楚了,特别像我们公司的测试人员,经常会反编译我们的项目,然后找...
  • Java编译: Apache Maven 因我们之前没有做过这方面的研究,所以请教各位提供详细的实施和部署操作! 同时还有两个问题请教各位: 1、JAR和Java类文件混淆后Tomcat如何调用? 2、JAR和Java类文件加密后Tomcat如何...
  • mavenProject,今天混淆之后mvn deploy的jar包启动报错: ``` Exception in thread "main" java.lang.VerifyError: Expecting a stackmap frame at branch target 55 Exception Details: Location: sophia...
  • Selenium+Java+Maven自动化测试系列❤

    千次阅读 2020-05-15 17:36:49
    为了便于大家查看,也为防止和之前的Java Project混淆,所以独立分出来成为第二篇。 ------------------------------------ 博主经验有限,若有不足,欢迎交流,共同改进~ 有意可加Q群 908417285 交流学习。 乾坤...
  • ProGuard注意事项 1.反射调用类或者方法,可能失败 2.对外接口的类和方法,不要混淆 3.嵌套类 4.native方法 5.枚举类 ...使用方法: 1.GUI界面使用proguardgui....3.maven配置 <plugin> <!-- proguard混淆插件-

空空如也

空空如也

1 2 3 4 5 6
收藏数 111
精华内容 44
关键字:

javamaven混淆

java 订阅