精华内容
下载资源
问答
  • 将dll注入到资源管理器explorer.exe中
  • 提升为系统权限,注入explorer中 一丶简介 二丶注入效果图 提升为系统权限,注入explorer中 一丶简介 我们上一面说了系统服务拥有系统权限.并且拥有system权限.还尝试启动了一个进程. 那么我们是不是...

    提升为系统权限,注入到explorer中

    一丶简介

    我们上一面说了系统服务拥有系统权限.并且拥有system权限.还尝试启动了一个进程.
    那么我们是不是可以做点坏事了.
    我们有一个系统权限进程.而调用 CreateRemoteThread可以创建远程线程,是否可以注入到我们桌面资源管理器当中那.
    答案是可以的.我也试过提权的方式注入.可惜都是拒绝访问.所以我提升为system权限(系统服务,创建的我们进程就是system权限)
    然后进行注入的.最后是可以注入的.
    我们资源管理器是64位的,所以我们的进程需要也是64.我们的DLL 也要64.当然网上很多32进程注入DLL到64位各种都很多.
    这里为了方便.直接 64进程+64DLL进行注入的.
    代码如下:

    void Cx64InjectProcessDlg::OnBnClickedOk()
    {
    
        //AdjustPrivileges();
        // TODO:  在此添加控件通知处理程序代码
        HANDLE                   hProcessSnap = NULL;
        BOOL                       bRet = FALSE;
        PROCESSENTRY32   pe32 = { 0 };
    
        hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hProcessSnap == INVALID_HANDLE_VALUE)
            return;
    
        pe32.dwSize = sizeof(PROCESSENTRY32);
    
        if (Process32First(hProcessSnap, &pe32))
        {
            do
            {
                if (!wcscmp(_wcsupr(pe32.szExeFile), _wcsupr(TEXT("EXPLORER.EXE"))))
                {
                    HANDLE   hProHandle =
                        OpenProcess(PROCESS_ALL_ACCESS,
                        FALSE, pe32.th32ProcessID);
                    //进行注入
                    if (NULL == hProHandle)
                    {
                        OutputDebugString(TEXT("权限失败"));
                        return;
                    }
                    LPVOID lpAddr = VirtualAllocEx(hProHandle, NULL, 0x1000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
                    if (NULL == lpAddr)
                    {
                        return;
                    }
    
                    TCHAR szBuf[MAX_PATH] = TEXT("x64Test.dll");
                    //GetCurrentDirectory(sizeof(szBuf), szBuf); //这三行代码主要是拼接我们的DLL,DLL是我们自己写的
                    //wcscat(szBuf, TEXT("x64Test.dll"));//DLL这里就不写了,用我的吧,我会发上去的
                    OutputDebugString(szBuf);
                    BOOL bRet = WriteProcessMemory(hProHandle, lpAddr, szBuf, wcslen(szBuf) + 2, NULL);
                    if (!bRet)
                    {
    
                        return;
                    }
    
                    HANDLE hThreadHandle = CreateRemoteThread(hProHandle,
                        NULL,
                        0,
                        (LPTHREAD_START_ROUTINE)LoadLibrary,
                        lpAddr,
                        0,
                        NULL);
                    if (!hThreadHandle)
                    {
                        OutputDebugString(TEXT("注入失败了"));
                        return;
                    }
                    OutputDebugString(TEXT("注入了"));
    
                    return;
                }
            } while (Process32Next(hProcessSnap, &pe32));
            bRet = TRUE;
        }
        else
            bRet = FALSE;
    
        CloseHandle(hProcessSnap);
        return  CDialogEx::OnOK();
    }

    二丶注入效果图

    1197364-20190502111637729-263166211.png

    转载于:https://www.cnblogs.com/iBinary/p/10801864.html

    展开全文
  • 方式1: nacos-config.sh和config.txt文件位置需如下放置到同一目录:

    Ctrl+Alt+Del呼出任务管理器,工具栏,文件--新建.任务(运行)--跳出运行窗口,点击浏览

    展开全文
  • exe将dll注入explorer.exe资源管理器进程_DLL注入示例.zip
  • DLL注入explorer.exe进程

    千次阅读 2019-03-07 10:51:20
    **DLL注入explorer.exe进程**   最近一直在学习dll注入远程进程的相关知识,于是有了这篇文章。通过注入的方式会运行程序,在资源管理器中是看不到,相关的进程的,这为程序的隐藏提供了极大的便利。 一、新建dll...

    **DLL注入explorer.exe进程**

      最近一直在学习dll注入远程进程的相关知识,于是有了这篇文章。通过注入的方式会运行程序,在资源管理器中是看不到,相关的进程的,这为程序的隐藏提供了极大的便利。

    一、新建dll动态链接库,然后在dllmain.cpp文件中的 “case DLL_PROCESS_ATTACH:”下输入当你dll被进程加载时要执行的代码。这里我们用 “ MessageBox(NULL, L"呵呵", L"成功了,ye", NULL);”代替。

    二、导出dll文件,注意导出的dll要和系统的位数一样。32位的选择x86,64位的选x64。待后面的项目解决方案使用。

    // dllmain.cpp : 定义 DLL 应用程序的入口点。
    #include "pch.h"
    //#include "ShowModel.h"
    BOOL APIENTRY DllMain( HMODULE hModule,
                           DWORD  ul_reason_for_call,
                           LPVOID lpReserved
                         )
    {
        switch (ul_reason_for_call)
        {
        case DLL_PROCESS_ATTACH:
    		MessageBox(NULL, L"呵呵", L"成功了,ye", NULL);
    		//showFun(L"ddd");
        case DLL_THREAD_ATTACH:
        case DLL_THREAD_DETACH:
        case DLL_PROCESS_DETACH:
            break;
        }
        return TRUE;
    }
    

    三、新建c++控制台项目,导出位数和系统以及刚才的dll一样。

    #include <iostream>
    #include <Windows.h>
    #include <TlHelp32.h>
    bool RemoteThreadInject(SIZE_T dwPid);
    SIZE_T GetProcessIdByName(LPCTSTR pszExeFile);
    int main()
    {
    	SIZE_T pid;
    	pid = GetProcessIdByName(L"explorer.exe");//获取explorer.exe进程id
    	RemoteThreadInject(pid);//将dll注入explorer.exe进程,这样只要有explorer.exe的运行的时候,你的dll程序会一直运行
    }
    //该函数是通过进程的名称来获取进程的id
    SIZE_T GetProcessIdByName(LPCTSTR pszExeFile)
    
    {
    	SIZE_T nProcessID = 0;//定义进程的返回的id
    	PROCESSENTRY32 pe = { sizeof(PROCESSENTRY32) };
    	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);
    	if (hSnapshot != INVALID_HANDLE_VALUE)
    	{
    		if (Process32First(hSnapshot, &pe))
    		{
    			while (Process32Next(hSnapshot, &pe))
    			{
    				if (lstrcmpi(pszExeFile, pe.szExeFile) == 0)
    				{
    					nProcessID = pe.th32ProcessID;
    					break;
    				}
    			}
    		}
    		CloseHandle(hSnapshot);
    	}
    	return nProcessID;
    }
    bool RemoteThreadInject(SIZE_T dwPid)
    {
    	//1.使用PID打开进程获取权限
    	HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, NULL, dwPid);
    	//2.申请内存,写入DLL路径,dll路径必须为绝对路径
    	int nLen = sizeof(WCHAR) * (wcslen(L"F:\\win\\InjectionDll\\x64\\Release\\InjectionDll.dll") + 1);
    	LPVOID pBuf = VirtualAllocEx(hProcess, NULL, nLen, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
    	if (!pBuf)
    	{
    		printf("申请内存失败!\n");
    		return false;
    	}
    	//3.写入内存
    	SIZE_T dwWrite = 0;
    	if (!WriteProcessMemory(hProcess, pBuf, L"F:\\win\\InjectionDll\\x64\\Release\\InjectionDll.dll", nLen, &dwWrite))
    	{
    		printf("写入内存失败!\n");
    		return false;
    	}
    	//4.创建远程线程,让对方调用LoadLibrary
    	HANDLE hRemoteThread = CreateRemoteThread(hProcess, NULL, NULL,
    		(LPTHREAD_START_ROUTINE)LoadLibrary, pBuf, 0, 0);
    	//5.等待线程结束返回,释放资源
    	WaitForSingleObject(hRemoteThread, -1);
    	CloseHandle(hRemoteThread);
    	VirtualFreeEx(hProcess, pBuf, 0, MEM_FREE);
    	return true;
    }
    

    这样我们就达到了隐藏运行程序的目的。菜鸟初次写文章。

    展开全文
  • explorer注入dll[转]

    千次阅读 2009-02-09 16:01:00
    转载自 事在人为最近在学习如何向其它...这让我突然想到了提供操作界面的进程explorer.exe.对于用户来说,这个并不陌生。好!转入正题。 这里我选择远线程(CreateRemoteThread)注入,因为在kernel32.dll中封装了关于

    转载自 事在人为

    最近在学习如何向其它进程地址空间进行dll注入,主要在于了解一下注入原理,顺便也把有关如何修改进程访问控制列表(ACL)提升权限的知识复习一下,因为这是很有用的。这让我突然想到了提供操作界面的进程explorer.exe.对于用户来说,这个并不陌生。好!转入正题。


       这里我选择远线程(CreateRemoteThread)注入,因为在kernel32.dll中封装了关于装载动态链接库的函数LoadLibraryA(ANSI版本)和LoadLibraryW(Unicode版本),通过它们可以成功地将dll加载到进程的地址空间。令人惊喜的是,函数原型和线程执行函数很相似。
    LoadLibraryA的函数原型:
        HINSTANCE WINAPI LoadLibraryA(LPSTR);
    LoadLibraryW的函数原型:
        HINSTANCE WINAPI LoadLibraryW(LPWSTR);
    线程执行函数原型:
        DWORD WINAPI ThreadProc(LPVOID);
    因此只要让进程以LoadLibrayA或LoadLibraryW做为线程执行函数,便可以把参数中所指定的dll加载到进程的地址空间。要让其它进程创建线程可以通过远线程创建函数CreateRemoteThread进行。但使用时需要注意:你必须有对进程进行操作的PROCESS_VM_OPERATION(为进程分配虚拟地址空间时用到),PROCESS_VM_WRITE(向已分配的进程空间写数据时用到),PROCESS_CREATE_THREAD(创建远线程时用到)权限。这里为进程分配的地址空间主要用来存在想要加载的dll文件的路径信息。
       当然并不是所有的进程都允许你以PROCESS_VM_OPERATION|PROCESS_VM_WRITE|PROCESS_CREATE_THREAD的方式来操作它.这时可以尝试修改进程的访问控制列表(Access Control List)把所需的权限加入.如果目标进程阻止你这样去做,你还可以尝试修改安全描述符所有者(the Owner of security descriptor),然后再尝试去获得修改访问控制列表的特权。这样做可以提高注入成功的机率。
    一.源程序清单:
    1.Dll测试样本(Mydll.cpp):
    这里写一个简单的Dll,在Dll装载时,创建一个线程,每隔15秒钟弹出一个对话框,指示注入成功。当然线程函数体内可以写成任何自己想要做的工作,甚至可以继续创建其它线程来完成想要做的工作,比如加载钩子,网络监听等等。这里仅仅是测试,就只提供一个简单的操作。
    #include <windows.h>
    DWORD WINAPI ThreadProc(LPVOID lParam);
    volatile bool G_IsRunning=true;
    HANDLE G_hThread;
    BOOL APIENTRY DllMain(HINSTANCE hInstance,DWORD dwReason,LPVOID lpReserved)
    {
        switch(dwReason){
        case DLL_PROCESS_ATTACH:
            G_hThread=CreateThread(NULL,0,ThreadProc,NULL,0,NULL);
            break;
        case DLL_THREAD_ATTACH:
            break;
        case DLL_THREAD_DETACH:
            break;
        case DLL_PROCESS_DETACH:
            G_IsRunning=false;
            WaitForSingleObject(G_hThread,INFINITE);
            CloseHandle(G_hThread);
           break;
        }
        return true;
    }
    DWORD WINAPI ThreadProc(LPVOID lParam)
    {
        while(G_IsRunning){
         MessageBox(NULL,TEXT("已成功将Dll注入explorer!"),TEXT("提醒"),MB_OK);
         Sleep(15000);
        }
        return 0;
    }
    2.实现注入:
    (1)PutDll.h:
    bool EnablePrivilege(HANDLE hToken,LPCTSTR lpName,TOKEN_PRIVILEGES &OldPrivilege); //打开访问环(Access Token)中指定权限
    bool RestorePrivilege(HANDLE hToken,TOKEN_PRIVILEGES &OldPrivilege); //恢复访问环(Access Token)原来的权限
    bool AdjustDacl(HANDLE hProcess,DWORD dwDesiredAccess); //修改访问控制列表(DACL),打开指定的权限
    HANDLE OpenProcessWithEnoughGrant(DWORD dwProcessId,DWORD dwDesiredAccess); //以指定的权限打开指定ID号的进程
    DWORD GetProcessIdByName(char* lpName); //根据进程名获取进程ID
    (2)PutDll.cpp:
    #include <windows.h>
    #include <tlhelp32.h>
    #include <Accctrl.h>
    #include <Aclapi.h>
    #include <tchar.h>
    #include <wchar.h>
    #include <string.h>
    #include <stdio.h>
    #include "PutDll.h"
    #define DLLNAME "MyDll.dll"
    int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nShowCmd)
    {
        typedef HINSTANCE(WINAPI *lpfnLoadLibraryA)(LPCTSTR*);
        DWORD dwProcessId;
        HANDLE hProcess;
        dwProcessId=GetProcessIdByName("explorer.exe"); //获取exploer.exe进程ID
        if(dwProcessId==0)
           return 1;
        hProcess=OpenProcessWithEnoughGrant(dwProcessId,PROCESS_VM_OPERATION|PROCESS_VM_WRITE|PROCESS_CREATE_THREAD); //根据指定的权限打开目标进程(explorer.exe)
        if(hProcess==NULL)
          return 1;
        HMODULE hModule;
        lpfnLoadLibraryA LoadLibraryA;
        hModule=GetModuleHandle(TEXT("kernel32.dll"));
        if(hModule!=NULL){
            LoadLibraryA=(lpfnLoadLibraryA)GetProcAddress(hModule,TEXT("LoadLibraryA"));
            if(LoadLibraryA!=NULL){
                TCHAR lpPath[_MAX_PATH];
                GetModuleFileName(NULL,lpPath,_MAX_PATH);
                TCHAR Drive[_MAX_DRIVE],Dir[_MAX_DIR],fName[_MAX_FNAME],extName[_MAX_EXT];
                _tsplitpath(lpPath,Drive,Dir,fName,extName);
                _stprintf(lpPath,TEXT("%s%s%s"),Drive,Dir,DLLNAME); //获得要注入Dll路径
                LPTSTR lpRemotePath;
                lpRemotePath=(LPTSTR)VirtualAllocEx(hProcess,NULL,(_tcslen(lpPath)+1)*sizeof(TCHAR),MEM_COMMIT,PAGE_READWRITE); //在目标进程中分配一块虚拟地址空间
                if(lpRemotePath!=NULL){
                    WriteProcessMemory(hProcess,lpRemotePath,lpPath,(_tcslen(lpPath)+1)*sizeof(TCHAR),NULL);//将Dll路径信息保存到目标进程空间中
                    HANDLE hRemoteThread;
                    DWORD dwThreadId;
                    hRemoteThread=CreateRemoteThread(hProcess,NULL,0,
                                      (LPTHREAD_START_ROUTINE)LoadLibraryA,
                 (LPVOID)lpRemotePath,0,&dwThreadId); //在explorer.exe进程中创建一个线程来装载DLL,实现DLL注入
                    if(hRemoteThread!=NULL){
                        WaitForSingleObject(hRemoteThread,INFINITE);
                        CloseHandle(hRemoteThread);
                    }
                    VirtualFreeEx(hProcess,lpRemotePath,0,MEM_RELEASE); //释放先前在目标进程中分配的空间
               }
            }
         }
         CloseHandle(hProcess);
         return 0;
    }
    bool EnablePrivilege(HANDLE hToken,LPCTSTR lpName,TOKEN_PRIVILEGES &OldPrivilege)
    {
        //打开访问环(Access Token)中指定权限
        bool IsSuc=false;
        if(hToken!=NULL){
           TOKEN_PRIVILEGES tkpNewPrivilege;
           tkpNewPrivilege.PrivilegeCount=1;
           tkpNewPrivilege.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;
           if(LookupPrivilegeValue(NULL,lpName,&tkpNewPrivilege.Privileges[0].Luid)){
               DWORD dwBufferLen;
               dwBufferLen=sizeof(TOKEN_PRIVILEGES);
               IsSuc=AdjustTokenPrivileges(hToken,false,&tkpNewPrivilege,dwBufferLen,&OldPrivilege,&dwBufferLen);
               IsSuc=IsSuc&&GetLastError()==ERROR_SUCCESS;
           }
        }
        return IsSuc;
    }
    bool RestorePrivilege(HANDLE hToken,TOKEN_PRIVILEGES &OldPrivilege)
    {
        //恢复访问环(Access Token)原来的权限
        bool IsSuc=false;
        IsSuc=AdjustTokenPrivileges(hToken,false,&OldPrivilege,0,NULL,NULL);
        IsSuc=IsSuc&&GetLastError()==ERROR_SUCCESS;
        return IsSuc;
    }
    bool AdjustDacl(HANDLE hProcess,DWORD dwDesiredAccess)
    {
        //修改访问控制列表(DACL),打开指定的权限
        bool IsSuc=false;
        SID sid={SID_REVISION,1,SECURITY_WORLD_SID_AUTHORITY,0};
        EXPLICIT_ACCESS ea={
            dwDesiredAccess,
            SET_ACCESS,
            NO_INHERITANCE,
           {
               NULL,
               NO_MULTIPLE_TRUSTEE,
               TRUSTEE_IS_SID,
               TRUSTEE_IS_USER,
               reinterpret_cast<LPTSTR>(&sid)
            }
        };
        PACL pAcl;
        if(SetEntriesInAcl(1,&ea,NULL,&pAcl)==ERROR_SUCCESS){
            DWORD dwResult=SetSecurityInfo(hProcess,SE_KERNEL_OBJECT,DACL_SECURITY_INFORMATION,NULL,NULL,pAcl,NULL);
            IsSuc=dwResult==ERROR_SUCCESS;
            LocalFree(pAcl);    
        }
        return IsSuc;
    }
    HANDLE OpenProcessWithEnoughGrant(DWORD dwProcessId,DWORD dwDesiredAccess)
    {
        //以指定的权限打开指定ID号的进程,成功时返回进程句柄,失败返回NULL
        HANDLE hProcess;
        hProcess=OpenProcess(dwDesiredAccess,false,dwProcessId);
        if(hProcess==NULL){
            //以普通方式打开进程失败,尝试以WRITE_DAC的方式打开,以获得WRITE_DAC权限
            //如果以WRITE_DAC的方式打开失败,则尝试以WRITE_OWNER方式打开,以便通过修改安全描述符所有者(security descriptor owner)的方式来获得WRITE_DAC权限
           //只要获得了WRITE_DAC权限,就可以修改进程的访问控制列表(dacl)从设置dwDesiredAccess指定的权限
           HANDLE hWriteDAC;
           hWriteDAC=OpenProcess(WRITE_DAC,false,dwProcessId);
           if(hWriteDAC==NULL){
               //第一次尝试失败,无法以WRITE_DAC的方式打开
               //则以WRITE_OWNER的方式打开,进行第二次尝试
               HANDLE hWriteOwner;
               hWriteOwner=OpenProcess(WRITE_OWNER,false,dwProcessId);
               if(hWriteOwner!=NULL){
                   //根据当前进程环中的用户Sid修改安全描述符号所有者
                   HANDLE hToken;
                   if(OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY|TOKEN_ADJUST_PRIVILEGES,&hToken)){
                       TOKEN_PRIVILEGES OldPrivilege;
                   if(EnablePrivilege(hToken,SE_TAKE_OWNERSHIP_NAME,OldPrivilege)){
                       BYTE TokenInfo[256];
                       DWORD dwLen=sizeof(TokenInfo);
                       GetTokenInformation(hToken,TokenUser,TokenInfo,dwLen,&dwLen);
                       DWORD dwErr=SetSecurityInfo(hWriteOwner,SE_KERNEL_OBJECT,OWNER_SECURITY_INFORMATION,
                       reinterpret_cast<PTOKEN_USER>(TokenInfo)->User.Sid,NULL,NULL,NULL);
                   if(dwErr=ERROR_SUCCESS){
                        //修改安全描述符所有者成功,句柄复制,检测是否有WRITE_DAC权限
                        if(!DuplicateHandle(GetCurrentProcess(),hWriteOwner,GetCurrentProcess(),&hWriteDAC,WRITE_DAC,false,0))
                            hWriteDAC=NULL;  //无WRITE_DAC权限,失败
                    }
                    RestorePrivilege(hToken,OldPrivilege);
             }
             CloseHandle(hToken);
         }
         CloseHandle(hWriteOwner);
        }
      }
      if(hWriteDAC!=NULL){
          if(AdjustDacl(hWriteDAC,dwDesiredAccess)){
              if(!DuplicateHandle(GetCurrentProcess(),hWriteDAC,
                        GetCurrentProcess(),&hProcess,
               dwDesiredAccess,false,0))
                  hProcess=NULL;
           }
           CloseHandle(hWriteDAC);
       }
    }
    return hProcess;
    }
    DWORD GetProcessIdByName(char* lpName)
    {
        //根据进程名获取进程ID,失败时返回0(System Idle Process)
        DWORD dwProcessId;
        HANDLE hSnapshot;
        hSnapshot=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
        if(hSnapshot!=INVALID_HANDLE_VALUE){
            PROCESSENTRY32 ppe;
            ppe.dwSize=sizeof(PROCESSENTRY32);
            if(Process32First(hSnapshot,&ppe)){
                if(strcmpi(lpName,ppe.szExeFile)==0){
                    dwProcessId=ppe.th32ProcessID;
                    CloseHandle(hSnapshot);
                    return dwProcessId;
                }
                while(Process32Next(hSnapshot,&ppe)){
                    if(strcmpi(lpName,ppe.szExeFile)==0){
                        dwProcessId=ppe.th32ProcessID;
                        CloseHandle(hSnapshot);
                        return dwProcessId;
                    }    
                }
            }
            CloseHandle(hSnapshot);
        }
        return 0;
    }
    展开全文
  • 打开process explorer,点击选中你要查看的程序,然后点击菜单栏的【view】——》【lower pane view】——》选中【DLLs】 选中之后程序下面会列出DLL名称
  • #define UNICODE #define _UNICODE  #include  #include  #include  typedef struct _remoteparameter { DWORD rpfindfirstfile; DWORD rpdeletefile; DWORD rpfindclose; ...HANDL
  • 暴力”注入Explorer

    千次阅读 2013-05-02 09:56:12
    举不胜举,一个木马或后门启动时向Explorer或IE的注入操作就像在自己脸上写上 “我是贼”一样。  用户态代码想要更隐蔽地藏身于别的进程,就应该在注入的环节隐蔽自己的行 为。下面就介绍一种非常简单不过比较...
  • 可在 explorer.exe 上使用 DLL 注入 先决条件 服务器 mysql 促进 开放式SSL 客户 视觉工作室 开放式SSL 它是如何工作的? 服务器 在 Keylogger/Server 中编译服务器 - make 执行它 - ./server 输入你的服务器端口...
  • 1、去微软下载此工具https://docs.microsoft.com/en-us/sysinternals/downloads/process-explorer2、右键管理员启动3、点击你要查看的进程
  • 简介 笔者当初为了学习JAVA,收集了很多经典源码,源码难易程度分为初级、中级、高级等,详情看源码列表,需要的可以直接下载! 这些源码反映了那时那景笔者对未来的盲目,对代码的热情、执着,对IT的憧憬、向往!...
  • 注入explorer.exe的dll添加上开机自动启动的功能 在此处我们通过写注册表的方式进行开机启动 void AutoRunFun() { TCHAR szFullPath[MAX_PATH + 1] = { 0 };//定义存放当前文件的字符串变量 GetModuleFileName...
  • 记录下学习的经历.. win10系统 被某杀毒给挂钩了.. 直接用虚拟机来操作 // dllmain.cpp : 定义 DLL 应用程序的入口点。 #include "stdafx.h" #include ...#pragma comment(lib, "libMinHoo
  • 用于SSL和客户端证书注入的MITM代理服务器,可用于与Internet Explorer进行测试。 这样可以避免在使用selenium和InternetExplorerDriver运行测试时使用缓慢的UI自动化从本机弹出窗口中选择证书。 这段代码只是我...
  • 程序界面,可自定义任意shellcode 注入任意进程 此程序自带将msf的远控shellcode转换成 易语言 可调用的shellcode 同时还可以将注入的功能生成出自己的程序可调用的代码 双击第三个输入框即可生成shellcode,这里...
  • DLL注入工具x64

    热门讨论 2015-12-31 13:37:18
    DLL注入工具有很多,但是也有很多无法注入系统进程如explorer.exe,notepad.exe等,特别是Win7以上平台。此注入工具核心注入部分使用NtCreateThreadEx + LdrLoadDlll方式实现,特色在于比一般的远程线程注入稳定,...
  •  remotepid=GetProcessId(_T("explorer.exe"));  if(remotepid==-1)  return -1;  HANDLE rphandle=OpenProcess(PROCESS_CREATE_THREAD |   PROCESS_VM_OPERATION |   PROCESS_VM_WRITE,   FALSE,...
  • 俗话说得好:“知已知彼,百战不殆”。这句话,不仅常用到军事战争中, 同样的,在网络这块没有...在接下来的介绍中,我们从中了解下“远程线程注入DLL”的方式,并使用相关的技巧做好防御。测试环境: Win XP SP2 ...
  • DLL注入工具有很多,但是也有很多无法注入系统进程如explorer.exe,notepad.exe等,特别是Win7以上平台。此注入工具核心注入部分使用NtCreateThreadEx + LdrLoadDlll方式实现,特色在于比一般的远程线程注入稳定,...
  • 文章目录一、关于Process Explorer二、下载地址三、如何使用1、Process Explorer主界面2、显示进程的系统信息3、显示当前进程所加载的DLL4、显示当前进程所占用的系统资源句柄5、操控进程以及显示进程的内部信息6、...
  • 我很喜欢的两款系统监控工具Process Monitor 可以监测系统进程读写那些文件、对注册表有那些操作Process Explorer 进程查看器 下载:Microsoft Process Monitor 1.37下载:Process Explorer 11.21 收藏链接:...
  • Process Explorer使用图文教程

    万次阅读 2017-09-26 16:04:21
    1.通过这种方式可以观察,我们的进程是否被其他程序注入DLL 2.通过这种方式了解当前进程使用了那些编程技术,如图可见当前进程用到了Gdi+ 3.可以修改Pane View的选项卡,让其显示更多的内容,比如DLL基...
  • Process Explorer 是一款免费的增强型任务管理器,是最好的进程管理器. 它能让使用者了解看不到的在后台执行的处理程序,可以使用它方便地管理你的程序进程. 能监视,挂起,重启,强行终止任何程序,包括系统级别的不允许...
  • 从这篇文章开始,作者将带着...第二篇文章主要介绍4种常见的注入技术,包括全局钩子、远线程钩子、突破SESSION 0隔离的远线程注入、APC注入,案例包括键盘钩子、计算器远线程注入实现、APC注入等,希望对您有所帮助。
  • DLL注入工具有很多,但是也有很多无法注入系统进程如explorer.exe,notepad.exe等,特别是Win7以上平台。此注入工具核心注入部分使用NtCreateThreadEx + LdrLoadDlll方式实现,特色在于比一般的远程线程注入稳定,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,324
精华内容 4,129
关键字:

explorer注入