nmapfe.c

来自「Ubuntu packages of security software。 相」· C语言 代码 · 共 1,601 行 · 第 1/5 页

  gtk_window_position(GTK_WINDOW(aboutDialog), GTK_WIN_POS_CENTER);

  vbox = GTK_DIALOG(aboutDialog)->vbox;

  notebook = gtk_notebook_new();
  gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);

  label = gtk_label_new("NmapFE");
  text = gtk_label_new("Author: Zach Smith\n"
		       "EMail: [e-mail]\n"
		       "http://a.linuxbox.com\n"
		       "Written in: C/GTK\n"
		       "\n"
		       "GUI rewritten by:\n"
		       "Author: Peter Marschall\n"
                       "EMail: [e-mail]");

  gtk_widget_show(label);
  gtk_widget_show(text);
  gtk_notebook_append_page(GTK_NOTEBOOK(notebook), text, label);

  label = gtk_label_new("Nmap");
  text = gtk_label_new("Author: Fyodor\n"
		       "EMail: [e-mail]\n"
		       "http://www.insecure.org/nmap\n"
		       "Written in: C++");

  gtk_widget_show(label);
  gtk_widget_show(text);
  gtk_notebook_append_page(GTK_NOTEBOOK(notebook), text, label);

  gtk_widget_show_all(aboutDialog);

#endif
    
}
#if GTK_CHECK_VERSION(2,6,0)
/* FIXME: This needs to be rewritten because it's an ugly hack :(
 * See below for comment...
 */
static gboolean
is_separator (GtkTreeModel *model,
              GtkTreeIter  *iter,
              gpointer      data)
{
    GtkTreePath *path;
    gboolean     result;

    path = gtk_tree_model_get_path (model, iter);
    /* FIXME: Here we should see whether the contents of the row
     * equals "<separator>. But it works for now... :)
     */
    result = gtk_tree_path_get_indices (path)[0] == SEPARATOR;
    gtk_tree_path_free (path);

    return result;
}
#endif
static GtkTreeModel *
create_dropdown_store(Entry *data, gboolean is_root)
{
    GtkTreeIter     iter;
    GtkTreeStore    *store;
    gint i;
    
    store = gtk_tree_store_new (1, G_TYPE_STRING);

    for (i = 0; data[i].scan; i++) {
        if (is_root || (data[i].rootonly == is_root)) {
            gtk_tree_store_append(store, &iter, NULL);
            gtk_tree_store_set(store, &iter, 0, data[i].scan, -1);
        }
    }
    return GTK_TREE_MODEL (store);
}
        
GtkWidget* create_main_win()
{
  GtkWidget *main_vbox;
  GtkWidget *menubar;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *notebook;
GtkWidget *nblabel;
GtkWidget *nbpage;
GtkWidget *frame;
GtkWidget *table;
GtkAdjustment *adjust;

  GtkAccelGroup *accel_group;
  GtkActionGroup *action_group;
  GtkUIManager *ui_manager;

  GError *error;

  /* initialize our options */
  opt.viewValue = 1;
  opt.appendLog = FALSE;
  opt.scanValue = SYN_SCAN;
  opt.throttleValue = NORMAL_THROTTLE;
  opt.resolveValue = DEFAULT_RESOLVE;
  opt.protportValue = DEFAULT_PROTPORT;
  opt.outputFormatValue = NORMAL_OUTPUT;

#ifdef WIN32
  opt.isr00t = 1;
  /* for nmap version */
#include "nmap_winconfig.h"
#define VERSION NMAP_VERSION
#else
  opt.isr00t = !geteuid();
#endif

/* main (toplevel) window */
  main_win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(main_win), "Nmap Front End v" VERSION);
  gtk_window_set_position (GTK_WINDOW (main_win), GTK_WIN_POS_CENTER);
  g_signal_connect (GTK_OBJECT (main_win), "delete_event",
		     GTK_SIGNAL_FUNC(Quit_callback), NULL);
  
/* vertical box for menu bar, input, output and status fields */
  main_vbox = gtk_vbox_new(FALSE, 0);
  gtk_container_add (GTK_CONTAINER (main_win), main_vbox);
  gtk_widget_show (main_vbox);

  action_group = gtk_action_group_new ("MenuActions");
  gtk_action_group_add_actions (action_group, menu_entries, 
          G_N_ELEMENTS (menu_entries), main_win);
  gtk_action_group_add_radio_actions (action_group, menu_entries_radio, 
          G_N_ELEMENTS (menu_entries_radio), 0, 
          G_CALLBACK(Colourize_callback), main_win);
  
  gtk_action_group_add_toggle_actions (action_group, menu_entries_toggle, 
          G_N_ELEMENTS (menu_entries_toggle), main_win);

  ui_manager = gtk_ui_manager_new ();
  gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);

  error = NULL;
  if (!gtk_ui_manager_add_ui_from_string (ui_manager, menu_description, -1, &error)) {
      g_message ("building menus failed: %s", error->message);
      g_error_free (error);
      exit (EXIT_FAILURE);
  }

  /* main menu */
  menubar = gtk_ui_manager_get_widget (ui_manager, "/MainMenu");
  gtk_box_pack_start (GTK_BOX (main_vbox), menubar, 
          FALSE, TRUE, 0);
  gtk_widget_show (menubar);
  /*  Install the accelerator table in the main window  */
  accel_group = gtk_ui_manager_get_accel_group (ui_manager);
  gtk_window_add_accel_group (GTK_WINDOW (main_win), accel_group);

/* upper hbox for horizontal alignment */
  hbox = gtk_hbox_new(FALSE, 5);
  gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);
  gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 10);

/* Target(s) entry field and label */
  label = gtk_label_new("Target(s):");
  gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
  gtk_widget_show(label);

  opt.targetHost = gtk_entry_new();
  gtk_entry_set_max_length(GTK_ENTRY(opt.targetHost), 256);
  GTK_WIDGET_SET_FLAGS(opt.targetHost, GTK_CAN_DEFAULT);
  gtk_widget_grab_focus(opt.targetHost);
  gtk_entry_set_text(GTK_ENTRY(opt.targetHost), "127.0.0.1");
  g_signal_connect(GTK_OBJECT(opt.targetHost), "changed",
                     GTK_SIGNAL_FUNC(display_nmap_command_cb), NULL);
  gtk_box_pack_start(GTK_BOX(hbox), opt.targetHost, TRUE, TRUE, 0);
  gtk_widget_show(opt.targetHost);

/* Exit button (rightmost in hbox) */
  button = gtk_button_new_with_label("Exit");
  /*gtk_object_set(GTK_OBJECT(button), "width", 48, NULL);*/
  g_signal_connect(GTK_OBJECT(button), "clicked",
                     GTK_SIGNAL_FUNC(Quit_callback), NULL);
  gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
  gtk_widget_show(button);

/* Scan button (2nd right in hbox) */
  opt.scanButton = gtk_toggle_button_new_with_label("Scan");
  /*gtk_object_set(GTK_OBJECT(opt.scanButton), "width", 72, NULL);*/
  g_signal_connect(GTK_OBJECT(opt.scanButton), "toggled",
                     GTK_SIGNAL_FUNC(scanButton_toggled_cb), NULL);
  gtk_box_pack_end(GTK_BOX(hbox), opt.scanButton, FALSE, FALSE, 0);
  gtk_widget_show(opt.scanButton);

  gtk_widget_show(hbox);


/* notebook in vbox below hbox */
  notebook = gtk_notebook_new();
  gtk_container_set_border_width(GTK_CONTAINER(notebook), 5);

/* Scan page (first in notebook) */
  nblabel = gtk_label_new("Scan");
  // nbpage = gtk_vbox_new(FALSE, 5);
  nbpage = gtk_table_new(5, 3, TRUE);
  gtk_table_set_col_spacings(GTK_TABLE(nbpage), 5);
  gtk_table_set_row_spacings(GTK_TABLE(nbpage), 5);
  gtk_container_set_border_width(GTK_CONTAINER(nbpage), 5);

  frame = gtk_frame_new("Scan Type");
  // gtk_box_pack_start(GTK_BOX(nbpage), frame, FALSE, FALSE, 0);
  gtk_table_attach_defaults(GTK_TABLE(nbpage), frame, 0, 2, 0, 3);

  table = gtk_table_new(2, 4, FALSE);
  gtk_container_set_border_width(GTK_CONTAINER(table), 5);
  gtk_table_set_col_spacings(GTK_TABLE(table), 5);
  gtk_table_set_row_spacings(GTK_TABLE(table), 5);
  gtk_container_add(GTK_CONTAINER(frame), table);

  /* Create "Scan Type" combobox */
  {
      GtkCellRenderer *renderer;
      GtkTreeModel    *model;
      model = create_dropdown_store (scanentries, 
              opt.isr00t ? TRUE : FALSE);
      opt.scanType = gtk_combo_box_new_with_model (model);
      g_object_unref (model);

      opt.scanValue = opt.isr00t ? SYN_SCAN : CONNECT_SCAN;

      gtk_table_attach_defaults (GTK_TABLE(table), opt.scanType, 0, 4, 0, 1);
      gtk_widget_show (opt.scanType);

      renderer = gtk_cell_renderer_text_new ();
      gtk_cell_layout_pack_start (
              GTK_CELL_LAYOUT (opt.scanType), renderer, TRUE);
      gtk_cell_layout_set_attributes (
              GTK_CELL_LAYOUT (opt.scanType), renderer,
              "text", 0,
              NULL);
      g_object_unref(renderer);

      g_signal_connect(G_OBJECT(opt.scanType), "changed",
              G_CALLBACK (scanType_cb), scanentries);
      
  }
  
  opt.scanRelayLabel = gtk_label_new("Relay Host:");
  gtk_label_set_justify(GTK_LABEL(opt.scanRelayLabel), GTK_JUSTIFY_LEFT);
  if ((opt.scanValue != BOUNCE_SCAN) && (opt.scanValue != IDLE_SCAN))
    gtk_widget_set_sensitive(GTK_WIDGET(opt.scanRelayLabel), FALSE);
  gtk_table_attach_defaults(GTK_TABLE(table), opt.scanRelayLabel, 0, 1, 1, 2);
  gtk_widget_show(opt.scanRelayLabel);

  opt.scanRelay = gtk_entry_new();
  gtk_entry_set_max_length(GTK_ENTRY(opt.scanRelay), 256);
  /*gtk_object_set(GTK_OBJECT(opt.scanRelay), "width", 150, NULL);*/
  g_signal_connect(GTK_OBJECT(opt.scanRelay), "changed",
                     GTK_SIGNAL_FUNC(display_nmap_command_cb), NULL);
  if ((opt.scanValue != BOUNCE_SCAN) && (opt.scanValue != IDLE_SCAN))
    gtk_widget_set_sensitive(GTK_WIDGET(opt.scanRelay), FALSE);
  gtk_table_attach_defaults(GTK_TABLE(table), opt.scanRelay, 1, 4, 1, 2);
  gtk_widget_show(opt.scanRelay);

  gtk_widget_show(table);
  gtk_widget_show(frame);


  /* Scanned ports frame */
  {
    gint i;
    opt.protportFrame = gtk_frame_new("Scanned Ports");
    gtk_table_attach_defaults(GTK_TABLE(nbpage), opt.protportFrame, 2, 3, 0, 3);

    table = gtk_table_new(2, 2, FALSE);
    gtk_container_set_border_width(GTK_CONTAINER(table), 5);
    gtk_table_set_col_spacings(GTK_TABLE(table), 5);
    gtk_table_set_row_spacings(GTK_TABLE(table), 5);
    gtk_container_add(GTK_CONTAINER(opt.protportFrame), table);

    opt.protportType = gtk_combo_box_new_text();
    
    for(i = 0; protportEntries[i]; i++) {
        gtk_combo_box_append_text(GTK_COMBO_BOX(opt.protportType), protportEntries[i]);
    }

    g_signal_connect(G_OBJECT(opt.protportType), "changed",
            G_CALLBACK (protportType_cb), NULL);
    
    gtk_table_attach_defaults(GTK_TABLE(table), opt.protportType, 0, 2, 0, 1);

    opt.protportLabel = gtk_label_new("Range:");
    gtk_label_set_justify(GTK_LABEL(opt.protportLabel), GTK_JUSTIFY_LEFT);
    if (opt.protportValue != GIVEN_PROTPORT)
        gtk_widget_set_sensitive(GTK_WIDGET(opt.protportLabel), FALSE);
    gtk_table_attach_defaults(GTK_TABLE(table), opt.protportLabel, 0, 1, 1, 2);
    gtk_widget_show(opt.protportLabel);
    
    opt.protportRange = gtk_entry_new();
    gtk_entry_set_max_length(GTK_ENTRY(opt.protportRange), 256);
    /*gtk_object_set(GTK_OBJECT(opt.protportRange), "width", 100, NULL);*/
    g_signal_connect(GTK_OBJECT(opt.protportRange), "changed",
            GTK_SIGNAL_FUNC(display_nmap_command_cb), NULL);
    if (opt.protportValue != GIVEN_PROTPORT)
        gtk_widget_set_sensitive(GTK_WIDGET(opt.protportRange), FALSE);
    gtk_table_attach_defaults(GTK_TABLE(table), opt.protportRange, 1, 2, 1, 2);

    gtk_widget_show_all(opt.protportFrame);
  }


  frame = gtk_frame_new("Scan Extensions");
  // gtk_box_pack_start(GTK_BOX(nbpage), frame, FALSE, FALSE, 0);
  gtk_table_attach_defaults(GTK_TABLE(nbpage), frame, 0, 2, 3, 5);

  table = gtk_table_new(1, 4, FALSE);
  gtk_container_set_border_width(GTK_CONTAINER(table), 5);
  gtk_table_set_col_spacings(GTK_TABLE(table), 5);
  gtk_table_set_row_spacings(GTK_TABLE(table), 5);
  gtk_container_add(GTK_CONTAINER(frame), table);

  opt.RPCInfo = gtk_check_button_new_with_label("RPC Scan");
  g_signal_connect(GTK_OBJECT(opt.RPCInfo), "released",