开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 系统/网络安全 > ICQ弱点检测代码 > 查看源码
filter.c
资源名称：PassthruEx.rar　[点击查看]
上传用户：jencksen
上传日期：2016-04-08
资源大小：66k
文件大小：13k
源码类别：

ICQ弱点检测代码

开发平台：

Visual C++

filter.c：源码内容
  1. /////////////////////////////////////////////////////
  2. // filter.c文件
  4. // 这个文件包含了驱动程序中过滤相关的代码  过滤部分
  7. #include "precomp.h"
  8. #pragma hdrstop
  10. #include "iocommon.h"
  13. #include "protoinfo.h"
  15. // 过滤规则列表
  16. typedef struct _PassthruFilterList
  17. {
  18. PassthruFilter filter;
  19. struct _PassthruFilterList *pNext;
  21. } PassthruFilterList, *PPassthruFilterList;
  23. // ADAPT结构中FilterReserved部分
  24. typedef struct _ADAPT_FILTER_RSVD
  25. {
  26. BOOLEAN     bFilterInitDone;
  28. //  Per-Adapter过滤相关成员
  29. PassthruStatistics Statistics; // 记录网络状态，如传输了多少封包，丢弃了多少等等
  31. PPassthruFilterList pFilterList; // 指向过滤列表
  33. }ADAPT_FILTER_RSVD, *PADAPT_FILTER_RSVD;
  34. C_ASSERT(sizeof(ADAPT_FILTER_RSVD) <= sizeof(((PADAPT)0)->FilterReserved));
  37. // OPEN_CONTEXT结构中FilterReserved部分.
  38. typedef struct _OPEN_CONTEXT_FILTER_RSVD
  39. {
  40. BOOLEAN     bFilterInitDone;
  42. // 更多的Per-Open-Handle过滤相关成员
  44. }OPEN_FILTER_RSVD, *POPEN_FILTER_RSVD;
  46. C_ASSERT(sizeof(OPEN_FILTER_RSVD) <= sizeof(((POPEN_CONTEXT)0)->FilterReserved));
  50. VOID FltOnInitAdapter(PADAPT pAdapt)
  51. {
  52. PADAPT_FILTER_RSVD   pFilterContext;
  54. //
  55. // 初始化ADAPT结构中的FilterReserved域
  56. //
  57. pFilterContext = (PADAPT_FILTER_RSVD )&pAdapt->FilterReserved;
  58. }
  61. VOID FltOnDeinitAdapter(PADAPT pAdapt)
  62. {
  63. PADAPT_FILTER_RSVD   pFilterContext;
  65. //
  66. // 反初始化ADAPT结构中的FilterReserved域
  67. //
  68. pFilterContext = (PADAPT_FILTER_RSVD)&pAdapt->FilterReserved;
  70. ClearFilterList(pFilterContext);
  71. }
  74. /////////////////////////////////////////////////////
  76. // 向适配器过滤列表中添加一个过滤规则
  77. NTSTATUS AddFilterToAdapter(PADAPT_FILTER_RSVD pFilterContext, PPassthruFilter pFilter)
  78. {
  79. PPassthruFilterList pNew;
  80. // 为新的过滤规则申请内存空间
  81. if(NdisAllocateMemoryWithTag(&pNew, sizeof(PassthruFilterList), TAG) != NDIS_STATUS_SUCCESS)
  82. return STATUS_INSUFFICIENT_RESOURCES;
  84. // 填充这块内存
  85. NdisMoveMemory(&pNew->filter, pFilter, sizeof(PassthruFilter));
  87. // 连接到过滤列表中
  88. pNew->pNext = pFilterContext->pFilterList;
  89. pFilterContext->pFilterList = pNew;
  91. return STATUS_SUCCESS;
  92. }
  94. // 删除适配器过滤列表中的规则
  95. void ClearFilterList(PADAPT_FILTER_RSVD pFilterContext)
  96. {
  97. PPassthruFilterList pList = pFilterContext->pFilterList;
  98. PPassthruFilterList pNext;
  99. // 释放过滤列表占用的内存
  100. while(pList != NULL)
  101. {
  102. pNext = pList->pNext;
  104. NdisFreeMemory(pList, 0, 0); 
  105. pList = pNext;
  106. }
  107. pFilterContext->pFilterList = NULL;
  108. }
  114. // 对那些不能识别的IOCTL，PassThru从主要的DevIoControl例程调用此例程
  116. NTSTATUS FltDevIoControl(PDEVICE_OBJECT pDeviceObject, PIRP pIrp)
  117. {
  118. // 假设失败
  119. NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
  121. // 取得此IRP（pIrp）的I/O堆栈指针
  122. PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
  124. // 取得I/O控制代码
  125. ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
  126. // 取得I/O缓冲区指针和它的长度
  127. PVOID pIoBuffer = pIrp->AssociatedIrp.SystemBuffer;
  128. ULONG uInSize = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
  129. ULONG uOutSize = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
  131. ULONG uTransLen = 0;
  133. PADAPT              pAdapt = NULL;
  134.     PADAPT_FILTER_RSVD  pFilterContext = NULL;
  135.     POPEN_CONTEXT       pOpenContext = pIrpStack->FileObject->FsContext;
  137. if(pOpenContext == NULL || (pAdapt = pOpenContext->pAdapt) == NULL)
  138. {
  139. status = STATUS_INVALID_HANDLE;
  140. goto CompleteTheIRP;
  141. }
  143. pFilterContext = (PADAPT_FILTER_RSVD)&pAdapt->FilterReserved;
  146. //
  147. // Fail IOCTL If Unbind Is In Progress   Fail IOCTL If Adapter Is Powering Down
  148. //
  149. NdisAcquireSpinLock(&pAdapt->Lock);
  151. if( pAdapt->UnbindingInProcess || pAdapt->StandingBy == TRUE)
  152. {
  153. NdisReleaseSpinLock(&pAdapt->Lock);
  155. status = STATUS_INVALID_DEVICE_STATE;
  156. goto CompleteTheIRP;
  157. }
  159. // 当改变数据时,要拥有SpinLock
  161. // 最后,处理IO控制代码
  162. switch(uIoControlCode)
  163. {
  164. case IOCTL_PTUSERIO_QUERY_STATISTICS: // 获取网络活动状态
  165. {
  166. uTransLen = sizeof(PassthruStatistics);
  167. if(uOutSize < uTransLen)
  168. {
  169. status =  STATUS_BUFFER_TOO_SMALL;
  170. break;
  171. }
  173. NdisMoveMemory(pIoBuffer, &pFilterContext->Statistics, uTransLen);
  174. status = STATUS_SUCCESS;
  175. }
  176. break;
  177. case IOCTL_PTUSERIO_RESET_STATISTICS: // 重设网络活动状态
  178. {
  179. NdisZeroMemory(&pFilterContext->Statistics, sizeof(PassthruStatistics));
  180. status = STATUS_SUCCESS;
  181. }
  182. break;
  183. case IOCTL_PTUSERIO_ADD_FILTER: // 添加一个过滤规则
  184. {
  185. if(uInSize >= sizeof(PassthruFilter))
  186. {
  187. DBGPRINT((" 添加一个过滤规则"));
  188. status = AddFilterToAdapter(pFilterContext, (PPassthruFilter)pIoBuffer);
  189. }
  190. else
  191. {
  192. status = STATUS_INVALID_DEVICE_REQUEST;
  193. }
  194. }
  195. break;
  196. case IOCTL_PTUSERIO_CLEAR_FILTER: // 清除过滤规则
  197. {
  198. DBGPRINT((" 清除过滤规则"));
  199. ClearFilterList(pFilterContext);
  200. status = STATUS_SUCCESS;
  201. }
  202. break;
  203. }
  205. NdisReleaseSpinLock(&pAdapt->Lock);
  207. CompleteTheIRP:
  209. if(status == STATUS_SUCCESS)
  210. pIrp->IoStatus.Information = uTransLen;
  211. else
  212. pIrp->IoStatus.Information = 0;
  214. pIrp->IoStatus.Status = status;
  215. IoCompleteRequest(pIrp, IO_NO_INCREMENT);
  216. return status;
  217. }
  220. ////////////////////////////////////////////////////
  221. // 读取封包中的数据
  222. void FltReadPacketData(PNDIS_PACKET pPacket, 
  223.    PUCHAR lpBufferIn, ULONG nNumberToRead, PUINT lpNumberOfRead)
  224. {
  225. PUCHAR pBuf;
  226. ULONG nBufferSize;
  227. PNDIS_BUFFER pBufferDes = NULL;
  230. // 检查参数
  231. if(pPacket == NULL || lpBufferIn == NULL || nNumberToRead == 0)
  232. {
  233. if(lpNumberOfRead != NULL)
  234. {
  235. *lpNumberOfRead = 0;
  236. return ;
  237. }
  238. }
  240. // 设置返回数据
  241. *lpNumberOfRead = 0;
  244. // 遍历封包中的缓冲区描述表,将数据复制到用户缓冲区
  245. pBufferDes = pPacket->Private.Head;
  246. while(pBufferDes != pPacket->Private.Tail && pBufferDes != NULL)
  247. {
  248. // 获取此缓冲区描述表的缓冲区信息
  249. NdisQueryBufferSafe(pBufferDes, &pBuf, &nBufferSize, NormalPagePriority);
  250. if(pBuf == NULL)
  251. return;
  253. if(nNumberToRead > nBufferSize) // 复制整个缓冲区
  254. {
  255. NdisMoveMemory(lpBufferIn + *lpNumberOfRead, pBuf, nBufferSize);
  256. nNumberToRead -= nBufferSize;
  257. *lpNumberOfRead += nBufferSize;
  258. }
  259. else // 仅复制剩下的部分
  260. {
  261. NdisMoveMemory(lpBufferIn + *lpNumberOfRead, pBuf, nNumberToRead);
  262. *lpNumberOfRead += nNumberToRead;
  263. return;
  264. }
  265. // 下一个缓冲区描述表
  266. pBufferDes = pBufferDes->Next;
  267. }
  268. }
  270. /////////////////////////////////////////////
  271. // 检查过滤规则
  272. BOOLEAN FltCheckFilterRules(PPassthruFilterList pFilterList, PUCHAR pPacketData, ULONG nDataLen, BOOLEAN bIncludeETHdr)
  273. {
  274. int nLeavingLen = nDataLen;
  276. PETHeader pEtherHdr;
  277. PIPHeader pIpHdr;
  278. PTCPHeader pTcpHdr;
  279. PUDPHeader pUdpHdr;
  283. // 从缓冲区中萃取出IP头
  284. // 如果包含以太头，就要先检查以太头
  285. if(bIncludeETHdr)
  286. {
  287. if(nLeavingLen < sizeof(ETHeader))
  288. {
  289. return TRUE;
  290. }
  291. nLeavingLen -= sizeof(ETHeader);
  293. pEtherHdr = (PETHeader)pPacketData;
  295. if(pEtherHdr->type != 0x8) // 如果不是IP协议，则不处理
  296. return TRUE;
  298. pIpHdr = (PIPHeader)(pEtherHdr + 1);
  299. }
  300. else
  301. {
  302. pIpHdr = (PIPHeader)pPacketData;
  303. }
  305. // 验证剩余数据长度，防止发生内核非法访问
  306. if(nLeavingLen < sizeof(IPHeader))
  307. return TRUE;
  308. nLeavingLen -= sizeof(IPHeader);
  311. // 检查版本信息，我们仅处理IPv4
  312. if(((pIpHdr->iphVerLen >> 4) & 0x0f) == 6)
  313. {
  314. return TRUE;
  315. }
  317. if(pIpHdr->ipProtocol == 6 && nLeavingLen >= sizeof(TCPHeader))  // 是TCP协议？
  318. {
  319. // 提取TCP头
  320. pTcpHdr = (PTCPHeader)(pIpHdr + 1);
  321. // 我们接受所有已经建立连接的TCP封包
  322. if(!(pTcpHdr->flags & 0x02))
  323. {
  324. return TRUE;
  325. }
  326. }
  328. // 与过滤规则比较，决定采取的行动
  329. while(pFilterList != NULL)
  330. {
  331. // 查看封包使用的协议是否和过滤规则相同
  332. if(pFilterList->filter.protocol == 0 || pFilterList->filter.protocol == pIpHdr->ipProtocol)
  333. {
  334. // 如果协议相同，再查看源IP地址
  335. if(pFilterList->filter.sourceIP != 0 &&
  336. pFilterList->filter.sourceIP != (pFilterList->filter.sourceMask & pIpHdr->ipSource))
  337. {
  338. pFilterList = pFilterList->pNext;
  339. continue;
  340. }
  342. // 再查看目的IP地址
  343. if(pFilterList->filter.destinationIP != 0 &&
  344. pFilterList->filter.destinationIP != (pFilterList->filter.destinationMask & pIpHdr->ipDestination))
  345. {
  346. pFilterList = pFilterList->pNext;
  347. continue;
  348. }
  350. // 如果是TCP封包，接着查看TCP端口号
  351. if(pIpHdr->ipProtocol == 6)
  352. {
  353. if(nLeavingLen < 4)
  354. {
  355. return TRUE;
  356. }
  357. pTcpHdr = (PTCPHeader)(pIpHdr + 1);
  358. // 如果源端口号和目的端口号都与规则中的一样，则按照规则的记录处理这个封包
  359. if(pFilterList->filter.sourcePort == 0 || pFilterList->filter.sourcePort == pTcpHdr->sourcePort)
  360. {
  361. if(pFilterList->filter.destinationPort == 0 ||
  362. pFilterList->filter.destinationPort == pTcpHdr->destinationPort)
  363. {
  364. DBGPRINT((" 按照规则处理一个TCP封包 n "));
  365. return !pFilterList->filter.bDrop; 
  366. }
  367. }
  369. }
  370. // 如果是UDP封包，接着查看UDP端口号
  371. else if(pIpHdr->ipProtocol == 17)
  372. {
  373. if(nLeavingLen < 4)
  374. {
  375. return !pFilterList->filter.bDrop;
  376. }
  377. pUdpHdr = (PUDPHeader)(pIpHdr + 1);
  378. if(pFilterList->filter.sourcePort == 0 || 
  379. pFilterList->filter.sourcePort == pUdpHdr->sourcePort)
  380. {
  381. if(pFilterList->filter.destinationPort == 0 ||
  382. pFilterList->filter.destinationPort == pUdpHdr->destinationPort)
  383. {
  384. DBGPRINT((" 按照规则处理一个UDP封包 n "));
  385. return !pFilterList->filter.bDrop; 
  386. }
  387. }
  388. }
  389. else
  390. {
  391. // 对于其它封包，我们直接处理
  392. return !pFilterList->filter.bDrop; 
  393. }
  394. }
  395. // 比较下一个封包
  396. pFilterList = pFilterList->pNext;
  397. }
  400. // 默认情况下接收所有封包
  401. return TRUE;
  402. }
  406. // 过滤向外发送的数据，从MPSendPackets或者MPSend函数调用
  407. // 如果从MPSendPackets调用就运行在IRQL <= DISPATCH_LEVEL级别
  408. // 如果从MPSend调用，就运行在IRQL == DISPATCH_LEVEL级别
  409. BOOLEAN FltFilterSendPacket(
  410. IN PADAPT          pAdapt,
  411. IN PNDIS_PACKET   pSendPacket,
  412. IN BOOLEAN         bDispatchLevel  // TRUE -> IRQL == DISPATCH_LEVEL
  413. )
  414. {
  415. BOOLEAN bPass = TRUE;
  416. PADAPT_FILTER_RSVD pFilterContext = (PADAPT_FILTER_RSVD)&pAdapt->FilterReserved;
  417. UCHAR buffer[MAX_PACKET_HEADER_LEN];
  418. ULONG nReadBytes;
  420. // 当使用过滤数据时，要获取旋转锁
  421. if(bDispatchLevel)
  422. {
  423. NdisDprAcquireSpinLock(&pAdapt->Lock);
  424. }
  425. else
  426. {
  427. NdisAcquireSpinLock(&pAdapt->Lock);
  428. }
  430. // 设置统计数字
  431. pFilterContext->Statistics.nMPSendPktsCt ++;
  433. // 如果没有设置过滤规则，则放行所有封包
  434. if(pFilterContext->pFilterList == NULL)
  435. goto ExitTheFilter;
  437. ////////////////////////////////////////////////////
  438. // 读取封包中的数据，这里仅读取封包头即可
  439. FltReadPacketData(pSendPacket, buffer, MAX_PACKET_HEADER_LEN, &nReadBytes);
  440. // 检查过滤规则，看看是否允许这个封包通过
  441. bPass = FltCheckFilterRules(pFilterContext->pFilterList, buffer, nReadBytes, TRUE);
  443. if(!bPass)
  444. {
  445. // 拒绝了一个封包
  446. pFilterContext->Statistics.nMPSendPktsDropped ++;
  447. }
  449. ExitTheFilter:
  450. // 过滤之后要释放旋转锁
  451. if(bDispatchLevel)
  452. NdisDprReleaseSpinLock(&pAdapt->Lock);
  453. else
  454. NdisReleaseSpinLock(&pAdapt->Lock);
  456. return bPass;
  457. }
  461. // 过滤接收到的数据,从PtReceivePacket函数调用，运行在DISPATCH_LEVEL IRQL级别
  462. BOOLEAN FltFilterReceivePacket(
  463. IN PADAPT         pAdapt,
  464. IN PNDIS_PACKET   pReceivedPacket
  465. )
  466. {
  467. BOOLEAN bPass = TRUE;
  468. PADAPT_FILTER_RSVD pFilterContext = (PADAPT_FILTER_RSVD)&pAdapt->FilterReserved;
  469. UCHAR buffer[MAX_PACKET_HEADER_LEN];
  470. ULONG nReadBytes;
  472. // 当使用过滤数据时，要获取旋转锁
  473. NdisDprAcquireSpinLock(&pAdapt->Lock);
  476. // 设置统计数字
  477. pFilterContext->Statistics.nPTRcvPktCt ++;
  479. // 如果没有设置过滤规则，则放行所有封包
  480. if(pFilterContext->pFilterList == NULL)
  481. goto ExitTheFilter;
  483. ////////////////////////////////////////////////////
  484. // 读取封包中的数据，这里仅读取封包头即可
  485. FltReadPacketData(pReceivedPacket, buffer, MAX_PACKET_HEADER_LEN, &nReadBytes);
  486. if(nReadBytes != MAX_PACKET_HEADER_LEN)
  487. {
  488. DBGPRINT(("  FltFilterReceivePacket:  nReadBytes != MAX_PACKET_HEADER_LEN"));
  489. }
  490. // 检查过滤规则，看看是否允许这个封包通过
  491. bPass = FltCheckFilterRules(pFilterContext->pFilterList,buffer, nReadBytes, TRUE);
  492. if(!bPass)
  493. {
  494. // 拒绝了一个封包
  495. pFilterContext->Statistics.nPTRcvPktDropped ++;
  496. }
  498. ExitTheFilter:
  499. // 过滤之后要释放旋转锁
  500. NdisDprReleaseSpinLock(&pAdapt->Lock);
  502. return bPass;
  503. }
  505. // 过滤接收到的数据,从PtReceivePacket函数调用，运行在DISPATCH_LEVEL IRQL级别
  506. BOOLEAN FltFilterReceive(
  507. IN PADAPT         pAdapt,
  508. IN NDIS_HANDLE    MacReceiveContext,
  509. IN PVOID          HeaderBuffer,
  510. IN UINT           HeaderBufferSize,
  511. IN PVOID          LookAheadBuffer,
  512. IN UINT           LookAheadBufferSize,
  513. IN UINT           PacketSize
  514. )
  515. {
  516. BOOLEAN bPass = TRUE;
  517. PADAPT_FILTER_RSVD pFilterContext = (PADAPT_FILTER_RSVD)&pAdapt->FilterReserved;
  518. PETHeader pEtherHdr = (PETHeader)HeaderBuffer;
  520. // 当使用过滤数据时，要获取旋转锁
  521. NdisDprAcquireSpinLock(&pAdapt->Lock);
  524. // 设置统计数字
  525. pFilterContext->Statistics.nPTRcvCt ++;
  526. // 如果没有设置过滤规则，则放行所有封包
  527. if(pFilterContext->pFilterList == NULL)
  528. goto ExitTheFilter;
  530. // 如果不是IP协议，则放行
  531. if(pEtherHdr->type != 0x8)  
  532. goto ExitTheFilter;
  534. // 检查过滤规则，看看是否允许这个封包通过
  535. bPass = FltCheckFilterRules(pFilterContext->pFilterList,LookAheadBuffer, LookAheadBufferSize, FALSE);
  536. if(!bPass)
  537. {
  538. // 拒绝了一个封包
  539. pFilterContext->Statistics.nPTRcvDropped ++;
  540. }
  542. ExitTheFilter:
  543. // 过滤之后要释放旋转锁
  544.     NdisDprReleaseSpinLock(&pAdapt->Lock);
  546. return bPass;
  547. }