java反編譯goto
❶ 混淆的class文件怎麼進行反編譯
一般情況下java應用的開發者為了保護代碼不被別人抄襲，在生成class文件的時候都java文件進行了混淆，這種class文件用反編譯工具得到的結果很難看懂，並且不能進行編譯。
從研究的角度，淺析如何讀懂這種反編譯過來的文件。
例子一：賦值
反編譯過來的代碼如下：
Node node;
Node node1 = _$3.getChildNodes().item(0);
node1;
node1;
JVM INSTR swap ;
node;
getChildNodes();
0;
item();
getChildNodes();
0;
item();
getNodeValue();
String s;
s;
原始語句：
Node node;
Node node1 = currDocument.getChildNodes().item(0);
node = node1;
String s = node.getChildNodes().item(0).getChildNodes().item(0).getNodeValue();
註解：
JVM INSTR swap ; //賦值語句
練習：
String s1;
String s8 = node.getChildNodes().item(1).getChildNodes().item(0).getNodeValue();
s8;
s8;
JVM INSTR swap ;
s1;
10;
Integer.parseInt();
int i;
i;
例子二：不帶參數創建對象
反編譯過來的代碼如下：
JVM INSTR new #244 ;
JVM INSTR p ;
JVM INSTR swap ;
CrossTable();
CrossTable crosstable;
crosstable;
原始語句：
CrossTable crosstable = new CrossTable();
註解：
練習：
JVM INSTR new #246 ;
JVM INSTR p ;
JVM INSTR swap ;
Database();
Object obj;
obj;
例子三：帶參數創建對象
反編譯過來的代碼如下：
JVM INSTR new #262 ;
JVM INSTR p ;
JVM INSTR swap ;
String.valueOf(s2);
StringBuffer();
s.substring(j, i);
append();
s6;
append();
toString();
s2;
原始語句：
s2 = (new StringBuffer(String.valueOf(s2))).append(s.substring(j, i)).append(s6).toString();
註解：
此語句實際上是：s2 += s.substring(j, i) + s6;
練習：
例子四：for循環
反編譯過來的代碼如下：
int k = 0;
goto _L4
_L8:
...
k++;
_L4:
if(k < as.length) goto _L8; else goto _L7
原始語句：
for(int k=0;k < as.length;k++)
{
...
}
註解：
例子五：while循環
反編譯過來的代碼如下：
String s1 = "";
goto _L1
_L3:
JVM INSTR new #262 ;
JVM INSTR p ;
JVM INSTR swap ;
String.valueOf(s1);
StringBuffer();
_$2(resultset, s, l);
append();
toString();
s1;
_L1:
if(resultset.next()) goto _L3; else goto _L2
原始語句：
String s1 = "";
while(resultset.next())
{
s1 = s1 + resultSetToString(resultset, s, l);
}
❷ vb exe程序能夠反編譯到何種程度
反編譯到代碼的程度。和你自己的源代碼的差別就是一些sub/function的名字。
想增加反編譯後解讀難度的話，多加一些sub/function，多加一些goto。
❸ java的源代碼隱藏問題
你要的功能其實是Java代碼混淆，如果要了解Java編譯成exe，可以看「參考資料」。
下面一段文字摘自《Java 手機/PDA 程序設計入門》一書，可以做為混淆器性能的大致觀點：
筆者沒用過DashO，所以無法對其作出個人評價。所以現在僅說明筆者曾用過的產品。以筆者的個人觀點，如果就混淆的程度來說，ZKM最好，JAX中等，RetroGuard和ProGuard最差，一分錢一分貨，這是千古不變的道理。如果就功能性而言，ZKM和JAX都不錯，不過，JAX是IBM所開發的產品，因此也繼承了大部分IBM產品的最大特色，就是「功能超強，可是不易使用」，可能光是要看完JAX的設定文件就是一個很大的問題。
下面分別介紹幾種具有代表性的混淆器，對它們的產品性能進行對比。我們使用不同混淆器對同一段java代碼進行混淆，分別列出混淆後代碼反編譯的結果，並給出使用的一些直接體會。
原始java代碼：
public class SimpleBean implements Serializable {
private String[] name = {"name0","name1","name2","name3"};
private List myList = null;
public void SimpleBean() {
myList = new ArrayList(4);
}
public void init_public() {
myList.add("name");
for(int i= 1; i < 4; i++){
init_private(i);
}
}
private void init_private(int j) {
myList.add(name[j]);
}
private void writeObject(java.io.ObjectOutputStream out)
throws IOException {
}
}
一、ProGuard 4.5.1
ProGuard是一款免費的Java類文件壓縮器、優化器和混淆器。它能發現並刪除無用類、欄位（field）、方法和屬性值（attribute）。它也能優化位元組碼並刪除無用的指令。最後，它使用簡單無意義的名字來重命名你的類名、欄位名和方法名。經過以上操作的jar文件 會變得更小，並很難進行逆向工程。eclipse已經把Proguard集成在一起了。它支持腳本控制，可以使用GUI界面，字元串不加密，支持 J2ME。
類似功能的開源混淆器：
RetroGuard yGuard（RetroGuard的一個升級版本） JODE
Jad反編譯混淆後class得到的代碼：
public class SimpleBean
implements Serializable
{
public SimpleBean()
{
a_java_util_List_fld = null;
}
public void SimpleBean()
{
a_java_util_List_fld = new ArrayList(4);
}
public void init_public()
{
a_java_util_List_fld.add("name");
for(int i = 1; i < 4; i++)
{
int j = i;
SimpleBean simplebean = this;
a_java_util_List_fld.add(simplebean.a_java_lang_String_array1d_fld[j]);
}
}
private String a_java_lang_String_array1d_fld[] = {
"name0", "name1", "name2", "name3"
};
private List a_java_util_List_fld;
}
優點：
1、對內部private方法的調用進行了內聯，但基本達不到混淆效果；
2、使用文檔詳盡，混淆選項配置文件的編寫示例多；
3、混淆選項粒度較細，可以使用GUI界面，支持本地方法的保護等；
4、支持j2me，可以集成到Eclipse；
5、開源。
缺點：
1、符號混淆的命名具有提示性，字元串未加密，沒有其它的混淆措施；
2、混淆主要針對Xlet、Midlet等應用，混淆庫文件時配置文件將會很復雜。
二、Jocky
Jocky是金蝶中間件技術領袖袁紅崗先生的個人作品（舊有名稱JOC)。原本是方便Apusic 應用伺服器的開發，現在開放出來，供大家自由使用。Jocky混淆編譯器是在Sun JDK中提供的Java編譯器(javac)的基礎上完成的，修改了其中的代碼生成過程，對編譯器生成的中間代碼進行混淆，最後再生成class文件，這樣編譯和混淆只需要一個步驟就可以完成。也就是說，它是直接從源碼上做文章，這是Jocky與其它混淆編譯器最大的不同之處。另外可以在源程序中插入符號保留指令來控制哪些符號需要保留，將混淆過程與開發過程融合在一起，不需要單獨的混淆選項配置文件。Jocky的上述特點較適合於java類庫的混淆。
Jad反編譯混淆後class得到的代碼：
public class SimpleBean
implements Serializable
{
public SimpleBean()
{
this;
String as[] = new String[4];
as;
as[0] = "name0";
as;
JVM INSTR swap ;
1;
"name1";
JVM INSTR aastore ;
JVM INSTR p ;
JVM INSTR swap ;
2;
"name2";
JVM INSTR aastore ;
JVM INSTR p ;
JVM INSTR swap ;
3;
"name3";
JVM INSTR aastore ;
_$2;
_$1 = null;
return;
}
public void SimpleBean()
{
this;
JVM INSTR new #9 <Class ArrayList>;
JVM INSTR p ;
JVM INSTR swap ;
4;
ArrayList();
_$1;
}
public void init_public()
{
_$1.add("name");
for(int i = 1; i < 4; i++)
_$1(i);
}
private void _$1(int i)
{
_$1.add(_$2[i]);
}
private void writeObject(ObjectOutputStream objectoutputstream)
throws IOException
{
}
private String _$2[];
private List _$1;
}
優點：
1、除符號混淆外增加了數據混淆（字元數組初始化）；
2、有一些語句反編譯只能得到位元組碼指令；
3、在Sun JDK中提供的Java編譯器(javac)的基礎上完成，編譯和混淆一體完成，不需要先生成class文件再混淆；
4、提供了Eclipse的插件，能夠直接在Eclipse中使用Jocky。
缺點：
1、混淆選項粒度較粗，使用中可能要在具體代碼中添加@preserve指令來實現，工作量大；
2、沒有控制流混淆。
三、Allatori 3.1_demo
Allatori屬於第二代混淆器，具有全方位保護你的知識產權的能力。Allatori具有以下幾種保護方式：命名混淆，流混淆，調試信息混淆，字元串編碼，以及水印技術。對於教育和非商業項目來說這個混淆器是免費的。2.1版本支持war和ear文件格式，並且允許對需要混淆代碼的應用程序添加有效日期。
Jad反編譯混淆後class得到的代碼：
public class SimpleBean
implements Serializable
{
public void init_public()
{
d.add(c.k("{u{0"));
int i = 1;
goto _L1
_L3:
H(i);
++i;
_L1:
4;
JVM INSTR icmplt 21;
goto _L2 _L3
_L2:
}
public void SimpleBean()
{
d = new ArrayList(4);
}
private void H(int a)
{
d.add(c[a]);
}
public SimpleBean()
{
d = null;
}
private void H(ObjectOutputStream objectoutputstream)
throws IOException
{
}
private String c[] = {
c.k("\177q\177te"), c.k("\177q\177td"), c.k("\177q\177tg"), c.k("\177q\177tf")
};
private List d;
}
註：c.k是為進行字元串加密額外生成的類c的靜態方法。
優點：
1、設計考慮了庫文件混淆的使用場景；
2、使用文檔詳盡，混淆選項配置文件的編寫示例多；
3、除符號混淆外，還使用了兩種高級的混淆手段：控制混淆（改寫了for循環）和字元串加密（String數組初始化）；
4、混淆選項粒度較細，支持本地方法的保護等；
5、支持水印技術，允許對需要混淆的代碼添加有效日期；
6、支持j2me；
缺點：
1、商業軟體（價格附後），對教育和非商業用途免費（網站鏈接是http://www.allatori.com/price.html）。
附：價格情況
SINGLE DEVELOPER LICENSE
1 license $290
2-5 licenses $260
6-10 licenses $230
11+ licenses $200
SITE LICENSE $3750
BUSINESS LICENSE $4850
ANNUAL SUPPORT UPDATE $45
四、Zelix KlassMaster（ZKM）
Zelix KlassMaster是一個來自Zelix Pty Ltd的商業混淆器。官方文檔中關於它的混淆特性的介紹很少。它的保護功能非常強大，可以進行符號混淆和控制混淆，支持字元串的復雜加密保護，堆棧混亂，支持異常重構，支持增量混淆，支持J2ME。Zelix KlassMaster提供試用版本，可以到http://www.zelix.com下載。
五、DashO Pro
DashO Pro 是由Preemptive Solutions開發的商業化的混淆器. 免費的評估版可以到http://www.preemptive.com下載。DashO Pro代碼保護能力強大易用，方便靈活（商業軟體，非開源）。該Java混淆器是Sun的選擇，對於企業級應用，作為其Java開發包的一部分，Sun微系統使用DashO Pro來混淆其加密庫。DashO Pro能夠對ID進行重新命名，使之成為毫無意義的字元；混淆元數據；改變控制流等，所有這些操作使得java代碼被混淆，難於理解。產品特點包括：
領先的Java源碼保護機制；
運用專利Overload-Inction技術對包/類/方法/域進行重命名；
高級的流程式控制制混淆機制；
字元串加密技術；
防止反編譯器生成有用的輸出；
水印軟體；
提高Java源碼效率；
不採用類/方法/域，全面移除常數存儲庫；
類/方法級別的優化，以提高JIT效果；
動態載入檢測到的類；
全面高效的Java源碼的拓展和部署；
支持所有的JDK版本 (JSE, J2EE, J2ME, etc)包括1.5；
自動堆棧跟蹤轉換；
在指定路徑打包或者java jars；
支持任何打包類型的Java內容——程序、庫、applets程序、小伺服器程序、EJB等；支持基於J2ME CLDC的架構，包括MIDP和 iAppli；
支持CLDC預檢驗庫中的類；
可以從指定路徑、Zip壓縮包或者jars中提取；
支持導出100%純粹的Java，並提供驗證；
命令行介面適合集成到構建環境內；
基於XML的配置文件，易於使用；
全面准確的PDF格式用戶指南。
❹ jave語言的string字元串有哪些特點
以主流的 JDK 版本 1.8 來說，String 內部實際存儲結構為 char 數組，源碼如下：
publicfinalclassString
implementsjava.io.Serializable,Comparable<String>,CharSequence{
//用於存儲字元串的值privatefinalcharvalue[];
//緩存字元串的hashcodeprivateinthash;//Defaultto0
//......其他內容}
String源碼中包含下面幾個重要的方法。
1. 多構造方法
String 字元串有以下 4 個重要的構造方法：
//String為參數的構造方法publicString(Stringoriginal){
this.value=original.value;
this.hash=original.hash;
}//char[]為參數構造方法publicString(charvalue[]){
this.value=Arrays.Of(value,value.length);
}//StringBuffer為參數的構造方法publicString(StringBufferbuffer){
synchronized(buffer){
this.value=Arrays.Of(buffer.getValue(),buffer.length());
}
}//StringBuilder為參數的構造方法publicString(StringBuilderbuilder){
this.value=Arrays.Of(builder.getValue(),builder.length());
}
其中，比較容易被我們忽略的是以 StringBuffer 和 StringBuilder 為參數的構造函數，因為這三種數據類型，我們通常都是單獨使用的，所以這個小細節我們需要特別留意一下。
2. equals() 比較兩個字元串是否相等，源碼如下：
publicbooleanequals(ObjectanObject){
//對象引用相同直接返回trueif(this==anObject){
returntrue;
}
//判斷需要對比的值是否為String類型，如果不是則直接返回falseif(anObjectinstanceofString){
StringanotherString=(String)anObject;
intn=value.length;
if(n==anotherString.value.length){
//把兩個字元串都轉換為char數組對比charv1[]=value;
charv2[]=anotherString.value;
inti=0;
//循環比對兩個字元串的每一個字元while(n--!=0){
//如果其中有一個字元不相等就truefalse，否則繼續對比if(v1[i]!=v2[i])
returnfalse;
i++;
}
returntrue;
}
}
returnfalse;
}
String 類型重寫了 Object 中的 equals() 方法，equals() 方法需要傳遞一個 Object 類型的參數值，在比較時會先通過 instanceof 判斷是否為 String 類型，如果不是則會直接返回 false，instanceof 的使用如下：
ObjectoString="123";
ObjectoInt=123;
System.out.println(oStringinstanceofString);//返回trueSystem.out.println(oIntinstanceofString);//返回false
當判斷參數為 String類型之後，會循環對比兩個字元串中的每一個字元，當所有字元都相等時返回true，否則則返回 false。
還有一個和equals()比較類似的方法 equalsIgnoreCase()，它是用於忽略字元串的大小寫之後進行字元串對比。
3. compareTo() 比較兩個字元串
compareTo()方法用於比較兩個字元串，返回的結果為int類型的值，源碼如下：
publicintcompareTo(StringanotherString){
intlen1=value.length;
intlen2=anotherString.value.length;
//獲取到兩個字元串長度最短的那個int值intlim=Math.min(len1,len2);
charv1[]=value;
charv2[]=anotherString.value;
intk=0;
//對比每一個字元while(k<lim){
charc1=v1[k];
charc2=v2[k];
if(c1!=c2){
//有字元不相等就返回差值returnc1-c2;
}
k++;
}
returnlen1-len2;
}
從源碼中可以看出，compareTo()方法會循環對比所有的字元，當兩個字元串中有任意一個字元不相同時，則 returnchar1-char2。比如，兩個字元串分別存儲的是 1和 2，返回的值是 -1；如果存儲的是 1和 1，則返回的值是 0 ，如果存儲的是 2和 1，則返回的值是 1。
還有一個和compareTo()比較類似的方法 compareToIgnoreCase()，用於忽略大小寫後比較兩個字元串。
可以看出compareTo()方法和equals()方法都是用於比較兩個字元串的，但它們有兩點不同：
equals()可以接收一個 Object類型的參數，而 compareTo()只能接收一個String類型的參數；
equals()返回值為Boolean，而compareTo()的返回值則為int。
它們都可以用於兩個字元串的比較，當equals()方法返回true時，或者是compareTo()方法返回 0時，則表示兩個字元串完全相同。
4.其他重要方法
indexOf()：查詢字元串首次出現的下標位置
lastIndexOf()：查詢字元串最後出現的下標位置
contains()：查詢字元串中是否包含另一個字元串
toLowerCase()：把字元串全部轉換成小寫
toUpperCase()：把字元串全部轉換成大寫
length()：查詢字元串的長度
trim()：去掉字元串首尾空格
replace()：替換字元串中的某些字元
split()：把字元串分割並返回字元串數組
join()：把字元串數組轉為字元串
知識擴展
1.== 和equals的區別
== 對於基本數據類型來說，是用於比較 「值」是否相等的；而對於引用類型來說，是用於比較引用地址是否相同的。
查看源碼我們可以知道 Object 中也有equals() 方法，源碼如下：
publicbooleanequals(Objectobj){
return(this==obj);
}
可以看出，Object 中的 equals() 方法其實就是 ==，而 String 重寫了 equals() 方法把它修改成比較兩個字元串的值是否相等。
publicbooleanequals(ObjectanObject){
//對象引用相同直接返回trueif(this==anObject){
returntrue;
}
//判斷需要對比的值是否為String類型，如果不是則直接返回falseif(anObjectinstanceofString){
StringanotherString=(String)anObject;
intn=value.length;
if(n==anotherString.value.length){
//把兩個字元串都轉換為char數組對比charv1[]=value;
charv2[]=anotherString.value;
inti=0;
//循環比對兩個字元串的每一個字元while(n--!=0){
//如果其中有一個字元不相等就truefalse，否則繼續對比if(v1[i]!=v2[i])
returnfalse;
i++;
}
returntrue;
}
}
returnfalse;
}
2.final修飾的好處
從String類的源碼我們可以看出String是被final修飾的不可繼承類，源碼如下：
publicfinalclassString implementsjava.io.Serializable,Comparable<String>,CharSequence{//......}
那這樣設計有什麼好處呢？他會更傾向於使用 final，因為它能夠緩存結果，當你在傳參時不需要考慮誰會修改它的值；如果是可變類的話，則有可能需要重新拷貝出來一個新值進行傳參，這樣在性能上就會有一定的損失。
String 類設計成不可變的另一個原因是安全，當你在調用其他方法時，比如調用一些系統級操作指令之前，可能會有一系列校驗，如果是可變類的話，可能在你校驗過後，它的內部的值又被改變了，這樣有可能會引起嚴重的系統崩潰問題，這是迫使 String 類設計成不可變類的一個重要原因。
總結來說，使用 final 修飾的第一個好處是安全；第二個好處是高效，以 JVM 中的字元串常量池來舉例，如下兩個變數：
Strings1="java";
Strings2="java";
只有字元串是不可變時，我們才能實現字元串常量池，字元串常量池可以為我們緩存字元串，提高程序的運行效率，如下圖所示：
除此之外編譯器還會對String字元串做一些優化，例如以下代碼：
Strings1="Ja"+"va";
Strings2="Java";
System.out.println(s1==s2);
雖然s1拼接了多個字元串，但對比的結果卻是true，我們使用反編譯工具，看到的結果如下：
Compiledfrom"StringExample.java"publicclasscom.lagou.interview.StringExample{
publiccom.lagou.interview.StringExample();
Code:
0:aload_0
1:invokespecial#1//Methodjava/lang/Object."<init>":()V4:returnLineNumberTable:
line3:0publicstaticvoidmain(java.lang.String[]);
Code:
0:ldc#2//StringJava2:astore_1
3:ldc#2//StringJava5:astore_2
6:getstatic#3//Fieldjava/lang/System.out:Ljava/io/PrintStream;9:aload_1
10:aload_2
11:if_acmpne1814:iconst_1
15:goto1918:iconst_0
19:invokevirtual#4//Methodjava/io/PrintStream.println:(Z)V22:returnLineNumberTable:
line5:0line6:3line7:6line8:22}
從編譯代碼 #2 可以看出，代碼 "Ja"+"va" 被直接編譯成了 "Java" ，因此 s1==s2 的結果才是 true，這就是編譯器對字元串優化的結果。