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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网络截获/分析 > 查看源码
ec_fingerprint.c
资源名称：ettercap-0.4.0.tar.gz　[点击查看]
上传用户：nilegod
上传日期：2007-01-08
资源大小：220k
文件大小：13k
源码类别：

网络截获/分析

开发平台：

C/C++

ec_fingerprint.c：源码内容
  1. /*
  2.     ettercap -- fingerprinter
  4.     Copyright (C) 2001  ALoR <alor@users.sourceforge.net>, NaGA <crwm@freemail.it>
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 2 of the License, or
  9.     (at your option) any later version.
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19. */
  21. #include "include/ec_main.h"
  23. #include <string.h>
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <errno.h>
  27. #include <fcntl.h>
  28. #include <sys/time.h>
  29. #include <unistd.h>
  31. #include "include/ec_inet_structures.h"
  32. #include "include/ec_inet.h"
  33. #include "include/ec_inet_forge.h"
  34. #include "include/ec_decodedata.h"
  35. #include "include/ec_error.h"
  37. #ifdef DEBUG
  38.    #include "include/ec_debug.h"
  39. #endif
  41. #ifdef HAVE_SYS_UTSNAME_H
  42.    #include <sys/utsname.h>
  43. #endif
  45. #define NUM_TESTS 7
  46. #define NUM_CONDS 6
  48. #define MSS 265
  50. // global data...
  52. int IPS, IPD, sock, MTU;
  53. u_short open_port=0, closed_port=0, PORTS;
  54. long SYN_SEQ;
  55. unsigned short IP_ID;
  56. unsigned char MACS[6];
  57. unsigned char MACD[6];
  58. // Static arrays? bleah...
  59. char packet_stamp[NUM_TESTS][NUM_CONDS][10];
  60. char test_name[NUM_CONDS][10];
  62. // protos....
  64. char * Fingerprint_OS(char *IP);
  65. char * Fingerprint_MAC(char *MAC);
  67. //--------------------------
  70. int Fingerprint_Match(char *mycond, char *fpcond)
  71. {
  72.    int matched=0; char *single_cond, *deadend=NULL;
  74.    deadend=fpcond+strlen(fpcond);
  75.    if (deadend==fpcond) matched=1;
  76.    while( !matched && (unsigned long)fpcond<(unsigned long)deadend )
  77.    {
  78.       single_cond=(char *)strtok(fpcond,"|");
  79. if (!strcmp(mycond,single_cond)) matched=1;
  80. fpcond+=strlen(single_cond)+1;
  81.    }
  82.    return matched;
  83. }
  85. void Fingerprint_send_probes()
  86. {
  87.    char *probe_pck;
  89. #define TH_BOGUS 64
  90. #define OPTIONS "0303120102040111101277777777000000000000"
  91. #define OPT_LEN 20
  93.    PORTS++;
  94.    probe_pck=(char *)Inet_Forge_packet(ETH_HEADER + IP_HEADER + TCP_HEADER + OPT_LEN);
  95.    Inet_Forge_ethernet( probe_pck, MACS, MACD, ETH_P_IP );
  97.    Inet_Forge_ip( probe_pck + ETH_HEADER, IPS, IPD, TCP_HEADER, IP_ID++, 0, IPPROTO_TCP);
  98.    Inet_Forge_tcp( probe_pck + ETH_HEADER + IP_HEADER, PORTS, open_port,  SYN_SEQ, 0, TH_BOGUS|TH_SYN, 0, 0);
  99.    Inet_Forge_Insert_TCPOpt( probe_pck + ETH_HEADER + IP_HEADER, OPTIONS , OPT_LEN);
  100.    Inet_SendRawPacket(sock, probe_pck, ETH_HEADER + IP_HEADER + TCP_HEADER + OPT_LEN);
  102.    Inet_Forge_ip( probe_pck + ETH_HEADER, IPS, IPD, TCP_HEADER, IP_ID++, 0, IPPROTO_TCP);
  103.    Inet_Forge_tcp( probe_pck + ETH_HEADER + IP_HEADER, PORTS+1, open_port,  SYN_SEQ, 0, 0, 0, 0);
  104.    Inet_Forge_Insert_TCPOpt( probe_pck + ETH_HEADER + IP_HEADER, OPTIONS ,OPT_LEN );
  105.    Inet_SendRawPacket(sock, probe_pck, ETH_HEADER + IP_HEADER + TCP_HEADER + OPT_LEN);
  107.   Inet_Forge_ip( probe_pck + ETH_HEADER, IPS, IPD, TCP_HEADER, IP_ID++, 0, IPPROTO_TCP);
  108.    Inet_Forge_tcp( probe_pck + ETH_HEADER + IP_HEADER, PORTS+2, open_port,  SYN_SEQ, 0, TH_SYN|TH_FIN|TH_URG|TH_PSH, 0, 0);
  109.    Inet_Forge_Insert_TCPOpt( probe_pck + ETH_HEADER + IP_HEADER, OPTIONS ,OPT_LEN );
  110. Inet_SendRawPacket(sock, probe_pck, ETH_HEADER + IP_HEADER + TCP_HEADER + OPT_LEN);
  112. Inet_Forge_ip( probe_pck + ETH_HEADER, IPS, IPD, TCP_HEADER, IP_ID++, 0, IPPROTO_TCP);
  113.    Inet_Forge_tcp( probe_pck + ETH_HEADER + IP_HEADER, PORTS+3, open_port,  SYN_SEQ, 0, TH_ACK, 0, 0);
  114.    Inet_Forge_Insert_TCPOpt( probe_pck + ETH_HEADER + IP_HEADER, OPTIONS ,OPT_LEN );
  115. Inet_SendRawPacket(sock, probe_pck, ETH_HEADER + IP_HEADER + TCP_HEADER + OPT_LEN );
  117. Inet_Forge_ip( probe_pck + ETH_HEADER, IPS, IPD, TCP_HEADER, IP_ID++, 0, IPPROTO_TCP);
  118.    Inet_Forge_tcp( probe_pck + ETH_HEADER + IP_HEADER, PORTS+4, closed_port,  SYN_SEQ, 0, TH_SYN, 0, 0);
  119.    Inet_Forge_Insert_TCPOpt( probe_pck + ETH_HEADER + IP_HEADER, OPTIONS ,OPT_LEN );
  120. Inet_SendRawPacket(sock, probe_pck, ETH_HEADER + IP_HEADER + TCP_HEADER + OPT_LEN );
  122. Inet_Forge_ip( probe_pck + ETH_HEADER, IPS, IPD, TCP_HEADER, IP_ID++, 0, IPPROTO_TCP);
  123.    Inet_Forge_tcp( probe_pck + ETH_HEADER + IP_HEADER, PORTS+5, closed_port,  SYN_SEQ, 0, TH_ACK, 0, 0);
  124.    Inet_Forge_Insert_TCPOpt( probe_pck + ETH_HEADER + IP_HEADER, OPTIONS ,OPT_LEN );
  125. Inet_SendRawPacket(sock, probe_pck, ETH_HEADER + IP_HEADER + TCP_HEADER + OPT_LEN );
  127.    Inet_Forge_ip( probe_pck + ETH_HEADER, IPS, IPD, TCP_HEADER, IP_ID++, 0, IPPROTO_TCP);
  128.    Inet_Forge_tcp( probe_pck + ETH_HEADER + IP_HEADER, PORTS+6, closed_port,  SYN_SEQ, 0, TH_FIN|TH_PSH|TH_URG, 0, 0);
  129.    Inet_Forge_Insert_TCPOpt( probe_pck + ETH_HEADER + IP_HEADER, OPTIONS ,OPT_LEN );
  130. Inet_SendRawPacket(sock, probe_pck, ETH_HEADER + IP_HEADER + TCP_HEADER + OPT_LEN );
  132.    Inet_Forge_packet_destroy( probe_pck );
  133. }
  135. void Fingerprint_parse_probes()
  136. {
  137.    ETH_header *eth;
  138.    IP_header *ip;
  139.    TCP_header *tcp;
  140.    short type;
  141.    int len;
  142.    char *probe_pck;
  144.    TIME_DECLARE;
  145.    TIME_START;
  146.    probe_pck=(char *)Inet_Forge_packet(MTU);
  148.    do
  149.    {
  150. len=Inet_GetRawPacket(sock,probe_pck,MTU,&type);
  151. TIME_FINISH;
  153. if (len>0 && type==PACKET_HOST)
  154. {
  155.    eth=(ETH_header *)probe_pck;
  156.    if (ntohs(eth->type)==ETH_P_IP)
  157.    {
  158. ip=(IP_header *)(probe_pck+ETH_HEADER);
  159. if (ip->proto==IPPROTO_TCP && ip->source_ip==IPD)
  160. {
  161.    tcp=(TCP_header *)(probe_pck+ETH_HEADER+IP_HEADER);
  163.    if ( (u_short)ntohs(tcp->dest)>=PORTS && (u_short)ntohs(tcp->dest)<PORTS+NUM_TESTS)
  164.    {
  165. char *p, *q, *arrive;
  166. unsigned int num_test;
  168. num_test=ntohs(tcp->dest)-PORTS;
  170. // Replied
  171. strcpy(&packet_stamp[num_test][0][0],"Y");
  172.     // DF flag
  173. if(ntohs(ip->frag_and_flags) & 0x4000)
  174. {
  175.    strcpy(&packet_stamp[num_test][1][0],"Y");
  176. }
  177. else strcpy(&packet_stamp[num_test][1][0], "N");
  178. // Window Size
  179. sprintf(&packet_stamp[num_test][2][0],"%hX",ntohs(tcp->window));
  180. // ACK Sequence
  181. if (ntohl(tcp->ack_seq) == SYN_SEQ+1)
  182.    strcpy(&packet_stamp[num_test][3][0],"S++");
  183. else if (ntohl(tcp->ack_seq) == SYN_SEQ)
  184.    strcpy(&packet_stamp[num_test][3][0],"S");
  185. else
  186.    strcpy(&packet_stamp[num_test][3][0],"O");
  187. // Flags
  188. p=&packet_stamp[num_test][4][0];
  189. *p='';
  190. if (tcp->flags & 0x40)   *p++='B'; // BOGUS
  191. if (tcp->flags & TH_URG) *p++='U';
  192. if (tcp->flags & TH_ACK) *p++='A';
  193. if (tcp->flags & TH_PSH) *p++='P';
  194. if (tcp->flags & TH_RST) *p++='R';
  195. if (tcp->flags & TH_SYN) *p++='S';
  196. if (tcp->flags & TH_FIN) *p++='F';
  197. *p++='';
  198. // TCP Options
  199. p=&packet_stamp[num_test][5][0];
  200. q=((char *)tcp) + TCP_HEADER;
  201. arrive = ((char *)tcp) + (tcp->doff*4);
  202. while(q<arrive)
  203. {
  204.    int opcode;
  206.    opcode=*q++;
  207.    if (!opcode) {
  208. *p++ = 'L';
  209. break;
  210.    } else if (opcode == 1) {
  211.      *p++ = 'N';
  212.    } else if (opcode == 2) {
  213.      *p++ = 'M';
  214.      q++;
  215.      if (ntohs(ptohs(q)) == MSS)
  216.       *p++ = 'E';
  217.      q+=2;
  218.    } else if (opcode == 3) {
  219.      *p++ = 'W';
  220.      q+=2;
  221.    } else if (opcode == 8) {
  222.      *p++ = 'T';
  223.      q+=9;
  224.    }
  225. }
  226. *p++='';
  227.    }
  228. }
  229.    }
  230. }
  231.    }while(TIME_ELAPSED<1);
  233.    Inet_Forge_packet_destroy( probe_pck );
  234. }
  237. void Fingerprint_Init_Test()
  238. {
  239.    sprintf(test_name[0],"Resp");
  240.    sprintf(test_name[1],"DF");
  241.    sprintf(test_name[2],"W");
  242.    sprintf(test_name[3],"ACK");
  243.    sprintf(test_name[4],"Flags");
  244.    sprintf(test_name[5],"Ops");
  246.    strcpy(&packet_stamp[0][0][0],"N");
  247.    strcpy(&packet_stamp[1][0][0],"N");
  248.    strcpy(&packet_stamp[2][0][0],"N");
  249.    strcpy(&packet_stamp[3][0][0],"N");
  250.    strcpy(&packet_stamp[4][0][0],"N");
  251.    strcpy(&packet_stamp[5][0][0],"N");
  252.    strcpy(&packet_stamp[6][0][0],"N");
  253. }
  255. char *Fingerprint_Make_Finger_print()
  256. {
  257.    FILE *file;
  258.    int i, no_match=1;
  259.    char dummy[500];
  260.    char num_test[5];
  261.    char *condition;
  262.    char *test;
  263.    static char osname[500];
  264.    #include "include/ec_install_path.h"
  265.    char database[sizeof(path)+22];
  266.    static char res_list[2000];
  268.    strcpy(database, path);
  269.    strcat(database, "nmap-os-fingerprints");
  271.    file = fopen(database, "r");
  272.    if (!file)
  273.       file = fopen("./share/nmap-os-fingerprints","r");
  274.       if (!file)
  275.          Error_msg("Can't open "nmap-os-fingerprints" file !!");
  278.    Fingerprint_Init_Test();
  279.    Fingerprint_send_probes();
  280.    Fingerprint_parse_probes();
  281. res_list[0]=0;
  283.    loop
  284.    {
  285. char *To_EOF;
  287. while( (To_EOF=fgets(osname,500,file)) && !strstr(osname,"Fingerprint") );
  288. if (!To_EOF) break;
  289. no_match=0;
  291. for (i=1; i<=7 && !no_match; i++)
  292. {
  293.    char *deadend;
  295.    sprintf(num_test,"T%1d",i);
  296.    while(fgets(dummy,500,file) && !strstr(dummy,num_test));
  298.    test=dummy+3;
  299.    dummy[strlen(dummy)-2]=0;
  300.    deadend=test+strlen(test);
  302.    while( !no_match &&  (unsigned long)test<(unsigned long)deadend )
  303.    {
  304. int j; char *pos=NULL;
  306. condition=(char *)strtok(test,"%");
  307. test+=strlen(condition)+1;
  308. for (j=0; j<NUM_CONDS && pos!=condition; j++)
  309.     pos=(char *)strstr(condition,test_name[j]);
  310. condition +=  strlen(test_name[j-1])+1;
  311. if ( !Fingerprint_Match(&packet_stamp[i-1][j-1][0],condition) ) no_match=1;
  312.    }
  313. }
  314. if (!no_match)
  315. {
  316.     strcat(res_list,osname+sizeof("Fingerprint"));
  317.   }
  318.    }
  320.    fclose(file);
  322. if (!strcmp(res_list, ""))
  323. strcpy(res_list, "Not found in the databasen");
  325.    //if ( res_list[strlen(res_list)-1] == 'n') res_list[strlen(res_list)-1] = 0; // trim the trailing n
  326.    return res_list;
  328. }
  331. void Fingerprint_Parse_packet(char *buffer)
  332. {
  333.    IP_header  *ip;
  334.    TCP_header *tcp;
  336.    ip = (IP_header *) (buffer+ETH_HEADER);
  337.    if (ip->source_ip==IPD && ip->dest_ip==IPS && ip->proto==IPPROTO_TCP)
  338.    {
  339.      tcp = (TCP_header *) ((int)ip + ip->h_len * 4);
  340.      if ( (tcp->flags & TH_SYN) && (tcp->flags & TH_ACK) )
  341.         open_port=ntohs(tcp->source);
  342.      if ( (tcp->flags & TH_RST) && ntohs(tcp->dest)==PORTS )
  343.         closed_port=ntohs(tcp->source);
  344.    }
  345. }
  347. void Fingerprint_Simple_Scan()
  348. {
  349.    int i, startP, finP;
  350.    char *pck_to_send;
  351.    TIME_DECLARE;
  353.    startP = 10;  finP = 150;
  355.    pck_to_send = (char *)Inet_Forge_packet(MTU);
  356.    Inet_Forge_ethernet( pck_to_send, MACS, MACD, ETH_P_IP );
  357.    Inet_Forge_ip( pck_to_send + ETH_HEADER, IPS, IPD, TCP_HEADER, IP_ID++, 0, IPPROTO_TCP);
  359.    for (i=startP; i<=finP; i++)
  360.    {
  361.       Inet_Forge_tcp( pck_to_send + ETH_HEADER + IP_HEADER, PORTS, i,  SYN_SEQ, 0, TH_SYN, 0, 0);
  362.       Inet_SendRawPacket(sock, pck_to_send, ETH_HEADER + IP_HEADER + TCP_HEADER );
  363.       if (!(i%5)) usleep(500);
  364.    }
  366.    TIME_START;
  367.    do
  368.    {
  369.       Inet_GetRawPacket(sock, pck_to_send, MTU, NULL);
  370.       Fingerprint_Parse_packet(pck_to_send);
  371.       TIME_FINISH;
  372.    } while (TIME_ELAPSED <2 && (!open_port || !closed_port) );
  373.    Inet_Forge_packet_destroy( pck_to_send );
  374. }
  378. char * Fingerprint_OS(char *IP)
  379. {
  380. char *res_name;
  382. #ifdef DEBUG
  383.    Debug_msg("Fingerprint_OS -- [%s]", IP);
  384. #endif
  386. if (!strcmp(IP, Inet_MyIPAddress()))
  387. {
  388. #ifdef HAVE_SYS_UTSNAME_H
  389. struct utsname buf;
  391. res_name = (char *)malloc(50);
  392. uname(&buf);
  393. strcpy(res_name, buf.sysname);
  394. strcat(res_name, " ");
  395. strcat(res_name, buf.release);
  396. return res_name;
  397. #else
  398. return "Yourself ;) try `uname -sr`";
  399. #endif
  400. }
  402.    IPD = inet_addr(IP);
  403.    sock = Inet_OpenRawSock(Options.netiface);
  404.    fcntl(sock, F_SETFL, O_NONBLOCK);
  405.    Inet_GetIfaceInfo(Options.netiface, &MTU, MACS, (unsigned long *)&IPS, 0);
  406.    memcpy(MACD, Inet_MacFromIP(inet_addr(IP)), 6);
  407.    srand(time(0)); IP_ID = PORTS = SYN_SEQ = rand()%(0xFFFE)+1;
  409. open_port = 0;
  410. closed_port = 0;
  412.    Fingerprint_Simple_Scan();
  414.    if (!open_port || !closed_port)
  415.       return "Can't find ports to probe";
  416.    else
  417.    {
  418. res_name = Fingerprint_Make_Finger_print();
  419. if (!res_name)
  420.        return "No match in database";
  421. else
  422.     return res_name;
  423.    }
  425. }
  429. char * Fingerprint_MAC(char *MAC)
  430. {
  431.    FILE *fto;
  432.    static char adname[200];
  433.    char ScanMAC[20];
  434.    #include "include/ec_install_path.h"
  435.    char file[sizeof(path)+20];
  437. #ifdef DEBUG
  438.    Debug_msg("Fingerprint_MAC -- [%s]", MAC);
  439. #endif
  441.    strcpy(file, path);
  442.    strcat(file, "mac-fingerprints");
  444.    fto = fopen(file, "r");
  445.    if (!fto)
  446.       fto = fopen("./share/mac-fingerprints","r");
  447.       if (!fto)
  448.          Error_msg("Can't open "mac-fingerprints" file !!");
  451.    while (fgets(adname, 200, fto))
  452.    {
  453.       int i;
  454.       for (i=0; i<200;i++)
  455.          if (adname[i]=='n')
  456.             adname[i]=0;
  458.       sscanf(adname,"%s",ScanMAC);
  460.       if (MAC==strstr(MAC,ScanMAC))
  461.       {
  462.          fclose(fto);
  463.          return adname+strlen(ScanMAC)+2;
  464.       }
  465.    }
  466.    fclose(fto);
  467.    return "unknown";
  468. }
  471. /* EOF */