Java class反编译后的代码还原

最新推荐文章于 2022-07-28 14:12:09 发布
最新推荐文章于 2022-07-28 14:12:09 发布
阅读量262 收藏
点赞数
分类专栏： J2SE 基础 文章标签： Java JVM JDK
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_2691/article/details/82007713
版权

 

Java class 利用jad 反编译之后，偶尔回碰到一些不正常的代码，例如：label0 :_L1 MISSING_BLOCK_LABEL_30、JVM INSTR ret 7 、JVM INSTR tableswitch 1 3: default 269、 JVM INSTR monitorexit、JVM INSTR monitorenter，这些一般是由特殊的for循环、try catch finally语句块、synchronized语句反编译后产生的。

下面，就简单介绍一下，一些反编译后的特殊代码的还原规则。

本文在Jdk 1.6.0_20+jad 1.58g下测试。

1、普通的循环，原始

 

 public void f1() {
      boolean flag = false;
      if (Boolean.getBoolean("sys")) {
       System.out.println("sys");
      } else {
       for (int i = 0; i < 10; i++) {
        flag = Boolean.getBoolean("sys");
        if (flag) {
         System.exit(0);
         }
        }
      }
    }

 反编译后的代码

 

 

public void f1()
     {
         boolean flag = false;
         if(Boolean.getBoolean("sys"))
         {
             System.out.println("sys");
         } else
         {
             for(int i = 0; i < 10; i++)
             {
                 flag = Boolean.getBoolean("sys");
                 if(flag)
                     System.exit(0);
             }

         }
     }

 2、反编译后代码变的很古怪，这是java原代码

 

 public void f2() {
      int[] list = new int[] { 1, 2, 3, 4 };
      if (Boolean.getBoolean("sys")) {
       System.out.println("sys");
      } else {
       check: while (true) {
        for (int i = 0; i < list.length; i++) {
         if (list[i] == 2) {
          continue check;
         } else {
          break;
         }
        }
       }
      }
    }

 Java反编译后的代码，部分逻辑丢失。

 

  public void f2()
        {
            int list[] = {
                1, 2, 3, 4
            };
            if(Boolean.getBoolean("sys"))
                System.out.println("sys");
            else
                do
                {
                    int i = 0;
                    if(i >= list.length || list[i] != 2);
                } while(true);
        }
就是比f2（）多了一行System.out.println("list[i]");，反编译后也挺怪的。源码如下
 public void f3() {
     int[] list = new int[] { 1, 2, 3, 4 };
     if (Boolean.getBoolean("sys")) {
      System.out.println("sys");
     } else {
      check: while (true) {
       for (int i = 0; i < list.length; i++) {
        System.out.println("list[i]");
        if (list[i] == 2) {
         continue check;
        } else {
         break;
        }
       }
      }
     }
    }

 反编译后的代码：

 public void f3()
        {
            int list[] = {
                1, 2, 3, 4
            };
            if(Boolean.getBoolean("sys"))
                System.out.println("sys");
            else
                do
                {
                    int i;
                    do
                        i = 0;
                    while(i >= list.length);
                    System.out.println("list[i]");
                    if(list[i] != 2);
                } while(true);
        }

4、 f2（）中的break语言，移动了位置。源码如下

 public void f4() {   
           int[] list = new int[] { 1, 2, 3, 4 };   
           if (Boolean.getBoolean("sys")) {   
               System.out.println("sys");   
           } else {   
               check: while (true) {   
                   for (int i = 0; i < list.length; i++) {   
                       if (list[i] == 2) {   
                           continue check;   
                       }   
                   }   
                   break;   
               }   
           }   
       }

   反编译后代码：

 public void f4()
        {
            int list[] = {
                1, 2, 3, 4
            };
            int i;
            if(Boolean.getBoolean("sys"))
                System.out.println("sys");
            else
    label0:
                do
                {
                    for(i = 0; i < list.length; i++)
                        if(list[i] == 2)
                            continue label0;
    
                    break;
                } while(true);
        } 

  5、就是比f4（）多了一行System.out.println("list[i]");，反编译后相当怪的。源码如下： 

public void f5() {
      int[] list = new int[] { 1, 2, 3, 4 };
      if (Boolean.getBoolean("sys")) {
       System.out.println("sys");
      } else {
       check: while (true) {
        for (int i = 0; i < list.length; i++) {
         System.out.println("list[i]");
         if (list[i] == 2) {
          continue check;
         }
        }
        break;
       }
      }
     }

 反编译后比较晕的代码： 

  public void f5()
        {
            int list[] = {
                1, 2, 3, 4
            };
            if(!Boolean.getBoolean("sys")) goto _L2; else goto _L1
    _L1:
            System.out.println("sys");
              goto _L3
    _L2:
            int i = 0;
              goto _L4
    _L6:
            System.out.println("list[i]");
            if(list[i] != 2) goto _L5; else goto _L2
    _L5:
            i++;
    _L4:
            if(i < list.length) goto _L6; else goto _L3
    _L3:
        }

   6、就是比f5()多了一行System.exit(0);代码，但是差异确很大。源码如下：

  public void f6() {   
           int[] list = new int[] { 1, 2, 3, 4 };   
           if (Boolean.getBoolean("sys")) {   
               System.out.println("sys");   
           } else {   
               check: while (true) {   
                   for (int i = 0; i < list.length; i++) {   
                       System.out.println("list[i]");   
                       if (list[i] == 2) {   
                           continue check;   
                       }   
                   }   
                   System.exit(0);   
                   break;   
               }   
           }   
       }

 反编译后代码，比f5()差异太大了。

 public void f6()
        {
            int list[];
            list = (new int[] {
                1, 2, 3, 4
            });
            if(Boolean.getBoolean("sys"))
            {
                System.out.println("sys");
                break MISSING_BLOCK_LABEL_75;
            }
    _L2:
            int i = 0;
              goto _L1
    _L5:
            System.out.println("list[i]");
            if(list[i] != 2) goto _L3; else goto _L2
    _L3:
            i++;
    _L1:
            if(i < list.length) goto _L5; else goto _L4
    _L4:
            System.exit(0);
        }
 

  7、差异就是f6()中的System.exit(0);移动了位置，但是差异确很大。源码如下： 

 public void f7() {
      int[] list = new int[] { 1, 2, 3, 4 };
      if (Boolean.getBoolean("sys")) {
       System.out.println("sys");
      } else {
       check: while (true) {
        for (int i = 0; i < list.length; i++) {
         System.out.println("list[i]");
         if (list[i] == 2) {
          continue check;
         }
        }
        break;
       }
       System.exit(0);
      }
     }

 反编译后代码，比f6()差异太大了。

public void f7()
        {
            int list[];
            list = (new int[] {
                1, 2, 3, 4
            });
            if(Boolean.getBoolean("sys"))
            {
                System.out.println("sys");
                break MISSING_BLOCK_LABEL_75;
            }
    _L2:
            int i = 0;
              goto _L1
    _L5:
            System.out.println("list[i]");
            if(list[i] != 2) goto _L3; else goto _L2
    _L3:
            i++;
    _L1:
            if(i < list.length) goto _L5; else goto _L4
    _L4:
            System.exit(0);
        }

 8、逻辑和f7比没有变，只是多了一些System.out.println()代码。

 public void f8() {   
           int[] list = new int[] { 1, 2, 3, 4 };   
           if (Boolean.getBoolean("sys")) {   
               System.out.println("sys");   
           } else {   
               System.out.println(":check while");   
               check: while (true) {   
                   System.out.println("for");   
                   for (int i = 0; i < list.length; i++) {   
                       System.out.println("list[i]");   
                       if (list[i] == 2) {   
                           continue check;   
                       }   
                   }   
                   System.out.println("break");   
                   break;   
               }   
               System.out.println("exit(0)");   
               System.exit(0);   
           }   
       }
 反编译后的代码：和f7()比较一下，基本就可以确定反编译后的代码对应关系了。  

 public void f8()
        {
            int list[];
            list = (new int[] {
                1, 2, 3, 4
            });
            if(Boolean.getBoolean("sys"))
            {
                System.out.println("sys");
                break MISSING_BLOCK_LABEL_107;
            }
            System.out.println(":check while");
    _L2:
            int i;
            System.out.println("for");
            i = 0;
              goto _L1
    _L5:
            System.out.println("list[i]");
            if(list[i] != 2) goto _L3; else goto _L2
    _L3:
            i++;
    _L1:
            if(i < list.length) goto _L5; else goto _L4
    _L4:
            System.out.println("break");
            System.out.println("exit(0)");
            System.exit(0);
        }

 9、逻辑和f8比没有变，只是多了一行System.out.println()代码，导致了反编译后的/* Loop/switch isn&apos;t completed */

 public void f9() {   
        int[] list = new int[] { 1, 2, 3, 4 };   
        if (Boolean.getBoolean("sys")) {   
            System.out.println("sys");   
        } else {   
            System.out.println(":check while");   
            check: while (true) {   
                System.out.println("for");   
                for (int i = 0; i < list.length; i++) {   
                    System.out.println("list[i]");   
                    if (list[i] == 2) {   
                        System.out.println("continue check");   
                        continue check;   
                    }   
                }   
                System.out.println("break");   
                break;   
            }   
            System.out.println("exit(0)");   
            System.exit(0);   
          }   
     }   
    }

 反编译后的代码：

public void f9()
        {
            int list[] = {
                1, 2, 3, 4
            };
            if(!Boolean.getBoolean("sys")) goto _L2; else goto _L1
    _L1:
            System.out.println("sys");
              goto _L3
    _L2:
            System.out.println(":check while");
    _L5:
            System.out.println("for");
            for(int i = 0; i < list.length; i++)
            {
                System.out.println("list[i]");
                if(list[i] != 2)
                    continue;
                System.out.println("continue check");
                continue; /* Loop/switch isn&apos;t completed */
            }
    
            System.out.println("break");
            System.out.println("exit(0)");
            System.exit(0);
    _L3:
            return;
            if(true) goto _L5; else goto _L4
    _L4:
        }
    }
 
iteye_2691
关注
专栏目录
java class反编译后的代码还原
09-06
java class反编译后的代码还原 java class反编译后的代码还原
java class反编译后的代码还原（二）
feelinghappy的专栏
08-21 313
java class 利用jad 反编译之后，偶尔回碰到一些不正常的代码，例如：label0 :_L1 MISSING_BLOCK_LABEL_30、JVM INSTR ret 7、JVM INSTR tableswitch 1 3: default 269、 JVM INSTR monitorexit、JVM INSTR monitorenter，这些一般是由特殊的for循环、try catc...
java class反编译后的代码还原（一）
热门推荐
z3h的专栏，Java+Oracle...大杂烩
06-05 1万+
        java class 利用jad 反编译之后，偶尔回碰到一些不正常的代码，例如：label0 :_L1 MISSING_BLOCK_LABEL_30、JVM INSTR ret 7 、JVM INSTR tableswitch 1 3: default 269、 JVM INSTR monitorexit、JVM INSTR monitorenter，这些一般是由特殊的for循环、
javaClass反编译: jd-gui
08-29
JavaClass反编译是开发者在探索和理解Java代码运行机制时常用的一种技术。jd-gui是一款功能强大的开源工具，专门用于将编译后的.class文件转换回可读的Java源代码，帮助开发者查看和理解二进制字节码背后的逻辑。在...
Java Class文件反编译工具 jd-gui
11-22
3. 反编译细节：它可以解析出大部分的Java语法，如循环、条件语句、异常处理等，尽管可能无法完美还原原始源代码的注释和精确格式。 4. 内存友好：jd-gui运行时占用的内存资源相对较少，适合开发者日常使用。 5. ...
Java类class反编译工具
11-02
Java类class反编译工具是开发者在理解和学习Java字节码或者进行逆向工程时必不可少的辅助工具。这些工具能够将已经编译过的.class文件转换回可读性强的.java源代码，帮助我们查看和理解已有的Java类结构，尤其是在...
java Class 反编译软件
01-05
Java Class反编译是将已经编译好的Java字节码（.class文件）转换回可读的Java源代码（.java文件）的过程。这在进行逆向工程、学习开源库的内部实现或调试已丢失源代码的类时非常有用。在Java领域，有一些工具专门...
java反编译（将class文件反向编译成java源文件)
03-21
java反编译（将class文件反向编译成java源文件)
java反编译+回编教程
qq_28130847的博客
07-28 1443
放到如下文件夹有需要和原.jar包启动需要的依赖的lib依赖的文件夹下。然后执行javac命令如下命令指向需要的依赖classpath和编码然后即可回编。使用jd-gui-windows打开你需要反编译的jar文件或者.class文件。注意此命令在windows下执行才有效linux格式自行百度。-classpath指定依赖所需要的环境。Class文件放回压缩包。找到要修改的class。存为.java文件。.........
JAVA class反编译还原
weixin_30767835的博客
06-23 148
class反编译还原 java class 利用jad 反编译之后，偶尔回碰到一些不正常的代码，例如：label0 :_L1 MISSING_BLOCK_LABEL_30、JVM INSTR ret 7 、JVM INSTR tableswitch 1 3: default 269、 JVM INSTR monitorexit、JVM INSTR monitorenter，这些一般是由特殊的fo...
class文件反编译成java文件
qq_47333787的博客
02-01 236
1.win+R，cmd命令打开cmd.exe，进入到jad所在的文件，比如我的jad在F盘 2.将要反编译的class文件放到文件夹里，比如我放到了F盘的test文件夹中 3.执行命令：jad -d 盘符:\jad\文件夹名 -s java 文件夹名\class文件名 4.生成的java文件在新建的文件夹下 ...
java反编译还原_Java .class文件反编译后的特殊代码还原
weixin_35974411的博客
02-12 1196
javaclass反编译后的代码还原(一)Javaclass利用jad反编译之后，偶尔回碰到一些不正常的代码，例如：label0:_L1MISSING_BLOCK_LABEL_30、JVMINSTRret7、JVMINSTRtableswitch13:default269、JVMINSTRmonitorexit、JVMINSTRmonitorenter，这...
for循环
weixin_50266677的博客
09-09 1142
上代码： <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Document</title> </head><body>
保护JAVA代码不被反编译的策略
1. **混淆代码**：使用代码混淆工具（如ProGuard、Zelix KlassMaster或Obfuscator-LLVM）可以对Java字节码进行重命名和重新排列，使反编译后的代码变得难以理解和分析。混淆工具通常会改变类名、方法名和变量名，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值