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

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

网络截获/分析

开发平台：

C/C++

ec_interface_sniff_data.c：源码内容
  1. /*
  2.     ettercap -- ncurses interface for data sniffing-logging
  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. #ifdef HAVE_NCURSES  // don't compile if ncurses interface is not supported
  25. #include <string.h>
  26. #include <ncurses.h>
  27. #include <sys/time.h>
  28. #include <sys/types.h>
  29. #include <unistd.h>
  30. #include <signal.h>
  31. #include <time.h>
  33. #include "include/ec_interface.h"
  34. #include "include/ec_interface_inject.h"
  35. #include "include/ec_decodedata.h"
  36. #include "include/ec_dissector.h"
  37. #include "include/ec_doppleganger.h"
  38. #include "include/ec_illithid.h"
  39. #include "include/ec_buffer.h"
  41. #ifdef DEBUG
  42.    #include "include/ec_debug.h"
  43. #endif
  45. #define PAD_BUFFER 500        // buffered lines for sniffing
  48. #define BOTTOM_COLOR 1        // color schemes
  49. #define TITLE_COLOR  2
  50. #define MAIN_COLOR   3
  51. #define POINT_COLOR  4
  52. #define SEL_COLOR    5
  53. #define HELP_COLOR   6
  54. #define SNIFF_COLOR  7
  56. #define KEY_TAB      't'     // they aren't defined in ncurses.h :(
  57. #define KEY_RETURN   10
  58. #define KEY_CTRL_L   12
  60. #define ASCII_VIEW      0        // data in the sniffing windows...
  61. #define HEX_VIEW        1
  64. // protos...
  66. void Interface_Sniff_Data_Run(char *ipsource, int portsource, char *ipdest, int portdest, char *macsource, char *macdest, char proto, char *app, short mode);
  67. void Interface_Sniff_Data_Redraw(void);
  68. void Interface_Sniff_Data_KeyTab(char *ipsource, int portsource, char *ipdest, int portdest);
  69. void Interface_Sniff_Data_SniffData(char *source, char *dest, int portsource, int portdest, char proto);
  70. void Interface_Sniff_Data_LogToFile(char *ipsource, int portsource, char *ipdest, int portdest);
  71. void Interface_Sniff_Data_Winch(void);
  72. void Interface_Sniff_Data_StopCont(void);
  73. void Interface_Sniff_Data_View(short mode);
  74. void Interface_Sniff_Data_Scroll(short direction);
  75. void Interface_Sniff_Data_DrawScroller(void);
  76. void Interface_Sniff_Data_Inject(char proto, char *app);
  78. // global variables
  80. extern WINDOW *main_window, *bottom_window;
  81. WINDOW *data_source_win, *data_dest_win, *data_source, *data_dest;
  82. WINDOW *win_pointer;
  84. extern int W_MAINX1, W_MAINY1, W_MAINX2, W_MAINY2;
  85. extern int W_BOTTOMY2;
  87. extern int Conn_Pointer;
  89. short log_source, log_dest;
  90. short view;
  91. short stop = 0;
  92. short inject = -1;
  94. int inject_tod=0, inject_tos=0;
  96. short scroll_yd = 0, scroll_ys = 0;
  98. FILE *file_source, *file_dest;
  101. //---------------------------
  103. void Interface_Sniff_Data_Winch(void)  // TODO better handling...
  104. {
  105. #ifdef DEBUG
  106.    Debug_msg("Interface_Sniff_Data_WinchtTODO");
  107. #endif
  109.    Interface_Sniff_Data_Redraw();
  110. }
  113. void Interface_Sniff_Data_Redraw(void)
  114. {
  116.    Interface_Redraw();
  118. #ifdef DEBUG
  119.    Debug_msg("Interface_Sniff_Data_Redraw");
  120. #endif
  122.    redrawwin(data_dest_win);
  123.    redrawwin(data_source_win);
  125.    wnoutrefresh(data_dest_win);
  126.    wnoutrefresh(data_source_win);
  127.    pnoutrefresh(data_source, scroll_ys,0, W_MAINY1 + 3, 3, W_MAINY2 - 3 , W_MAINX2 / 2 - 2);
  128.    pnoutrefresh(data_dest, scroll_yd,0, W_MAINY1 + 3, W_MAINX2 / 2 + 2, W_MAINY2 - 3 , W_MAINX2 - 2);
  130.    doupdate();
  131. }
  135. void Interface_Sniff_Data_KeyTab(char *ipsource, int portsource, char *ipdest, int portdest)
  136. {
  139.    win_pointer = (win_pointer == data_source_win) ? data_dest_win : data_source_win;
  141.    wattroff(data_source_win, A_BOLD);
  142.    wattroff(data_dest_win, A_BOLD);
  144.    wattron(win_pointer, A_BOLD);
  146.    box(data_source_win,ACS_VLINE,ACS_HLINE);
  147.    box(data_dest_win,ACS_VLINE,ACS_HLINE);
  149.    mvwprintw(data_source_win, 0, 1, "%s:%d", ipsource, portsource);
  150.    mvwprintw(data_dest_win, 0, 1, "%s:%d", ipdest, portdest);
  152.    Interface_Sniff_Data_DrawScroller();
  154.    if (log_source) mvwprintw(data_source_win, W_MAINY2 - W_MAINY1 - 4, W_MAINX2 / 2 - 10, "LOGGED");
  155.    if (log_dest) mvwprintw(data_dest_win, W_MAINY2 - W_MAINY1 - 4, W_MAINX2 / 2 - 10, "LOGGED");
  157.    switch(view)
  158.    {
  159.       case ASCII_VIEW:
  160.                         mvwprintw(data_source_win, W_MAINY2 - W_MAINY1 - 4, 2, "ASCII");
  161.                         mvwprintw(data_dest_win, W_MAINY2 - W_MAINY1 - 4, 2, "ASCII");
  162.                         break;
  163.       case HEX_VIEW:
  164.                         mvwprintw(data_source_win, W_MAINY2 - W_MAINY1 - 4, 2, "HEX");
  165.                         mvwprintw(data_dest_win, W_MAINY2 - W_MAINY1 - 4, 2, "HEX");
  166.                         break;
  167.    }
  169.    if (stop) mvwprintw(data_source_win, W_MAINY2 - W_MAINY1 - 4, 2, "STOPPED");
  170.    if (stop) mvwprintw(data_dest_win, W_MAINY2 - W_MAINY1 - 4, 2, "STOPPED");
  172.    mvwprintw(win_pointer, 0, W_MAINX2 / 2 - 10, "active");
  174.    redrawwin(data_dest_win);
  175.    redrawwin(data_source_win);
  177.    wnoutrefresh(data_dest_win);
  178.    wnoutrefresh(data_source_win);
  179.    pnoutrefresh(data_source, scroll_ys,0, W_MAINY1 + 3, 3, W_MAINY2 - 3 , W_MAINX2 / 2 - 2);
  180.    pnoutrefresh(data_dest, scroll_yd,0, W_MAINY1 + 3, W_MAINX2 / 2 + 2, W_MAINY2 - 3 , W_MAINX2 - 2);
  182.    doupdate();
  184. }
  189. void Interface_Sniff_Data_LogToFile(char *ipsource, int portsource, char *ipdest, int portdest)
  190. {
  191.    WINDOW *question_window;
  192.    char question[100];
  193.    char filename[50];
  194.    char answer;
  195.    time_t tt;
  196.    struct tm *dd;
  197.    char date[8];
  199. #ifdef DEBUG
  200.    Debug_msg("Interface_Sniff_Data_LogToFile");
  201. #endif
  203.    tt = time(NULL);
  204.    dd = localtime(&tt);
  206.    sprintf(date, "%04d%02d%02d", dd->tm_year+1900, dd->tm_mon+1, dd->tm_mday);
  208.    if (win_pointer == data_source_win)
  209.    {
  210.       strcpy(question, "Do U want to log SOURCE-to-DEST to this file ? (y/n)");
  211.       sprintf(filename, "%s-%s:%d-%s:%d.log", date, ipsource, portsource, ipdest, portdest);
  212.    }
  213.    else
  214.    {
  215.       strcpy(question, "Do U want to log DEST-to-SOURCE to this file ? (y/n)");
  216.       sprintf(filename, "%s-%s:%d-%s:%d.log", date, ipdest, portdest, ipsource, portsource);
  217.    }
  219.    question_window = newwin(7, strlen(question) + 4,0,0);
  220.    mvwin(question_window, W_MAINY1+(W_MAINY2-W_MAINY1)/2-2, W_MAINX2/2 - (strlen(question)+4)/2 );
  221.    wbkgdset(question_window, COLOR_PAIR(TITLE_COLOR));
  222.    wattron(question_window, A_BOLD);
  223.    box(question_window,ACS_VLINE,ACS_HLINE);
  224.    mvwprintw(question_window,  2, 2, question);
  225.    wnoutrefresh(question_window);
  226.    doupdate();
  228.    wbkgdset(question_window, COLOR_PAIR(HELP_COLOR));
  229.    mvwprintw(question_window,  4, 7, filename);
  230.    answer = wgetch(question_window);
  231.    delwin(question_window);
  233.    if ( (answer == 'y') || (answer == 'Y') )
  234.    {
  235.       if (win_pointer == data_source_win)
  236.       {
  237.          file_source = fopen(filename, "a");
  238.          log_source = 1;
  239.          mvwprintw(data_source_win, W_MAINY2 - W_MAINY1 - 4, W_MAINX2 / 2 - 10, "LOGGED");
  240.       }
  241.       else
  242.       {
  243.          file_dest = fopen(filename, "a");
  244.          log_dest = 1;
  245.          mvwprintw(data_dest_win, W_MAINY2 - W_MAINY1 - 4, W_MAINX2 / 2 - 10, "LOGGED");
  246.       }
  247.    }
  248.    else
  249.    {
  250.       if (win_pointer == data_source_win)
  251.       {
  252.          if (log_source) fclose(file_source);
  253.          log_source = 0;
  254.          wmove(data_source_win, W_MAINY2 - W_MAINY1 - 4, W_MAINX2 / 2 - 10);
  255.          whline(data_source_win, ACS_HLINE, 6);
  256.       }
  257.       else
  258.       {
  259.          if (log_dest) fclose(file_dest);
  260.          log_dest = 0;
  261.          wmove(data_dest_win, W_MAINY2 - W_MAINY1 - 4, W_MAINX2 / 2 - 10);
  262.          whline(data_dest_win, ACS_HLINE, 6);
  263.       }
  264.    }
  267. #ifdef DEBUG
  268.    Debug_msg("Interface_Sniff_Data_LogToFile returns -- %c", answer);
  269.    if ( (answer == 'y') || (answer == 'Y') ) Debug_msg("t %s", filename);
  270. #endif
  272.    Interface_Sniff_Data_Redraw();
  274. }
  277. void Interface_Sniff_Data_StopCont(void)
  278. {
  279. #ifdef DEBUG
  280.    Debug_msg("Interface_Sniff_Data_StopCont");
  281. #endif
  284.    if (stop == 0)
  285.    {
  286.       mvwprintw(data_source_win, W_MAINY2 - W_MAINY1 - 4, 2, "STOPPED");
  287.       mvwprintw(data_dest_win, W_MAINY2 - W_MAINY1 - 4, 2, "STOPPED");
  288.       stop = 1;
  289.    }
  290.    else
  291.    {
  292.       wmove(data_source_win, W_MAINY2 - W_MAINY1 - 4, 2);   whline(data_source_win, ACS_HLINE, 7);
  293.       wmove(data_dest_win, W_MAINY2 - W_MAINY1 - 4, 2); whline(data_dest_win, ACS_HLINE, 7);
  294.       Interface_Sniff_Data_View(view);
  295.       stop = 0;
  296.    }
  298.    redrawwin(data_dest_win);
  299.    redrawwin(data_source_win);
  301.    wnoutrefresh(data_dest_win);
  302.    wnoutrefresh(data_source_win);
  303.    pnoutrefresh(data_source, scroll_ys,0, W_MAINY1 + 3, 3, W_MAINY2 - 3 , W_MAINX2 / 2 - 2);
  304.    pnoutrefresh(data_dest, scroll_yd,0, W_MAINY1 + 3, W_MAINX2 / 2 + 2, W_MAINY2 - 3 , W_MAINX2 - 2);
  306.    doupdate();
  308. }
  312. void Interface_Sniff_Data_View(short mode)
  313. {
  314. #ifdef DEBUG
  315.    Debug_msg("Interface_Sniff_Data_View -- %d", mode);
  316. #endif
  319.    switch(mode)
  320.    {
  321.       case ASCII_VIEW:
  322.                         wmove(data_source_win, W_MAINY2 - W_MAINY1 - 4, 2);   whline(data_source_win, ACS_HLINE, 7);
  323.                         wmove(data_dest_win, W_MAINY2 - W_MAINY1 - 4, 2); whline(data_dest_win, ACS_HLINE, 7);
  324.                         mvwprintw(data_source_win, W_MAINY2 - W_MAINY1 - 4, 2, "ASCII");
  325.                         mvwprintw(data_dest_win, W_MAINY2 - W_MAINY1 - 4, 2, "ASCII");
  326.                         break;
  327.       case HEX_VIEW:
  328.                         wmove(data_source_win, W_MAINY2 - W_MAINY1 - 4, 2);   whline(data_source_win, ACS_HLINE, 7);
  329.                         wmove(data_dest_win, W_MAINY2 - W_MAINY1 - 4, 2); whline(data_dest_win, ACS_HLINE, 7);
  330.                         mvwprintw(data_source_win, W_MAINY2 - W_MAINY1 - 4, 2, "HEX");
  331.                         mvwprintw(data_dest_win, W_MAINY2 - W_MAINY1 - 4, 2, "HEX");
  332.                         break;
  333.    }
  335.    view = mode;
  337.    redrawwin(data_dest_win);
  338.    redrawwin(data_source_win);
  340.    wnoutrefresh(data_dest_win);
  341.    wnoutrefresh(data_source_win);
  342.    pnoutrefresh(data_source, scroll_ys,0, W_MAINY1 + 3, 3, W_MAINY2 - 3 , W_MAINX2 / 2 - 2);
  343.    pnoutrefresh(data_dest, scroll_yd,0, W_MAINY1 + 3, W_MAINX2 / 2 + 2, W_MAINY2 - 3 , W_MAINX2 - 2);
  345.    doupdate();
  347. }
  351. void Interface_Sniff_Data_SniffData(char *source, char *dest, int portsource, int portdest, char proto)
  352. {
  353.    SNIFFED_DATA data_from_illithid;
  354.    int datalen;
  356.    memset(&data_from_illithid, 0, sizeof(SNIFFED_DATA));
  358.    datalen = Buffer_Get(pipe_with_illithid_data, &data_from_illithid, sizeof(SNIFFED_DATA));
  360.    if (datalen<=0)
  361.    {
  362.        usleep(1000);
  363.        return;
  364.    }
  366.    // Not from our stream
  367.    if (!Illithid_ToBeSniffed(source, portsource, dest, portdest, &data_from_illithid) || proto!=data_from_illithid.proto)
  368.        return;
  370.    if (!strcmp(source, data_from_illithid.ip_source))
  371.    {
  372.       if (log_source) { write(fileno(file_source), &data_from_illithid.data, data_from_illithid.datasize); fflush(file_source);}
  373.       if (!stop)
  374.          switch (view)
  375.          {
  376.             case ASCII_VIEW:
  377.                            wprintw(data_source, "%s", Decodedata_GetAsciiData(data_from_illithid.data, data_from_illithid.datasize));
  378.                            pnoutrefresh(data_source, scroll_ys,0, W_MAINY1 + 3, 3, W_MAINY2 - 3 , W_MAINX2 / 2 - 2);
  379.                            break;
  380.             case HEX_VIEW:
  381.                            if (data_from_illithid.proto == 'T')
  382.                               wprintw(data_source, "n> S %lx A %lx (%s) <n%s",
  383.                                                 data_from_illithid.seq,
  384.                                                 data_from_illithid.ack_seq,
  385.                                                 Decodedata_TCPFlags(data_from_illithid.flags),
  386.                                                 Decodedata_GetHexData(data_from_illithid.data, data_from_illithid.datasize, W_MAINX2/2 - 4));
  387.                            else
  388.                               wprintw(data_source, "%s", Decodedata_GetHexData(data_from_illithid.data, data_from_illithid.datasize, W_MAINX2/2 - 4));
  390.                            pnoutrefresh(data_source, scroll_ys,0, W_MAINY1 + 3, 3, W_MAINY2 - 3 , W_MAINX2 / 2 - 2);
  391.                            break;
  392.          }
  393.    }
  394.    else
  395.    {
  396.       if (log_dest) { write(fileno(file_dest), &data_from_illithid.data, data_from_illithid.datasize); fflush(file_dest);}
  397.       if (!stop)
  398.          switch (view)
  399.          {
  400.             case ASCII_VIEW:
  401.                            wprintw(data_dest, "%s", Decodedata_GetAsciiData(data_from_illithid.data, data_from_illithid.datasize));
  402.                            pnoutrefresh(data_dest, scroll_yd,0, W_MAINY1 + 3, W_MAINX2 / 2 + 2, W_MAINY2 - 3 , W_MAINX2 - 2);
  403.                            break;
  404.             case HEX_VIEW:
  405.                            if (data_from_illithid.proto == 'T')
  406.                               wprintw(data_dest, "n> S %lx A %lx (%s) <n%s",
  407.                                                 data_from_illithid.seq,
  408.                                                 data_from_illithid.ack_seq,
  409.                                                 Decodedata_TCPFlags(data_from_illithid.flags),
  410.                                                 Decodedata_GetHexData(data_from_illithid.data, data_from_illithid.datasize, W_MAINX2/2 - 4));
  411.                            else
  412.                               wprintw(data_dest, "%s", Decodedata_GetHexData(data_from_illithid.data, data_from_illithid.datasize, W_MAINX2/2 - 4));
  414.                            pnoutrefresh(data_dest, scroll_yd,0, W_MAINY1 + 3, W_MAINX2 / 2 + 2, W_MAINY2 - 3 , W_MAINX2 - 2);
  415.                            break;
  416.          }
  417.    }
  418.    if (inject == -1) inject = 0; // ok we have taken at least one packet
  419.    doupdate();
  420. }
  423. void Interface_Sniff_Data_DrawScroller(void)
  424. {
  425.    short sheight = (W_MAINY2-10)*(W_MAINY2-10)/PAD_BUFFER;
  426.    short svpos = (W_MAINY2-6)*scroll_ys/PAD_BUFFER;
  427.    short dvpos = (W_MAINY2-6)*scroll_yd/PAD_BUFFER;
  429.    sheight = (sheight < 1) ? 1 : sheight;
  431.    svpos = (svpos == 0) ? 1 : svpos;
  432.    svpos = (svpos > W_MAINY2-9-sheight) ? W_MAINY2-9-sheight : svpos;
  434.    dvpos = (dvpos == 0) ? 1 : dvpos;
  435.    dvpos = (dvpos > W_MAINY2-9-sheight) ? W_MAINY2-9-sheight : dvpos;
  437.    wattron(win_pointer, A_BOLD);
  439.    mvwvline(data_source_win, 1, W_MAINX2 / 2 - 3, ACS_VLINE, W_MAINY2-10);
  440.    wattron(data_source_win, A_REVERSE);
  441.    mvwvline(data_source_win, svpos, W_MAINX2 / 2 - 3, ' ', sheight);
  442.    wnoutrefresh(data_source_win);
  443.    wattroff(data_source_win, A_REVERSE);
  445.    mvwvline(data_dest_win, 1, W_MAINX2 / 2 - 3, ACS_VLINE, W_MAINY2-10);
  446.    wattron(data_dest_win, A_REVERSE);
  447.    mvwvline(data_dest_win, dvpos, W_MAINX2 / 2 - 3, ' ', sheight);
  448.    wnoutrefresh(data_dest_win);
  449.    wattroff(data_dest_win, A_REVERSE);
  451. }
  454. void Interface_Sniff_Data_Scroll(short direction)
  455. {
  457.    if (win_pointer == data_source_win)
  458.    {
  459.       scroll_ys += direction;
  460.       scroll_ys = (scroll_ys < 0) ? 0 : scroll_ys;
  461.       scroll_ys = (scroll_ys > PAD_BUFFER - (W_MAINY2-10)) ? PAD_BUFFER - (W_MAINY2-10) : scroll_ys;
  462.       pnoutrefresh(data_source, scroll_ys,0, W_MAINY1 + 3, 3, W_MAINY2 - 3 , W_MAINX2 / 2 - 2);
  463.       Interface_Sniff_Data_DrawScroller();
  464.    }
  465.    else
  466.    {
  467.       scroll_yd += direction;
  468.       scroll_yd = (scroll_yd < 0) ? 0 : scroll_yd;
  469.       scroll_yd = (scroll_yd > PAD_BUFFER - (W_MAINY2-10)) ? PAD_BUFFER - (W_MAINY2-10) : scroll_yd;
  470.       pnoutrefresh(data_dest, scroll_yd,0, W_MAINY1 + 3, W_MAINX2 / 2 + 2, W_MAINY2 - 3 , W_MAINX2 - 2);
  471.       Interface_Sniff_Data_DrawScroller();
  472.    }
  474.    doupdate();
  475. }
  479. void Interface_Sniff_Data_Inject(char proto, char *app)
  480. {
  482.    char inject_data[MAX_INJECT];
  483.    int data_len;
  484.    char answer;
  486. #ifdef DEBUG
  487.    Debug_msg("Interface_Sniff_Data_Inject");
  488. #endif
  490.    if (inject == -1 && proto == 'T')
  491.    {
  492.       Interface_PopUp("Before injecting we need to sniff at least one packet...");
  493.       Interface_Sniff_Data_Redraw();
  494.       return;
  495.    }
  497.    if (inject == 0)
  498.    {
  499.       answer = Interface_PopUp("Do U really want to inject character in this connection (y/n)?");
  500.       Interface_Sniff_Data_Redraw();
  501.       if ((answer != 'y') && (answer != 'Y'))
  502.          return;
  503.    }
  505.    inject = 1;  // on exit the connection must be RSTted
  507.    memset(inject_data, 0, MAX_INJECT);
  509.    data_len = Interface_Inject_Run(inject_data, proto, app);
  511.    Interface_Sniff_Data_Redraw();
  513.    if (win_pointer == data_dest_win)
  514.    {
  515.       write(pipe_inject_stod[1], inject_data, data_len);
  516.       wmove(bottom_window, 1, 30);
  517.       wbkgdset(bottom_window, COLOR_PAIR(BOTTOM_COLOR));
  518.       wprintw(bottom_window, "%d ", inject_tos += data_len);
  519.       wbkgdset(bottom_window, COLOR_PAIR(SNIFF_COLOR));
  520.       wprintw(bottom_window, "chars injected to %s", Host_Source.ip);
  521.    }
  522.    else
  523.    {
  524.       write(pipe_inject_dtos[1], inject_data, data_len);
  525.       wmove(bottom_window, 0, 30);
  526.       wbkgdset(bottom_window, COLOR_PAIR(BOTTOM_COLOR));
  527.       wprintw(bottom_window, "%d ", inject_tod += data_len);
  528.       wbkgdset(bottom_window, COLOR_PAIR(SNIFF_COLOR));
  529.       wprintw(bottom_window, "chars injected to %s", Host_Dest.ip);
  530.    }
  532.    wnoutrefresh(bottom_window);
  534.    doupdate();
  536. }
  540. void Interface_Sniff_Data_Run(char *ipsource, int portsource, char *ipdest, int portdest, char *macsource, char *macdest, char proto, char *app, short mode)
  541. {
  542.    int KeyPress;
  543.    int dimY = W_MAINY2 - W_MAINY1 - 3;
  544.    int dimX = W_MAINX2 / 2 - 2;
  545.    fd_set msk_fd;
  546.    struct timeval TimeOut;
  547.    int Illithid_data_pid = 0, dopple_pid = 0;
  549.    Buffer_Flush(pipe_with_illithid_data);
  551.    pipe(pipe_inject_stod);
  552.    pipe(pipe_inject_dtos);
  554.    if ( mode <= PUBLICARP ) // PUBLICARP or ARPBASED
  555.    {
  556.       if ( mode == PUBLICARP )
  557.          dopple_pid = Doppleganger_Run(Options.netiface, ipsource, ipdest, macsource, macdest);
  559.       Illithid_data_pid = Illithid_ARPBased_GetData(Options.netiface, proto, ipsource, portsource, ipdest, portdest, macsource, macdest);
  560.    }
  562. #ifdef DEBUG
  563.    Debug_msg("Interface_Sniff_Data_Run -- %d -- %c [%s:%d] [%s:%d] [%s] [%s]", mode, proto, ipsource, portsource, ipdest, portdest, macsource, macdest );
  564. #endif
  566.    init_pair(SNIFF_COLOR, COLOR_CYAN, COLOR_BLACK);
  568.    data_source_win = newwin(dimY, dimX, W_MAINY1 + 2, 2);
  569.    data_dest_win = newwin(dimY, dimX, W_MAINY1 + 2, W_MAINX2 / 2 + 1);
  570.    data_source = newpad(PAD_BUFFER, dimX - 2);
  571.    data_dest = newpad(PAD_BUFFER, dimX - 2);
  573.    win_pointer = data_source_win;
  575.    wbkgdset(data_source_win, COLOR_PAIR(SNIFF_COLOR));
  576.    wbkgdset(data_dest_win, COLOR_PAIR(SNIFF_COLOR));
  577.    wattron(data_source_win, A_BOLD);
  579.    box(data_source_win,ACS_VLINE,ACS_HLINE);
  580.    box(data_dest_win,ACS_VLINE,ACS_HLINE);
  582.    mvwprintw(data_source_win, 0, 1, "%s:%d", ipsource, portsource);
  583.    mvwprintw(data_dest_win, 0, 1, "%s:%d", ipdest, portdest);
  585.    mvwprintw(data_source_win, 0, W_MAINX2 / 2 - 10, "active");
  587.    scrollok(data_source, TRUE);
  588.    scrollok(data_dest, TRUE);
  590.    scroll_yd = PAD_BUFFER - (W_MAINY2-10);
  591.    scroll_ys = PAD_BUFFER - (W_MAINY2-10);
  593.    wmove(data_source, scroll_ys, 0);
  594.    wmove(data_dest, scroll_yd, 0);
  596.    wbkgdset(main_window, COLOR_PAIR(MAIN_COLOR));
  598.    Interface_Sniff_Data_DrawScroller();
  600.    werase(main_window);
  601.    werase(bottom_window);
  603.    wmove(bottom_window, 0, 1);
  604.    wbkgdset(bottom_window, COLOR_PAIR(SNIFF_COLOR));
  605.    wprintw(bottom_window, "Protocol: ");
  606.    wbkgdset(bottom_window, COLOR_PAIR(BOTTOM_COLOR));
  607.    if (proto == 'T')
  608.       wprintw(bottom_window, "TCP");
  609.    else
  610.       wprintw(bottom_window, "UDP");
  611.    wmove(bottom_window, 1, 1);
  612.    wbkgdset(bottom_window, COLOR_PAIR(SNIFF_COLOR));
  613.    wprintw(bottom_window, "Application: ");
  614.    wbkgdset(bottom_window, COLOR_PAIR(BOTTOM_COLOR));
  615.    wprintw(bottom_window, app);
  617.    redrawwin(main_window);
  618.    wnoutrefresh(main_window);
  619.    wnoutrefresh(bottom_window);
  621.    wnoutrefresh(data_source_win);
  622.    wnoutrefresh(data_dest_win);
  623.    doupdate();
  625.    if (Options.hexview)
  626.    {
  627.       view = HEX_VIEW;
  628.       Options.hexview = 0;
  629.    }
  631.    Interface_Sniff_Data_View(view);    // default view
  634.    memset(&TimeOut, 0, sizeof(TimeOut));  //  timeout = 0
  635.    FD_ZERO(&msk_fd);
  637.    loop
  638.    {
  640.       FD_SET(0, &msk_fd);
  642.       select(FOPEN_MAX, &msk_fd, (fd_set *) 0, (fd_set *) 0, &TimeOut);
  644.       Interface_Sniff_Data_SniffData(ipsource, ipdest, portsource, portdest, proto);
  646.       if (FD_ISSET(0, &msk_fd))
  647.       {
  648.          KeyPress = wgetch(main_window);
  650.          switch (KeyPress)
  651.          {
  652.             case KEY_DOWN:
  653.                   Interface_Sniff_Data_Scroll( +1 );
  654.                   break;
  656.             case KEY_UP:
  657.                   Interface_Sniff_Data_Scroll( -1 );
  658.                   break;
  660.             case KEY_NPAGE:
  661.                   Interface_Sniff_Data_Scroll( W_MAINY2-10 );     //PGDOWN
  662.                   break;
  664.             case KEY_PPAGE:
  665.                   Interface_Sniff_Data_Scroll( -(W_MAINY2-10) );  //PGUP
  666.                   break;
  668.             case 'L':
  669.             case 'l':
  670.                   Interface_Sniff_Data_LogToFile(ipsource, portsource, ipdest, portdest);
  671.                   break;
  673.             case 'A':
  674.             case 'a':
  675.                   Interface_Sniff_Data_View(ASCII_VIEW);
  676.                   break;
  678.             case 'X':
  679.             case 'x':
  680.                   Interface_Sniff_Data_View(HEX_VIEW);
  681.                   break;
  683.             case 'S':
  684.             case 's':
  685.                   Interface_Sniff_Data_StopCont();
  686.                   break;
  688.             case 'I':
  689.             case 'i':
  690.                   if ( mode == ARPBASED )
  691.                   {
  692.                      if (strstr(app, "ssh") || strstr(app, "SSH"))
  693.                      {
  694.                         Interface_PopUp("You CAN'T inject in a crypted connection !!");
  695.                         Interface_Sniff_Data_Redraw();
  696.                      }
  697.                      else
  698.                         Interface_Sniff_Data_Inject(proto, app);
  699.                   }
  700.                   else
  701.                   {
  702.                      Interface_PopUp("Characters injection only supported in ARP Based mode !!");
  703.                      Interface_Sniff_Data_Redraw();
  704.                   }
  705.                   break;
  707.             case KEY_TAB:
  708.                   Interface_Sniff_Data_KeyTab(ipsource, portsource, ipdest, portdest);
  709.                   break;
  711.             case KEY_CTRL_L:  // CTRL+L refresh the screen
  712.                   Interface_Sniff_Data_Redraw();
  713.                   break;
  715.             case KEY_F(1):
  716.             case 'H':
  717.             case 'h':{
  718.                         static char *help[] = {
  719.                         "[qQ][F10] - quit (and stop sniffing)",
  720.                         "[tab]     - switch between window",
  721.                         "[pgUp]    - scroll back (as well as UpArrow)",
  722.                         "[pgDw]    - scroll forward (as well as DownArrow)",
  723.                         "[iI]      - inject characters in the connection",
  724.                         "[aA]      - ASCII view",
  725.                         "[xX]      - HEX view",
  726.                         "[sS]      - stop/cont the sniff (only visualization)",
  727.                         "[lL]      - Log to file",
  728.                         NULL};
  729.                         Interface_HelpWindow(help);
  730.                      }
  731.                      Interface_Sniff_Data_Redraw();
  732.                   break;
  734.             case KEY_F(10):
  735.             case 'Q':
  736.             case 'q':
  737.                      if (inject == 1 && proto == 'T')
  738.                      {
  739.                         char answer;
  740.                         answer = Interface_PopUp("If U exit now the connection will be ReSeTted!! continue (y/n)?");
  741.                         Interface_Sniff_Data_Redraw();
  742.                         if ((answer != 'y') && (answer != 'Y'))
  743.                            break;
  744.                         else
  745.                            strcpy(Conn_Between_Hosts[Conn_Pointer].status, "KILLED");
  746.                      }
  747.                      if (Illithid_data_pid) kill(Illithid_data_pid, SIGTERM);
  748.                      if (dopple_pid) kill(dopple_pid, SIGTERM);
  749.                      if (log_dest) fclose(file_dest);
  750.                      if (log_source) fclose(file_source);
  751.                      log_dest = log_source = 0;
  752.                      stop = 0;
  753.                      inject = -1;
  754.                      inject_tod=0; inject_tos=0;  // reset counter
  755.                      delwin(data_source_win);
  756.                      data_source_win = NULL;    // for winching (see ec_signal.c)
  757.                      wbkgdset(bottom_window, COLOR_PAIR(BOTTOM_COLOR));
  758.                      delwin(data_dest_win);
  759.                      delwin(data_source);
  760.                      delwin(data_dest);
  761.                      werase(bottom_window);
  762.                      wnoutrefresh(bottom_window);
  763.                      wnoutrefresh(main_window);
  764.                      doupdate();
  765.                      #ifdef DEBUG
  766.                         Debug_msg("Interface_Sniff_Data_End");
  767.                      #endif
  768.                      return;
  769.                   break;
  770.          }
  771.       }
  773.    }
  775. }
  779. #endif
  781. /* EOF */