Java编程中的流氓手段(1)——天下为公

程序员应是创造者,创造0与1世界中万物万象。程序员也应是毁灭者,毁灭0与1世界中一切令人厌恶的存在。——cping1982

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

俗语云“流氓会武术,谁都挡不住”。

在编程的世界中,这种情况依旧存在,而且比之现实世界还有过之而无不及。

不信你看病毒(含木马)、外挂、流氓插件这许许多多优秀程序员的“杰作”充斥互联网上,而且愈演愈烈,大有燎原之势,试问现实世界中,流氓有他们那么嚣张吗?即使那么嚣张,发展能有这么快吗?

且不但嚣张,投身其中的“有志青年”还个个事业有成,虽然跻身富豪行列者还寥寥可数,比之我等小程序员们,却也可谓功成名就,家财颇丰了。

但无论再怎么羡慕人家,我们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
阅读更多

没有更多推荐了,返回首页