java class反编译后的代码还原

最新推荐文章于 2022-07-28 14:12:09 发布
最新推荐文章于 2022-07-28 14:12:09 发布
阅读量1.2k 收藏
点赞数
分类专栏： Android

java 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，这些一般是由特殊的for循环、try catch finally语句块、synchronized语句反编译后产生的。下面，就简单介绍一下，一些反编译后的特殊代码的还原规则。本文在Jdk 1.4.2_08+jad 1.58f下测试。jad 1.5.8f可以到这里http://download.csdn.net/source/470540 下载。

   第一部分、for、while循环

1、普通的循环，原始


  1. public void f1() {  
  2.         boolean flag = false;  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             for (int i = 0; i < 10; i++) {  
  7.                 flag = Boolean.getBoolean("sys");  
  8.                 if (flag) {  
  9.                     System.exit(0);  
  10.                 }  
  11.             }  
  12.         }  
  13.     }  
  14.    
  15.    
反编译后的代码

  1. public void f1()  
  2.      {  
  3.          boolean flag = false;  
  4.          if(Boolean.getBoolean("sys"))  
  5.          {  
  6.              System.out.println("sys");  
  7.          } else  
  8.          {  
  9.              for(int i = 0; i < 10; i++)  
  10.              {  
  11.                  flag = Boolean.getBoolean("sys");  
  12.                  if(flag)  
  13.                      System.exit(0);  
  14.              }  
  15.    
  16.          }  
  17.      }  
  18.    
  19.       
2、反编译后代码变的很古怪，这是java原代码

  1. public void f2() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     if (list[i] == 2) {  
  9.                         continue check;  
  10.                     } else {  
  11.                         break;  
  12.                     }  
  13.                 }  
  14.             }  
  15.         }  
  16.     }  
  17.    
  18.        
Java反编译后的代码，部分逻辑丢失。

  1. public void f2()  
  2.      {  
  3.          int list[] = {  
  4.              1, 2, 3, 4  
  5.          };  
  6.          if(Boolean.getBoolean("sys"))  
  7.              System.out.println("sys");  
  8.          else  
  9.              do  
  10.              {  
  11.                  int i = 0;  
  12.                  if(i >= list.length || list[i] != 2);  
  13.              } while(true);  
  14.      }  
  15.    
  16.       
3、就是比f2（）多了一行System.out.println("list[i]");，反编译后也挺怪的。源码如下：

  1. public void f3() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     System.out.println("list[i]");  
  9.                     if (list[i] == 2) {  
  10.                         continue check;  
  11.                     } else {  
  12.                         break;  
  13.                     }  
  14.                 }  
  15.             }  
  16.         }  
  17.     }  
  18.        
反编译后的代码：

  1. public void f3()  
  2.      {  
  3.          int list[] = {  
  4.              1, 2, 3, 4  
  5.          };  
  6.          if(Boolean.getBoolean("sys"))  
  7.              System.out.println("sys");  
  8.          else  
  9.              do  
  10.              {  
  11.                  int i;  
  12.                  do  
  13.                      i = 0;  
  14.                  while(i >= list.length);  
  15.                  System.out.println("list[i]");  
  16.                  if(list[i] != 2);  
  17.              } while(true);  
  18.      }  
  19.    
  20.       
4、f2（）中的break语言，移动了位置。源码如下：

  1. public void f4() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     if (list[i] == 2) {  
  9.                         continue check;  
  10.                     }  
  11.                 }  
  12.                 break;  
  13.             }  
  14.         }  
  15.     }  
  16.    
  17.        
反编译后代码：

  1. public void f4()  
  2.      {  
  3.          int list[] = {  
  4.              1, 2, 3, 4  
  5.          };  
  6.          int i;  
  7.          if(Boolean.getBoolean("sys"))  
  8.              System.out.println("sys");  
  9.          else  
  10.  label0:  
  11.              do  
  12.              {  
  13.                  for(i = 0; i < list.length; i++)  
  14.                      if(list[i] == 2)  
  15.                          continue label0;  
  16.    
  17.                  break;  
  18.              } while(true);  
  19.      }  
  20.    
  21.       
5、就是比f4（）多了一行System.out.println("list[i]");，反编译后相当怪的。源码如下：

  1. public void f5() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     System.out.println("list[i]");  
  9.                     if (list[i] == 2) {  
  10.                         continue check;  
  11.                     }  
  12.                 }  
  13.                 break;  
  14.             }  
  15.         }  
  16.     }  
  17.        
反编译后比较晕的代码：

  1. public void f5()  
  2.      {  
  3.          int list[] = {  
  4.              1, 2, 3, 4  
  5.          };  
  6.          if(!Boolean.getBoolean("sys")) goto _L2; else goto _L1  
  7.  _L1:  
  8.          System.out.println("sys");  
  9.            goto _L3  
  10.  _L2:  
  11.          int i = 0;  
  12.            goto _L4  
  13.  _L6:  
  14.          System.out.println("list[i]");  
  15.          if(list[i] != 2) goto _L5; else goto _L2  
  16.  _L5:  
  17.          i++;  
  18.  _L4:  
  19.          if(i < list.length) goto _L6; else goto _L3  
  20.  _L3:  
  21.      }  
  22.       
6、就是比f5()多了一行System.exit(0);代码，但是差异确很大。源码如下：

  1. public void f6() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     System.out.println("list[i]");  
  9.                     if (list[i] == 2) {  
  10.                         continue check;  
  11.                     }  
  12.                 }  
  13.                 System.exit(0);  
  14.                 break;  
  15.             }  
  16.         }  
  17.     }  
  18.        
编译后代码，比f5()差异太大了。

  1. public void f6()  
  2.      {  
  3.          int list[];  
  4.          list = (new int[] {  
  5.              1, 2, 3, 4  
  6.          });  
  7.          if(Boolean.getBoolean("sys"))  
  8.          {  
  9.              System.out.println("sys");  
  10.              break MISSING_BLOCK_LABEL_75;  
  11.          }  
  12.  _L2:  
  13.          int i = 0;  
  14.            goto _L1  
  15.  _L5:  
  16.          System.out.println("list[i]");  
  17.          if(list[i] != 2) goto _L3; else goto _L2  
  18.  _L3:  
  19.          i++;  
  20.  _L1:  
  21.          if(i < list.length) goto _L5; else goto _L4  
  22.  _L4:  
  23.          System.exit(0);  
  24.      }  
  25.       
7、差异就是f6()中的System.exit(0);移动了位置，但是差异确很大。源码如下：

  1. public void f7() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     System.out.println("list[i]");  
  9.                     if (list[i] == 2) {  
  10.                         continue check;  
  11.                     }  
  12.                 }  
  13.                 break;  
  14.             }  
  15.             System.exit(0);  
  16.         }  
  17.     }  
  18.        
编译后代码，比f6()差异太大了。

  1. public void f7()  
  2.      {  
  3.          int list[];  
  4.          list = (new int[] {  
  5.              1, 2, 3, 4  
  6.          });  
  7.          if(Boolean.getBoolean("sys"))  
  8.          {  
  9.              System.out.println("sys");  
  10.              break MISSING_BLOCK_LABEL_75;  
  11.          }  
  12.  _L2:  
  13.          int i = 0;  
  14.            goto _L1  
  15.  _L5:  
  16.          System.out.println("list[i]");  
  17.          if(list[i] != 2) goto _L3; else goto _L2  
  18.  _L3:  
  19.          i++;  
  20.  _L1:  
  21.          if(i < list.length) goto _L5; else goto _L4  
  22.  _L4:  
  23.          System.exit(0);  
  24.      }  
  25.       
8、逻辑和f7比没有变，只是多了一些System.out.println()代码。

  1. public void f8() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             System.out.println(":check while");  
  7.             check: while (true) {  
  8.                 System.out.println("for");  
  9.                 for (int i = 0; i < list.length; i++) {  
  10.                     System.out.println("list[i]");  
  11.                     if (list[i] == 2) {  
  12.                         continue check;  
  13.                     }  
  14.                 }  
  15.                 System.out.println("break");  
  16.                 break;  
  17.             }  
  18.             System.out.println("exit(0)");  
  19.             System.exit(0);  
  20.         }  
  21.     }  
  22.       
反编译后的代码：和f7()比较一下，基本就可以确定反编译后的代码对应关系了。

  1. public void f8()  
  2.      {  
  3.          int list[];  
  4.          list = (new int[] {  
  5.              1, 2, 3, 4  
  6.          });  
  7.          if(Boolean.getBoolean("sys"))  
  8.          {  
  9.              System.out.println("sys");  
  10.              break MISSING_BLOCK_LABEL_107;  
  11.          }  
  12.          System.out.println(":check while");  
  13.  _L2:  
  14.          int i;  
  15.          System.out.println("for");  
  16.          i = 0;  
  17.            goto _L1  
  18.  _L5:  
  19.          System.out.println("list[i]");  
  20.          if(list[i] != 2) goto _L3; else goto _L2  
  21.  _L3:  
  22.          i++;  
  23.  _L1:  
  24.          if(i < list.length) goto _L5; else goto _L4  
  25.  _L4:  
  26.          System.out.println("break");  
  27.          System.out.println("exit(0)");  
  28.          System.exit(0);  
  29.      }  
  30.       
9、逻辑和f8比没有变，只是多了一行System.out.println()代码，导致了反编译后的/* Loop/switch isn't completed */。

  1. public void f9() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             System.out.println(":check while");  
  7.             check: while (true) {  
  8.                 System.out.println("for");  
  9.                 for (int i = 0; i < list.length; i++) {  
  10.                     System.out.println("list[i]");  
  11.                     if (list[i] == 2) {  
  12.                         System.out.println("continue check");  
  13.                         continue check;  
  14.                     }  
  15.                 }  
  16.                 System.out.println("break");  
  17.                 break;  
  18.             }  
  19.             System.out.println("exit(0)");  
  20.             System.exit(0);  
  21.         }  
  22.     }  
  23.  }  
  24.        
反编译后的代码：

  1. public void f9()  
  2.      {  
  3.          int list[] = {  
  4.              1, 2, 3, 4  
  5.          };  
  6.          if(!Boolean.getBoolean("sys")) goto _L2; else goto _L1  
  7.  _L1:  
  8.          System.out.println("sys");  
  9.            goto _L3  
  10.  _L2:  
  11.          System.out.println(":check while");  
  12.  _L5:  
  13.          System.out.println("for");  
  14.          for(int i = 0; i < list.length; i++)  
  15.          {  
  16.              System.out.println("list[i]");  
  17.              if(list[i] != 2)  
  18.                  continue;  
  19.              System.out.println("continue check");  
  20.              continue; /* Loop/switch isn't completed */  
  21.          }  
  22.    
  23.          System.out.println("break");  
  24.          System.out.println("exit(0)");  
  25.          System.exit(0);  
  26.  _L3:  
  27.          return;  
  28.          if(true) goto _L5; else goto _L4  
  29.  _L4:  
  30.      }  
  31.  }  

 

java 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，这些一般是由特殊的for循环、try catch finally语句块、synchronized语句反编译后产生的。下面，就简单介绍一下，一些反编译后的特殊代码的还原规则。本文在Jdk 1.4.2_08+jad 1.58f下测试。jad 1.5.8f可以到这里http://download.csdn.net/source/470540 下载。

    第二部分、异常

   下面的代码前提是类中有如下属性，  Calendar cal = Calendar.getInstance();。

    1、Exceptioin的还原    反编译后的代码如下：


  1. public boolean f1()  
  2.   
  3. {  
  4.   
  5.     return cal.getTime().after(new Date());  
  6.   
  7.     Exception e;  
  8.   
  9.     e;  
  10.   
  11.     e.printStackTrace();  
  12.   
  13.     return false;  
  14.   
  15. }  
还原后的Java代码

  1. public boolean f1()  
  2.   
  3. {  
  4.   
  5.     try  
  6.   
  7.     {  
  8.   
  9.         return cal.getTime().after(new Date());  
  10.   
  11.     }  
  12.   
  13.     catch (Exception e)  
  14.   
  15.     {  
  16.   
  17.         e.printStackTrace();  
  18.   
  19.         return false;  
  20.   
  21.     }  
  22.   
  23. }  
2、finally代码的还原 反编译后的Java代码如下：

  1. public boolean f2()  
  2.   
  3. {  
  4.   
  5.     boolean flag = cal.getTime().after(new Date());  
  6.   
  7.     System.out.println("finally");  
  8.   
  9.     return flag;  
  10.   
  11.     Exception e;  
  12.   
  13.     e;  
  14.   
  15.     e.printStackTrace();  
  16.   
  17.     System.out.println("finally");  
  18.   
  19.     return false;  
  20.   
  21.     Exception exception;  
  22.   
  23.     exception;  
  24.   
  25.     System.out.println("finally");  
  26.   
  27.     throw exception;  
  28.   
  29.   
  30.   
  31. }  
还原后的代码如下：

  1. public boolean f2()  
  2.   
  3. {  
  4.   
  5.     try  
  6.   
  7.     {  
  8.   
  9.         return cal.getTime().after(new Date());  
  10.   
  11.     }  
  12.   
  13.     catch (Exception e)  
  14.   
  15.     {  
  16.   
  17.         e.printStackTrace();  
  18.   
  19.         return false;  
  20.   
  21.     }  
  22.   
  23.     finally  
  24.   
  25.     {  
  26.   
  27.         System.out.println("finally");  
  28.   
  29.     }  
  30.   
  31. }  
3、MISSING_BLOCK_LABEL_的还原反编译后的代码

  1. public Object f22()  
  2.   
  3. {  
  4.   
  5.     Date date = cal.getTime();  
  6.   
  7.     System.out.println("finally");  
  8.   
  9.     return date;  
  10.   
  11.     Exception e;  
  12.   
  13.     e;  
  14.   
  15.     e.printStackTrace();  
  16.   
  17.     System.out.println("finally");  
  18.   
  19.     break MISSING_BLOCK_LABEL_45;  
  20.   
  21.     Exception exception;  
  22.   
  23.     exception;  
  24.   
  25.     System.out.println("finally");  
  26.   
  27.     throw exception;  
  28.   
  29.     return null;  
  30.   
  31. }  
还原后的Java代码

  1. public Object f22()  
  2.   
  3. {  
  4.   
  5.     try  
  6.   
  7.     {  
  8.   
  9.         return cal.getTime();  
  10.   
  11.     }  
  12.   
  13.     catch (Exception e)  
  14.   
  15.     {  
  16.   
  17.         e.printStackTrace();  
  18.   
  19.     }  
  20.   
  21.     finally  
  22.   
  23.     {  
  24.   
  25.         System.out.println("finally");  
  26.   
  27.     }  
  28.   
  29.     return null;  
  30.   
  31. }  
4、异常中:label的还原反编译后的代码

  1. public String f4()  
  2.   
  3.     throws Exception  
  4.   
  5. {  
  6.   
  7. l0:  
  8.   
  9.     {  
  10.   
  11.         try  
  12.   
  13.         {  
  14.   
  15.             Integer i = new Integer(1);  
  16.   
  17.             if(i.intValue() > 0)  
  18.   
  19.             {  
  20.   
  21.                 System.out.println(i);  
  22.   
  23.                 break label0;  
  24.   
  25.             }  
  26.   
  27.   
  28.   
  29.             System.err.println(i);  
  30.   
  31.         }  
  32.   
  33.         catch(Exception dae)  
  34.   
  35.   
  36.   
  37.   
  38.   
  39.   
  40.   
  41.         {  
  42.   
  43.             System.err.println(dae);  
  44.   
  45.             throw new RuntimeException(dae);  
  46.   
  47.         }  
  48.   
  49.         return null;  
  50.   
  51.     }  
  52.   
  53.     return "Hello";  
  54.   
  55. }  
注意，这个代码有点诡异，实际代码如下：

  1. public String f4() throws Exception  
  2.   
  3.   
  4.   
  5.   
  6.   
  7. {  
  8.   
  9.     try  
  10.   
  11.     {  
  12.   
  13.         Integer i = new Integer(1);  
  14.   
  15.         if (i.intValue() > 0)  
  16.   
  17.         {  
  18.   
  19.             System.out.println(i);  
  20.   
  21.         }  
  22.   
  23.         else  
  24.   
  25.         {  
  26.   
  27.             System.err.println(i);  
  28.   
  29.             return null;  
  30.   
  31.         }  
  32.   
  33.         return "Hello";  
  34.   
  35.     }  
  36.   
  37.     catch (Exception dae)  
  38.   
  39.     {  
  40.   
  41.         System.err.println(dae);  
  42.   
  43.         throw new RuntimeException(dae);  
  44.   
  45.     }  
  46.   
  47.   
  48.   
  49.   
  50.   
  51.   
  52.   
  53. }  
5、典型数据库操作代码还原 反编译后代码

  1. public HashMap f5()  
  2.   
  3. {  
  4.   
  5.   
  6.   
  7.     Connection conn = null;  
  8.   
  9.     HashMap hashmap;  
  10.   
  11.   
  12.   
  13.     HashMap map = new HashMap();  
  14.   
  15.     Class.forName("");  
  16.   
  17.     conn = DriverManager.getConnection("jdbc:odbc:");  
  18.   
  19.     PreparedStatement pstmt = conn.prepareStatement("select * from table");  
  20.   
  21.     pstmt.setString(1, "param");  
  22.   
  23.     String columnVallue;  
  24.   
  25.     for(ResultSet rs = pstmt.executeQuery(); rs.next(); map.put(columnVallue, ""))  
  26.   
  27.         columnVallue = rs.getString("column");  
  28.   
  29.   
  30.   
  31.     hashmap = map;  
  32.   
  33.     if(conn != null)  
  34.   
  35.         try  
  36.   
  37.         {  
  38.   
  39.             conn.close();  
  40.   
  41.         }  
  42.   
  43.         catch(SQLException sqlce)  
  44.   
  45.         {  
  46.   
  47.             sqlce.printStackTrace();  
  48.   
  49.         }  
  50.   
  51.     return hashmap;  
  52.   
  53.     ClassNotFoundException cnfe;  
  54.   
  55.     cnfe;  
  56.   
  57.     cnfe.printStackTrace();  
  58.   
  59.     if(conn != null)  
  60.   
  61.         try  
  62.   
  63.         {  
  64.   
  65.             conn.close();  
  66.   
  67.         }  
  68.   
  69.         catch(SQLException sqlce)  
  70.   
  71.         {  
  72.   
  73.             sqlce.printStackTrace();  
  74.   
  75.         }  
  76.   
  77.     break MISSING_BLOCK_LABEL_188;  
  78.   
  79.     SQLException sqle;  
  80.   
  81.     sqle;  
  82.   
  83.     sqle.printStackTrace();  
  84.   
  85.     if(conn != null)  
  86.   
  87.         try  
  88.   
  89.         {  
  90.   
  91.             conn.close();  
  92.   
  93.         }  
  94.   
  95.         catch(SQLException sqlce)  
  96.   
  97.         {  
  98.   
  99.             sqlce.printStackTrace();  
  100.   
  101.         }  
  102.   
  103.     break MISSING_BLOCK_LABEL_188;  
  104.   
  105.     Exception exception;  
  106.   
  107.     exception;  
  108.   
  109.     if(conn != null)  
  110.   
  111.         try  
  112.   
  113.         {  
  114.   
  115.             conn.close();  
  116.   
  117.         }  
  118.   
  119.         catch(SQLException sqlce)  
  120.   
  121.         {  
  122.   
  123.             sqlce.printStackTrace();  
  124.   
  125.         }  
  126.   
  127.     throw exception;  
  128.   
  129.     return null;  
  130.   
  131. }  
实际代码如下：

  1. public HashMap f5()  
  2.   
  3. {  
  4.   
  5.   
  6.   
  7.     Connection conn = null;  
  8.   
  9.     try  
  10.   
  11.     {  
  12.   
  13.         HashMap map = new HashMap();  
  14.   
  15.         Class.forName("");  
  16.   
  17.         conn = DriverManager.getConnection("jdbc:odbc:");  
  18.   
  19.         PreparedStatement pstmt = conn.prepareStatement("select * from table");  
  20.   
  21.         pstmt.setString(1, "param");  
  22.   
  23.         ResultSet rs = pstmt.executeQuery();  
  24.   
  25.         while (rs.next())  
  26.   
  27.         {  
  28.   
  29.             String columnVallue = rs.getString("column");  
  30.   
  31.             map.put(columnVallue, "");  
  32.   
  33.         }  
  34.   
  35.         return map;  
  36.   
  37.     }  
  38.   
  39.     catch (ClassNotFoundException cnfe)  
  40.   
  41.     {  
  42.   
  43.         cnfe.printStackTrace();  
  44.   
  45.     }  
  46.   
  47.     catch (SQLException sqle)  
  48.   
  49.     {  
  50.   
  51.         sqle.printStackTrace();  
  52.   
  53.     }  
  54.   
  55.     finally  
  56.   
  57.     {  
  58.   
  59.         if (conn != null)  
  60.   
  61.         {  
  62.   
  63.             try  
  64.   
  65.             {  
  66.   
  67.                 conn.close();  
  68.   
  69.             }  
  70.   
  71.             catch (SQLException sqlce)  
  72.   
  73.             {  
  74.   
  75.                 sqlce.printStackTrace();  
  76.   
  77.             }  
  78.   
  79.         }  
  80.   
  81.     }  
  82.   
  83.     return null;  
  84.   
  85. }  
6、两层异常嵌套代码还原 反编译后的代码

  1. public int f6()  
  2.   
  3. {  
  4.   
  5.     int i = cal.getTime().compareTo(new Date());  
  6.   
  7.     System.out.println("finally");  
  8.   
  9.     return i;  
  10.   
  11.     Exception e1;  
  12.   
  13.     e1;  
  14.   
  15.     e1.printStackTrace();  
  16.   
  17.     System.out.println("finally");  
  18.   
  19.     return -1;  
  20.   
  21.     Exception e2;  
  22.   
  23.     e2;  
  24.   
  25.     e2.printStackTrace();  
  26.   
  27.     System.out.println("finally");  
  28.   
  29.     return -2;  
  30.   
  31.     Exception exception;  
  32.   
  33.     exception;  
  34.   
  35.     System.out.println("finally");  
  36.   
  37.     throw exception;  
  38.   
  39. }  
实际代码

  1. public int f6()  
  2.   
  3. {  
  4.   
  5.     try  
  6.   
  7.     {  
  8.   
  9.         try  
  10.   
  11.         {  
  12.   
  13.             return cal.getTime().compareTo(new Date());  
  14.   
  15.         }  
  16.   
  17.         catch (Exception e1)  
  18.   
  19.         {  
  20.   
  21.             e1.printStackTrace();  
  22.   
  23.             return -1;  
  24.   
  25.         }  
  26.   
  27.     }  
  28.   
  29.     catch (Exception e2)  
  30.   
  31.     {  
  32.   
  33.         e2.printStackTrace();  
  34.   
  35.         return -2;  
  36.   
  37.     }  
  38.   
  39.     finally  
  40.   
  41.     {  
  42.   
  43.         System.out.println("finally");  
  44.   
  45.     }  
  46.   
  47. }  
7、非常诡异的代码 反编译后的代码

  1.     public int f7()  
  2.   
  3.     {  
  4.   
  5.         int i = cal.getTime().compareTo(new Date());  
  6.   
  7.         System.out.println("finally");  
  8.   
  9.         return i;  
  10.   
  11.         Exception e1;  
  12.   
  13.         e1;  
  14.   
  15.         e1.printStackTrace();  
  16.   
  17. _L2:  
  18.   
  19.         System.out.println("finally");  
  20.   
  21.         return -1;  
  22.   
  23.         Exception e2;  
  24.   
  25.         e2;  
  26.   
  27.         e2.printStackTrace();  
  28.   
  29.         if(true) goto _L2; else goto _L1  
  30.   
  31. _L1:  
  32.   
  33.         Exception exception;  
  34.   
  35.         exception;  
  36.   
  37.         System.out.println("finally");  
  38.   
  39.         throw exception;  
  40.   
  41.     }  
原始代码

  1. public int f7()  
  2.   
  3. {  
  4.   
  5.     try  
  6.   
  7.     {  
  8.   
  9.         try  
  10.   
  11.         {  
  12.   
  13.             return cal.getTime().compareTo(new Date());  
  14.   
  15.         }  
  16.   
  17.         catch (Exception e1)  
  18.   
  19.         {  
  20.   
  21.             e1.printStackTrace();  
  22.   
  23.             return -1;  
  24.   
  25.         }  
  26.   
  27.     }  
  28.   
  29.     catch (Exception e2)  
  30.   
  31.     {  
  32.   
  33.         e2.printStackTrace();  
  34.   
  35.         return -1;  
  36.   
  37.     }  
  38.   
  39.     finally  
  40.   
  41.     {  
  42.   
  43.         System.out.println("finally");  
  44.   
  45.     }  
  46.   
  47. }  


cuijinquan
关注
专栏目录
java反编译还原_Java .class文件反编译后的特殊代码还原
weixin_35974411的博客
02-12 1212
javaclass反编译后的代码还原(一)Javaclass利用jad反编译之后，偶尔回碰到一些不正常的代码，例如：label0:_L1MISSING_BLOCK_LABEL_30、JVMINSTRret7、JVMINSTRtableswitch13:default269、JVMINSTRmonitorexit、JVMINSTRmonitorenter，这...
如何在 Visual Studio Code 中反编译具有正确行号的 Java 类？
最新发布
程序猿进阶
09-13 549
经过彻底的搜索后，我发现了一个关于在 Visual Studio Code 中实现 Java 反编译器的未解决的问题，可以在https://github.com/dgileadi/vscode-java-decompiler/issues/4找到。仅供参考，我已经使用外部反编译器检查过，它显示正确的行号，这意味着类或 jar 文件仍然具有调试信息。答：已经使用外部反编译器检查过，它显示了正确的行号，这意味着类或 jar 仍然具有调试信息。我需要原始行号的原因是因为我可以从堆栈跟踪导航到引发异常的确切行。
java class反编译后的代码还原（二）
feelinghappy的专栏
08-21 329
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反编译后的代码还原
hongye
02-17 271
  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 ...
Java Class反编译与代码还原技术解析
Java Class反编译主要是将编译后的字节码转换回Java源代码，这在多种情况下非常有用。开发人员可能因为丢失了源代码，或是想要理解第三方库或框架的工作原理时，需要对编译后的类文件进行反编译。此外，反编译在进行...
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反编译还原
weixin_30767835的博客
06-23 153
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...
java 反编译 重新打包_java根据jar包反编译后修改再打包回jar的做法
weixin_31485835的博客
02-13 606
1. 得到一个待要修改的jar包2. 我的环境是windows，然后解压这个jar包，得到一堆class文件，这时候就找到你需要的那个class文件3. 我首先是使用jd-gui工具看一下这个class文件，然后复制出来，粘贴到一个java文件中，然后对这个文件按你需要的方式进行编辑4. cmd命令调出终端，使用javac 修改后的java文件路径 ---》 重新得出class文件5. 再次使用...
Java .class文件反编译后的特殊代码还原
weixin_30734435的博客
02-10 198
javaclass反编译后的代码还原（一）Javaclass利用jad反编译之后，偶尔回碰到一些不正常的代码，例如：label0:_L1MISSING_BLOCK_LABEL_30、JVMINSTRret7、JVMINSTRtableswitch13:default269、JVMINSTRmonitorexit、JVMINSTRmonit...
java反编译工具对比_主流java反编译器效率比对
weixin_36393239的博客
02-26 786
我们用6个反编译核心进行测试：Procyon-现代Java的快速反编译器CFR-对现代Java来说，非常好且受支持的反编译器JDCore(非常快)Jadx，快速且具有Android支持FernflowerJAD(非常快，但已过时)先来个helloworld，试试源程序public class HelloWorld{public static void main(String[] args){Sys...
java反编译+回编教程
qq_28130847的博客
07-28 1477
放到如下文件夹有需要和原.jar包启动需要的依赖的lib依赖的文件夹下。然后执行javac命令如下命令指向需要的依赖classpath和编码然后即可回编。使用jd-gui-windows打开你需要反编译的jar文件或者.class文件。注意此命令在windows下执行才有效linux格式自行百度。-classpath指定依赖所需要的环境。Class文件放回压缩包。找到要修改的class。存为.java文件。.........
java语言开发技巧:对jar包进行再次修改
helloklzs
04-26 506
在学习和开发JAVA项目中，我们经常会用到第三方提供的一些jar。使用这些第三方工具包，可以提高我们开发的效率，缩短开发的时间。有的第三方工具，提供具体的使用说明和源代码，有时有的却不提供源代码，使用说明也不是很具体，这对我们使用就非常不方便。 　　有道是，知其然才知其所以然。有时候，我们必须读取jar里的打包的类。而有时还有可能要对它进行小量修改，使之适用于自己的非凡需求。 前期预备 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值