prefs_dialog.c

Nessus的应用与漏洞扫描技术的研究

/* Nessus
 * Copyright (C) 1998 Renaud Deraison
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * In addition, as a special exception, Renaud Deraison
 * gives permission to link the code of this program with any
 * version of the OpenSSL library which is distributed under a
 * license identical to that listed in the included COPYING.OpenSSL
 * file, and distribute linked combinations including the two.
 * You must obey the GNU General Public License in all respects
 * for all of the code used other than OpenSSL.  If you modify
 * this file, you may extend this exception to your version of the
 * file, but you are not obligated to do so.  If you do not wish to
 * do so, delete this exception statement from your version.
 */

#include <includes.h>

#ifdef USE_GTK
#include <gtk/gtk.h>
#include "../xstuff.h"
#include "../preferences.h"
#include "../sighand.h"
#include "prefs_dialog_scan_opt.h"
#include "prefs_target.h"
#include "prefs_dialog_user.h"
#include "prefs_dialog_auth.h"
#include "prefs_help.h"
#include "prefs_plugins.h"
#include "prefs_dialog_plugins_prefs.h"
#include "prefs_dialog.h"
#include "prefs_about.h"


#ifdef ENABLE_SAVE_KB
#include "prefs_kb.h"
#endif


#include "../error_dialog.h"
#include "../monitor_dialog.h"
#include "../report.h"
#include "../read_target_file.h"
#include "globals.h"

static void prefs_dialog_set_tooltips(struct arglist *);
int prefs_dialog_ok(GtkWidget * , struct arglist *);
/*
 * prefs_dialog_setup
 * 
 * This function draws the preferences dialog of the Nessus
 * client
 *
 */
void 
prefs_dialog_setup(widget, preferences)
 GtkWidget * widget;
 struct arglist * preferences;
{
 GtkWidget * window;
 GtkWidget * notebook;
 GtkWidget * label;
 GtkWidget * frame;
 GtkWidget * box, * hbox;
 GtkWidget * ok, * loadrep, * cancel;
 struct arglist * prefs_scan;
 struct arglist * prefs_target;
 struct arglist * prefs_user;
 struct arglist * prefs_auth;
 struct arglist * prefs_plugins;
 struct arglist * prefs_plugins_prefs;
#ifdef ENABLE_SAVE_KB 
 struct arglist * prefs_kb;
#endif 
 struct arglist * prefs_about;
 struct arglist * ctrls = emalloc(sizeof(struct arglist));


 MainDialog = ctrls;


/*
 * We draw the window ....
 */
#if GTK_VERSION >= 20
 window = gtk_dialog_new();
#else 
 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#endif 
 gtk_signal_connect(GTK_OBJECT(window), "delete_event",
                     (GtkSignalFunc)close_display,NULL);
                     
 gtk_container_border_width(GTK_CONTAINER(window), 10);
 gtk_window_set_title(GTK_WINDOW(window), "Nessus Setup");
 arg_add_value(ctrls, "WINDOW", ARG_PTR, -1, window);
 arg_add_value(ctrls, "PREFERENCES", ARG_ARGLIST, -1, preferences);
 /*
  * We put a vbox in it...
  */
#if GTK_VERSION < 20  
 box = gtk_vbox_new(FALSE, 10);
 gtk_container_add(GTK_CONTAINER(window), box);
 gtk_widget_show(box);
#else
 box = GTK_DIALOG(window)->vbox; 
#endif 
/* 
 * We set up the notebook
 */
 notebook = gtk_notebook_new();
 gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
 gtk_box_pack_start(GTK_BOX(box), notebook, TRUE, TRUE, 5);
 gtk_widget_show(notebook);
 arg_add_value(ctrls, "NOTEBOOK", ARG_PTR, -1, notebook);

/*
 * We set up the pages of our notebook
 */
 prefs_scan = prefs_dialog_scan_opt();
 prefs_target = prefs_dialog_target(preferences);
 prefs_user = prefs_dialog_user(preferences);
 prefs_auth = prefs_dialog_auth(window);
 prefs_plugins = prefs_dialog_plugins(window);
 prefs_plugins_prefs = prefs_dialog_plugins_prefs();
#ifdef ENABLE_SAVE_KB
 prefs_kb = prefs_dialog_kb(); 
#endif 
 prefs_about  = prefs_dialog_about(window);
 
 arg_add_value(ctrls, "SCAN_OPTIONS", ARG_ARGLIST, -1, prefs_scan);
 arg_add_value(ctrls, "TARGET", ARG_ARGLIST, -1, prefs_target);
 arg_add_value(prefs_target, "MAIN", ARG_ARGLIST, -1, ctrls);
 arg_add_value(ctrls, "USER", ARG_ARGLIST, -1, prefs_user);
 arg_add_value(ctrls, "AUTH", ARG_ARGLIST, -1, prefs_auth);
 arg_add_value(ctrls, "PLUGINS", ARG_ARGLIST, -1, prefs_plugins);
 arg_add_value(ctrls, "PLUGINS_PREFS", ARG_ARGLIST, -1, prefs_plugins_prefs);
#ifdef ENABLE_SAVE_KB
 arg_add_value(ctrls, "SAVE_KB", ARG_ARGLIST, -1, prefs_kb);
#endif 
 arg_add_value(ctrls, "ABOUT", ARG_ARGLIST, -1, prefs_about);
/*
 * and we append them to it
 */

 label = gtk_label_new("Nessusd host");
 frame = arg_get_value(prefs_auth, "FRAME");
 gtk_widget_show(frame);
 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, label);
 

 label = gtk_label_new("Plugins");
 frame = arg_get_value(prefs_plugins, "FRAME");
 gtk_widget_show(frame);
 gtk_signal_connect(GTK_OBJECT(frame), "expose_event",
		     GTK_SIGNAL_FUNC(prefs_plugins_redraw),
		     prefs_plugins);
                                        
 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, label);
 
 
 label = gtk_label_new("Prefs.");
 frame = arg_get_value(prefs_plugins_prefs, "FRAME");
 gtk_widget_show(frame);
 gtk_signal_connect(GTK_OBJECT(frame), "expose_event", 
 		   GTK_SIGNAL_FUNC(prefs_plugins_prefs_redraw),
		   prefs_plugins_prefs);
 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, label);
 	
 label = gtk_label_new("Scan options");
 frame = arg_get_value(prefs_scan, "FRAME");
 gtk_widget_show(frame);
 gtk_signal_connect(GTK_OBJECT(frame), "expose_event",
		     GTK_SIGNAL_FUNC(prefs_scanner_redraw),
		     prefs_scan);
 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, label);
 
 

 label = gtk_label_new("Target selection");
 frame = arg_get_value(prefs_target, "FRAME");
 gtk_widget_show(frame);
 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, label);

 label = gtk_label_new("User");
 frame = arg_get_value(prefs_user, "FRAME");
 gtk_widget_show(frame);
 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, label);

#ifdef ENABLE_SAVE_KB
 label = gtk_label_new("KB");
 frame = arg_get_value(prefs_kb, "FRAME");
 gtk_widget_show(frame);
 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, label);
#endif

 label = gtk_label_new("Credits");
 frame = arg_get_value(prefs_about, "FRAME");
 gtk_widget_show(frame);
 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, label);
 
 
 hbox = gtk_hbox_new(TRUE, 10);
 gtk_box_pack_end(GTK_BOX(box), hbox, FALSE, FALSE, 0);
 gtk_widget_show(hbox);
 
 
 ok = gtk_button_new_with_label("Start the scan");
 gtk_signal_connect(GTK_OBJECT(ok), "clicked",
 	GTK_SIGNAL_FUNC(prefs_dialog_ok), ctrls);
 gtk_box_pack_start(GTK_BOX(hbox), ok,TRUE, TRUE, 0);
 gtk_widget_show(ok);
 
 loadrep = gtk_button_new_with_label("Load report");
 gtk_signal_connect(GTK_OBJECT(loadrep), "clicked",
 	GTK_SIGNAL_FUNC(open_report_selectfile), NULL );
 gtk_box_pack_start(GTK_BOX(hbox), loadrep,TRUE, TRUE, 0);
 gtk_widget_show(loadrep);

 cancel = gtk_button_new_with_label("Quit");
 gtk_signal_connect(GTK_OBJECT(cancel), "clicked",
 	GTK_SIGNAL_FUNC(close_display), NULL);
 gtk_box_pack_end(GTK_BOX(hbox), cancel,TRUE, TRUE, 0);
 gtk_widget_show(cancel);
 
 prefs_dialog_set_defaults(ctrls, preferences);
 prefs_dialog_set_tooltips(ctrls);
 gtk_widget_show(window);
 
}


void prefs_dialog_set_defaults(ctrls, preferences)
 struct arglist * ctrls;
 struct arglist * preferences;
{
#define EX_NONE 1
#define EX_DNS 2
#define EX_IP 4
#define EX_NFS 8
 
 struct arglist * t, * serv;
 char * v;
 int flag = 0;
 GtkWidget * gtkw;
 
 
 serv = arg_get_value(preferences, "SERVER_PREFS");
 if(!serv)return;
 
 
 t = arg_get_value(ctrls, "PLUGINS");
 gtkw = arg_get_value(t, "ENABLE_DEPS_AT_RUNTIME");
 if(gtkw)
 {
  v = arg_get_value(serv, "auto_enable_dependencies");
  if(arg_get_type(serv, "auto_enable_dependencies") == ARG_INT)
  {
      char * s = strdup(v ? "yes":"no");
      arg_set_type(serv, "auto_enable_dependencies", ARG_STRING);
      arg_set_value(serv, "auto_enable_dependencies", strlen(s), s);
      v = s;
  } 
  if(v && !strcmp(v, "yes"))
  	GTK_TOGGLE_BUTTON(gtkw)->active = TRUE;
  else
  	GTK_TOGGLE_BUTTON(gtkw)->active = FALSE;
 }
 /*
  *  Host expansion options
  */
 t = arg_get_value(ctrls, "TARGET");
 v = arg_get_value(serv, "host_expansion");
 if(!v)
  flag |= EX_NONE;
 else
 {
 if(strstr(v, "dns"))flag = EX_DNS;
 if(strstr(v, "nfs"))flag |= EX_NFS;
 if(strstr(v, "none"))flag |= EX_NONE;
 if(strstr(v, "ip"))flag |= EX_IP;
 }
 
 if(!(flag & EX_NONE))
 {
  GtkWidget *w;
  w = arg_get_value(t, "DNS_EXPAND");
  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(w), (flag & EX_DNS));
 }

#ifdef ENABLE_SAVE_TESTS
  gtkw = arg_get_value(t, "SAVE_THIS_SESSION");
  v = arg_get_value(serv, "save_session");
  if(arg_get_type(serv, "save_session") == ARG_INT)
  {
      char * s = strdup(v ? "yes":"no");
      arg_set_type(serv, "save_session", ARG_STRING);
      arg_set_value(serv, "save_session", strlen(s), s);
      v = s;
  } 
  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw),(v && !strcmp(v, "yes")));

 
  gtkw = arg_get_value(t, "SAVE_EMPTY_SESSIONS");
  v = arg_get_value(serv, "save_empty_sessions");
  if(arg_get_type(serv, "save_empty_sessions") == ARG_INT)
  {
      char * s = strdup(v ? "yes":"no");
      arg_set_type(serv, "save_empty_sessions", ARG_STRING);
      arg_set_value(serv, "save_empty_sessions", strlen(s), s);
      v = s;
  } 
  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw),(v && !strcmp(v, "yes")));




#endif 
 
 /*
  * Scan options 
  */
  t = arg_get_value(ctrls, "SCAN_OPTIONS");
  gtkw = arg_get_value(t, "PING_HOSTS");
  v = arg_get_value(serv, "ping_hosts");
  if(arg_get_type(serv, "ping_hosts")==ARG_INT)
  {
   char * s = emalloc(4);
   if(v)strncpy(s, "yes", 3);
   else strncpy(s, "no", 2);
   
   arg_set_value(serv, "ping_hosts", strlen(s), s);
   arg_set_type(serv, "ping_hosts", ARG_STRING);
  }
  v = arg_get_value(serv, "ping_hosts");
  if(v)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), !strcmp(v, "yes"));
  
  gtkw = arg_get_value(t, "REVERSE_LOOKUP");
  v = arg_get_value(serv, "reverse_lookup");
  if(arg_get_type(serv, "reverse_lookup")==ARG_INT)
  {
   char * s = emalloc(4);
   if(v)strncpy(s, "yes", 3);
   else strncpy(s, "no", 2);
   
   arg_set_value(serv, "reverse_lookup", strlen(s), s);
   arg_set_type(serv, "reverse_lookup", ARG_STRING);
  }
  v = arg_get_value(serv, "reverse_lookup");
  if(v)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), !strcmp(v, "yes"));
  
  
  gtkw = arg_get_value(t, "OPTIMIZE_TEST");
  v = arg_get_value(serv, "optimize_test");
  if(arg_get_type(serv, "optimize_test")==ARG_INT)
  {
   char * s = emalloc(4);
   if(v)strncpy(s, "yes", 3);
   else strncpy(s, "no", 2);
   
   arg_set_value(serv, "optimize_test", strlen(s), s);
   arg_set_type(serv, "optimize_test", ARG_STRING);
  }
  v = arg_get_value(serv, "optimize_test");
  if(v)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), !strcmp(v, "yes"));
  else gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), 1);
 
 
  gtkw = arg_get_value(t, "SAFE_CHECKS");
  v = arg_get_value(serv, "safe_checks");
  if(arg_get_type(serv, "safe_checks")==ARG_INT)
  {
   char * s = emalloc(4);
   if(v)strncpy(s, "yes", 3);
   else strncpy(s, "no", 2);
   
   arg_set_value(serv, "safe_checks", strlen(s), s);
   arg_set_type(serv, "safe_checks", ARG_STRING);
  }
  
   v = arg_get_value(serv, "safe_checks");
  if(v)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), !strcmp(v, "yes"));
  else gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), 1);
  
  
  gtkw = arg_get_value(t, "USE_MAC_ADDR");
  v = arg_get_value(serv, "use_mac_addr");
  if(arg_get_type(serv, "use_mac_addr")==ARG_INT)
  {
   char * s = emalloc(4);
   if(v)strncpy(s, "yes", 3);
   else strncpy(s, "no", 2);
   
   arg_set_value(serv, "use_mac_addr", strlen(s), s);
   arg_set_type(serv, "use_mac_addr", ARG_STRING);
  }
  
  v = arg_get_value(serv, "use_mac_addr");
  if(v)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), !strcmp(v, "yes"));
  else gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), 0);
 
  
#ifdef ENABLE_SAVE_KB

  /*
   * Detached scan and continuous scan are ALWAYS
   * disabled
   */
  gtkw = arg_get_value(t, "DETACHED_SCAN");
  v = arg_get_value(serv, "detached_scan");
  if(arg_get_type(serv, "detached_scan")==ARG_INT)
  {
   char * s = strdup("no");
   
   arg_set_value(serv, "detached_scan", strlen(s), s);
   arg_set_type(serv, "detached_scan", ARG_STRING);
  }
  
  v = arg_get_value(serv, "detached_scan");
  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), 0);
  
  
  gtkw = arg_get_value(t, "EMAIL_ADDR");
  v = arg_get_value(serv, "detached_scan_email_address");
  
  if(arg_get_type(serv, "detached_scan_email_address") == ARG_INT)
   {
   char * s = strdup("");
   arg_set_type(serv, "detached_scan_email_address", ARG_STRING);
   arg_set_value(serv, "detached_scan_email_address", strlen(s), s);
   }
  else if(arg_get_type(serv, "detached_scan_email_address") < 0)
   arg_add_value(serv, "detached_scan_email_address", ARG_STRING, 0, strdup(""));
   
  gtk_entry_set_text(GTK_ENTRY(gtkw), 
  		arg_get_value(serv,"detached_scan_email_address"));
  
   
  gtkw = arg_get_value(t, "CONTINUOUS_SCAN");
  v = arg_get_value(serv, "continuous_scan");
  if(arg_get_type(serv, "continuous_scan")==ARG_INT)
  {
   char * s = strdup("no");
   
   arg_set_value(serv, "continuous_scan", strlen(s), s);
   arg_set_type(serv, "continuous_scan", ARG_STRING);
  }
  gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), 0);
  

  v = arg_get_value(serv, "delay_between_scan_loops");
  if(v)
  {
   gtkw = arg_get_value(t, "DELAY");
   gtk_entry_set_text(GTK_ENTRY(gtkw), v);
  }
#endif  
 
 
  v = arg_get_value(serv, "port_range");
  if(v)
  {
   gtkw = arg_get_value(t, "PORT_RANGE");
   if(gtkw)gtk_entry_set_text(GTK_ENTRY(gtkw), v);
  }
 
  gtkw = arg_get_value(t, "UNSCANNED_CLOSED");
  v = arg_get_value(serv, "unscanned_closed");
  if(arg_get_type(serv, "unscanned_closed")==ARG_INT)
  {
   
   char * s;
   int v;
   v = (int)arg_get_value(serv, "unscanned_closed");
   if(v)
    s = strdup("yes");
   else
    s = strdup("no");
    
   arg_set_value(serv, "unscanned_closed", strlen(s), s);
   arg_set_type(serv, "unscanned_closed", ARG_STRING);
  }
  v = arg_get_value(serv, "unscanned_closed");

  if(v)gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), !strcmp(v, "yes"));
  else gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(gtkw), 0);
  
  
  
  gtkw = arg_get_value(t, "MAX_HOSTS");
  if(gtkw)
  {
   v = arg_get_value(serv, "max_hosts");