azd放 这个能不能用在安卓中

判断AVX2的函数不准确，建议参考此项目

https://files-cdn.cnblogs.com/files/zyl910/checkavx.rar

搜索小于16字节且搜索个数为0的时候会崩溃

加了两句

		if ((maxAddress - currAddress) < 16)
			break;

BOOL SSE2PatternFindEx(std::vector<ULONGLONG>& retList, const ULONGLONG searchStartAddr,
	const LONGLONG searchSize, const std::string& myPattern, const LONGLONG offsetSize, const ULONGLONG searchNum)
{
	if (0 == searchStartAddr || 0 == searchSize) { return FALSE; }

	ULONGLONG realStartAddr = searchStartAddr; // searchSize为负时(从给定的地址往上搜索)，searchStartAddr需要修正为真正的起始地址
	if ((searchSize < 0) && (searchStartAddr > std::abs(searchSize))) //searchSize可上负下正（以字节为单位）
	{
		realStartAddr = searchStartAddr - std::abs(searchSize);
	}

	std::vector<UCHAR> vecPtn;  // 存储转换后的特征码字节序列
	std::vector<UCHAR> vecMsk;  // 存储特征字符串中'??'、'?'的掩码('??'和'?'用1替代，非'?'为0)
	std::vector<ULONG> vecIdx;  // 存储不是'??'的特征码字节在原始特征码字节序列(传入的有'??'的特征码)中的索引下标

	if (!InitPattern(myPattern, vecPtn, vecMsk, vecIdx)) { return FALSE; }
	size_t vecPtnLen = vecPtn.size();
	size_t vecIdxLen = vecIdx.size();

	// 常规变量
	PUCHAR maxAddress = (PUCHAR)(realStartAddr + std::abs(searchSize));
	PUCHAR baseAddress;
	PUCHAR currAddress;
	PUCHAR currPattern = &vecPtn[0]; // 特征码字节序列的首地址
	UCHAR currEqual;
	register UCHAR currPtnCh;

	// SSE加速相关变量
	__m128i ptnHead = _mm_set1_epi8(vecPtn[vecIdx[0]]);
	__m128i headMsk = _mm_set1_epi8(vecMsk[vecIdx[0]]);
	__m128i curHead, curComp;
	ULONG bitComp, idxComp;

	size_t maxEndSize = min(std::abs(searchSize) - vecPtn.size(), std::abs(searchSize) - 16);
	for (ULONGLONG i = vecIdx[0]; i <= maxEndSize; i += 16)
	{
		baseAddress = (PUCHAR)(realStartAddr + i);
		if ((maxAddress - currAddress) < 16)
			break;
		curHead = _mm_loadu_si128((__m128i*)(baseAddress));
		curHead = _mm_or_si128(curHead, headMsk);	// 将对应特征码中'?'位置的二进制位替换为1
		curComp = _mm_cmpeq_epi8(ptnHead, curHead); // 比较sigHead和curHead，并将比较结果存储在curComp中。
		bitComp = _mm_movemask_epi8(curComp); //将curComp中的每个字节的最高位提取出来，并将这些位组合成一个 16 位的整数 bitComp。

		ULONG j = 0;
		while (_BitScanForward(&idxComp, bitComp))
		{
			currAddress = baseAddress + j + idxComp - vecIdx[0];
			for (ULONG iCh = 1; iCh < vecIdxLen && (size_t)currAddress <= (size_t)maxAddress - vecPtnLen; iCh++)
			{
				currPtnCh = currPattern[vecIdx[iCh]];

				// currPattern[vecIdx[iCh)] = currPtnCh + 0x1;  // 要排除本函数自身的特征码字节序列，可以打开这两行
				// currEqual为0时表示两个字节相同(包含半字节'?'的判断)
				currEqual = ((currAddress[vecIdx[iCh]] | vecMsk[vecIdx[iCh]]) ^ currPtnCh);
				// currPattern[vecIdx[iCh)] = currPtnCh; // 过了判断是否相等的代码后，恢复原来的自己

				if (currEqual) { break; } // currEqual不为0时两个字节不相同

				if (iCh + 1 == vecIdxLen) // 相同数据的个数等于特征码字节数长度，说明找到特征码字节序列
				{
					retList.push_back((ULONGLONG)(currAddress + offsetSize));
					if (searchNum != 0 && retList.size() >= searchNum) { return TRUE; }
					break;
				}
			}
			++idxComp;
			bitComp = bitComp >> idxComp;
			j += idxComp;
		}
	}
	if (vecPtn.size() < 16)  // 给定内存区域末尾搜剩的少于16字节的区域进行搜索
	{
		ULONGLONG tmpStarAddr = realStartAddr + maxEndSize + 1;
		ULONGLONG tmpSearchSize = std::abs(searchSize) - maxEndSize - 1;

		for (int i = 0; i <= tmpSearchSize - vecPtn.size(); i += vecPtn.size())
		{
			ULONGLONG tailPtnAddr = BFPatternFind(tmpStarAddr + i, tmpSearchSize - i, vecPtn, vecMsk, vecIdx);
			if (tailPtnAddr)
			{
				retList.push_back(tailPtnAddr);
			}
		}
	}
	return TRUE;
}

superlover 判断AVX2的函数不准确，建议参考此项目https://files-cdn.cnblogs.com/files/zyl910/checkavx.rar搜索小于16字节且搜索个数为0的时候会崩溃加了两句 ...

你这个代码是我上一个帖子的匹配算法，我修改一下上一帖子的代码，感谢指点！

本帖换了另外一种特征码匹配逻辑：

/****************************************************************************************
 * @brief ▲▲▲SSE2PatternFind128-使用SSE2加速搜索内存特征码(支持模糊匹配)-By.Haogl-20240906
 * @param retList 用于存储搜索到的特征码对应的内存地址（可以存储多个搜索到的内存地址）
 * @param searchStartAddr 需要搜索的起始内存地址
 * @param searchSize 要搜索的内存块的大小,可上负下正（以字节为单位）
 * @param myPattern 搜索特征码，支持通配符??、?，如："?? 5? 77 ?? 88 ?? ?A ??"
 * @param offsetSize 特征码地址离目标地址的偏移距离，上负下正，默认0不偏移
 * @param searchNum 搜索个数，0为搜索整个模块，默认为0
 * @return 成功返回TRUE，失败返回FALSE
*/
DLL_API BOOL SSE2PatternFind128(std::vector& retList, const ULONGLONG searchStartAddr,
	const LONGLONG searchSize, const std::string& myPattern, const LONGLONG offsetSize, const ULONGLONG searchNum)
{
	if (0 == searchStartAddr || 0 == searchSize) { return FALSE; }

	ULONGLONG realStartAddr = searchStartAddr; // searchSize为负时(从给定的地址往上搜索)，searchStartAddr需要修正为真正的起始地址
	if ((searchSize < 0) && (searchStartAddr > std::abs(searchSize))) //searchSize可上负下正（以字节为单位）
	{
		realStartAddr = searchStartAddr - std::abs(searchSize);
	}

	std::vector vecPtn;  // 存储转换后的特征码字节序列
	vecPtn.reserve(16);  // 设置容器的初始预留空间
	std::vector vecMsk;  // 存储特征字符串中'??'、'?'的掩码('??'和'?'用1替代，非'?'为0)
	vecMsk.reserve(16);
	std::vector vecIdx;  // 存储不是'??'的特征码字节在原始特征码字节序列(传入的有'??'的特征码)中的索引下标
	vecIdx.reserve(8);
	if (!InitPattern(myPattern, vecPtn, vecMsk, vecIdx)) { return FALSE; }

	std::vector<__m128i> m128VecPtn;
	m128VecPtn.reserve(16);
	std::vector<__m128i> m128VecMsk;
	m128VecMsk.reserve(16);
	for (size_t k = 0; k < vecIdx.size(); k++)
	{
		m128VecPtn.push_back(_mm_set1_epi8(vecPtn.at(vecIdx[k])));
		m128VecMsk.push_back(_mm_set1_epi8(vecMsk.at(vecIdx[k])));
	}

	UCHAR bakVecPtnCh = vecPtn.at(vecIdx[0]);
	vecPtn.at(vecIdx[0]) += 1;  // 下面搜索前把自己改得不是自己，防止搜索到自己

	retList.clear();
	retList.reserve(16);
	__m128i curMemByte, curCmp, curByteCorr;
	register size_t curBit = 0;
	PUCHAR currMemAddr;
	size_t maxEndSize = min(std::abs(searchSize) - vecPtn.size(), std::abs(searchSize) - 16);
	for (size_t i = vecIdx[0]; i <= maxEndSize; i += 16)
	{
		PUCHAR baseMemAddr = (PUCHAR)(realStartAddr + i - vecIdx[0]);
		size_t prevCmpBit = 0xFFFFFFFF;
		for (size_t j = 0; j < vecIdx.size(); j++)
		{
			curMemByte = _mm_loadu_si128((__m128i*)(baseMemAddr + vecIdx[j]));
			curByteCorr = _mm_or_si128(curMemByte, m128VecMsk.at(j));	// 当前内存字节的'?'位置的二进制位修正为1
			curCmp = _mm_cmpeq_epi8(m128VecPtn.at(j), curByteCorr); // 进行字节比较，并将比较结果存储在curCmp中。
			curBit = _mm_movemask_epi8(curCmp); // 将curCmp中的每个字节的最高位提取出来，并将这些位组合成一个16位的整数curBit。
			curBit = curBit & prevCmpBit;

			if (0 == curBit) { break; }  // 在给定的内存区域中没有找到特征码
			prevCmpBit = curBit;

			if (j + 1 == vecIdx.size()) // 相同数据的个数等于特征码字节数长度，说明找到特征码字节序列
			{
				ULONG bitIdx = 0, n = 0;
				while (_BitScanForward(&bitIdx, curBit))  // 遍历不为0的二进制位(找到的特征码位置)
				{
					currMemAddr = baseMemAddr + n + bitIdx;
					retList.push_back((ULONGLONG)(currMemAddr + offsetSize));
					if (searchNum != 0 && retList.size() >= searchNum) { return TRUE; }

					++bitIdx;
					curBit = curBit >> bitIdx;
					n += bitIdx;
				}
			}
		}
	}

	vecPtn.at(vecIdx[0]) = bakVecPtnCh;  // 恢复原来的自己
	if (vecPtn.size() < 16)  // 给定内存区域末尾搜剩的少于16字节的区域进行搜索
	{
		ULONGLONG tmpStarAddr = realStartAddr + maxEndSize + 1;
		ULONGLONG tmpSearchSize = std::abs(searchSize) - maxEndSize - 1;

		for (int i = 0; i <= tmpSearchSize - vecPtn.size(); i += vecPtn.size())
		{
			ULONGLONG tailPtnAddr = BFPatternFind(tmpStarAddr + i, tmpSearchSize - i, vecPtn, vecMsk, vecIdx);
			if (tailPtnAddr)
			{
				retList.push_back(tailPtnAddr);
			}
		}
	}
	return TRUE;
}

haogl superlover 判断AVX2的函数不准确，建议参考此项目https://files-cdn.cnblogs.com/files/zy ...

感谢分享，这个算法已经很好了

以下是我的测试代码，VS2017，x86，O2最大优化，没有?或者半节?的情况下会崩溃

int main(int argc, char* argv[])
{
	char *buf = NULL;
	bool bok = false;
	DWORD bytesRead = 0;
	HANDLE hFile = CreateFileW(L"C:\\Users\\Administrator\\AppData\\Local\\Programs\\Microsoft VS Code\\Code.exe", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hFile)
	{
		LARGE_INTEGER fileSize;
		if (GetFileSizeEx(hFile, &fileSize))
		{
			size_t num = fileSize.QuadPart * sizeof(char *);
			buf = (char*)malloc(num);
			if (buf && ::ReadFile(hFile, buf, num, &bytesRead, NULL))
			{
				bok = true;
			}
		}
		CloseHandle(hFile);
	}
	if (bok)
	{
		printf("file size:%ld\n", bytesRead);
		std::vector retList;
		std::string myPattern = "4157?156415541545657555348";
		ULONGLONG start_time1 = _GetSysTickCount64();
		for (int i = 0; i < 1; ++i)
		{
			SSE2PatternFind128(retList, (ULONGLONG)buf, bytesRead, myPattern, 0, 0);
		}
		ULONGLONG end_time1 = _GetSysTickCount64();
		printf("\n执行时间:%lld ms\n\n", (end_time1 - start_time1));
		printf("ret:%d\n", retList.size());
		free(buf);
	}
}

curByteCorr = _mm_or_si128(curMemByte, m128VecMsk.at(j));    // 当前内存字节的'?'位置的二进制位修正为1
应该改为
curByteCorr = _mm_or_si128(curMemByte, _mm_srli_epi16(m128VecMsk[j], 8));        // 当前内存字节的'?'位置的二进制位修正为1

搜索目标小于16字节也会崩溃，如果不用来搜索字符串问题不大

int main(int argc, char* argv[])
{
	std::vector<ULONGLONG> retList;
	std::string myPattern = "AWAVAUATVWUSH";
	std::string myPatterna = "4157??56415541545657555348";
	SSE2PatternFind128(retList, (ULONGLONG)myPattern.c_str(), myPattern.length(), myPatterna, 0, 0);
	printf("ret:%d\n", retList.size());
}

superlover haogl superlover 判断AVX2的函数不准确，建议参考此项目h ...

是的，没有考虑搜索的内存尺寸小于16字节的情况，可以加个判断解决。

我主要基于内存Hex特征码搜索写的代码，一个char字符在内存中是一个字节，要搜索字符串应该要稍微改造一下代码，特别是字符串中的通配符'?'，在Hex特征码中，'?'我只是对应的按半个字节（4bit）来处理。

curByteCorr = _mm_or_si128(curMemByte, _mm_srli_epi16(m128VecMsk[j], 8));

改为这句代码貌似不符合我的匹配逻辑预期？

haogl superlover haogl s ...

好像有点问题，我再测试测试

目前发现VS2017  x86编译 , O2必崩，禁用优化正常

AVX2PatternFind256函数O2、SDK10正常，10以下崩溃

x64编译正常

有点玄学，可能是位操作导致溢出了吧