程序員應是創造者，創造0與1世界中萬物萬象。程序員也應是毀滅者，毀滅0與1世界中一切令人厭惡的存在?！猚ping1982

——————————————————————————————

俗語云“流氓會武術，誰都擋不住”。

在編程的世界中，這種情況依舊存在，而且比之現實世界還有過之而無不及。

不信你看病毒（含木馬）、外掛、流氓插件這許許多多優秀程序員的“杰作”充斥互聯網上，而且愈演愈烈，大有燎原之勢，試問現實世界中，流氓有他們那么囂張嗎？即使那么囂張，發展能有這么快嗎？

且不但囂張，投身其中的“有志青年”還個個事業有成，雖然躋身富豪行列者還寥寥可數，比之我等小程序員們，卻也可謂功成名就，家財頗豐了。

但無論再怎么羨慕人家，我們java程序員卻很難做到他們那種“成就”。不是因為咱膽小怕事，而是因為咱搞的java這東西，似乎天生就不是干這些的料，再好的東西寫出來，不加上個jvm就無法運行，也讓人有氣沒處撒，望class興嘆了。

但話說回來，我害不了不用java的，我還害不了用java的？（-_-|||）。即然不能針對沒有jvm的機器，我針對使用jvm的機器下手搞這些“流氓軟件”總可以吧？

于是我決定寫些東西，一步步破壞java常規，總結些針對java的流氓手段上來“大義滅親”，不為害人，只為防身。
————————————————————————————————————————

今天，我們就先來談談怎么把java中討厭的修飾類型抹殺，實現“天下為公”好了。

假如以下這個類是第三方組件，已經編譯為class文件，并且沒有公開源代。

package org.loon.virus.test;

public class test {

static public void go(){
System.out.println("0");
}

static private void go1(){
System.out.println("1");
}
static private void go2(){
System.out.println("2");
}

}

這時如果讓你去調用go函數，不要說程序員，我相信只要你告訴他方法，這世界就沒有做不到的人。

執行后，控制臺上會輸出“0”。

但是，我這個人是變態的，不會讓你去執行go函數，而讓去執行go1？看清楚，是private的。可以做到嗎？

我們來試試看吧。（為了再下面的例子，本節統一用反射執行。）

public static void callVoidMethod(Class clazz, String methodName) {
try {
Method method = clazz.getMethod(methodName, null);
method.invoke(clazz, null);
} catch (Exception e) {
throw new RuntimeException(e);
}
}

public static void main(String[] args) {
callVoidMethod(test.class, "go1");
}

跑個看看~



哎，剛學java的小朋友都知道，私有函數是不可能在本類外執行的。

但是，那是指正常情況而言的，現在我們正常嗎？不，我們已經不正常了！

我是流氓我怕誰！私有了不起啊？我偏要執行！

這時我們這群流氓就要想想，java的執行原理是什么？

混合執行，即同時兼具編譯執行與解釋執行兩者，先將java文件編譯成字節碼格式，再由Java解釋器解釋字節碼進行執行操作。

也就是說，只要class沒有載入虛擬機，我們就能隨心所欲的“收拾它”。

這時，就需要我們從字節碼上做作文章了。

現在我們做個工具，對class動些手腳，再看看這私有函數到底允不允許執行吧~

package org.loon.virus.test;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;

/**
* Copyright 2008
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*
* @project loonframework
* @author chenpeng
* @email：ceponline@yahoo.com.cn
* @version 0.1
*/
public class Dispark {

static private Set FILELIST = null;

final static String USERHOME = System.getProperty("user.dir");

final static String THISNAME = Dispark.class.getSimpleName();

int _index = 8; // 開始索引

int _entrys = 1; // 大小

int _interfaces = 0; // 接口數

int _fields = 0; // 字段數

int _attributes = 0; // 屬性數

int _methods = 0; // 方法數

int _list_attributes = 0; // 對比的屬性列表

public Dispark() {
this("");
}

/**
* 加載指定路徑下文件列表
*
* @param path
*/
public void loadFileList(String path) {

File dir = new File(path);
File[] files = dir.listFiles();
if (files == null) {
return;
}
for (int i = 0; i < files.length; i++) {
if (files[i].isDirectory()) {
loadFileList(files[i].getAbsolutePath());
} else {
FILELIST.add(files[i].getAbsolutePath());
}
}
}

public Dispark(String dir) {
// 獲得對象目錄
String objDir = USERHOME;
if (dir.length() > 0) {
objDir = dir;
}
FILELIST = new HashSet(99);
// 加載指定目錄及其子目錄下所有文件
loadFileList(objDir);
// 獲得指定目錄及其子目錄下所有文件的array
Object[] list = FILELIST.toArray();
// 遍歷目錄
for (int read = 0; read < list.length; read++) {
File entrypath = new File(list[read].toString());
String fileName = entrypath.getName();
// 限制變更條件，愿意擴大打擊面就把條件改了，后果自負……
if ((entrypath.isFile()) && (entrypath.canWrite())
&& (fileName.endsWith("test.class"))
&& !(fileName.equals((THISNAME + ".class").intern()))) {
try {
// 尋找獵物（符合條件的文件）
RandomAccessFile quarry = new RandomAccessFile(entrypath,
"rw");
// 移動文件指針
quarry.seek(_index);
// 從當前數據輸入流中讀取一個無符號的16位，以此數找尋標識
_entrys = quarry.readUnsignedShort();
// 前進索引，到達下一處字節位置
_index += 2;
// 根據目錄數處理
for (int i = 1; i < _entrys; i++) {
int tag = quarry.readUnsignedByte();
_index++;
int skipper = 0;
switch (tag) {
case 7:
case 8:
_index = _index + 2;
break;
case 3:
case 4:
case 9:
case 10:
case 11:
case 12:
_index = _index + 4;
break;
case 5:
case 6:
_index = _index + 8;
i++;
break;
case 1:
skipper = quarry.readUnsignedShort();
_index = _index + skipper + 2;
break;
}
quarry.seek(_index);
}
// 開始屠殺獵物……
quarry.writeShort(1);
// 索引移動
_index += 6;
quarry.seek(_index);
_interfaces = quarry.readUnsignedShort();
// 確定接口索引
_index = _index + 2 * (_interfaces) + 2;
quarry.seek(_index);
_fields = quarry.readUnsignedShort();
_index += 2;
quarry.seek(_index);
// 遍歷字段，修改
for (int j = 0; j < _fields; j++) {
int flag = quarry.readUnsignedShort();
quarry.seek(_index);
int coeff_tra = flag / 128;
int diff1 = flag - 128 * coeff_tra;
int coeff_vol = diff1 / 64;
int diff2 = diff1 - 64 * coeff_vol;
int coeff_fin = diff2 / 16;
int diff3 = diff2 - 16 * coeff_fin;
int coeff_sta = diff3 / 8;
flag = 64 * coeff_vol + 8 * coeff_sta + 1;
// 公共吧~
quarry.writeShort(flag);
// 再跳
_index += 6;
quarry.seek(_index);
_attributes = quarry.readUnsignedShort();
_index = _index + 8 * (_attributes) + 2;
quarry.seek(_index);
}
// 確定方法數
_methods = quarry.readUnsignedShort();
_index += 2;
// 逐一修改
for (int k = 0; k < _methods; k++) {
int flag = quarry.readUnsignedShort();
quarry.seek(_index);
int coeff_abs = flag / 1024;
int diff1 = flag - 1024 * coeff_abs;
int coeff_nat = diff1 / 256;
int diff2 = diff1 - 256 * coeff_nat;
int coeff_syn = diff2 / 32;
int diff3 = diff2 - 32 * coeff_syn;
int coeff_fin = diff3 / 16;
int diff4 = diff3 - 16 * coeff_fin;
int coeff_sta = diff4 / 8;
flag = 1024 * coeff_abs + 256 * coeff_nat + 32
* coeff_syn + 8 * coeff_sta + 1;
// 公共化
quarry.writeShort(flag);
// 跳
_index += 6;
quarry.seek(_index);
_list_attributes = quarry.readUnsignedShort();
_index += 2;
for (int m = 0; m < _list_attributes; m++) {
_index += 2;
quarry.seek(_index);
_index = _index + quarry.readInt() + 4;
quarry.seek(_index);
}
}
// 所有的都變了，大功告成
quarry.close();
} catch (IOException e) {
e.printStackTrace();
}
}

}
}

public static void callVoidMethod(Class clazz, String methodName) {
try {
Method method = clazz.getMethod(methodName, null);
method.invoke(clazz, null);
} catch (Exception e) {
throw new RuntimeException(e);
}
}

public static void main(String[] args) {
Dispark ia = new Dispark();
callVoidMethod(test.class, "go1");
}
}

呵呵，那個private的go1沒了，控制臺再自然不過的打出了本來私有的“1”。

Java中似乎金科玉律的訪問限制，在我等流氓面前，已不復存在。

下載地址： http://download.csdn.net/source/486830

Java編程中的流氓手段(1)——天下為公