获取 Windows 系统托盘图标信息的最新方案（一）

目录

前言

1 获取系统托盘图标的一般方法

1.1 使用 TB_ 类消息的注意事项

1.2 代码编写和测试

1.3 技术的适用范围

2 深度分析系统托盘图标信息

2.1 分析 Shell_NotifyIcon 函数参数

2.2 分析 Shell_NotifyIcon 函数的内部细节

2.3 分析 WM_COPYDATA 消息

2.4 调用方挂钩拦截消息封送过程

2.5 接收方挂钩实现获取任意图标信息

3 注入 HOOK 模块的方案

3.1 创建挂起进程注入

3.2 创建调试进程注入

3.3 等待调试事件

3.4 处理调试事件

3.5 完整代码和测试结果

3.6 补充说明

4 初步分析系统托盘图标的注册表转储

4.1 传统的注册表转储信息

4.2 Win11 特有的转储信息

本文出处链接:[https://blog.csdn.net/qq_59075481/article/details/136134195]

前言

本文分析获取系统通知区域图标的多种方法。解释了在 Win11 22H2 更新后无法获取托盘图标信息的问题所在，并给出了有效的解决方案。这篇文章发布前，我一直在我的一篇历史文章中更新我的研究进度。在解决这个这个问题的过程中，我逐步地了解到了通知消息传递的一些细节，而在此之前对细节实现的分析过程只是被我潦草地堆砌在一起，并没有很好地梳理事情的整个流程。所以我决定将文章重新整理出来。也就是大家现在看到的这篇长文，请认真地阅读下去，这将会解决一部分的一直以来在文献中含糊不清的问题。如果你不了解系统通知方面的知识，建议你先阅读第 5 篇 “对通知区域（Win 系统托盘）窗口层次的分析” 以便于了解设计基础知识。

系列文章列表：

P.S.: 第 3 篇文章主要解释本篇第 4 节的代码原理，第 4 篇文章是改进了挂钩处理的方式。

1 获取系统托盘图标的一般方法

在 Windows 操作系统上，一般情况下我们可以通过 TB_BUTTONCOUNT 消息来获取 ToolBar 的按钮个数。传统的任务栏通知区域（俗称系统托盘）就采用了 Toolbar 的设计，所以我们可以通过发送 TB_BUTTONCOUNT 来获取通知图标的个数。获取到个数后，就可以通过 TB_GETBUTTONTEXT 来获取 Toolbar 上图标的显示文本信息，但调用它的前提是使用 TB_GETBUTTON 消息。这个方法从 WinXP 以来是一直在使用的。

关于该方法的原理前面已经有人整理过了，可以看这一系列文章：

• 一种清除windows通知区域“僵尸”图标的方案——问题分析；
• 一种清除windows通知区域“僵尸”图标的方案——XP系统解决方案；
• 一种清除windows通知区域“僵尸”图标的方案——Windows7系统解决方案；

1.1 使用 TB_ 类消息的注意事项

使用 SendMessage 函数发送 TB_BUTTONCOUNT 消息到指定窗口，可以检索工具栏中当前按钮的计数。但这个值可能并不是最新的，个数仅仅是当前的个数，而且并非显示的个数，也非有效按钮窗口的个数，这也是为什么微软想要清除这个接口的原因。

使用 SendMessage 函数发送 TB_GETBUTTON 消息到指定窗口获取指针，然后向指定进程申请访问内存，获取 TBBUTTON 结构体中 dwData 字段数据，可以获得远线程的工具栏窗口中当前所有按钮的句柄、标题、进程路径信息。但该信息可能包含旧的内容。

任务栏的通知区域分为四个部分：用户提示的通知区域、系统升级的通知区域，溢出角通知区域、 DUI 弹出式通知区域（部分图标如：电源电量、音量等的注册记录在溢出通知区域窗口，但是并不是在溢出窗口内显示的，所以单独归类）。通知区域是外壳处理器 Shell 控件：ToolBarWindow32.

首先我们需要明白任务栏的 ToolBarWindow (工具栏视图)的一些特征：

1）除系统升级的通知区域以外的通知区域图标不会自动刷新，需要接收到鼠标移动消息、模拟点击消息才会逐个刷新。

2）如果一个窗口多次在通知区域注册通知图标，即使它是由同一个窗口发出的，也会被记录为独立的窗口，但他们具有相同的信息，在外壳程序内存中相应位置按序排列。

1.2 代码编写和测试

下面我们简单谈一谈代码的编写，网络上一种用于 Win7-Win11 的代码如下（有缺陷）：

#include 
#include 
#include 
#include 
#include 
 
using namespace std;
 
// 判断 x64 系统
BOOL Is64bitSystem()
{
	SYSTEM_INFO si;
	GetNativeSystemInfo(&si);
	if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ||
		si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64)
		return TRUE;
	else
		return FALSE;
}
 
// 获取托盘窗口句柄
HWND FindTrayWnd()
{
	HWND hWnd = NULL;
 
	hWnd = FindWindow(_T("Shell_TrayWnd"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("TrayNotifyWnd"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("SysPager"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("ToolbarWindow32"), NULL);
 
	return hWnd;
}
 
// 获取折叠托盘窗口句柄
HWND FindNotifyIconOverflowWindow()
{
	HWND hWnd = NULL;
 
	hWnd = FindWindow(_T("NotifyIconOverflowWindow"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("ToolbarWindow32"), NULL);
 
	return hWnd;
}
 
// 遍历窗口
BOOL EnumNotifyWindow(HWND hWnd)
{
	// 获取托盘进程ID
	DWORD dwProcessId = 0;
	GetWindowThreadProcessId(hWnd, &dwProcessId);
	if (dwProcessId == 0) {
		cout << "GetWindowThreadProcessId failed:" << GetLastError() << endl;
		return FALSE;
	}
 
	// 获取托盘进程句柄
	HANDLE hProcess = OpenProcess(
		PROCESS_VM_OPERATION |	// 需要在进程的地址空间上执行操作
		PROCESS_VM_READ |	// 需要使用 ReadProcessMemory 读取进程中的内存
		PROCESS_VM_WRITE,	// 需要在使用 WriteProcessMemory 的进程中写入内存
		FALSE,					// 子进程不继承句柄
		dwProcessId				// 目标进程 PID
	);
	if (hProcess == NULL) {
		cout << "OpenProcess failed:" << GetLastError() << endl;
		return FALSE;
	}
 
	// 在进程虚拟空间中分配内存，用来接收 TBBUTTON 结构体指针
	LPVOID p_tbbutton = VirtualAllocEx(
		hProcess,					// 目标进程句柄
		0,							// 内存起始地址（默认）
		4096,						// 内存大小
		MEM_COMMIT,					// 内存类型（提交）
		PAGE_EXECUTE_READWRITE		// 内存保护属性（可读可写可执行）
	);
	if (p_tbbutton == NULL) {
		cout << "VirtualAllocEx failed:" << GetLastError() << endl;
		return FALSE;
	}
 
	// 初始化
	DWORD dw_addr_dwData = 0;
	BYTE buff[1024] = { 0 };
	wstring ws_filePath = L"";
	wstring ws_tile = L"";
	HWND h_mainWnd = NULL;
	int i_data_offset = 12;
	int i_str_offset = 18;
 
	// 判断 x64
	if (Is64bitSystem()) {
		i_data_offset += 4;
		i_str_offset += 6;
	}
 
	// 获取托盘图标个数
	int i_buttons = 0;
	i_buttons = SendMessage(hWnd, TB_BUTTONCOUNT, 0, 0);
	if (i_buttons == 0) {
		cout << "TB_BUTTONCOUNT message failed:" << GetLastError() << endl;
		return FALSE;
	}
 
 
 
	// 遍历托盘
	for (int i = 0; i < i_buttons; i++) {
		// 获取 TBBUTTON 结构体指针
		if (!SendMessage(hWnd, TB_GETBUTTON, i, (LPARAM)p_tbbutton)) {
			cout << "TB_GETBUTTON message failed:" << GetLastError() << endl;
			return FALSE;
		}
 
		// 读 TBBUTTON.dwData（附加信息）
		if (!ReadProcessMemory(hProcess, (LPVOID)((DWORD)p_tbbutton + i_data_offset), &dw_addr_dwData, 4, 0)) {
			cout << "ReadProcessMemory failed:" << GetLastError() << endl;
			return FALSE;
		}
 
		// 读文本
		if (dw_addr_dwData) {
			if (!ReadProcessMemory(hProcess, (LPCVOID)dw_addr_dwData, buff, 1024, 0)) {
				cout << "ReadProcessMemory failed:" << GetLastError() << endl;
				return FALSE;
			}
 
			h_mainWnd = (HWND)(*((DWORD*)buff));
			ws_filePath = (WCHAR*)buff + i_str_offset;
			ws_tile = (WCHAR*)buff + i_str_offset + MAX_PATH;
			TCHAR szBuff[256];
			GetClassNameW(h_mainWnd, szBuff, sizeof(szBuff) / sizeof(TCHAR));//函数调用
 
			cout << "MainWindowHandleVale = " << hex << h_mainWnd << endl;
			wcout << "ExecuteFileBinPath = " << ws_filePath << endl;
			wcout << "WindowTitle = " << ws_tile << endl;
			printf("WindowClassName = %ws\n", szBuff);//控制台的输出类名
			printf("Press Enter to continue.");
			cin.get();
		}
 
		// 清理
		dw_addr_dwData = 0;
		h_mainWnd = NULL;
		ws_filePath = L"";
		ws_tile = L"";
 
		cout << endl;
	}
	if (VirtualFreeEx(hProcess, p_tbbutton, 0, MEM_RELEASE) == 0) {
		cout << "VirtualFreeEx failed:" << GetLastError() << endl;
		return FALSE;
	}
	if (CloseHandle(hProcess) == 0) {
		cout << "CloseHandle failed:" << GetLastError() << endl;
		return FALSE;
	}
 
	return TRUE;
}
 
int main()
{
	// 解决控制台中文
	setlocale(LC_ALL, "chs");
 
	// 获取托盘句柄
	HWND h_tray = FindTrayWnd();
	HWND h_tray_fold = FindNotifyIconOverflowWindow();
 
	// 遍历托盘窗口
	if (EnumNotifyWindow(h_tray) == FALSE || EnumNotifyWindow(h_tray_fold) == FALSE) {
		cout << "EnumNotifyWindow false." << endl;
	}
	printf("Press any Key to CLOSE Console.");
	cin.get();
	return 0;
}

为了满足 Win 10 的需求，我曾对代码做了改进（以前写的有点丑）

#include 
#include 
#include 
#include 
#include 
#include 
 
int RepeatedHwndscout;
HWND h_oldHwnd = NULL;
HWND Lasterrorhwnd = NULL;
 
// 判断 x64 系统
BOOL Is64bitSystem()
{
	SYSTEM_INFO si;
	GetNativeSystemInfo(&si);
	if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ||
		si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64)
		return TRUE;
	else
		return FALSE;
}
 
// 获取托盘窗口句柄
HWND FindTrayWnd()
{
	HWND hWnd = NULL;
 
	hWnd = FindWindow(_T("Shell_TrayWnd"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("TrayNotifyWnd"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("SysPager"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("ToolbarWindow32"), NULL);
 
	return hWnd;
}
 
// 获取折叠托盘窗口句柄
HWND FindNotifyIconOverflowWindow()
{
	HWND hWnd = NULL;
 
	hWnd = FindWindow(_T("NotifyIconOverflowWindow"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("ToolbarWindow32"), NULL);
 
	return hWnd;
}
 
// 获取系统升级的通知区域句柄
HWND FindSysUpdateNotifyWindow() {
 
	HWND hWnd = NULL;
 
	hWnd = FindWindow(_T("Shell_TrayWnd"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("TrayNotifyWnd"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("ToolbarWindow32"), NULL);
 
	return hWnd;
}
 
 
/*
* 已知路径转换函数
*
* 例如：{F38BF404-1D43-42F2-9305-67DE0B28FC23} 表示 C:\Windows；
* {F38BF404-1D43-42F2-9305-67DE0B28FC23}\explorer.exe 可以合并转换为 C:\Windows\explorer.exe
* {F38BF404-1D43-42F2-9305-67DE0B28FC23}  // SystemRoot:Windows Folder
* {1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}  // SystemRoot:Windows\\System32 Folder
* {7C5A40EF-A0FB-4BFC-874A-C0F2E0B9FA8E}  // SystemRoot:Program Files (x86) Folder
* {6D809377-6AF0-444B-8957-A3773F02200E}  // SystemRoot:Program Files Folder
*/
 
HRESULT RestructureDataFilePath(const wchar_t* strGuid, wchar_t** strBinPathAffer) {
 
	GUID stGuid = { 0 };
	WCHAR* strBuffer = nullptr;
	size_t wcsBufferlen = 0;
	HRESULT str2sidreslt = CLSIDFromString((LPCOLESTR)strGuid, (LPCLSID)&stGuid);
 
	if (str2sidreslt == (HRESULT)NOERROR) {
 
		// 查询已知文件夹路径
 
		str2sidreslt = ::SHGetKnownFolderPath(stGuid, KF_FLAG_DONT_VERIFY, NULL, &strBuffer);
 
		if (SUCCEEDED(str2sidreslt)) {
			wcsBufferlen = wcslen(strBuffer) * sizeof(WCHAR) + sizeof(WCHAR);
			*strBinPathAffer = (WCHAR*)malloc(wcsBufferlen);
			memset(*strBinPathAffer, 0, wcsBufferlen);
			memcpy(*strBinPathAffer, strBuffer, wcsBufferlen);
			CoTaskMemFree(strBuffer);// 释放内存
			return NOERROR;
		}
		else {
			printf("SHGetKnownFolderPathFailed,errorCode = [%d]\n", GetLastError());
			return str2sidreslt;
		}
	}
	else
		return str2sidreslt;
}
 
// 遍历窗口
BOOL EnumNotifyWindow(HWND hWnd)
{
	// 获取托盘进程ID
	DWORD dwProcessId = 0;
	// 初始化
	DWORD dw_addr_dwData = 0;
	BYTE buff[1024] = { 0 };
	WCHAR* ws_filePath = nullptr, filepathsuffix[MAX_PATH] = { 0 };
	WCHAR* ws_tile = nullptr;
	WCHAR KnownfoldID[39] = { 0 };
	wchar_t* strBinPathAffer = nullptr;
	HWND h_mainWnd = NULL;
	TCHAR szWndClassName[256] = { 0 },
		toolBarTitle[256] = { 0 },
		toolBarClass[256] = { 0 };
	const char* delimiter = "\\";
	char filepath[256]{};
	char* szExeFile = nullptr;
	char* pBufferContext = nullptr;
	char szWndTitleName[1024] = { 0 };
	char shortHwnds[64] = { 0 };
 
	int i_data_offset = 12;
	int i_str_offset = 18;
 
	GetWindowThreadProcessId(hWnd, &dwProcessId);
	if (dwProcessId == 0) {
		printf("-------------------------------------------------------------------------------------\n");
		printf("GetWindowThreadProcessId failed: %d \tFrom hwnd: %I64X.\n", GetLastError(), (UINT64)hWnd);
		printf("-------------------------------------------------------------------------------------\n");
		Lasterrorhwnd = hWnd;
		return FALSE;
	}
 
	// 获取托盘进程句柄
	HANDLE hProcess = OpenProcess(
		PROCESS_VM_OPERATION |	// 需要在进程的地址空间上执行操作
		PROCESS_VM_READ |	// 需要使用 ReadProcessMemory 读取进程中的内存
		PROCESS_VM_WRITE,	// 需要在使用 WriteProcessMemory 的进程中写入内存
		FALSE,					// 子进程不继承句柄
		dwProcessId				// 目标进程 PID
	);
 
	if (hProcess == nullptr) {
		printf("-------------------------------------------------------------------------------------\n");
		printf("OpenProcess failed: %d \tFrom hwnd: %I64X.\n", GetLastError(), (UINT64)hWnd);
		printf("-------------------------------------------------------------------------------------\n");
		Lasterrorhwnd = hWnd;
		return FALSE;
	}
 
	// 在进程虚拟空间中分配内存，用来接收 TBBUTTON 结构体指针
	LPVOID p_tbbutton = VirtualAllocEx(
		hProcess,					// 目标进程句柄
		0,							// 内存起始地址（默认）
		4096,						// 内存大小
		MEM_COMMIT,					// 内存类型（提交）
		PAGE_EXECUTE_READWRITE		// 内存保护属性（可读可写可执行）
	);
 
	if (p_tbbutton == nullptr) {
		printf("VirtualAllocEx failed: %d.\n", GetLastError());
		Lasterrorhwnd = hWnd;
		return FALSE;
	}
 
	/*
		typedef struct _TBBUTTON {
			int iBitmap;				// 索引
			int idCommand;				// 与按钮关联的命令标识符
			BYTE fsState;				// 按钮状态
			BYTE fsStyle;				// 按钮风格
		#ifdef _WIN64
			BYTE bReserved[6];          // 对齐
		#elif defined(_WIN32)
			BYTE bReserved[2];          // 对齐
		#endif
			DWORD_PTR dwData;			// 存放程序自定义数据
			INT_PTR iString;			// 存放信息字符
		} TBBUTTON, NEAR* PTBBUTTON, *LPTBBUTTON;
	*/
 
	// 判断 x64
	if (Is64bitSystem()) {
		i_data_offset += 4;
		i_str_offset += 6;
	}
 
	// 获取托盘图标个数
	int i_buttons = 0;
	i_buttons = (int)SendMessage(hWnd, TB_BUTTONCOUNT, 0, 0);
	if (i_buttons == 0) {
		printf("-------------------------------------------------------------------------------------\n");
		printf("TB_BUTTONCOUNT message failed: %d \tFrom hwnd: %I64X.\n", GetLastError(), (UINT64)hWnd);
		printf("-------------------------------------------------------------------------------------\n");
		Lasterrorhwnd = hWnd;
		return FALSE;
	}
 
	// 获取通知区域主窗口的标题和窗口类名称
 
	GetWindowTextW(hWnd, toolBarTitle, sizeof(toolBarTitle) / sizeof(TCHAR));
	GetClassNameW(hWnd, toolBarClass, sizeof(toolBarClass) / sizeof(TCHAR));
 
	// 输出标题 & 窗口类名称
	printf("=====================================================================================\n");
	printf("Tray_ToolBar WindowName = %ws | Tray_ToolBar ClassName = %ws\n", toolBarTitle, toolBarClass);
	printf("ChildTray PointsNumber = %d.\n\n", i_buttons);
 
	// 遍历通知区域图标信息
 
	for (int i = 0; i < i_buttons; i++) {
 
		// 获取 TBBUTTON 结构体指针
 
		if (!SendMessage(hWnd, TB_GETBUTTON, i, (LPARAM)p_tbbutton)) {
			printf("-------------------------------------------------------------------------------------\n");
			printf("TB_GETBUTTON message failed: %d \tFrom hwnd: %I64X.\n", GetLastError(), (UINT64)hWnd);
			printf("-------------------------------------------------------------------------------------\n");
			Lasterrorhwnd = hWnd;
			return FALSE;
		}
 
		// 读 TBBUTTON.dwData（附加信息）
 
		if (!ReadProcessMemory(hProcess, (LPVOID)((DWORD)p_tbbutton + i_data_offset), &dw_addr_dwData, 4, 0)) {
			printf("-------------------------------------------------------------------------------------\n");
			printf("ReadProcessMemory failed: %d \tFrom hwnd: %I64X.\n", GetLastError(), (UINT64)hWnd);
			printf("-------------------------------------------------------------------------------------\n");
			Lasterrorhwnd = hWnd;
			return FALSE;
		}
 
		// 读取结构体信息
 
		if (dw_addr_dwData) {
			if (!ReadProcessMemory(hProcess, (LPCVOID)dw_addr_dwData, buff, 1024, 0)) {
				printf("-------------------------------------------------------------------------------------\n");
				printf("ReadProcessMemory failed: %d \tFrom hwnd: %I64X.\n", GetLastError(), (UINT64)hWnd);
				printf("-------------------------------------------------------------------------------------\n");
				Lasterrorhwnd = hWnd;
				return FALSE;
			}
 
			h_mainWnd = (HWND)(*((DWORD*)buff));
			ws_filePath = (WCHAR*)buff + i_str_offset;
			ws_tile = (WCHAR*)buff + i_str_offset + MAX_PATH;
 
			/*
			* 排除重复记录的窗口
			*/
 
			if (h_oldHwnd == h_mainWnd) {
				printf("Rank(Limited)=%d; HWND 0x%I64X: MultipleRegisted once.\n", i + 1, (UINT64)h_mainWnd);
				RepeatedHwndscout += 1;
				continue;
			}
			else {
				printf("----------------\n");
				printf("Tray Rank = %d: \n", i + 1);
			}
 
			printf("MainWindowHandle = 0x%I64X\n", (UINT64)h_mainWnd);
 
			sprintf_s(filepath, "%ws", ws_filePath);
			szExeFile = strtok_s(filepath, delimiter, &pBufferContext);
			while (szExeFile)
			{
				size_t len = strlen(szExeFile);
				if (szExeFile[len - 1] == 101 && szExeFile[len - 2] == 120 && szExeFile[len - 3] == 101) {
					printf("PatrilinealProcessName = %s\n", szExeFile);
				}
				szExeFile = strtok_s(NULL, delimiter, &pBufferContext);
			}
 
			/*
			* 
			* 判断是否是系统已知文件路径，如果是就转换为可读路径
			* 
			*/
 
			// 初始化内存操作
			wmemset(KnownfoldID, 0, sizeof(KnownfoldID) / sizeof(wchar_t));
			wmemset(filepathsuffix, 0, sizeof(filepathsuffix) / sizeof(wchar_t));
			
			// GUID 字符串的特征定位操作，建议使用 C++ 的 std::string 操作
 
			if (ws_filePath[0] == L'{' && ws_filePath[37] == L'}' ) {
 
				for (int i = 0; i < 38; i++) {
					KnownfoldID[i] = ws_filePath[i];
				}
				
				for (int j = 38; j < wcslen(ws_filePath); j++) {
					filepathsuffix[j - 38] = ws_filePath[j];
				}
 
				// 查询已知路径字符串的 Win32 路径
 
				HRESULT lpresult = RestructureDataFilePath(KnownfoldID, &strBinPathAffer);
 
				printf("ExecuteFileBinPath = %ws%ws\n", strBinPathAffer, filepathsuffix);
				free(strBinPathAffer);
			}
			else {
				printf("ExecuteFileBinPath = %ws\n", ws_filePath);
			}
 
			if (!ws_tile[0]) {
				printf("WindowTitle = (None)\n");
			}
			else {
				bool bEnterFlag = false;
				sprintf_s(szWndTitleName, "%ws", ws_tile);
 
				// 查询并去除 szTip 字符串中的换行符号，
				// BUG：对中文处理可能存在问题，建议使用 C++
 
				for (int index = 1; index < strlen(szWndTitleName); index++) {
					if (szWndTitleName[index] == '\n') {
						// printf("Title have Enter at str[%d].\n", index);
						szWndTitleName[index] = ';';
						bEnterFlag = true;
					}
				}
 
				if (bEnterFlag) {
					printf("WindowTitle = %s \n", szWndTitleName);
				}
				else {
					wprintf(L"WindowTitle = %ws\n", ws_tile);
				}
 
			}
		}
 
		// 输出窗口类的名称字符串，如果不为空字符串的话
 
		if (h_mainWnd) {
			GetClassNameW(h_mainWnd, szWndClassName, sizeof(szWndClassName) / sizeof(TCHAR));// 函数调用
			printf("WindowClassName = %ws\n", szWndClassName);// 控制台的输出窗口类的名称
		}
		else {
			printf("WindowClassName = (None)\n");
		}
 
		// 判断窗口是否可见
 
		if (h_mainWnd != NULL && IsWindowVisible(h_mainWnd)) {
			printf("IsWindowVisible: True.\n");
		}
		else {
			printf("IsWindowVisible: False.\n");
		}
 
		// 获取窗口矩形的相关信息
 
		RECT rect = { 0,0,0,0 };
		if (h_mainWnd != NULL && !GetWindowRect(h_mainWnd, &rect)) {
			printf("Failed to Find Window Rect.ecode = %d\n", GetLastError());
		}
		else {
			int wid = rect.right - rect.left;
			int heit = rect.bottom - rect.top;
			if (!wid && !heit) {
				printf("Window rectangle size is Zero.\n");
			}
			else {
				printf("WindowRect: \n");
				printf(" left \t top \tright\tbottom\t\n");
				printf("  %d\t%d\t%d\t%d\t\n", rect.left, 
					rect.top, rect.right, rect.bottom);
			}
 
			if (!rect.right && !rect.left && !rect.bottom && !rect.top) {
				printf("The four corners of window are all with Zero-Pos.\n");
			}
			else {
				printf("Position: \n");
				printf("\t(%d,%d) - (%d,%d)\n", rect.left, 
					rect.top, rect.right, rect.bottom);
				printf("Rect: %d x %d.\n", wid, heit);
			}
		}
 
 
		// 记录遍历的窗口句柄
		h_oldHwnd = h_mainWnd;
 
		// 清理内存
		dw_addr_dwData = 0;
		h_mainWnd = NULL;
		ws_filePath = 0;
		ws_tile = NULL;
		filepath[0] = '\0';
		szWndClassName[0] = '\0';
		toolBarTitle[0] = '\0';
		toolBarClass[0] = '\0';
		printf("\n");
	}
 
 
	if (VirtualFreeEx(hProcess, p_tbbutton, 0, MEM_RELEASE) == 0) {
		printf("-------------------------------------------------------------------------------------\n");
		printf("VirtualFreeEx failed: %d \tFrom hwnd: %I64X\n", GetLastError(), (UINT64)hWnd);
		printf("-------------------------------------------------------------------------------------\n");
		Lasterrorhwnd = hWnd;
		return FALSE;
	}
 
 
	if (CloseHandle(hProcess) == 0) {
		printf("-------------------------------------------------------------------------------------\n");
		printf("CloseHandle failed: %d \tFrom hwnd: %I64X\n", GetLastError(), (UINT64)hWnd);
		printf("-------------------------------------------------------------------------------------\n");
		Lasterrorhwnd = hWnd;
		return FALSE;
	}
 
 
	if (RepeatedHwndscout != 0) {
		printf("Skipped %d Windows.\n", RepeatedHwndscout);
		printf("The number of Tray Notification Windows under this Notifi-hWnd should actually be %d, not %d.\n",
			i_buttons - RepeatedHwndscout, i_buttons);
	}
 
	return TRUE;
}
 
int main()
{
	system("cls");
 
	// 控制台中文支持
	setlocale(LC_ALL, ".utf8");
 
	// 获取通知区域窗口的句柄
	HWND h_tray = FindTrayWnd();
	HWND h_tray_fold = FindNotifyIconOverflowWindow();
	HWND h_sys_up = FindSysUpdateNotifyWindow();
 
	// 枚举各个窗口通知区域图标信息
 
	bool t1 = EnumNotifyWindow(h_tray);
	bool t2 = EnumNotifyWindow(h_tray_fold);
	bool t3 = EnumNotifyWindow(h_sys_up);
 
	// 判断遍历结果
 
	if (t1 == false || t2 == false || t3 == false) {
		if (Lasterrorhwnd == h_sys_up) {
			printf("===============================================================================================\n");
			printf("\t\t\tUpdateNotifyWindow - System, has none Icon now.\t\t\t\n");
			printf("===============================================================================================\n");
		}
		else {
			printf("EnumNotifyWindow false.ObjWindowHandle = %I64X.\n", (UINT64)Lasterrorhwnd);
		}
	}
 
	printf("Press any key to CLOSE the console.");
 
    ::getchar();
	return 0;
}

代码修复了已知路径未将 GUID 或 UUID 转换为完整路径，Taskmgr 重复窗口记录、窗口是否可见等问题。运行效果如下：

​

1.3 技术的适用范围

TBBUTTON 方法自 Win11 22H2 Build 22621.1344 和 22621.1413 (正式) 起不再有效。微软修复了加载系统托盘图标相关的问题，因为该问题可能会导致 explorer.exe 卡顿甚至崩溃。就是这一次修复其实微软顺便砍掉了很多冗余的东西，比如像 shell:::{05d7b0f4-2121-4eff-bf6b-ed3f69b894d9} 指向的旧版的通知区域图标管理页面，一些注册表设置等。

​

在这种情况下，TB_BUTTONCOUNT 应该会失败，并返回 0，并且最近一次错误是 “拒绝访问”，这也是国内、国外论坛在讨论的重点。

但是，资源管理器的图标管理是否存在其他接口，图标的数据是怎么组织的？首先，图标数据肯定不是一直放在内存中的，这不合理，因为伴随着重启，设置里面依然记录着已知的图标信息，即使它们曾经启用过而现在它们的进程并未启动。下文我们将逐个讨论并揭开 explorer 的神秘的面纱。

2 深度分析系统托盘图标信息

系统通知区域图标的创建需要依赖一些接口函数，通过分析这些接口函数，我们就能够对资源管理器的通知栏图标有更加多维的理解。

2.1 分析 Shell_NotifyIcon 函数参数

托盘图标目前只能通过微软提供的 Shell_NotifyIcon 函数来管理，那么我们研究的切入点也就是这个函数。

 Shell_NotifyIcon 函数的声明和参数的部分解释如下：

MSDN 称该函数是只将消息发送到任务栏的通知区域的一个函数。这说明了很可能该函数不是实现图标的全部功能，而是将特定的窗口消息发送给 explorer 进程。

函数声明：

BOOL Shell_NotifyIconW(
        DWORD                          dwMessage,
        PNOTIFYICONDATAW   lpData
);

一个 DWORD 数值，该值指定要由此函数执行的操作。 可以具有下表列出的任意数值之一：

第二个参数 lpData 为指向 NOTIFYICONDATA 结构的指针。 结构的内容取决于 dwMessage 的值。它可以定义要添加到通知区域的图标、使该图标显示通知，或标识要修改或删除的图标。

NOTIFYICONDATA 结构体有 Unicode 和 ANSI 别名表示的不同版本。其次， MSDN 上给出的是简化版，实际上和 SDK 中的定义不完全一致。下面摘录的是 MSDN 的简化版：

typedef struct _NOTIFYICONDATAW {
  DWORD cbSize;
  HWND  hWnd;
  UINT  uID;
  UINT  uFlags;
  UINT  uCallbackMessage;
  HICON hIcon;
#if ...
  WCHAR szTip[64];
#else
  WCHAR szTip[128];
#endif
  DWORD dwState;
  DWORD dwStateMask;
  WCHAR szInfo[256];
  union {
    UINT uTimeout;
    UINT uVersion;
  } DUMMYUNIONNAME;
  WCHAR szInfoTitle[64];
  DWORD dwInfoFlags;
  GUID  guidItem;
  HICON hBalloonIcon;
} NOTIFYICONDATAW, *PNOTIFYICONDATAW;

关于各个成员的解释我就不过多介绍了，可以直接看 MSDN 的文档：

NOTIFYICONDATAW (shellapi.h) - Win32 apps | Microsoft Learn。

2.2 分析 Shell_NotifyIcon 函数的内部细节

下面我们需要对 Shell_NotifyIcon 函数做进一步的分析。从 NT5.0 开始，Shell_NotifyIcon 函数一直是 Shell32.dll 的导出函数。

首先，我们通过 IDA Pro 对该函数进行静态分析。该函数查找了 Shell_TrayWnd 窗口的句柄，并且如果该窗口不存在（比如资源管理器未启动），则立即返回失败信息：

​

 Shell_TrayWnd 窗口相信对很多人来说并不陌生，它是任务栏父窗口，在以前的 SendMessage 方法中就涉及到从它的子窗口中获取通知区域窗口句柄的过程。下图展示了 Win 11 的任务栏窗口层次结构：

​

网上的代码大多数情况下忽略了 TrayNotifyWnd 下的“系统升级通知窗口”的图标，我将这个区域称为临时区域，是因为它默认情况下窗口大小为 0，在 Win 7 到 Win11 更新之前的版本上，该区域为程序刚刚创建系统托盘图标时候，微软会将该图标显示在临时通知区域（Win11 更新过后似乎不会自动放到这个区域），它位于系统通知区域和任务栏溢出区域角标之间。具体如下图所示：

​

最左侧的是溢出栏角标，中间新增的就是临时通知栏，右侧是系统常驻通知区域。系统会将新创建的图标放在这个可变大小的临时通知区域中，时间长达 1 分钟，随后根据配置文件，将该图标从临时区域移动到溢出通知区域或者常驻通知区域。

这也就解释了我在 1.2 的改进版代码中增加了对系统升级通知区域（临时通知区域）的解析的原因：

// 获取系统升级的通知区域句柄
HWND FindSysUpdateNotifyWindow() {
 
	HWND hWnd = NULL;
 
	hWnd = FindWindow(_T("Shell_TrayWnd"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("TrayNotifyWnd"), NULL);
	hWnd = FindWindowEx(hWnd, NULL, _T("ToolbarWindow32"), NULL);
 
	return hWnd;
}

当然，上面谈的这些只适用于 10.0.22621.1413 之前的发布版本系统，对于最新的系统，已经删除了窗口对 TBBUTTON 消息处理的支持。下面我们继续分析 Shell_NotifyIcon 函数。

由于从 NT 6 (Vista) 以来进行了一些功能性更改，该函数支持的结构体大小不唯一，产生了不同版本号的结构体。所以接下来函数对结构体参数的大小进行了判断，以便于区分版本。

​

这一部分其实 MSDN 文档中有记录。

文档中写道：必须使用结构的大小初始化结构。如果使用当前定义的结构的大小，则应用程序可能不会使用早期版本的 Shell32.dll 运行，这需要更小的结构。

通过适当设置 NOTIFYICONDATA 结构的大小，可以保持应用程序与所有 Shell32.dll 版本的兼容性，同时仍使用当前头文件。 在初始化结构之前，使用 DllGetVersion 确定系统上安装的 Shell32.dll 版本，并使用以下值之一初始化 cbSize ：

可以看出在Vista之前使用常量定义结构体的大小，在 Vista 之后直接定义 NTDDI_VERSION 宏并使用结构的大小 sizeof (NOTIFYICONDATA) 即可。

随后，将结构体数据拷贝到新分配的内存上（参数重组，这里的 IDA 分析有部分问题）：

​

对字符串参数的处理（这一部分没有仔细去分析）：

​

随后，开始解析 dwMessage 参数，因为该参数决定了要对通知区域的具体操作：

​

如果 dwMessage == NIM_SETFOCUS 则会调用 AllowSetForegroundWindow 允许 explorer 设置前台窗口。

在 dwMessage 不是 NIM_SETFOCUS 的情况下，则会首先检查调用方进程的消息线程是否注册了 TaskbarCreated 这个系统保留的消息字符串，该消息在任务栏创建时候会由 explorer 向全部的顶级窗口广播，用于在任务栏重建时候允许调用方重新请求创建通知区域图标。

如果 dwMessage 是 NIM_MODIFY 则跳转到 LABEL_22 处，不是则跳转到 LABEL_23 处。如果 dwMessage 是 NIM_ADD 则继续向下执行而不跳转。从中可以看出，这里可以解释为下面的伪代码结构：

switch(dwMessage)
{
case NIM_ADD:
{
    // 添加通知区域图标
}
break;
case NIM_MODIFY:
{
    // 修改通知区域图标信息
}
break;
case NIM_DELETE:
{
    // 删除通知区域图标
}
break;
case NIM_SETFOCUS:
{
    // 返还任务栏焦点
}
break;
case NIM_SETVERSION:
{
    // 设置通知版本
}
break;
default:
    // 默认错误处理
    break;
}

如果是 NIM_ADD 则会首先执行下面的过程：

​

通过对 lpData->hWnd 也就是图标绑定的窗口句柄调用 GetWindowThreadProcessId 来获取对应的进程 ID。再使用 OpenProcess 以 PROCESS_QUERY_LIMITED_INFORMATION 权限获取进程的访问句柄，因为后面调用 QueryFullProcessImageNameW 获取进程完整的路径必须指定  PROCESS_QUERY_LIMITED_INFORMATION 权限或者 PROCESS_QUERY_INFORMATION 权限的访问句柄。而像 SYSTEM 进程等完整性较高的进程，普通进程可能无法获取到 PROCESS_QUERY_INFORMATION 访问权限，只能获取到 PROCESS_QUERY_LIMITED_INFORMATION 权限。所以理所当然这里用的是受限访问权限。

当然这个过程是可能失败的，一方面是窗口句柄可能无效，另一方面是进程的访问和路径获取可能失败。如果路径访问失败，则错误代码是 0x80004005(LRESULT 错误代码)，也就是 E_FAIL 未知故障的意思，这个错误代码是十分常见的。

​

那么接下来，你肯定会想到，万一是 hWnd 指向无效窗口导致访问路径失败呢？那我们也不一定需要抛出失败啊，只需要尝试默认窗口即可了啊？该函数确实也是这么做的：

​

此时，会尝试通过 GetCurrentProcessId 获取调用方进程的 PID，随后通过 SHExePathFromPid 函数来获取调用方进程的完整 Win32 路径。这个函数非常有意思，其实和刚刚的流程差不多，只不过进程 PID 不是 hWnd 指向的窗口的进程 PID，而是调用方进程的 PID。

​

随后对于两种方式获取的路径都需要校验，GetLongPathNameW 判断是否始终为长路径，PathIsNetworkPathW 判断路径中是否不包含网络路径。这两部分就是确保路径是完整的本地路径。

下面就是一个有意思的环节了：

​

这里将系统中部分已知文件夹的 KNOWNFOLDERID (GUID) 通过 XMM 寄存器传输到全局变量上。

接下来，通过 SHGetKnownFolderPath 获取 GUID 对应的已知文件夹默认路径，通过 PathCommonPrefixW 的返回值判断当前程序文件路径和已知文件夹路径是否存在公共前缀，并指示公共前缀的字符长度(v45)，通过 lstrlenW 判断已知路径长度是否等于公共前缀长度来确定当前文件路径是否是位于已知文件夹路径下。

如果满足路径在已知文件夹路径下，则用已知文件夹路径的 GUID 字符串(StringFromGUID2 获取)，替代实际的文件夹路径前缀。

​

这也是为什么上文在 1.2 的改进代码中，我增加了已知路径 GUID 转换函数(GUIDStringToPathPrefix)的原因：

/*
* 已知路径转换函数
*
* 例如：{F38BF404-1D43-42F2-9305-67DE0B28FC23} 表示 C:\Windows；
* {F38BF404-1D43-42F2-9305-67DE0B28FC23}\explorer.exe 将被转换为 C:\Windows\explorer.exe
* {F38BF404-1D43-42F2-9305-67DE0B28FC23}  // SystemRoot:Windows Folder
* {1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}  // SystemRoot:Windows\\System32 Folder
* {7C5A40EF-A0FB-4BFC-874A-C0F2E0B9FA8E}  // SystemRoot:Program Files (x86) Folder
* {6D809377-6AF0-444B-8957-A3773F02200E}  // SystemRoot:Program Files Folder
*/
 
HRESULT RestructureDataFilePath(const wchar_t* strGuid, wchar_t** strBinPathAffer) {
 
	GUID stGuid = { 0 };
	WCHAR* strBuffer = nullptr;
	size_t wcsBufferlen = 0;
	HRESULT str2sidreslt = CLSIDFromString((LPCOLESTR)strGuid, (LPCLSID)&stGuid);
 
	if (str2sidreslt == (HRESULT)NOERROR) {
 
		// 查询已知文件夹路径
 
		str2sidreslt = ::SHGetKnownFolderPath(stGuid, KF_FLAG_DONT_VERIFY, NULL, &strBuffer);
 
		if (SUCCEEDED(str2sidreslt)) {
			wcsBufferlen = wcslen(strBuffer) * sizeof(WCHAR) + sizeof(WCHAR);
			*strBinPathAffer = (WCHAR*)malloc(wcsBufferlen);
			memset(*strBinPathAffer, 0, wcsBufferlen);
			memcpy(*strBinPathAffer, strBuffer, wcsBufferlen);
			CoTaskMemFree(strBuffer);// 释放内存
			return NOERROR;
		}
		else {
			printf("SHGetKnownFolderPathFailed,errorCode = [%d]\n", GetLastError());
			return str2sidreslt;
		}
	}
	else
		return str2sidreslt;
}

上面的代码是我去年早些时候编写的。现已经改进并整合到在 4.1 节的工具代码中，部分内容如下：

/*
* 已知路径转换函数
*
* 参数：LPCWSTR szKnownPath 包含 GUID 前缀的完整路径
*       PWSTR szWin32FilePath 返回 Win32 完整路径
*
* ********************************************************************************************
* 备注：
*
* {F38BF404-1D43-42F2-9305-67DE0B28FC23} 表示 C:\Windows
* {F38BF404-1D43-42F2-9305-67DE0B28FC23}\explorer.exe 将被转换为 C:\Windows\explorer.exe
*
* SystemRoot = "{F38BF404-1D43-42F2-9305-67DE0B28FC23}";//SystemRoot:Windows Folder
* System32 = "{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}";//SystemRoot:Windows\\System32 Folder
* Program86 = "{7C5A40EF-A0FB-4BFC-874A-C0F2E0B9FA8E}";//SystemRoot:Program Files (x86) Folder
* Program = "{6D809377-6AF0-444B-8957-A3773F02200E}";//SystemRoot:Program Files Folder
*
* ********************************************************************************************
*/
HRESULT FilePathFromKnownPrefix(
    LPCWSTR szKnownPath,
    PWSTR* szWin32FilePath
)
{
 
    GUID stGuid = { 0 };
    PWSTR strPathPrefix = nullptr;
    PWSTR strWin32Path = nullptr;
    HRESULT str2GuidReslt = E_FAIL;
    std::wstring wsKnownPath;
    size_t nPos = std::string::npos;
    size_t nPrefix = 0,
        nKnownPath = 0,
        nWin32Path = 0,
        wsWin32PathLen = 0;
    int nCoResponse = -1;
 
    if (szKnownPath == nullptr)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return str2GuidReslt;
    }
 
    if (szKnownPath[0] == L'\0')
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return str2GuidReslt;
    }
 
    wsKnownPath = szKnownPath;
 
    nPos = wsKnownPath.find_first_of(L'\\');
 
    if (nPos != 0x26u)       // GUID String 长度为 38 字符
    {
        SetLastError(ERROR_PATH_NOT_FOUND);
        return str2GuidReslt;
    }
 
    wsKnownPath.resize(0x26u);
 
    SetLastError(0);
 
    str2GuidReslt = CLSIDFromString((LPCOLESTR)wsKnownPath.c_str(), (LPCLSID)&stGuid);
 
    if (str2GuidReslt == (HRESULT)NOERROR) {
        //printf("The CLSID was obtained successfully.\n");
        str2GuidReslt = SHGetKnownFolderPath(stGuid, KF_FLAG_DONT_VERIFY, NULL, &strPathPrefix);
 
        if (SUCCEEDED(str2GuidReslt) && strPathPrefix != nullptr)
        {
            nPrefix = wcslen_s(strPathPrefix, 0x800u);
            nKnownPath = wcslen_s(szKnownPath, 0x800u);
 
            if (nPrefix == 0 || nKnownPath == 0)
            {
                std::wcerr << L"Get string length faild." << std::endl;
                CoTaskMemFree(strPathPrefix);// 释放内存
                return E_FAIL;
            }
 
            nWin32Path = nKnownPath - 0x26u + nPrefix + 1;
 
            // 计算需要分配的缓冲区字节数
            if (SizeTMult(nWin32Path, sizeof(wchar_t), &wsWin32PathLen) != S_OK) {
                // 乘法溢出，处理错误
                std::wcerr << L"Multiplication overflow occurred." << std::endl;
                CoTaskMemFree(strPathPrefix);// 释放内存
                return E_FAIL;
            }
 
            strWin32Path = (PWSTR)CoTaskMemAlloc(wsWin32PathLen);
 
            if (strWin32Path == nullptr)
            {
                CoTaskMemFree(strPathPrefix);// 释放内存
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return E_FAIL;
            }
 
            nCoResponse = CoCreateSuffixFullPath(strWin32Path,
                nWin32Path, L"%s%s", strPathPrefix, &szKnownPath[0x26]);
 
            if (nCoResponse && nCoResponse == nWin32Path)
            {
                *szWin32FilePath = strWin32Path;
                CoTaskMemFree(strPathPrefix);// 释放内存
                return NOERROR;
            }
 
            CoTaskMemFree(strPathPrefix);// 释放内存
            return E_FAIL;
        }
 
        std::cerr << "SHGetKnownFolderPath Failed,errorCode = "
            << GetLastError() << std::endl;
        return str2GuidReslt;
    }
    std::cerr << "CLSIDFromString Failed,errorCode = "
        << GetLastError() << std::endl;
    return str2GuidReslt;
}
 
int CoCreateSuffixFullPath(
    wchar_t* wsBuffer,
    size_t wsCount,
    const wchar_t* wsFormat, ...
)
{
    if (wsBuffer == nullptr) return -1;
 
    int nWriteCount = 0;
    // hold the variable argument 
    va_list argsList = nullptr;
 
    // A function that invokes va_start 
    // shall also invoke va_end before it returns. 
    va_start(argsList, wsFormat);
    nWriteCount = vswprintf_s(wsBuffer, wsCount, wsFormat, argsList);
    va_end(argsList);
 
    return ++nWriteCount;
}
 
 
 
// wcslen 安全版本
size_t wcslen_s(
    const wchar_t* str, size_t ccmaxlen)
{
    size_t length = 0;
 
    if (ccmaxlen > 0x5000)
        ccmaxlen = 0x5000;  // 20480 字节，路径长度应该远小于该值
 
    __try {
        while (length < ccmaxlen && str[length] != L'\0') {
            ++length;
        }
        // 说明发生越界访问或者超出限制
        if (length == ccmaxlen)
        {
            std::cerr << "Trigger limit: The buffer exceeds the limit of characters." << std::endl;
            return 0;
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        // 捕获并处理访问无效指针引发的异常
        std::cerr << "Access violation: Attempted to read from null pointer." << std::endl;
        return 0;
    }
 
    return length;
}
 
 
errno_t __fastcall memset_s(void* v, rsize_t smax, int c, rsize_t n) {
    if (v == NULL) return EINVAL;
    if (smax > RSIZE_MAX) return EINVAL;
    if (n > smax) return EINVAL;
    volatile unsigned char* p = (volatile unsigned char*)v;
    while (smax-- && n--) {
        *p++ = c;
    }
    return 0;
}

当 dwMessage 为 NIM_MODIFY 和 NIM_DELETE 时，过程如下：

​

NIM_MODIFY 过程检查 uFlags 参数是否包含 NIF_MESSAGE 标志。如果包含则说明 lpData->uCallbackMessage 参数有效，该参数是要发送到 hWnd 窗口的用户自定义消息。此时会检查 lpData->hWnd 是否不为空，如果不为空则会调用 ChangeWindowMessageFilterEx 并指定 MSGFLT_ALLOW 允许 uCallbackMessage 消息通过 UIPI ，取消 UIPI 的限制。UIPI 是 Vista 开始引入的一种消息安全机制，限制低完整级别进程向高完整级别进程发送窗口/线程消息。完成修改后，进入 LABEL_32，再次利用相同函数取消对 TaskbarCreated 字符串命名的消息的限制。随后向下执行 LABEL_24。

如果 dwMessage 为 NIM_DELETE ，则首先检查 uFlags 是否不包含 NIF_MESSAGE 标志，如果不包含，则直接执行 LABEL_24；否则，会检查  lpData->hWnd 是否为空，如果为空，则直接执行 LABEL_24；否则，禁止 uCallbackMessage 消息通过 UIPI，恢复 UIPI 限制。这也很好理解，因为 NIM_DELETE 表明将要删除图标，那么此时 hWnd 肯定不需要再接收消息了。

我们来看一下 LABEL_24，这是整个调用过程中最重要的一个部分。

​

这个部分主要调用了 SendMessageTimeout 函数向最初查找的 Shell_TrayWnd 窗口发送了 0x4a 这个特定的消息，这个消息是什么呢？

通过查阅 MSDN 文档，我们了解到它是 WM_COPYDATA 消息。分析到这里，其实我们已经明显明白 Shell_NotifyIcon 其实只是消息发送接口，而真正的处理在 explorer 的 Shell_TrayWnd 窗口中。但是这一部分也是最难理解的，下面我将对该消息发送过程进行详细的解释。

2.3 分析 WM_COPYDATA 消息

其实早在 2007 年左右，就有工程师逆向分析过资源管理器，在 Geoff Chappell 的个人笔记主页上就有相关的记录。

下文是摘选自

[WM_COPYDATA for Taskbar Interface (geoffchappell.com)]

www.geoffchappell.com/studies/windows/shell/shell32/api/shlnot/copydata.htm?tx=65

的一段文本介绍，我做了一些翻译：

任务栏界面的 WM_COPYDATA 消息

每一个 SHAppBarMessage、Shell_NotifyIcon、 SHEnableServiceObject 和 SHLoadInProc 函数都只不过是一个用于将数据发送到任务栏窗口的接口（在少数情况下用于获取返回数据）。这些数据的打包及其传输方法是(未被文档化的)实现细节，他们的各个功能之间有很多共同点。

[正文部分]

调用方进程通常不是实现任务栏通知窗口的进程。在另一个进程中传递数据到一个窗口过程的标准方法是使用 WM_COPYDATA 消息。WM_COPYDATA 消息提供了在 COPYDATASTRUCT 结构的 dwData 成员中传递一个 DWORD 值或者在 lpData 和 cbData 成员描述的缓冲区中传递任意数量的 DWORD 值的方法。SHELL32 同时支持这两种传递模式。下表列出的 DWORD 值用于标识缓冲区中传递的数据用于调用哪个函数：

0	SHAppBarMessage
1	Shell_NotifyIcon
2	SHEnableServiceObject 或者 SHLoadInProc

1. 传递 SHAppBarMessage 函数调用的参数的缓冲区布局为：

偏移	大小	备注
0x00	0x28 字节	APPBARDATA 结构的扩展，cbSize 设置为 0x28, lParam 符号扩展为QWORD 类型
0x28	DWORD	对应于 dwMessage 参数
0x2C	DWORD	位于共享内存中 APPBARDATA 扩展结构的副本的句柄，否则为 NULL
0x30	DWORD	调用方进程 ID
0x34	0x04 字节	该字段尚未使用，假定是为 QWORD 填充的对齐字节

共享内存和进程 ID 的关键在于，对于 dwMessage 的某些值，SHAppBarMessage 函数需要返回 APPBARDATA 结构成员中的信息。然而，WM_COPYDATA 消息的机制只将数据从源复制到任务栏窗口，而不提供回写的方法。SHELL32 给出的解决方案是：在需要的情况下，无论如何在缓冲区中传递的 APPBARDATA 扩展结构也被复制到共享内存中，并且访问该共享内存的方法也在缓冲区中传递。

2. 对于 Shell_NotifyIcon 函数，其缓冲区的数据结构如下表所示。在 explorer.exe 的符号文件中，微软为这个未记录的结构发布了一个名称：TRAYNOTIFYDATAW。

偏移	大小	备注
0x00	DWORD	该值写为：0x34753423，explorer 通过该签名确定调用方不是普通的 WM_COPYDATA
0x04	DWORD	dwMessage 参数
0x08	0x03B8  字节	表示当前缓冲区布局中的 NOTIFYICONDATAW 结构，该结构在 lpData 的指向堆栈上构造

3. SHEnableServiceObject 和 SHLoadInProc 函数缩减为一个由标识符区分的操作。缓冲区布局如下:

偏移	大小	备注
0x00	0x10 字节	类型为 CLSID。该值由 rclsid 参数指定。
0x10	DWORD	0x01 为 SHLoadInProc 0x02 为 SHEnableServiceObject 如果 fEnable 参数为 FALSE 0x03 为 SHEnableServiceObject 如果 fEnable 参数为 非零值

事实上，现今的 dwData 成员已经不止 0，1，2 三种 ID 了，在我的测试过程中就发现了超过 2 的 ID 号。

看完上面的笔记，大家可能依然处于懵懂的状态，下面我将分享我的分析理解心得：

通过 MSDN 文档并结合 IDA 的伪代码，我们知道 SendMessageTimeoutW 在被 Shell_NotifyIcon 函数调用时候，参数分别为：

参数 1：Shell_TrayWnd 窗口句柄(hWnd)；

参数 2：WM_COPYDATA (0x4A) 消息(uMsg)；

参数 3：调用方的窗口句柄(wParam)；

参数 4：COPYDATASTRUCT 结构体(lParam)；

参数 5：指定 SendMessageTimeoutW 发送消息方式的标识符，该值为 0xB，经过查表知该标志位由 SMTO_BLOCK | SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG 组成；

参数 6：以毫秒间隔计的等待超时时间，参数值为 0x1B58，表示 7 秒；

参数 7：消息返回状态，dwResult 是额外参数，表示消息处理的结果。

为了进一步理解这里 IDA 错误解析的部分参数构造，我们采用 WinDbg 调试分析该函数。

我首先准备了一个测试程序，该程序调用 Shell_NotifyIcon 并显示一个提示信息，代码如下。

#include 
#include 
#include 
 
// 系统托盘的自定义消息
#define WM_IAWENTRAY  WM_USER + 0x5
 
// 定义全局变量  
NOTIFYICONDATAW lpNotifyData = { 0 };
 
void SetConsoleCodePageToUTF8() {  // Utf-8 为了兼容中文
    _wsetlocale(LC_ALL, L".UTF8");
}
 
int main()
{
    SetConsoleCodePageToUTF8();
 
    // 初始化 NOTIFYICONDATA 结构
    lpNotifyData.cbSize = (DWORD)sizeof(NOTIFYICONDATAW);
    lpNotifyData.hWnd = GetConsoleWindow();
    lpNotifyData.uID = 0x5;
    lpNotifyData.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP | NIF_INFO;
    lpNotifyData.uCallbackMessage = WM_IAWENTRAY;
    lpNotifyData.hIcon = LoadIconW(NULL, IDI_APPLICATION);
    wcscpy_s(lpNotifyData.szTip, L"通知栏图标测试程序");
    wcscpy_s(lpNotifyData.szInfo, L"提示窗口内容");
    wcscpy_s(lpNotifyData.szInfoTitle, L"提示窗口标题");
    lpNotifyData.dwInfoFlags = NIIF_INFO;
    lpNotifyData.uTimeout = 5000;
    Shell_NotifyIconW(NIM_ADD, &lpNotifyData);  // 在托盘区添加图标
 
    getchar();
 
    Shell_NotifyIconW(NIM_DELETE, &lpNotifyData);  // 删除图标
 
    return 0;
}

运行时候的效果如图所示：

​

用 WinDbg 调试测试程序并设置 USER32!SendMessageTimeoutW 断点。随后让测试程序（调用 Shell_NotifyIcon 函数）运行起来并触发断点。

我们查看此时的寄存器，以便于获取前四个参数的值：

Breakpoint 0 hit

USER32!SendMessageTimeoutW:

00007ffc`be1f53a0        4053        push rbx

0:000> r

rax=000000f4d95ee338        rbx=00000000000000cf        rcx=00000000000100fc

rdx=000000000000004a        rsi=0000000000000000        rdi=00007ff616d45630

rip=00007ffcbe1f53a0        rsp=000000f4d95ee2b8         rbp=000000f4d95ee3c0

r8=0000000000050e7c         r9=000000f4d95ee308         r10=0000000000000000

r11=0000000000000246         r12=0000000000000000         r13=00000000000100fc

r14=0000000000000005         r15=0000000000000000         

iopl=0                 nv up ei pl zr na po nc

cs=0033         ss=002b         ds=002b         es=002b        fs=0053         gs=002b

efl=00000246

USER32!SendMessageTimeoutW:

00007ffc`be1f53a0        4053        push rbx

我们知道，x64 的前 4 个参数是在寄存器上的，分别对应：

• rcx = 00000000000100fc  == > HWND hTrayWnd
• rdx = 000000000000004a  == > UINT Msg
• r8   = 0000000000050e7c  == > HWND hMainWnd
• r9   = 000000f4d95ee308  == > PCOPYDATASTRUCT
• r8 表明了调用方窗口，r9 寄存器就是我们要找的数据，是指向 COPYDATASTRUCT 结构体的指针。

根据 MSDN 的文档: [https://learn.microsoft.com/zh-cn/windows/win32/dataxchg/wm-copydata]

WM_COPYDATA 消息发送时，wParam 为传递数据的窗口的句柄，lParam 为指向包含要传递的数据 的 COPYDATASTRUCT 结构的指针。 COPYDATASTRUCT 结构体的声明如下：

typedef struct tagCOPYDATASTRUCT {
    ULONG_PTR dwData;
    DWORD cbData;
    _Field_size_bytes_(cbData) PVOID lpData;
} COPYDATASTRUCT, *PCOPYDATASTRUCT;

其中，dwData 就是要执行函数的编号，也就是 Geoff Chappell 给的那个表：

在从 NT 5.2 开始至今的多次改版中，explorer 已经新增了一些该表未能够展示的功能。

比如 ID 为 3 可以代表调用了 Shell_NotifyIconGetRect 函数（Win 7 引入），该函数可以获取通知图标的边框的屏幕坐标。

SHSTDAPI Shell_NotifyIconGetRect(
    const NOTIFYICONIDENTIFIER *identifier,
    RECT                       *iconLocation
);

第一个是入参，使用仅 guidItem 或者 hWnd 加 uID 来向 explorer 请求数据，该过程中使用一个未文档的 CLSID。他的调试符号是 GUID_ShellNotifyChevron 具体的 GUID 为：{964B6543-BBAD-44EE-848A-3A95D85951EA}。

当然，对于本文的目的来说这些新增的内容不太重要。

由于我们测试用的是 Shell_NotifyIcon，则结果应该是 1，WinDbg 查看发现是一致的：

 0:000> dps 000000f4d95ee308

000000f4`d95ee308        00000000`00000001   ---->  dwData
000000f4`d95ee310        00000000`000005cc   ---->  cbData
000000f4`d95ee318        000000f4`d95ee360   ---->  lpData
000000f4`d95ee320        00000000`00000020
000000f4`d95ee328        00007ffc`00000000
000000f4`d95ee330        000001fa`7544f160
000000f4`d95ee338        00000000`00000000
000000f4`d95ee340        00000000`40000163
000000f4`d95ee348        00000000`40000163
000000f4`d95ee350        000001fa`75430000
000000f4`d95ee358        00000000`00000000
000000f4`d95ee360        00000000`34753423
000000f4`d95ee368        00050e7c`000003bc
000000f4`d95ee370        00000007`0000245f
000000f4`d95ee378        0001002b`000007ed
000000f4`d95ee380        76d86258`8bd56d4b

这里的 lpData 是什么呢？我们接着分析：

0:000> dps 000000f4`d95ee360
000000f4`d95ee360  00000000`34753423
000000f4`d95ee368  00050e7c`000003bc
000000f4`d95ee370  00000007`0000245f
000000f4`d95ee378  0001002b`000007ed
000000f4`d95ee380  76d86258`8bd56d4b
000000f4`d95ee388  5e8f7a0b`75285e94
000000f4`d95ee390  00000000`00000000
000000f4`d95ee398  00000000`00000000
000000f4`d95ee3a0  00000000`00000000
000000f4`d95ee3a8  00000000`00000000
000000f4`d95ee3b0  00000000`00000000
000000f4`d95ee3b8  00000000`00000000
000000f4`d95ee3c0  00000000`00000000
000000f4`d95ee3c8  00000000`00000000
000000f4`d95ee3d0  00000000`00000000
000000f4`d95ee3d8  00000000`00000000

由于中途关闭了一次电脑，记录的解析图时候来重新画的，下图是前面几个成员的解释：

和 Geoff Chappell 说的差不多，基本上是 NOTIFYICONDATAW 结构。为了方便处理我们将 Signature(0x34753423) 和 dwMessage 合并到这个结构体中第一个成员的前面。explorer 通过Signature 验证调用是否是发送至任务栏的通知区域的，因为 lParam->dwData 指向的 ID == 1 并不一定是由 Shell_NotifyIcon 发起的，只是说 Shell_NotifyIcon 发起时的 ID 为 1。

此外，可能是因为版本问题，HICON hIcon 成员对应位置被改成 DWORD uKnown。这个值在测试过程中是 01002b，暂时还不清楚他是什么。

根据 IDA 反汇编的代码，ICON 是创建之后才单独去绘制的，所以可能结构体有所变化，其他位置目前没有发现变化，完整的结构体如下所示。

typedef struct _TRAY_ICON_DATAW {
    DWORD Signature;
    DWORD dwMessage;   // dwMessage <-- Shell_NotifyIconW(DWORD dwMessage, PNOTIFYICONDATAW lpData)
    DWORD cbSize;
    DWORD hWnd;
    UINT uID;
    UINT uFlags;
    UINT uCallbackMessage;
    DWORD uIconID; // HICON hIcon; why?
#if (NTDDI_VERSION < NTDDI_WIN2K)
    WCHAR  szTip[64];
#endif
#if (NTDDI_VERSION >= NTDDI_WIN2K)
    WCHAR  szTip[128];
    DWORD dwState;
    DWORD dwStateMask;
    WCHAR  szInfo[256];
#ifndef _SHELL_EXPORTS_INTERNALAPI_H_
    union {
        UINT  uTimeout;
        UINT  uVersion;  // used with NIM_SETVERSION, values 0, 3 and 4
    } DUMMYUNIONNAME;
#endif
    WCHAR  szInfoTitle[64];
    DWORD dwInfoFlags;
#endif
#if (NTDDI_VERSION >= NTDDI_WINXP)
    GUID guidItem;
#endif
#if (NTDDI_VERSION >= NTDDI_VISTA)
    HICON hBalloonIcon;
#endif
} TRAY_ICON_DATAW, * PTRAY_ICON_DATAW;

2.4 调用方挂钩拦截消息封送过程

为了验证我们分析的结论，下面我将通过调用方挂钩拦截这个消息的封送过程。

我们利用 detours 库挂钩 SendMessageTimeoutW 函数，并对 TRAY_ICON_DATAW 进行解析，就可以获取发送的消息内容。

一个测试代码如下：

// TrayNotifyIconTest.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
 
#include 
#include 
#include   
#include 
#include 
#include 
 
#pragma comment(lib, "detours.lib")
#define WM_IAWENTRAY  WM_USER + 0x5  // 系统托盘的自定义消息
 
// 保存原始函数指针
LPVOID Real_SendMessageTimeoutW = nullptr;
// 定义全局变量  
NOTIFYICONDATAW lpNotifyData = { 0 };
 
typedef struct _TRAY_ICON_DATAW {
    DWORD Signature;
    DWORD dwMessage;   // dwMessage <-- Shell_NotifyIconW(DWORD dwMessage, PNOTIFYICONDATAW lpData)
    DWORD cbSize;
    DWORD hWnd;
    UINT uID;
    UINT uFlags;
    UINT uCallbackMessage;
    DWORD uIconID; // HICON hIcon; why?
#if (NTDDI_VERSION < NTDDI_WIN2K)
    WCHAR  szTip[64];
#endif
#if (NTDDI_VERSION >= NTDDI_WIN2K)
    WCHAR  szTip[128];
    DWORD dwState;
    DWORD dwStateMask;
    WCHAR  szInfo[256];
#ifndef _SHELL_EXPORTS_INTERNALAPI_H_
    union {
        UINT  uTimeout;
        UINT  uVersion;  // used with NIM_SETVERSION, values 0, 3 and 4
    } DUMMYUNIONNAME;
#endif
    WCHAR  szInfoTitle[64];
    DWORD dwInfoFlags;
#endif
#if (NTDDI_VERSION >= NTDDI_WINXP)
    GUID guidItem;
#endif
#if (NTDDI_VERSION >= NTDDI_VISTA)
    HICON hBalloonIcon;
#endif
} TRAY_ICON_DATAW, * PTRAY_ICON_DATAW;
 
 
// 定义原始函数指针类型
typedef BOOL(WINAPI* RealSendMessageTimeoutW)(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam,
    UINT fuFlags,
    UINT uTimeout,
    PDWORD_PTR lpdwResult
    );
 
// Utf-8 为了兼容中文
void SetConsoleCodePageToUTF8() {
    _wsetlocale(LC_ALL, L".UTF8");
}
 
// 定义挂钩函数
BOOL WINAPI MySendMessageTimeoutW(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam,
    UINT fuFlags,
    UINT uTimeout,
    PDWORD_PTR lpdwResult
)
{
    // 显示调用参数
    std::wcout << "SendMessageTimeoutW called:" << std::endl;
    std::wcout << "hWnd: " << std::hex << hWnd << std::endl;
    std::wcout << "Msg: " << std::hex << Msg << std::endl;
    std::wcout << "wParam: " << std::hex << wParam << std::endl;
    std::wcout << "lParam: " << std::hex << lParam << std::endl;
 
    // 如果 lParam 指向 WM_COPYDATA 结构体
    if (Msg == WM_COPYDATA) {
        PCOPYDATASTRUCT lpCopyData = reinterpret_cast(lParam);
        PTRAY_ICON_DATAW lpIconData = reinterpret_cast(lpCopyData->lpData); // x64 系统偏移量 0x58
        std::wcout << L"pData: " << std::hex << lpIconData << std::endl;
        std::wcout << L"hWnd: " << std::hex << lpIconData->hWnd << std::endl;
        std::wcout << L"szTip: " << std::hex << lpIconData->szTip << std::endl;
        std::wcout << L"szInfo: " << std::hex << lpIconData->szInfo << std::endl;
        std::wcout << L"szInfoTitle: " << std::hex << lpIconData->szInfoTitle << std::endl;
    }
    // 调用原始函数
    BOOL result = ((RealSendMessageTimeoutW)Real_SendMessageTimeoutW)(
        hWnd, Msg, wParam, lParam, fuFlags, uTimeout, lpdwResult);
    return result;
}
 
int main()
{
    SetConsoleCodePageToUTF8();
 
    // 挂钩 SendMessageTimeoutW
    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());
    Real_SendMessageTimeoutW = &SendMessageTimeoutW;
    DetourAttach(&(PVOID&)Real_SendMessageTimeoutW, MySendMessageTimeoutW);
    DetourTransactionCommit();
 
	// 初始化NOTIFYICONDATA结构
    lpNotifyData.cbSize = (DWORD)sizeof(NOTIFYICONDATAW);
    lpNotifyData.hWnd = GetConsoleWindow();
    lpNotifyData.uID = 0x5;
    lpNotifyData.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP | NIF_INFO;
    lpNotifyData.uCallbackMessage = WM_IAWENTRAY;
    lpNotifyData.hIcon = LoadIconW(NULL, IDI_APPLICATION);
    wcscpy_s(lpNotifyData.szTip, L"通知栏图标测试程序");
    wcscpy_s(lpNotifyData.szInfo, L"提示窗口内容");
    wcscpy_s(lpNotifyData.szInfoTitle, L"提示窗口标题");
    lpNotifyData.dwInfoFlags = NIIF_INFO;
    lpNotifyData.uTimeout = 5000;
    Shell_NotifyIconW(NIM_ADD, &lpNotifyData);  // 在托盘区添加图标
 
	getchar();
 
	Shell_NotifyIconW(NIM_DELETE, &lpNotifyData);  // 删除图标
 
    // 卸载挂钩
    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());
    DetourDetach(&(PVOID&)Real_SendMessageTimeoutW, MySendMessageTimeoutW);
    DetourTransactionCommit();
 
	return 0;
}

可以很轻松地解析出发送的数据内容，结果如下图所示：

下面我们解释一下这几个参数，szInfo 和 szInfoTitle 只有在显示气泡提示时候才用到，分别对应消息的内容和标题，如下图所示：

szTip 则是任务栏图标的标签文本：

这说明了对 WM_COPYDATA 消息的分析是正确的。

2.5 接收方挂钩实现获取任意图标信息

讲完了消息封送过程(调用方)的拦截方法，我们必然需要去研究接收方的消息处理机制。这是因为接收方作为消息的总管理者，我们有能力获取所有使用 Shell_NotifyIcon 函数的程序而不必大动干戈地去想着全局挂钩消息的封送过程。全局挂钩往往消耗过多的计算机资源且面临着兼容性风险从而不是一个优选的方案。

根据我前一阵子研究的动态壁纸制作技术内幕，当时就已经分析了一部分 explorer 内部的桌面机制，分析时遇到了一类消息回调的模板，里面就有这里需要用的内容，只不过第二部分的动态壁纸制作分析文章搁置了很久而未发布。原因是这真的是一个很复杂的工程，而我又没有太多空余时间，所以进展就比较慢，下面是部分未发布的内容截图：

当然，关于桌面动态壁纸和虚拟桌面等接口，未来有进展了我就会先发布一部分的。

通过 IDA 分析 explorer 的导入表，我们对所有窗口创建和消息发送函数进行交叉引用、特征字符串等排查。最终确定了 CTray 类是实现系统通知区域的窗口程序类，并在其中找到了 v_WndProc 消息回调函数，在 explorer 所有的窗口回调函数中只有该函数处理 WM_COPYDATA(0x4A) 消息。

随后我们结合 WinDbg 调试进一步确定了这个函数就是处理 WM_COPYDATA 的函数，由于 explorer 不是很好动态调试，所以测试时没有留图。

在 x64 系统下，该函数的声明（已经分析并修正参数）如下：

typedef LRESULT(__fastcall* v_WndProc)(
    LPVOID pthis,   // CTray *this，由于没有 CTray 的原型，这里就改写成 void* 类型。
    HWND hWnd, 
    UINT uMsg, 
    WPARAM wParam, 
    LPARAM lParam
);

我猜测 x86 的调用约定是 __stdcall ，具体声明如何还未进行验证，交给读者啦。

它后面几个参数其实和一般的窗口回调没有什么区别。

最后两个参数 IDA 很有可能根据调试符号直接解析为 LPITEMIDLIST 结构体指针，我觉得这是不对的，就改了过来。注意： IDA 对最后一个参数名称解析为 pidl 。

由于这里具体的处理过程理解起来比较复杂，而且我觉得暂时也没有必要去讲解。所以我就不逐一解释了，感兴趣的可以自己去分析一下这个函数，它相对于桌面其他几个窗口的消息处理机制来说还是稍微简单一点的。

P.S.: 可以不使用挂钩 CTray::v_WndProc  API 的方式拦截消息，详细见第 4 篇文章《最新方案（三）》。

我们使用 Detours 库再次实现挂钩过程，测试时使用了硬编码偏移量，发布时应该采用特征码定位方法，定位过程用到的代码我也会附加在后面的，需要的自己完善一下代码。

我测试的系统是最新的 Win 11 Release 23H2 | x64 | Build 10.0.22631.3155，该函数偏移量为 0xB630。

再次警告：Explorer 属于经常更新的组件，且 CTray::v_WndProc 函数是内部函数，偏移量随系统更新而变化，实际过程必须使用定位算法。

下面是 HOOK 模块的简单测试用代码：

#include "pch.h"
#include 
#include "detours.h"
#include 
#include 
#include 
#include 
#include 
#pragma comment(lib, "detours.lib")
 
HINSTANCE g_hinstDLL = NULL;   // 模块句柄
LPVOID fpVWndProc = NULL;      // CTray::v_WndProc 函数原始地址
 
// 一些宏定义
#define NIM_ADD         0x00000000
#define NIM_MODIFY      0x00000001
#define NIM_DELETE      0x00000002
#define NIM_SETFOCUS    0x00000003
#define NIM_SETVERSION  0x00000004
 
#define NIF_TIP         0x00000004
#define NIF_INFO        0x00000010
 
// Notify Icon Infotip flags
#define NIIF_NONE       0x00000000
#define NIIF_INFO       0x00000001
#define NIIF_WARNING    0x00000002
#define NIIF_ERROR      0x00000003
#define NIIF_USER       0x00000004
#define NIIF_ICON_MASK  0x0000000F
#define NIIF_NOSOUND    0x00000010
#define NIIF_LARGE_ICON 0x00000020
#define NIIF_RESPECT_QUIET_TIME 0x00000080
 
// 窗口句柄转换字符串的函数
std::wstring make_hwnd_text(HWND hwnd)
{
    wchar_t buf[25];
    wsprintfW(buf, L"HWND:0x%I64X", (UINT64)hwnd);
    return buf;
}
 
// dwMessage 参数转换为已知参数字符串
std::wstring make_snmsg_text(DWORD dwMessage)
{
#define CHECK_DMSG(dwMessage, var) if (dwMessage == var) return L#var;
    CHECK_DMSG(dwMessage, NIM_ADD);
    CHECK_DMSG(dwMessage, NIM_MODIFY);
    CHECK_DMSG(dwMessage, NIM_DELETE);
    CHECK_DMSG(dwMessage, NIM_SETFOCUS);
    CHECK_DMSG(dwMessage, NIM_SETVERSION);
 
    wchar_t buf[25];
    wsprintfW(buf, L"Message:%u", dwMessage);
    return buf;
#undef CHECK_HWND
}
 
// dwInfoFlags 参数转换为已知参数字符串
std::wstring make_infoflag_text(DWORD dwInfoFlags)
{
#define CHECK_DMSG(dwInfoFlags, var) if (dwInfoFlags == var) return L#var;
    CHECK_DMSG(dwInfoFlags, NIIF_NONE);
    CHECK_DMSG(dwInfoFlags, NIIF_INFO);
    CHECK_DMSG(dwInfoFlags, NIIF_WARNING);
    CHECK_DMSG(dwInfoFlags, NIIF_ERROR);
    CHECK_DMSG(dwInfoFlags, NIIF_USER);
    CHECK_DMSG(dwInfoFlags, NIIF_ICON_MASK);
    CHECK_DMSG(dwInfoFlags, NIIF_NOSOUND);
    CHECK_DMSG(dwInfoFlags, NIIF_LARGE_ICON);
    CHECK_DMSG(dwInfoFlags, NIIF_RESPECT_QUIET_TIME);
    wchar_t buf[25];
    wsprintfW(buf, L"Message:%u", dwInfoFlags);
    return buf;
#undef CHECK_HWND
}
 
// 方便于调用
#define HWND2TEXT(hwnd) make_hwnd_text(hwnd).c_str()
#define DMSG2TEXT(dwMessage) make_snmsg_text(dwMessage).c_str()
#define NIIF2TEXT(dwInfoFlags) make_infoflag_text(dwInfoFlags).c_str()
 
// 日志记录函数，在模块的目录下创建 SysNotifyLog.txt 日志文件
void log_printf(const wchar_t* fmt, ...)
{
    DWORD dwError = GetLastError();
    _wsetlocale(LC_ALL, L".UTF8");  // 设置代码页以支持中文
    wchar_t buf[800];
    va_list va;
    va_start(va, fmt);
    vswprintf_s(buf, fmt, va);
    va_end(va);
 
    TCHAR szPath[MAX_PATH];
    GetModuleFileName(g_hinstDLL, szPath, MAX_PATH);
    TCHAR* pch = _tcsrchr(szPath, TEXT('\\'));
    if (pch == NULL)
        pch = _tcsrchr(szPath, TEXT('/'));
    lstrcpy(pch + 1, TEXT("SysNotifyLog.txt"));
 
    HANDLE hMutex = CreateMutex(NULL, FALSE, TEXT("SysNotifyHooker Mutex"));
    WaitForSingleObject(hMutex, 800);
    {
        using namespace std;
        FILE* fp = NULL;
        _tfopen_s(&fp, szPath, TEXT("a"));
        if (fp)
        {
            fprintf(fp, "PID:%08lX:TID:%08lX> ",
                GetCurrentProcessId(), GetCurrentThreadId());
            fputws(buf, fp);
            fflush(fp);
            fclose(fp);
        }
    }
    ReleaseMutex(hMutex);
    CloseHandle(hMutex);
 
    SetLastError(dwError);
}
 
// x64 结构体的声明
typedef struct _TRAY_ICON_DATAW {
    DWORD Signature;
    DWORD dwMessage;   // dwMessage <-- Shell_NotifyIconW(DWORD dwMessage, ...)
    DWORD cbSize;
    DWORD hWnd;
    UINT uID;
    UINT uFlags;
    UINT uCallbackMessage;
    DWORD uIconID; // HICON hIcon; why it changes?
#if (NTDDI_VERSION < NTDDI_WIN2K)
    WCHAR  szTip[64];
#endif
#if (NTDDI_VERSION >= NTDDI_WIN2K)
    WCHAR  szTip[128];
    DWORD dwState;
    DWORD dwStateMask;
    WCHAR  szInfo[256];
#ifndef _SHELL_EXPORTS_INTERNALAPI_H_
    union {
        UINT  uTimeout;
        UINT  uVersion;  // used with NIM_SETVERSION, values 0, 3 and 4
    } DUMMYUNIONNAME;
#endif
    WCHAR  szInfoTitle[64];
    DWORD dwInfoFlags;
#endif
#if (NTDDI_VERSION >= NTDDI_WINXP)
    GUID guidItem;
#endif
#if (NTDDI_VERSION >= NTDDI_VISTA)
    HICON hBalloonIcon;
#endif
} TRAY_ICON_DATAW, * PTRAY_ICON_DATAW;
 
// 函数原型的声明
typedef LRESULT(__fastcall* __v_WndProc)(
    LPVOID pthis, 
    HWND hWnd, 
    UINT uMsg, 
    WPARAM wParam, 
    LPARAM lParam
);
 
 
// 我们的钩子函数
LRESULT __fastcall v_WndProc(
    LPVOID pthis,   HWND hWnd, 
    UINT   uMsg,    WPARAM wParam, 
    LPARAM lParam
)
{
    LRESULT ret = 0;
    ret = ((__v_WndProc)fpVWndProc)(pthis, hWnd, uMsg, wParam, lParam);
    
    if ((UINT)uMsg == WM_COPYDATA)
    {
        COPYDATASTRUCT* pCopyData = reinterpret_cast(lParam);
        if (pCopyData->dwData == 1)
        {
            PTRAY_ICON_DATAW pTrayIcon = reinterpret_cast(pCopyData->lpData);
 
            if (pTrayIcon->Signature == 0x34753423) // 检查是否是通知区域图标消息
            {
                // log_printf(L"CTray::v_WndProc -- COPYDATA: Signature = 0x34753423;\n");
                log_printf(L"CTray::v_WndProc:[%ws]:[%ws];\n",
                    DMSG2TEXT(pTrayIcon->dwMessage), HWND2TEXT((HWND)wParam));
                if ((pTrayIcon->uFlags & NIF_INFO) != 0)
                {
                    log_printf(L"Tip[%ws], szInfoParam:\n",
                        pTrayIcon->szTip);
                    log_printf(L"InfoTitle[%ws], Info[%ws], InfoFlags[%ws];\n",
                        pTrayIcon->szInfoTitle, pTrayIcon->szInfo, NIIF2TEXT(pTrayIcon->dwInfoFlags));
                }
                else if ((pTrayIcon->uFlags & NIF_TIP) != 0)
                {
                    log_printf(L"Tip[%ws], non-szInfo;\n", pTrayIcon->szTip);
                }
                else {
                    log_printf(L"non-szTip, non-szInfo;\n");
                }
                
                // log_printf(L"CTray::v_WndProc: leave: ret = %Id;\n", ret);
            }
            
        }
    }
    return ret;
}
 
 
void StartHookingFunction()
{
    // 开始事务
    DetourTransactionBegin();
    // 更新线程信息  
    DetourUpdateThread(GetCurrentThread());
 
    HMODULE hExpBase = GetModuleHandleW(L"explorer.exe");
    if (hExpBase == nullptr)
        return;
 
#if (NTDDI_VERSION >= NTDDI_WIN10 && _WIN64)
    // 硬编码了 v_WndProc 函数的偏移量，系统版本 Win11, 10.0.22631.3155, x64, 23H2
    fpVWndProc = reinterpret_cast(
        reinterpret_cast(hExpBase) + 0xB630u);
#else
    NOT_SUPPORT_VERSION;
#endif
 
    if (fpVWndProc == nullptr)
        return;
 
    // 将拦截的函数附加到原函数的地址上,这里可以拦截多个函数。
    DetourAttach(&fpVWndProc,
        v_WndProc);
 
    // 结束事务
    DetourTransactionCommit();
}
 
void UnmappHookedFunction()
{
    // 开始事务
    DetourTransactionBegin();
    // 更新线程信息 
    DetourUpdateThread(GetCurrentThread());
 
    // 将拦截的函数从原函数的地址上解除，这里可以解除多个函数。
 
    DetourDetach(&fpVWndProc,
        v_WndProc);
 
    // 结束事务
    DetourTransactionCommit();
}
 
 
extern "C"
BOOL WINAPI
DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
{
    DisableThreadLibraryCalls(hinstDLL);
    switch (fdwReason)
    {
    case DLL_PROCESS_ATTACH:
        g_hinstDLL = hinstDLL;
        log_printf(L"DLL_PROCESS_ATTACH: %p\n", hinstDLL);
        StartHookingFunction();
        break;
    case DLL_PROCESS_DETACH:
        log_printf(L"DLL_PROCESS_DETACH: %p\n", hinstDLL);
        UnmappHookedFunction();
        break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
        break;
    }
    return TRUE;
}
 
// just for exporting a function
extern "C" __declspec(dllexport) void ImportFunc()
{
    // Do nothing
}