windows LSP 实现及多个lsp兼容安装的几个坑

最新推荐文章于 2023-12-19 15:51:18 发布
最新推荐文章于 2023-12-19 15:51:18 发布
阅读量1.4k 收藏 2
点赞数
文章标签： c/c++
原文链接：https://my.oschina.net/lastmagician/blog/741952
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

在项目中使用LSP模块时碰到以下几个问题，在此总结下：

1、在64位系统中，针对32位程序和64位程序需要分别实现对应的LSP模块，即64位程序不会加载32位的lsp

2、lsp模块最后放到系统盘的system32（64位 syswow64）下，否则可能导致某些程序加载不到对应的模块

3、多个lsp同时安装时，按照google搜索的用例（中文主要是这篇http://blog.csdn.net/xxaqzy/article/details/4399271，和这篇文章 http://blog.csdn.net/karen_mo/article/details/26674249），会导致后面安装的lsp卸载其他lsp模块问题，主要原因在于 lsp实现的 WSPStartup 函数，在 LoadLibrary 加载下层LSP后，不能进行释放，否则会导致下层LSP失效

 

示例代码如下：

LSP实现（实现代码自行google，这里仅给出关键的WSPStartup函数）


//WSPStartup
int WSPAPI WSPStartup(
    WORD wversionrequested,
    LPWSPDATA lpwspdata,
    LPWSAPROTOCOL_INFOW lppProtoInfo,
    WSPUPCALLTABLE upcalltable,
    LPWSPPROC_TABLE lpproctable)
{
    int nRet = -1;
    int i;
    int nErrcode = 0;
    int filterpathlen, wfilterpathlen;
    int count;
    string strErr;
    DWORD layerid=0;
    DWORD nextlayerid=0;
    TCHAR *filterpath = NULL;
    WCHAR *wfilterpath = NULL;
    HINSTANCE hfilter = NULL;
    LPWSPSTARTUP wspstartupfunc = NULL;
    LPWSAPROTOCOL_INFOW pProtoInfo = NULL;

    do {
        if (1 >= lppProtoInfo->ProtocolChain.ChainLen) {
            //error 
            break;
        }
        if (NULL == (pProtoInfo = _get_lsp(count))) {
            //error 
            break;
        }
        for (i = 0; i < count; ++i) {
            if (0 == memcmp(&pProtoInfo[i].ProviderId,&filterguid,sizeof(GUID))) {
                layerid = pProtoInfo[i].dwCatalogEntryId;
                break;
            }
        }
        if (i == count) {
            //error 
            break;
        }
        for (i = 0; i < lppProtoInfo->ProtocolChain.ChainLen; ++i) {
            if (lppProtoInfo->ProtocolChain.ChainEntries[i] == layerid) {
                nextlayerid = lppProtoInfo->ProtocolChain.ChainEntries[i + 1];
                break;
            }
        }
        if (i == lppProtoInfo->ProtocolChain.ChainLen) {
            //error 
            break;
        }
        filterpathlen = MAX_PATH*2;
        wfilterpathlen = MAX_PATH;
        if (NULL == (filterpath =(TCHAR*)GlobalAlloc(GPTR, filterpathlen))) {
            //error 
            break;
        }
        if (NULL == (wfilterpath =(WCHAR*)GlobalAlloc(GPTR, wfilterpathlen))) {
            //error 
            break;
        }
        for (i = 0; i < count; ++i) {
            if (nextlayerid == pProtoInfo[i].dwCatalogEntryId) {
                break;
            }
        }
        if (i == count) {
            //error 
            break;
        }
        if (SOCKET_ERROR == WSCGetProviderPath(&pProtoInfo[i].ProviderId, wfilterpath, &wfilterpathlen ,&nErrcode)) {
            //error 
            break;
        }
        if (0 == WideCharToMultiByte(CP_OEMCP, NULL, wfilterpath, wfilterpathlen,
            (char *)filterpath, filterpathlen, NULL, NULL))
        {
            //error 
            break;
        }
        TCHAR szPath[MAX_PATH];
        memset(szPath, 0, sizeof(szPath)*sizeof(TCHAR));
        if (0 == ExpandEnvironmentStrings(filterpath, szPath, MAX_PATH)) {
            //error 
            break;
        }
        if (NULL == (hfilter = LoadLibrary(szPath))) {
            nErrcode = GetLastError();
            //error 
            break;
        }
        if (NULL == (wspstartupfunc = (LPWSPSTARTUP)GetProcAddress(hfilter, "WSPStartup"))) {
           //error 
            break;
        }
        if (ERROR_SUCCESS != (nErrcode = wspstartupfunc(wversionrequested, lpwspdata, lppProtoInfo, upcalltable, lpproctable))) {
            //error 
            break;
        }

        g_next_proc_table = *lpproctable;

        lpproctable->lpWSPConnect = WSPConnect;
        lpproctable->lpWSPSend = WSPSend;		//TCP
        lpproctable->lpWSPSendTo = WSPSendTo;	//UDP

        nRet = 0;
    } while (0);

    if (0 != nRet) {
        //error 
    }

    _free_lsp(&pProtoInfo);
    if (NULL != filterpath) {
        GlobalFree(filterpath);
        filterpath = NULL;
    }
    if (NULL != wfilterpath) {
        GlobalFree(wfilterpath);
        wfilterpath = NULL;
    }
	/* 此处不能释放，否则会导致安装多个LSP时卸载下层的LSP
    if (NULL != hfilter) {
        FreeLibrary(hfilter);
        hfilter = NULL;
    }*/

    return nRet;
}

LSP安装代码


int _install(
	IN const TCHAR *pszPathName)
{
	int nRet = -1;
	string strErr;
	WCHAR wszLSPName[] = L"mmclient.lsp";
	LPWSAPROTOCOL_INFOW pProtoInfo = NULL;
	int i, nProtocols;
	WSAPROTOCOL_INFOW OriginalProtocolInfo[3];
	DWORD dwOrigCatalogId[3];
	int nArrayCount = 0;
	DWORD dwLayeredCatalogId; // 要安装的分层协议的目录ID号
	int nErrcode = 0;
	WCHAR *pwszPathName = NULL;
	DWORD dwPathNameLen = strlen(pszPathName);
	DWORD dwWPathNameLen = dwPathNameLen*3;
	PDWORD dwIds = NULL;

	do {
		if (NULL == (pwszPathName = (WCHAR *)GlobalAlloc(GPTR, dwWPathNameLen))) {
			//error
			break;
		}
		if (0 == MultiByteToWideChar(CP_ACP, 0, (char *)pszPathName, dwPathNameLen, pwszPathName, dwWPathNameLen)) {
			//error
			break;
		}

		// 枚举所有服务程序提供者
		if (NULL == (pProtoInfo = _get_provider(&nProtocols))) {
			//error
			break;
		}
		BOOL bFindUdp = FALSE;
		BOOL bFindTcp = FALSE;
		BOOL bFindRaw = FALSE;
		for (i = 0; i < nProtocols; ++i) {
			if (AF_INET == pProtoInfo[i].iAddressFamily) {
				if (FALSE == bFindUdp && IPPROTO_UDP == pProtoInfo[i].iProtocol) {
					memmove(&OriginalProtocolInfo[nArrayCount], &pProtoInfo[i], sizeof(WSAPROTOCOL_INFOW));
					OriginalProtocolInfo[nArrayCount].dwServiceFlags1 = OriginalProtocolInfo[nArrayCount].dwServiceFlags1 & (~XP1_IFS_HANDLES);
					dwOrigCatalogId[nArrayCount++] = pProtoInfo[i].dwCatalogEntryId;
					bFindUdp = TRUE;
				}
				if (FALSE == bFindTcp && IPPROTO_TCP == pProtoInfo[i].iProtocol) {
					memmove(&OriginalProtocolInfo[nArrayCount], &pProtoInfo[i], sizeof(WSAPROTOCOL_INFOW));
					OriginalProtocolInfo[nArrayCount].dwServiceFlags1 = OriginalProtocolInfo[nArrayCount].dwServiceFlags1 & (~XP1_IFS_HANDLES);
					dwOrigCatalogId[nArrayCount++] = pProtoInfo[i].dwCatalogEntryId;
					bFindTcp = TRUE;
				}
				if (FALSE == bFindRaw && IPPROTO_IP == pProtoInfo[i].iProtocol && pProtoInfo[i].ProtocolChain.ChainLen != LAYERED_PROTOCOL) {
					memmove(&OriginalProtocolInfo[nArrayCount], &pProtoInfo[i], sizeof(WSAPROTOCOL_INFOW));
					OriginalProtocolInfo[nArrayCount].dwServiceFlags1 = OriginalProtocolInfo[nArrayCount].dwServiceFlags1 & (~XP1_IFS_HANDLES);
					dwOrigCatalogId[nArrayCount++] = pProtoInfo[i].dwCatalogEntryId;
					bFindRaw = TRUE;
				}
			}
		}

		// 安装我们的分层协议，获取一个dwLayeredCatalogId
		// 随便找一个下层协议的结构复制过来即可
		WSAPROTOCOL_INFOW LayeredProtocolInfo;
		memmove(&LayeredProtocolInfo, &OriginalProtocolInfo[0], sizeof(WSAPROTOCOL_INFOW));
		// 修改协议名称，类型，设置PFL_HIDDEN标志
		wcscpy_s(LayeredProtocolInfo.szProtocol, wszLSPName);
		LayeredProtocolInfo.ProtocolChain.ChainLen = LAYERED_PROTOCOL; // 0;
		LayeredProtocolInfo.dwProviderFlags |= PFL_HIDDEN;
		// 安装
		if (SOCKET_ERROR == ::WSCInstallProvider(&ProviderGuid, pwszPathName, &LayeredProtocolInfo, 1, &nErrcode)) {
			//error
			break;
		}

		_free_provider(&pProtoInfo);
		
		// 重新枚举协议，获取分层协议的目录ID号
		if (NULL == (pProtoInfo = _get_provider(&nProtocols))) {
			//error
			break;
		}

		for (i = 0; i < nProtocols; ++i) {
			if (memcmp(&pProtoInfo[i].ProviderId, &ProviderGuid, sizeof(ProviderGuid)) == 0) {
				dwLayeredCatalogId = pProtoInfo[i].dwCatalogEntryId;
				break;
			}
		}
		if (i == nProtocols) {
			//error
			break;
		}
		// 安装协议链
		// 修改协议名称，类型
		WCHAR wszChainName[WSAPROTOCOL_LEN + 1];

		for (i = 0; i < nArrayCount; ++i) {
			swprintf_s(wszChainName, L"%ws over %ws", wszLSPName, OriginalProtocolInfo[i].szProtocol);
			wcscpy_s(OriginalProtocolInfo[i].szProtocol, wszChainName);
			if (OriginalProtocolInfo[i].ProtocolChain.ChainLen == 1) {
				OriginalProtocolInfo[i].ProtocolChain.ChainEntries[1] = dwOrigCatalogId[i];
			} else {
				for (int j = OriginalProtocolInfo[i].ProtocolChain.ChainLen; j > 0; --j) {
					OriginalProtocolInfo[i].ProtocolChain.ChainEntries[j] = OriginalProtocolInfo[i].ProtocolChain.ChainEntries[j-1];
				}
			}
			OriginalProtocolInfo[i].ProtocolChain.ChainLen ++;
			OriginalProtocolInfo[i].ProtocolChain.ChainEntries[0] = dwLayeredCatalogId;
		}

		// 获取一个Guid，安装之
		GUID ProviderChainGuid;
		if (RPC_S_OK != ::UuidCreate(&ProviderChainGuid)) {
			//error
			break;
		}
		if (::WSCInstallProvider(&ProviderChainGuid, pwszPathName, OriginalProtocolInfo, nArrayCount, &nErrcode) == SOCKET_ERROR) {
			//error
			break;
		}

		_free_provider(&pProtoInfo);

		// 重新排序Winsock目录，将我们的协议链提前
		// 重新枚举安装的协议
		if (NULL == (pProtoInfo = _get_provider(&nProtocols))) {
			//error
			break;
		}

		if (NULL == (dwIds = (PDWORD)malloc(sizeof(DWORD) * nProtocols))) {
			//error
			break;
		}

		int nIndex = 0;
		// 添加我们的协议链
		for (i = 0; i < nProtocols; ++i) {
			if ((pProtoInfo[i].ProtocolChain.ChainLen > 1) &&
				(pProtoInfo[i].ProtocolChain.ChainEntries[0] == dwLayeredCatalogId))
			{
				dwIds[nIndex++] = pProtoInfo[i].dwCatalogEntryId;
			}
		}
		// 添加其它协议
		for (i = 0; i < nProtocols; ++i) {
			if ((pProtoInfo[i].ProtocolChain.ChainLen <= 1) ||
				(pProtoInfo[i].ProtocolChain.ChainEntries[0] != dwLayeredCatalogId))
			{
				dwIds[nIndex++] = pProtoInfo[i].dwCatalogEntryId;
			}
		}
		// 重新排序Winsock目录
		if ((nErrcode = ::WSCWriteProviderOrder(dwIds, nIndex)) != ERROR_SUCCESS) {
			//error
			break;
		}

		nRet = 0;
	} while(0);

	_free_provider(&pProtoInfo);
	if (NULL != pwszPathName) {
		GlobalFree(pwszPathName);
		pwszPathName = NULL;
	}
	if (NULL != dwIds) {
		free(dwIds);
		dwIds = NULL;
	}

	return nRet;
}

 

另，附上比较有价值的 通用LSP实现和安装示例

http://www.komodia.com/lsp/lsp-sample

转载于:https://my.oschina.net/lastmagician/blog/741952

weixin_34128411
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
安装LSP
刻苦与奋斗
08-01 5207
/* 安装LSP时,应先安装分层协议,然后安装协议链,最后排序. */ #include #include #include #include #pragma comment(lib,"ws2_32") #pragma comment(lib,"rpcrt4") GUID ProviderGuid={0xfa5774ac, 0x5338, 0x4a58,{
LSP实现挟持网络
10-22
LSP实现挟持网络 lsp 网络挟持 浏览器挟持
lsp注入（原理及其实现代码）
09-17
lsp注入（原理及其实现代码）
LSP入门
weixin_30502965的博客
03-27 1616
LSP是Layered Service Provider的缩写，是介于winsock和应用程序之间的一层。可以让我们实现数据的侦听、拦截和修改。LSP入门的最简单方式是自己编译一个例子运行一下：首先，安装一下windows sdk，win7版的下载页面：http://www.microsoft.com/en-us/download/details.aspx?id=18950 带X的是64位版。...
windows lsp 指导
weixin_33713503的博客
09-30 339
http://www.komodia.com/ 
InstLSP_LSP_LSP安装_LSP安装_LSP注入_
09-29
LSP注入，LSP安装 LSP injection
安装LSP服务提供程序.rar_LSP_LSP 安装_lsp718.con
09-15
安装+LSP服务提供程序 Install + the LSP service provider
cad统计多线段总长度插件lsp
03-24
转载： cad插件，用于一次性统计多线段总长度，方便实用
24Lsp_24个Lisp绘制程序_
09-29
常用图形的绘制，用于LISP开发学习参考。
pylspclient:LSP客户端在Python中的实现
05-27
pylspclient 客户端在Python中的实现。 什么是LSP？ 安装 pip install pylspclient 运行测试 tox 或者 python setup.py test
SwiftLSPClient:一个用于与语言服务器协议实现交互的Swift库
05-28
SwiftLSP客户端 这是一个Swift库，用于与实现进行交互。 LSP服务器提供有关源代码的丰富信息。 LSP客户端使用此信息。 这个库是关于客户端的。 例子 import SwiftLSPClient let executablePath = " path/to/your/lsp-server-executable " let host = LanguageServerProcessHost ( path : executablePath, arguments : [], environment : [ /* the environment your lsp server requires e.g. PATH */ ]) host. start { (server) in guard let server = server else { Swift
网络编程之编写LSP进行Winsock API监控拦截或LSP注入
热门推荐
Aaron的博客
09-19 2万+
【1】工具介绍：用到的工具：VS2015 语言：C/C++ 需要系统提供的动态链接库：1、 sporder.dll //很多系统不自带着个dll,导致编译时缺少dll无法编译. （发布时必须将此dll放到程序目录） 本人只提供： WIN7 64位的sporder.dll ：http://download.csdn.net/download/aaron133/10153240 ...
presscad图层LIsp_PRESSCAD常见问题处理方法
weixin_39778582的博客
12-22 2853
问题描述可能原因处理方法1,图层不能用1.pcad2k\program里面没有acad,lsp和lay_on.lsp二个文件，2.电脑lisp中毒.3.有可能在电脑中有多个相同文件4.acad.lsp里面未的加载lay_on.lsp5.环境选项中没有设定ok1.从光碟复制acad.lsp,lay_on.lsp到prorgram下面2.电脑中了一种叫做acad,lsp的毒,把所以的acad,lsp找...
LSP 网络劫持（Layered Service Provider Hijacking）
最新发布
【Rainbow Network Technology co., LTD】
12-19 778
LSP 劫持（Layered Service Provider Hijacking）是一种计算机安全漏洞和攻击技术，通常与Windows操作系统相关。它涉及到网络协议栈中的层式服务提供程序（Layered Service Provider，LSP），这些提供程序用于修改、监视或过滤网络流量。LSP劫持是指攻击者通过操纵LSP，以在网络通信中插入恶意代码或进行网络监听，从而捕获敏感信息或执行恶意操作。
Windows 驱动开发 新手入门（四）
Doub1's Blog
06-21 1987
本篇文章介绍一下设备对象，这是写驱动过滤的基础，比如键盘，串口等等的过滤。是的缩写，直译就是物理设备对象，一般来说，就是在就是的设备对象。 只能返回设备对象地址。 指向包含 Unicode 字符串的缓冲区的指针，该字符串是设备对象的名称。 指定表示所需访问的。 通常 ，DesiredAccess指定FILE_READ_DATA。 不经常指定FILE_WRITE_DATA或FILE_ALL_ACCESS访问权限。 指向表示相应设备对象到用户模式代码的文件对象的指针（如果调用成功）。 指向表示命名逻辑、虚
vscode 代码提示插件开发：动态的光标位置 & lsp server-client 通信
luoluoyang23的博客
09-17 634
vscode 代码提示插件开发，这次带来代码插入后如何让光标移动到指定的位置，以及 lsp 协议中 server 和 client 的通信
C/C++语言的服务器LS调研 (Language Server 实现代码索引 跳转定义 智能提示等功能)
biao2488890051的博客
09-18 2542
先说一下LSP（Language Server Protocol），它是语言服务器协议，是一种被用于编辑器或集成开发环境 与 支持比如自动补全，定义跳转，查找所有引用等语言特性的语言服务器（LS，(Language Server）之间的一种协议。只要IDE和LS都遵循这个协议，那么各种各样得LS都能与IDE快速进行集成使用了。不然，两者不通，导致给IDE的插件生态非常不好了。LSP的官网：https://microsoft.github.io/language-server-protocol/ 这玩意是微软
LSP 语言服务协议
weixin_38358700的博客
03-29 2530
LSP是Language Server Protocol 的缩写，它定义了一种标准化的协议，用于编辑器和语言工具之间的通信。这个协议定义了编辑器可以向语言工具查询的功能，同时还定义了语言工具可以向编辑器发送的信息。开发人员可以在多个编辑器中使用同一种语言工具，无需了解编辑器的具体实现细节。LSP可以提供多种功能，例如语法分析、代码高亮、错误检查、代码重构以及文档导航等。通过使用LSP，我们可以在不同的编辑器和语言工具之间共享这些功能，让开发变得更加高效和一致。
lsp统计多个矩形长宽
09-09
LSP（Length × Width Sum Problem）是一个问题，要求统计多个矩形的总长和总宽。我们可以利用循环和累加的方法来解决这个问题。 首先，我们定义一个变量sumLength和一个变量sumWidth，分别用来保存总长和总宽的累加结果。初始时，将它们都设置为0。 然后，我们使用循环来遍历每个矩形。对于每个矩形，我们将其长和宽分别与sumLength和sumWidth累加。假设有n个矩形，那么循环的次数为n。 最后，当循环结束后，sumLength中保存的就是所有矩形的总长，sumWidth中保存的就是所有矩形的总宽。可以通过输出这两个变量的值来得到统计结果。 下面是一个简单的示例代码： ```python # 假设有三个矩形的长宽分别为(1,2)、(3,4)、(5,6) rectangles = [(1,2), (3,4), (5,6)] sumLength = 0 sumWidth = 0 for rectangle in rectangles: sumLength += rectangle[0] sumWidth += rectangle[1] # 输出总长和总宽 print("总长：", sumLength) print("总宽：", sumWidth) ``` 运行该代码，输出结果为： ``` 总长： 9 总宽： 12 ``` 因此，对于给定的多个矩形的长宽，我们可以通过循环遍历并累加长和宽，得到这些矩形的总长和总宽。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值