diff --git a/NEWS b/NEWS new file mode 100644 index 0000000..e69de29 diff --git a/gtk/INSTALL b/gtk/INSTALL new file mode 100644 index 0000000..b42a17a --- /dev/null +++ b/gtk/INSTALL @@ -0,0 +1,182 @@ +Basic Installation +================== + + These are generic installation instructions. + + The `configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation. It uses +those values to create a `Makefile' in each directory of the package. +It may also create one or more `.h' files containing system-dependent +definitions. Finally, it creates a shell script `config.status' that +you can run in the future to recreate the current configuration, a file +`config.cache' that saves the results of its tests to speed up +reconfiguring, and a file `config.log' containing compiler output +(useful mainly for debugging `configure'). + + If you need to do unusual things to compile the package, please try +to figure out how `configure' could check whether to do them, and mail +diffs or instructions to the address given in the `README' so they can +be considered for the next release. If at some point `config.cache' +contains results you don't want to keep, you may remove or edit it. + + The file `configure.in' is used to create `configure' by a program +called `autoconf'. You only need `configure.in' if you want to change +it or regenerate `configure' using a newer version of `autoconf'. + +The simplest way to compile this package is: + + 1. `cd' to the directory containing the package's source code and type + `./configure' to configure the package for your system. If you're + using `csh' on an old version of System V, you might need to type + `sh ./configure' instead to prevent `csh' from trying to execute + `configure' itself. + + Running `configure' takes awhile. While running, it prints some + messages telling which features it is checking for. + + 2. Type `make' to compile the package. + + 3. Optionally, type `make check' to run any self-tests that come with + the package. + + 4. Type `make install' to install the programs and any data files and + documentation. + + 5. You can remove the program binaries and object files from the + source code directory by typing `make clean'. To also remove the + files that `configure' created (so you can compile the package for + a different kind of computer), type `make distclean'. There is + also a `make maintainer-clean' target, but that is intended mainly + for the package's developers. If you use it, you may have to get + all sorts of other programs in order to regenerate files that came + with the distribution. + +Compilers and Options +===================== + + Some systems require unusual options for compilation or linking that +the `configure' script does not know about. You can give `configure' +initial values for variables by setting them in the environment. Using +a Bourne-compatible shell, you can do that on the command line like +this: + CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure + +Or on systems that have the `env' program, you can do it like this: + env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure + +Compiling For Multiple Architectures +==================================== + + You can compile the package for more than one kind of computer at the +same time, by placing the object files for each architecture in their +own directory. To do this, you must use a version of `make' that +supports the `VPATH' variable, such as GNU `make'. `cd' to the +directory where you want the object files and executables to go and run +the `configure' script. `configure' automatically checks for the +source code in the directory that `configure' is in and in `..'. + + If you have to use a `make' that does not supports the `VPATH' +variable, you have to compile the package for one architecture at a time +in the source code directory. After you have installed the package for +one architecture, use `make distclean' before reconfiguring for another +architecture. + +Installation Names +================== + + By default, `make install' will install the package's files in +`/usr/local/bin', `/usr/local/man', etc. You can specify an +installation prefix other than `/usr/local' by giving `configure' the +option `--prefix=PATH'. + + You can specify separate installation prefixes for +architecture-specific files and architecture-independent files. If you +give `configure' the option `--exec-prefix=PATH', the package will use +PATH as the prefix for installing programs and libraries. +Documentation and other data files will still use the regular prefix. + + In addition, if you use an unusual directory layout you can give +options like `--bindir=PATH' to specify different values for particular +kinds of files. Run `configure --help' for a list of the directories +you can set and what kinds of files go in them. + + If the package supports it, you can cause programs to be installed +with an extra prefix or suffix on their names by giving `configure' the +option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. + +Optional Features +================= + + Some packages pay attention to `--enable-FEATURE' options to +`configure', where FEATURE indicates an optional part of the package. +They may also pay attention to `--with-PACKAGE' options, where PACKAGE +is something like `gnu-as' or `x' (for the X Window System). The +`README' should mention any `--enable-' and `--with-' options that the +package recognizes. + + For packages that use the X Window System, `configure' can usually +find the X include and library files automatically, but if it doesn't, +you can use the `configure' options `--x-includes=DIR' and +`--x-libraries=DIR' to specify their locations. + +Specifying the System Type +========================== + + There may be some features `configure' can not figure out +automatically, but needs to determine by the type of host the package +will run on. Usually `configure' can figure that out, but if it prints +a message saying it can not guess the host type, give it the +`--host=TYPE' option. TYPE can either be a short name for the system +type, such as `sun4', or a canonical name with three fields: + CPU-COMPANY-SYSTEM + +See the file `config.sub' for the possible values of each field. If +`config.sub' isn't included in this package, then this package doesn't +need to know the host type. + + If you are building compiler tools for cross-compiling, you can also +use the `--target=TYPE' option to select the type of system they will +produce code for and the `--build=TYPE' option to select the type of +system on which you are compiling the package. + +Sharing Defaults +================ + + If you want to set default values for `configure' scripts to share, +you can create a site shell script called `config.site' that gives +default values for variables like `CC', `cache_file', and `prefix'. +`configure' looks for `PREFIX/share/config.site' if it exists, then +`PREFIX/etc/config.site' if it exists. Or, you can set the +`CONFIG_SITE' environment variable to the location of the site script. +A warning: not all `configure' scripts look for a site script. + +Operation Controls +================== + + `configure' recognizes the following options to control how it +operates. + +`--cache-file=FILE' + Use and save the results of the tests in FILE instead of + `./config.cache'. Set FILE to `/dev/null' to disable caching, for + debugging `configure'. + +`--help' + Print a summary of the options to `configure', and exit. + +`--quiet' +`--silent' +`-q' + Do not print messages saying which checks are being made. To + suppress all normal output, redirect it to `/dev/null' (any error + messages will still be shown). + +`--srcdir=DIR' + Look for the package's source code in directory DIR. Usually + `configure' can determine that directory automatically. + +`--version' + Print the version of Autoconf used to generate the `configure' + script, and exit. + +`configure' also accepts some other, not widely useful, options. diff --git a/gtk/NEWS b/gtk/NEWS new file mode 100644 index 0000000..e69de29 diff --git a/gtk/src/interface.c b/gtk/src/interface.c new file mode 100644 index 0000000..e6262e1 --- /dev/null +++ b/gtk/src/interface.c @@ -0,0 +1,1175 @@ + +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#ifdef HAVE_UNISTD_H +#include +#endif +#include +#include + +#include +#include + +#include "callbacks.h" +#include "interface.h" +#include "support.h" + +#define GLADE_HOOKUP_OBJECT(component, widget, name) g_object_set_data_full(G_OBJECT(component), name, gtk_widget_ref(widget), (GDestroyNotify)gtk_widget_unref) + +#define GLADE_HOOKUP_OBJECT_NO_REF(component, widget, name) g_object_set_data(G_OBJECT(component), name, widget) + +GtkWidget *create_wndMain(void) { + GtkWidget *wndMain; + GtkWidget *vbox1; + GtkWidget *menubar1; + GtkWidget *quit1; + GtkWidget *ntbMain; + GtkWidget *vbox5; + GtkWidget *frame11; + GtkWidget *table8; + GtkWidget *cmbProtocol; + GList *cmbProtocol_items = NULL; + GtkWidget *entProtocol; + GtkWidget *label7; + GtkObject *spnPort_adj; + GtkWidget *spnPort; + GtkWidget *label6; + GtkWidget *radioTarget2; + GSList *radioTarget2_group = NULL; + GtkWidget *entTargetFile; + GtkWidget *entTarget; + GtkWidget *radioTarget1; + GtkWidget *label28; + GtkWidget *frame12; + GtkWidget *table9; + GtkWidget *chkVerbose; + GtkWidget *chkDebug; + GtkWidget *chkAttempts; + GtkWidget *chkIPV6; + GtkWidget *chkSSL; + GtkWidget *chkServiceDetails; + GtkWidget *chkCompleteHelp; + GtkWidget *chkOldSSL; + GtkWidget *label29; + GtkWidget *label1; + GtkWidget *vbox2; + GtkWidget *frmUsername; + GtkWidget *table2; + GtkWidget *entUsernameFile; + GtkWidget *entUsername; + GtkWidget *chkUsernameLoop; + GtkWidget *chkDisUser; + GtkWidget *radioUsername1; + GSList *radioUsername1_group = NULL; + GtkWidget *radioUsername2; + GtkWidget *label8; + GtkWidget *frmPass; + GtkWidget *table3; + GtkWidget *entPassFile; + GtkWidget *entPass; + GtkWidget *radioPass1; + GSList *radioPass1_group = NULL; + GtkWidget *radioPass2; + GtkWidget *radioGenerate; + GtkWidget *entGeneration; + GtkWidget *labelpass; + GtkWidget *frame8; + GtkWidget *table5; + GtkWidget *chkColon; + GtkWidget *entColonFile; + GtkWidget *label20; + GtkWidget *table6; + GtkWidget *chkPassLogin; + GtkWidget *chkPassNull; + GtkWidget *chkPassReverse; + GtkWidget *label2; + GtkWidget *table4; + GtkWidget *frame9; + GtkWidget *table7; + GtkWidget *label22; + GtkWidget *entHTTPProxy; + GtkWidget *chkProxyAuth; + GtkWidget *label23; + GtkWidget *entProxyUser; + GtkWidget *label24; + GtkWidget *entProxyPass; + GtkWidget *label26; + GtkWidget *hbox3; + GtkWidget *radioProxy; + GSList *radioProxy_group = NULL; + GtkWidget *radioProxy2; + GtkWidget *radioProxy3; + GtkWidget *label21; + GtkWidget *frame13; + GtkWidget *table10; + GtkWidget *chkExitf; + GtkObject *spnTimeout_adj; + GtkWidget *spnTimeout; + GtkObject *spnTasks_adj; + GtkWidget *spnTasks; + GtkWidget *label32; + GtkWidget *label31; + GtkWidget *chkExitF; + GtkWidget *chkNoErr; + GtkWidget *label30; + GtkWidget *label3; + GtkWidget *vbox4; + GtkWidget *frame10; + GtkWidget *entHTTPProxyURL; + GtkWidget *label27; + GtkWidget *frame3; + GtkWidget *entHTTPURL; + GtkWidget *label15; + GtkWidget *frame4; + GtkWidget *entCiscoPass; + GtkWidget *label16; + GtkWidget *frame5; + GtkWidget *entLDAPDN; + GtkWidget *label17; + GtkWidget *frame6; + GtkWidget *hbox2; + GtkWidget *chkLocal; + GtkWidget *chkDomain; + GtkWidget *chkNTLM; + GtkWidget *label18; + GtkWidget *frame7; + GtkObject *spnSAPR3_adj; + GtkWidget *spnSAPR3; + GtkWidget *label19; + GtkWidget *frame15; + GtkWidget *entCVS; + GtkWidget *label34; + GtkWidget *frame17; + GtkWidget *alignment1; + GtkWidget *entTelnet; + GtkWidget *label36; + GtkWidget *frame16; + GtkWidget *entSNMP; + GtkWidget *label35; + GtkWidget *label14; + GtkWidget *vbox3; + GtkWidget *scrolledwindow1; + GtkWidget *viewport1; + GtkWidget *frame14; + GtkWidget *txtOutput; + GtkWidget *label33; + GtkWidget *hbox1; + GtkWidget *btnStart; + GtkWidget *btnStop; + GtkWidget *btnSave; + GtkWidget *btnClear; + GtkWidget *label4; + GtkWidget *statusbar; + GtkWidget *lblSMB2; + GtkWidget *entSMB2Workgroup; + GtkWidget *fraSMB2; + GtkAccelGroup *accel_group; + GtkTooltips *tooltips; + + tooltips = gtk_tooltips_new(); + + accel_group = gtk_accel_group_new(); + + wndMain = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_widget_set_name(wndMain, "wndMain"); + gtk_window_set_title(GTK_WINDOW(wndMain), "xHydra"); + + vbox1 = gtk_vbox_new(FALSE, 0); + gtk_widget_set_name(vbox1, "vbox1"); + gtk_widget_show(vbox1); + gtk_container_add(GTK_CONTAINER(wndMain), vbox1); + + menubar1 = gtk_menu_bar_new(); + gtk_widget_set_name(menubar1, "menubar1"); + gtk_widget_show(menubar1); + gtk_box_pack_start(GTK_BOX(vbox1), menubar1, FALSE, FALSE, 0); + + quit1 = gtk_image_menu_item_new_from_stock("gtk-quit", accel_group); + gtk_widget_set_name(quit1, "quit1"); + gtk_widget_show(quit1); + gtk_container_add(GTK_CONTAINER(menubar1), quit1); + + ntbMain = gtk_notebook_new(); + gtk_widget_set_name(ntbMain, "ntbMain"); + gtk_widget_show(ntbMain); + gtk_box_pack_start(GTK_BOX(vbox1), ntbMain, TRUE, TRUE, 0); + + vbox5 = gtk_vbox_new(FALSE, 0); + gtk_widget_set_name(vbox5, "vbox5"); + gtk_widget_show(vbox5); + gtk_container_add(GTK_CONTAINER(ntbMain), vbox5); + + frame11 = gtk_frame_new(NULL); + gtk_widget_set_name(frame11, "frame11"); + gtk_widget_show(frame11); + gtk_box_pack_start(GTK_BOX(vbox5), frame11, TRUE, TRUE, 0); + + table8 = gtk_table_new(5, 2, FALSE); + gtk_widget_set_name(table8, "table8"); + gtk_widget_show(table8); + gtk_container_add(GTK_CONTAINER(frame11), table8); + + cmbProtocol = gtk_combo_new(); + g_object_set_data(G_OBJECT(GTK_COMBO(cmbProtocol)->popwin), "GladeParentKey", cmbProtocol); + gtk_widget_set_name(cmbProtocol, "cmbProtocol"); + gtk_widget_show(cmbProtocol); + gtk_table_attach(GTK_TABLE(table8), cmbProtocol, 1, 2, 4, 5, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "adam6500"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "afp"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "asterisk"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "cisco"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "cisco-enable"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "cvs"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "firebird"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "ftp"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "ftps"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "http-head"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "http-get"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "http-get-form"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "http-post-form"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "http-proxy"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "http-proxy-urlenum"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "https-head"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "https-get"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "https-get-form"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "https-post-form"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "icq"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "irc"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "imap"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "ldap2"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "ldap3"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "ldap3-crammd5"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "ldap3-digestmd5"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "memcached"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "mongodb"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "mssql"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "mysql"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "ncp"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "nntp"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "oracle"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "oracle-listener"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "oracle-sid"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "pcnfs"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "pop3"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "pcanywhere"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "postgres"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "radmin2"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "rdp"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "redis"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "rexec"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "rlogin"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "rpcap"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "rsh"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "rtsp"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "s7-300"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "sapr3"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "sip"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "smb"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "smb2"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "smtp"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "snmp"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "socks5"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "ssh"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "sshkey"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "svn"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "teamspeak"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "telnet"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "vnc"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "vmauthd"); + cmbProtocol_items = g_list_append(cmbProtocol_items, (gpointer) "xmpp"); + gtk_combo_set_popdown_strings(GTK_COMBO(cmbProtocol), cmbProtocol_items); + g_list_free(cmbProtocol_items); + + entProtocol = GTK_COMBO(cmbProtocol)->entry; + gtk_widget_set_name(entProtocol, "entProtocol"); + gtk_widget_show(entProtocol); + gtk_tooltips_set_tip(tooltips, entProtocol, "The protocol to use for the login/password cracking attempt", NULL); + + label7 = gtk_label_new("Protocol"); + gtk_widget_set_name(label7, "label7"); + gtk_widget_show(label7); + gtk_table_attach(GTK_TABLE(table8), label7, 0, 1, 4, 5, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_misc_set_alignment(GTK_MISC(label7), 0, 0.5); + + spnPort_adj = gtk_adjustment_new(0, 0, 65535, 1, 10, 0); + spnPort = gtk_spin_button_new(GTK_ADJUSTMENT(spnPort_adj), 1, 0); + gtk_widget_set_name(spnPort, "spnPort"); + gtk_widget_show(spnPort); + gtk_table_attach(GTK_TABLE(table8), spnPort, 1, 2, 3, 4, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, spnPort, "select the port on which the daemon you want to brute force runs, 0 means default", NULL); + + label6 = gtk_label_new("Port"); + gtk_widget_set_name(label6, "label6"); + gtk_widget_show(label6); + gtk_table_attach(GTK_TABLE(table8), label6, 0, 1, 3, 4, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_misc_set_alignment(GTK_MISC(label6), 0, 0.5); + + chkIPV6 = gtk_check_button_new_with_mnemonic("Prefer IPV6"); + gtk_widget_set_name(chkIPV6, "chkIPV6"); + gtk_widget_show(chkIPV6); + gtk_table_attach(GTK_TABLE(table8), chkIPV6, 0, 2, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkIPV6, "Enable to use IPV6", NULL); + + radioTarget2 = gtk_radio_button_new_with_mnemonic(NULL, "Target List"); + gtk_widget_set_name(radioTarget2, "radioTarget2"); + gtk_widget_show(radioTarget2); + gtk_table_attach(GTK_TABLE(table8), radioTarget2, 0, 1, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(radioTarget2), radioTarget2_group); + radioTarget2_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radioTarget2)); + + entTargetFile = gtk_entry_new(); + gtk_widget_set_name(entTargetFile, "entTargetFile"); + gtk_widget_show(entTargetFile); + gtk_table_attach(GTK_TABLE(table8), entTargetFile, 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, entTargetFile, "A file which contains the targets to attack. One entry per line. IP\naddresses and/or DNS names.", NULL); + + entTarget = gtk_entry_new(); + gtk_widget_set_name(entTarget, "entTarget"); + gtk_widget_show(entTarget); + gtk_table_attach(GTK_TABLE(table8), entTarget, 1, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, entTarget, "The target to attack - DNS name or IP address", NULL); + gtk_entry_set_text(GTK_ENTRY(entTarget), "127.0.0.1"); + + radioTarget1 = gtk_radio_button_new_with_mnemonic(NULL, "Single Target"); + gtk_widget_set_name(radioTarget1, "radioTarget1"); + gtk_widget_show(radioTarget1); + gtk_table_attach(GTK_TABLE(table8), radioTarget1, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(radioTarget1), radioTarget2_group); + radioTarget2_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radioTarget1)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radioTarget1), TRUE); + + label28 = gtk_label_new("Target"); + gtk_widget_set_name(label28, "label28"); + gtk_widget_show(label28); + gtk_frame_set_label_widget(GTK_FRAME(frame11), label28); + + frame12 = gtk_frame_new(NULL); + gtk_widget_set_name(frame12, "frame12"); + gtk_widget_show(frame12); + gtk_box_pack_start(GTK_BOX(vbox5), frame12, TRUE, TRUE, 0); + + table9 = gtk_table_new(3, 3, FALSE); + gtk_widget_set_name(table9, "table9"); + gtk_widget_show(table9); + gtk_container_add(GTK_CONTAINER(frame12), table9); + + chkVerbose = gtk_check_button_new_with_mnemonic("Be Verbose"); + gtk_widget_set_name(chkVerbose, "chkVerbose"); + gtk_widget_show(chkVerbose); + gtk_table_attach(GTK_TABLE(table9), chkVerbose, 2, 3, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkVerbose, "be verbose", NULL); + + chkDebug = gtk_check_button_new_with_mnemonic("Debug"); + gtk_widget_set_name(chkDebug, "chkDebug"); + gtk_widget_show(chkDebug); + gtk_table_attach(GTK_TABLE(table9), chkDebug, 2, 3, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkDebug, "Enable debug mode", NULL); + + chkAttempts = gtk_check_button_new_with_mnemonic("Show Attempts"); + gtk_widget_set_name(chkAttempts, "chkAttempts"); + gtk_widget_show(chkAttempts); + gtk_table_attach(GTK_TABLE(table9), chkAttempts, 0, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkAttempts, "Show attempts", NULL); + + chkSSL = gtk_check_button_new_with_mnemonic("Use SSL"); + gtk_widget_set_name(chkSSL, "chkSSL"); + gtk_widget_show(chkSSL); + gtk_table_attach(GTK_TABLE(table9), chkSSL, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkSSL, "Enable to use SSL (the target must have SSL enabled!)", NULL); + + chkServiceDetails = gtk_check_button_new_with_mnemonic("Service Module Usage Details"); + gtk_widget_set_name(chkServiceDetails, "chkServiceDetails"); + gtk_widget_show(chkServiceDetails); + gtk_table_attach(GTK_TABLE(table9), chkServiceDetails, 2, 3, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkServiceDetails, "Service Module Usage Details", NULL); + + chkCompleteHelp = gtk_check_button_new_with_mnemonic("COMPLETE HELP"); + gtk_widget_set_name(chkCompleteHelp, "chkCompleteHelp"); + gtk_widget_show(chkCompleteHelp); + gtk_table_attach(GTK_TABLE(table9), chkCompleteHelp, 0, 2, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkCompleteHelp, "Complete Help", NULL); + + chkOldSSL = gtk_check_button_new_with_mnemonic("Use old SSL"); + gtk_widget_set_name(chkOldSSL, "chkOldSSL"); + gtk_widget_show(chkOldSSL); + gtk_table_attach(GTK_TABLE(table9), chkOldSSL, 1, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkOldSSL, "Enable to use old SSL (the target must have SSL enabled!)", NULL); + + label29 = gtk_label_new("Output Options"); + gtk_widget_set_name(label29, "label29"); + gtk_widget_show(label29); + gtk_frame_set_label_widget(GTK_FRAME(frame12), label29); + + label1 = gtk_label_new("Target"); + gtk_widget_set_name(label1, "label1"); + gtk_widget_show(label1); + gtk_notebook_set_tab_label(GTK_NOTEBOOK(ntbMain), gtk_notebook_get_nth_page(GTK_NOTEBOOK(ntbMain), 0), label1); + + vbox2 = gtk_vbox_new(FALSE, 0); + gtk_widget_set_name(vbox2, "vbox2"); + gtk_widget_show(vbox2); + gtk_container_add(GTK_CONTAINER(ntbMain), vbox2); + + frmUsername = gtk_frame_new(NULL); + gtk_widget_set_name(frmUsername, "frmUsername"); + gtk_widget_show(frmUsername); + gtk_box_pack_start(GTK_BOX(vbox2), frmUsername, TRUE, TRUE, 0); + + table2 = gtk_table_new(3, 2, FALSE); + gtk_widget_set_name(table2, "table2"); + gtk_widget_show(table2); + gtk_container_add(GTK_CONTAINER(frmUsername), table2); + + entUsernameFile = gtk_entry_new(); + gtk_widget_set_name(entUsernameFile, "entUsernameFile"); + gtk_widget_show(entUsernameFile); + gtk_table_attach(GTK_TABLE(table2), entUsernameFile, 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), 0, 0); + gtk_tooltips_set_tip(tooltips, entUsernameFile, "File with user logins, one entry per line", NULL); + + entUsername = gtk_entry_new(); + gtk_widget_set_name(entUsername, "entUsername"); + gtk_widget_show(entUsername); + gtk_table_attach(GTK_TABLE(table2), entUsername, 1, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), 0, 0); + gtk_tooltips_set_tip(tooltips, entUsername, "The login to use", NULL); + gtk_entry_set_text(GTK_ENTRY(entUsername), "yourname"); + + radioUsername1 = gtk_radio_button_new_with_mnemonic(NULL, "Username"); + gtk_widget_set_name(radioUsername1, "radioUsername1"); + gtk_widget_show(radioUsername1); + gtk_table_attach(GTK_TABLE(table2), radioUsername1, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), 0, 0); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(radioUsername1), radioUsername1_group); + radioUsername1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radioUsername1)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radioUsername1), TRUE); + + radioUsername2 = gtk_radio_button_new_with_mnemonic(NULL, "Username List"); + gtk_widget_set_name(radioUsername2, "radioUsername2"); + gtk_widget_show(radioUsername2); + gtk_table_attach(GTK_TABLE(table2), radioUsername2, 0, 1, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), 0, 0); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(radioUsername2), radioUsername1_group); + radioUsername1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radioUsername2)); + + chkUsernameLoop = gtk_check_button_new_with_mnemonic("Loop around users"); + gtk_widget_set_name(chkUsernameLoop, "chkUsernameLoop"); + gtk_widget_show(chkUsernameLoop); + gtk_table_attach(GTK_TABLE(table2), chkUsernameLoop, 0, 1, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkUsernameLoop, "Enable this option to loop around users not passwords", NULL); + + chkDisUser = gtk_check_button_new_with_mnemonic("Protocol does not require usernames"); + gtk_widget_set_name(chkDisUser, "chkDisUser"); + gtk_widget_show(chkDisUser); + gtk_table_attach(GTK_TABLE(table2), chkDisUser, 1, 2, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkDisUser, "Protocols like Cisco, Cisco enable, redis, Oracle listener, SNMP, S7-300, VNC etc. are not using usernames", NULL); + + label8 = gtk_label_new("Username"); + gtk_widget_set_name(label8, "label8"); + gtk_widget_show(label8); + gtk_frame_set_label_widget(GTK_FRAME(frmUsername), label8); + + frmPass = gtk_frame_new(NULL); + gtk_widget_set_name(frmPass, "frmPass"); + gtk_widget_show(frmPass); + gtk_box_pack_start(GTK_BOX(vbox2), frmPass, TRUE, TRUE, 0); + + table3 = gtk_table_new(3, 2, FALSE); + gtk_widget_set_name(table3, "table3"); + gtk_widget_show(table3); + gtk_container_add(GTK_CONTAINER(frmPass), table3); + + entPassFile = gtk_entry_new(); + gtk_widget_set_name(entPassFile, "entPassFile"); + gtk_widget_show(entPassFile); + gtk_table_attach(GTK_TABLE(table3), entPassFile, 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), 0, 0); + gtk_tooltips_set_tip(tooltips, entPassFile, "File with passwords to try, one entry per line", NULL); + + entPass = gtk_entry_new(); + gtk_widget_set_name(entPass, "entPass"); + gtk_widget_show(entPass); + gtk_table_attach(GTK_TABLE(table3), entPass, 1, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), 0, 0); + gtk_tooltips_set_tip(tooltips, entPass, "The password to try", NULL); + gtk_entry_set_text(GTK_ENTRY(entPass), "yourpass"); + + radioPass1 = gtk_radio_button_new_with_mnemonic(NULL, "Password"); + gtk_widget_set_name(radioPass1, "radioPass1"); + gtk_widget_show(radioPass1); + gtk_table_attach(GTK_TABLE(table3), radioPass1, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), 0, 0); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(radioPass1), radioPass1_group); + radioPass1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radioPass1)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radioPass1), TRUE); + + radioPass2 = gtk_radio_button_new_with_mnemonic(NULL, "Password List"); + gtk_widget_set_name(radioPass2, "radioPass2"); + gtk_widget_show(radioPass2); + gtk_table_attach(GTK_TABLE(table3), radioPass2, 0, 1, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), 0, 0); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(radioPass2), radioPass1_group); + radioPass1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radioPass2)); + radioGenerate = gtk_radio_button_new_with_mnemonic(NULL, "Generate"); + gtk_widget_set_name(radioGenerate, "radioGenerate"); + gtk_widget_show(radioGenerate); + gtk_table_attach(GTK_TABLE(table3), radioGenerate, 0, 1, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), 0, 0); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(radioGenerate), radioPass1_group); + radioPass1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radioGenerate)); + + entGeneration = gtk_entry_new(); + gtk_widget_set_name(entGeneration, "entGeneration"); + gtk_widget_show(entGeneration); + gtk_table_attach(GTK_TABLE(table3), entGeneration, 1, 2, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), 0, 0); + gtk_tooltips_set_tip(tooltips, entGeneration, "Generate passwords", NULL); + gtk_entry_set_text(GTK_ENTRY(entGeneration), "1:1:a"); + + labelpass = gtk_label_new("Password"); + gtk_widget_set_name(labelpass, "labelpass"); + gtk_widget_show(labelpass); + gtk_frame_set_label_widget(GTK_FRAME(frmPass), labelpass); + + frame8 = gtk_frame_new(NULL); + gtk_widget_set_name(frame8, "frame8"); + gtk_widget_show(frame8); + gtk_box_pack_start(GTK_BOX(vbox2), frame8, TRUE, TRUE, 0); + + table5 = gtk_table_new(1, 2, FALSE); + gtk_widget_set_name(table5, "table5"); + gtk_widget_show(table5); + gtk_container_add(GTK_CONTAINER(frame8), table5); + + chkColon = gtk_check_button_new_with_mnemonic("Use Colon separated file"); + gtk_widget_set_name(chkColon, "chkColon"); + gtk_widget_show(chkColon); + gtk_table_attach(GTK_TABLE(table5), chkColon, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkColon, "Enable this option to use a colon file for login/password attempts", NULL); + + entColonFile = gtk_entry_new(); + gtk_widget_set_name(entColonFile, "entColonFile"); + gtk_widget_show(entColonFile); + gtk_table_attach(GTK_TABLE(table5), entColonFile, 1, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, entColonFile, "The colon file to use, each line has to be structured like \"mylogin:mypass\"", NULL); + + label20 = gtk_label_new("Colon separated file"); + gtk_widget_set_name(label20, "label20"); + gtk_widget_show(label20); + gtk_frame_set_label_widget(GTK_FRAME(frame8), label20); + + table6 = gtk_table_new(1, 3, FALSE); + gtk_widget_set_name(table6, "table6"); + gtk_widget_show(table6); + gtk_box_pack_start(GTK_BOX(vbox2), table6, TRUE, TRUE, 0); + + chkPassLogin = gtk_check_button_new_with_mnemonic("Try login as password"); + gtk_widget_set_name(chkPassLogin, "chkPassLogin"); + gtk_widget_show(chkPassLogin); + gtk_table_attach(GTK_TABLE(table6), chkPassLogin, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkPassLogin, "Enable this option to try the login as password, in addition to the password/file", NULL); + + chkPassNull = gtk_check_button_new_with_mnemonic("Try empty password"); + gtk_widget_set_name(chkPassNull, "chkPassNull"); + gtk_widget_show(chkPassNull); + gtk_table_attach(GTK_TABLE(table6), chkPassNull, 1, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkPassNull, "Enable this option to try an empty password, in addition to the password/file", NULL); + + chkPassReverse = gtk_check_button_new_with_mnemonic("Try reversed login"); + gtk_widget_set_name(chkPassReverse, "chkPassReverse"); + gtk_widget_show(chkPassReverse); + gtk_table_attach(GTK_TABLE(table6), chkPassReverse, 2, 3, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkPassReverse, "Enable this option to try an reverse password, in addition to the password/file", NULL); + + label2 = gtk_label_new("Passwords"); + gtk_widget_set_name(label2, "label2"); + gtk_widget_show(label2); + gtk_notebook_set_tab_label(GTK_NOTEBOOK(ntbMain), gtk_notebook_get_nth_page(GTK_NOTEBOOK(ntbMain), 1), label2); + + table4 = gtk_table_new(2, 1, FALSE); + gtk_widget_set_name(table4, "table4"); + gtk_widget_show(table4); + gtk_container_add(GTK_CONTAINER(ntbMain), table4); + + frame9 = gtk_frame_new(NULL); + gtk_widget_set_name(frame9, "frame9"); + gtk_widget_show(frame9); + gtk_table_attach(GTK_TABLE(table4), frame9, 0, 1, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL), 0, 0); + + table7 = gtk_table_new(5, 2, FALSE); + gtk_widget_set_name(table7, "table7"); + gtk_widget_show(table7); + gtk_container_add(GTK_CONTAINER(frame9), table7); + + label22 = gtk_label_new("Proxy "); + gtk_widget_set_name(label22, "label22"); + gtk_widget_show(label22); + gtk_table_attach(GTK_TABLE(table7), label22, 0, 1, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_misc_set_alignment(GTK_MISC(label22), 0, 0.5); + + entHTTPProxy = gtk_entry_new(); + gtk_widget_set_name(entHTTPProxy, "entHTTPProxy"); + gtk_widget_show(entHTTPProxy); + gtk_table_attach(GTK_TABLE(table7), entHTTPProxy, 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, entHTTPProxy, "The address of the proxy. Syntax: \"http://123.45.67.89:8080\"", NULL); + gtk_entry_set_text(GTK_ENTRY(entHTTPProxy), "http://127.0.0.1:8080"); + + chkProxyAuth = gtk_check_button_new_with_mnemonic("Proxy needs authentication"); + gtk_widget_set_name(chkProxyAuth, "chkProxyAuth"); + gtk_widget_show(chkProxyAuth); + gtk_table_attach(GTK_TABLE(table7), chkProxyAuth, 0, 1, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkProxyAuth, "Enable this if the proxy requires authenticatio", NULL); + + label23 = gtk_label_new("Username"); + gtk_widget_set_name(label23, "label23"); + gtk_widget_show(label23); + gtk_table_attach(GTK_TABLE(table7), label23, 0, 1, 3, 4, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_misc_set_alignment(GTK_MISC(label23), 0, 0.5); + + entProxyUser = gtk_entry_new(); + gtk_widget_set_name(entProxyUser, "entProxyUser"); + gtk_widget_show(entProxyUser); + gtk_table_attach(GTK_TABLE(table7), entProxyUser, 1, 2, 3, 4, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, entProxyUser, "The user name for proxy authentication", NULL); + gtk_entry_set_text(GTK_ENTRY(entProxyUser), "yourname"); + + label24 = gtk_label_new("Password"); + gtk_widget_set_name(label24, "label24"); + gtk_widget_show(label24); + gtk_table_attach(GTK_TABLE(table7), label24, 0, 1, 4, 5, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_misc_set_alignment(GTK_MISC(label24), 0, 0.5); + + entProxyPass = gtk_entry_new(); + gtk_widget_set_name(entProxyPass, "entProxyPass"); + gtk_widget_show(entProxyPass); + gtk_table_attach(GTK_TABLE(table7), entProxyPass, 1, 2, 4, 5, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, entProxyPass, "The password for proxy authentication", NULL); + gtk_entry_set_text(GTK_ENTRY(entProxyPass), "yourpass"); + + label26 = gtk_label_new(""); + gtk_widget_set_name(label26, "label26"); + gtk_widget_show(label26); + gtk_table_attach(GTK_TABLE(table7), label26, 1, 2, 2, 3, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); + gtk_misc_set_alignment(GTK_MISC(label26), 0, 0.5); + + hbox3 = gtk_hbox_new(FALSE, 0); + gtk_widget_set_name(hbox3, "hbox3"); + gtk_widget_show(hbox3); + gtk_table_attach(GTK_TABLE(table7), hbox3, 0, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); + + radioProxy = gtk_radio_button_new_with_mnemonic(NULL, "No Proxy"); + gtk_widget_set_name(radioProxy, "radioProxy"); + gtk_widget_show(radioProxy); + gtk_box_pack_start(GTK_BOX(hbox3), radioProxy, TRUE, TRUE, 0); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(radioProxy), radioProxy_group); + radioProxy_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radioProxy)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radioProxy), TRUE); + + radioProxy2 = gtk_radio_button_new_with_mnemonic(NULL, "HTTP Method"); + gtk_widget_set_name(radioProxy2, "radioProxy2"); + gtk_widget_show(radioProxy2); + gtk_box_pack_start(GTK_BOX(hbox3), radioProxy2, TRUE, TRUE, 0); + gtk_tooltips_set_tip(tooltips, radioProxy2, "Enable this to use a proxy for scanning ( Only for HTTP Module )", NULL); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(radioProxy2), radioProxy_group); + radioProxy_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radioProxy2)); + + radioProxy3 = gtk_radio_button_new_with_mnemonic(NULL, "CONNECT Method"); + gtk_widget_set_name(radioProxy3, "radioProxy3"); + gtk_widget_show(radioProxy3); + gtk_box_pack_start(GTK_BOX(hbox3), radioProxy3, TRUE, TRUE, 0); + gtk_tooltips_set_tip(tooltips, radioProxy3, "Enable this to use a proxy for scanning", NULL); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(radioProxy3), radioProxy_group); + radioProxy_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radioProxy3)); + + label21 = gtk_label_new("Use a HTTP/HTTPS Proxy"); + gtk_widget_set_name(label21, "label21"); + gtk_widget_show(label21); + gtk_frame_set_label_widget(GTK_FRAME(frame9), label21); + + frame13 = gtk_frame_new(NULL); + gtk_widget_set_name(frame13, "frame13"); + gtk_widget_show(frame13); + gtk_table_attach(GTK_TABLE(table4), frame13, 0, 1, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); + + table10 = gtk_table_new(5, 2, FALSE); + gtk_widget_set_name(table10, "table10"); + gtk_widget_show(table10); + gtk_container_add(GTK_CONTAINER(frame13), table10); + + chkExitf = gtk_check_button_new_with_mnemonic("Exit after first found pair (per host)"); + gtk_widget_set_name(chkExitf, "chkExitf"); + gtk_widget_show(chkExitf); + gtk_table_attach(GTK_TABLE(table10), chkExitf, 0, 2, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkExitf, "Enable this to stop all attacking processes once a valid login/password pair is found (per host)", NULL); + + spnTimeout_adj = gtk_adjustment_new(30, 0, 295, 1, 10, 0); + spnTimeout = gtk_spin_button_new(GTK_ADJUSTMENT(spnTimeout_adj), 1, 0); + gtk_widget_set_name(spnTimeout, "spnTimeout"); + gtk_widget_show(spnTimeout); + gtk_table_attach(GTK_TABLE(table10), spnTimeout, 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, spnTimeout, "The maximum timeout an attack process is waiting for a response from the target", NULL); + + spnTasks_adj = gtk_adjustment_new(16, 0, 128, 1, 10, 0); + spnTasks = gtk_spin_button_new(GTK_ADJUSTMENT(spnTasks_adj), 1, 0); + gtk_widget_set_name(spnTasks, "spnTasks"); + gtk_widget_show(spnTasks); + gtk_table_attach(GTK_TABLE(table10), spnTasks, 1, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, spnTasks, "The number of attack tasks to run in parallel. The more the faster, the most: computer lockup :-) 16-64 is a good choice", NULL); + + label32 = gtk_label_new("Timeout"); + gtk_widget_set_name(label32, "label32"); + gtk_widget_show(label32); + gtk_table_attach(GTK_TABLE(table10), label32, 0, 1, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_misc_set_alignment(GTK_MISC(label32), 0, 0.5); + + label31 = gtk_label_new("Number of Tasks"); + gtk_widget_set_name(label31, "label31"); + gtk_widget_show(label31); + gtk_table_attach(GTK_TABLE(table10), label31, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_misc_set_alignment(GTK_MISC(label31), 0, 0.5); + + chkExitF = gtk_check_button_new_with_mnemonic("Exit after first found pair (global)"); + gtk_widget_set_name(chkExitF, "chkExitF"); + gtk_widget_show(chkExitF); + gtk_table_attach(GTK_TABLE(table10), chkExitF, 0, 2, 3, 4, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkExitF, "Enable this to stop all attacking processes once a valid login/password pair is found (global)", NULL); + + chkNoErr = gtk_check_button_new_with_mnemonic("Do not print messages about connection errors"); + gtk_widget_set_name(chkNoErr, "chkNoErr"); + gtk_widget_show(chkNoErr); + gtk_table_attach(GTK_TABLE(table10), chkNoErr, 0, 2, 4, 5, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_EXPAND), 0, 0); + gtk_tooltips_set_tip(tooltips, chkNoErr, "Do not print messages about connection errors", NULL); + + label30 = gtk_label_new("Performance Options"); + gtk_widget_set_name(label30, "label30"); + gtk_widget_show(label30); + gtk_frame_set_label_widget(GTK_FRAME(frame13), label30); + + label3 = gtk_label_new("Tuning"); + gtk_widget_set_name(label3, "label3"); + gtk_widget_show(label3); + gtk_notebook_set_tab_label(GTK_NOTEBOOK(ntbMain), gtk_notebook_get_nth_page(GTK_NOTEBOOK(ntbMain), 2), label3); + + vbox4 = gtk_vbox_new(FALSE, 0); + gtk_widget_set_name(vbox4, "vbox4"); + gtk_widget_show(vbox4); + gtk_container_add(GTK_CONTAINER(ntbMain), vbox4); + + frame10 = gtk_frame_new(NULL); + gtk_widget_set_name(frame10, "frame10"); + gtk_widget_show(frame10); + gtk_box_pack_start(GTK_BOX(vbox4), frame10, TRUE, TRUE, 0); + + entHTTPProxyURL = gtk_entry_new(); + gtk_widget_set_name(entHTTPProxyURL, "entHTTPProxyURL"); + gtk_widget_show(entHTTPProxyURL); + gtk_container_add(GTK_CONTAINER(frame10), entHTTPProxyURL); + gtk_tooltips_set_tip(tooltips, entHTTPProxyURL, "URL to connect to via the proxy", NULL); + gtk_entry_set_text(GTK_ENTRY(entHTTPProxyURL), "www.suse.com"); + + label27 = gtk_label_new("http-proxy url / http-proxy-urlenum credential module"); + gtk_widget_set_name(label27, "label27"); + gtk_widget_show(label27); + gtk_frame_set_label_widget(GTK_FRAME(frame10), label27); + + frame3 = gtk_frame_new(NULL); + gtk_widget_set_name(frame3, "frame3"); + gtk_widget_show(frame3); + gtk_box_pack_start(GTK_BOX(vbox4), frame3, TRUE, TRUE, 0); + + entHTTPURL = gtk_entry_new(); + gtk_widget_set_name(entHTTPURL, "entHTTPURL"); + gtk_widget_show(entHTTPURL); + gtk_container_add(GTK_CONTAINER(frame3), entHTTPURL); + gtk_tooltips_set_tip(tooltips, entHTTPURL, "The protected URL you want to access", NULL); + gtk_entry_set_text(GTK_ENTRY(entHTTPURL), "/foo/bar/protected.html"); + + label15 = gtk_label_new("http / https url"); + gtk_widget_set_name(label15, "label15"); + gtk_widget_show(label15); + gtk_frame_set_label_widget(GTK_FRAME(frame3), label15); + + frame4 = gtk_frame_new(NULL); + gtk_widget_set_name(frame4, "frame4"); + gtk_widget_show(frame4); + gtk_box_pack_start(GTK_BOX(vbox4), frame4, TRUE, TRUE, 0); + + entCiscoPass = gtk_entry_new(); + gtk_widget_set_name(entCiscoPass, "entCiscoPass"); + gtk_widget_show(entCiscoPass); + gtk_container_add(GTK_CONTAINER(frame4), entCiscoPass); + gtk_tooltips_set_tip(tooltips, entCiscoPass, "The password to the cisco device", NULL); + gtk_entry_set_text(GTK_ENTRY(entCiscoPass), "password"); + + label16 = gtk_label_new("Cisco Enable, Login for Cisco device"); + gtk_widget_set_name(label16, "label16"); + gtk_widget_show(label16); + gtk_frame_set_label_widget(GTK_FRAME(frame4), label16); + + frame5 = gtk_frame_new(NULL); + gtk_widget_set_name(frame5, "frame5"); + gtk_widget_show(frame5); + gtk_box_pack_start(GTK_BOX(vbox4), frame5, TRUE, TRUE, 0); + + entLDAPDN = gtk_entry_new(); + gtk_widget_set_name(entLDAPDN, "entLDAPDN"); + gtk_widget_show(entLDAPDN); + gtk_container_add(GTK_CONTAINER(frame5), entLDAPDN); + gtk_tooltips_set_tip(tooltips, entLDAPDN, "The DN scope of ldap to authenticate against", NULL); + gtk_entry_set_text(GTK_ENTRY(entLDAPDN), "dn-scope"); + + label17 = gtk_label_new("LDAP DN"); + gtk_widget_set_name(label17, "label17"); + gtk_widget_show(label17); + gtk_frame_set_label_widget(GTK_FRAME(frame5), label17); + + frame6 = gtk_frame_new(NULL); + gtk_widget_set_name(frame6, "frame6"); + gtk_widget_show(frame6); + gtk_box_pack_start(GTK_BOX(vbox4), frame6, TRUE, TRUE, 0); + + hbox2 = gtk_hbox_new(FALSE, 0); + gtk_widget_set_name(hbox2, "hbox2"); + gtk_widget_show(hbox2); + gtk_container_add(GTK_CONTAINER(frame6), hbox2); + + chkLocal = gtk_check_button_new_with_mnemonic("local accounts"); + gtk_widget_set_name(chkLocal, "chkLocal"); + gtk_widget_show(chkLocal); + gtk_box_pack_start(GTK_BOX(hbox2), chkLocal, TRUE, TRUE, 0); + gtk_tooltips_set_tip(tooltips, chkLocal, "Just attack local accounts (only valid for smb module)", NULL); + + chkDomain = gtk_check_button_new_with_mnemonic("domain accounts"); + gtk_widget_set_name(chkDomain, "chkDomain"); + gtk_widget_show(chkDomain); + gtk_box_pack_start(GTK_BOX(hbox2), chkDomain, TRUE, TRUE, 0); + gtk_tooltips_set_tip(tooltips, chkDomain, "Attack domain and local accounts (only valid for smb module)", NULL); + + chkNTLM = gtk_check_button_new_with_mnemonic("Interpret passes as NTLM hashes"); + gtk_widget_set_name(chkNTLM, "chkNTLM"); + gtk_widget_show(chkNTLM); + gtk_box_pack_start(GTK_BOX(hbox2), chkNTLM, FALSE, FALSE, 0); + gtk_tooltips_set_tip(tooltips, chkNTLM, "Interpret passes as NTML hashes (valid for both smb and smb2 modules)", NULL); + + label18 = gtk_label_new("SMB"); + gtk_widget_set_name(label18, "label18"); + gtk_widget_show(label18); + gtk_frame_set_label_widget(GTK_FRAME(frame6), label18); + + fraSMB2 = gtk_frame_new(NULL); + gtk_widget_set_name(fraSMB2, "fraSMB2"); + gtk_widget_show(fraSMB2); + gtk_box_pack_start(GTK_BOX(vbox4), fraSMB2, TRUE, TRUE, 0); + + entSMB2Workgroup = gtk_entry_new(); + gtk_widget_set_name(entSMB2Workgroup, "entSMB2Workgroup"); + gtk_widget_show(entSMB2Workgroup); + gtk_container_add(GTK_CONTAINER(fraSMB2), entSMB2Workgroup); + gtk_tooltips_set_tip(tooltips, entSMB2Workgroup, "Workgroup to use for SMB authentication (only valid for smb2 module)", NULL); + gtk_entry_set_text(GTK_ENTRY(entSMB2Workgroup), "WORKGROUP"); + + lblSMB2 = gtk_label_new("SMB2 Workgroup"); + gtk_widget_set_name(lblSMB2, "lblSMB2"); + gtk_widget_show(lblSMB2); + gtk_frame_set_label_widget(GTK_FRAME(fraSMB2), lblSMB2); + + frame7 = gtk_frame_new(NULL); + gtk_widget_set_name(frame7, "frame7"); + gtk_widget_show(frame7); + gtk_box_pack_start(GTK_BOX(vbox4), frame7, TRUE, TRUE, 0); + + spnSAPR3_adj = gtk_adjustment_new(1, 0, 99, 1, 10, 0); + spnSAPR3 = gtk_spin_button_new(GTK_ADJUSTMENT(spnSAPR3_adj), 1, 0); + gtk_widget_set_name(spnSAPR3, "spnSAPR3"); + gtk_widget_show(spnSAPR3); + gtk_container_add(GTK_CONTAINER(frame7), spnSAPR3); + gtk_tooltips_set_tip(tooltips, spnSAPR3, "The client id you want to attack, something between 0 and 99", NULL); + + label19 = gtk_label_new("sapr3 client id"); + gtk_widget_set_name(label19, "label19"); + gtk_widget_show(label19); + gtk_frame_set_label_widget(GTK_FRAME(frame7), label19); + + frame15 = gtk_frame_new(NULL); + gtk_widget_set_name(frame15, "frame15"); + gtk_widget_show(frame15); + gtk_box_pack_start(GTK_BOX(vbox4), frame15, TRUE, TRUE, 0); + + entCVS = gtk_entry_new(); + gtk_widget_set_name(entCVS, "entCVS"); + gtk_widget_show(entCVS); + gtk_container_add(GTK_CONTAINER(frame15), entCVS); + gtk_tooltips_set_tip(tooltips, entCVS, "Directory of the CVS/SVN repository", NULL); + gtk_entry_set_text(GTK_ENTRY(entCVS), "trunk"); + + label34 = gtk_label_new("CVS/SVN Repository"); + gtk_widget_set_name(label34, "label34"); + gtk_widget_show(label34); + gtk_frame_set_label_widget(GTK_FRAME(frame15), label34); + + frame17 = gtk_frame_new(NULL); + gtk_widget_set_name(frame17, "frame17"); + gtk_widget_show(frame17); + gtk_box_pack_start(GTK_BOX(vbox4), frame17, TRUE, TRUE, 0); + + alignment1 = gtk_alignment_new(0.5, 0.5, 1, 1); + gtk_widget_set_name(alignment1, "alignment1"); + gtk_widget_show(alignment1); + gtk_container_add(GTK_CONTAINER(frame17), alignment1); + + entTelnet = gtk_entry_new(); + gtk_widget_set_name(entTelnet, "entTelnet"); + gtk_widget_show(entTelnet); + gtk_container_add(GTK_CONTAINER(alignment1), entTelnet); + gtk_tooltips_set_tip(tooltips, entTelnet, "Insert the return string for a successful login", NULL); + + label36 = gtk_label_new("Telnet - Successful Login String"); + gtk_widget_set_name(label36, "label36"); + gtk_widget_show(label36); + gtk_frame_set_label_widget(GTK_FRAME(frame17), label36); + gtk_label_set_use_markup(GTK_LABEL(label36), TRUE); + + frame16 = gtk_frame_new(NULL); + gtk_widget_set_name(frame16, "frame16"); + gtk_widget_show(frame16); + gtk_box_pack_start(GTK_BOX(vbox4), frame16, TRUE, TRUE, 0); + + entSNMP = gtk_entry_new(); + gtk_widget_set_name(entSNMP, "entSNMP"); + gtk_widget_show(entSNMP); + gtk_container_add(GTK_CONTAINER(frame16), entSNMP); + gtk_tooltips_set_tip(tooltips, entSNMP, "SNMP options", NULL); + gtk_entry_set_text(GTK_ENTRY(entSNMP), "3:SHA:AES:READ"); + + label35 = gtk_label_new("SNMP"); + gtk_widget_set_name(label35, "label35"); + gtk_widget_show(label35); + gtk_frame_set_label_widget(GTK_FRAME(frame16), label35); + + label14 = gtk_label_new("Specific"); + gtk_widget_set_name(label14, "label14"); + gtk_widget_show(label14); + gtk_notebook_set_tab_label(GTK_NOTEBOOK(ntbMain), gtk_notebook_get_nth_page(GTK_NOTEBOOK(ntbMain), 3), label14); + + vbox3 = gtk_vbox_new(FALSE, 0); + gtk_widget_set_name(vbox3, "vbox3"); + gtk_widget_show(vbox3); + gtk_container_add(GTK_CONTAINER(ntbMain), vbox3); + + scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); + gtk_widget_set_name(scrolledwindow1, "scrolledwindow1"); + gtk_widget_show(scrolledwindow1); + gtk_box_pack_start(GTK_BOX(vbox3), scrolledwindow1, TRUE, TRUE, 0); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); + + viewport1 = gtk_viewport_new(NULL, NULL); + gtk_widget_set_name(viewport1, "viewport1"); + gtk_widget_show(viewport1); + gtk_container_add(GTK_CONTAINER(scrolledwindow1), viewport1); + + frame14 = gtk_frame_new(NULL); + gtk_widget_set_name(frame14, "frame14"); + gtk_widget_show(frame14); + gtk_container_add(GTK_CONTAINER(viewport1), frame14); + + txtOutput = gtk_text_view_new(); + gtk_widget_set_name(txtOutput, "txtOutput"); + gtk_widget_show(txtOutput); + gtk_container_add(GTK_CONTAINER(frame14), txtOutput); + gtk_text_view_set_editable(GTK_TEXT_VIEW(txtOutput), FALSE); + + label33 = gtk_label_new("Output"); + gtk_widget_set_name(label33, "label33"); + gtk_widget_show(label33); + gtk_frame_set_label_widget(GTK_FRAME(frame14), label33); + + hbox1 = gtk_hbox_new(FALSE, 0); + gtk_widget_set_name(hbox1, "hbox1"); + gtk_widget_show(hbox1); + gtk_box_pack_start(GTK_BOX(vbox3), hbox1, FALSE, TRUE, 0); + + btnStart = gtk_button_new_with_mnemonic("Start"); + gtk_widget_set_name(btnStart, "btnStart"); + gtk_widget_show(btnStart); + gtk_box_pack_start(GTK_BOX(hbox1), btnStart, TRUE, FALSE, 0); + gtk_tooltips_set_tip(tooltips, btnStart, "start hydra", NULL); + + btnStop = gtk_button_new_with_mnemonic("Stop"); + gtk_widget_set_name(btnStop, "btnStop"); + gtk_widget_show(btnStop); + gtk_box_pack_start(GTK_BOX(hbox1), btnStop, TRUE, FALSE, 0); + gtk_tooltips_set_tip(tooltips, btnStop, "stop hydra", NULL); + + btnSave = gtk_button_new_with_mnemonic("Save Output"); + gtk_widget_set_name(btnSave, "btnSave"); + gtk_widget_show(btnSave); + gtk_box_pack_start(GTK_BOX(hbox1), btnSave, TRUE, FALSE, 0); + gtk_tooltips_set_tip(tooltips, btnSave, "save output", NULL); + + btnClear = gtk_button_new_with_mnemonic("Clear Output"); + gtk_widget_set_name(btnClear, "btnClear"); + gtk_widget_show(btnClear); + gtk_box_pack_start(GTK_BOX(hbox1), btnClear, TRUE, FALSE, 0); + gtk_tooltips_set_tip(tooltips, btnClear, "clear screen", NULL); + + label4 = gtk_label_new("Start"); + gtk_widget_set_name(label4, "label4"); + gtk_widget_show(label4); + gtk_notebook_set_tab_label(GTK_NOTEBOOK(ntbMain), gtk_notebook_get_nth_page(GTK_NOTEBOOK(ntbMain), 4), label4); + + statusbar = gtk_statusbar_new(); + gtk_widget_set_name(statusbar, "statusbar"); + gtk_widget_show(statusbar); + gtk_box_pack_start(GTK_BOX(vbox1), statusbar, FALSE, FALSE, 0); + + g_signal_connect((gpointer)wndMain, "destroy", G_CALLBACK(on_wndMain_destroy), NULL); + g_signal_connect((gpointer)quit1, "button-press-event", G_CALLBACK(on_quit1_activate), NULL); + g_signal_connect((gpointer)entTargetFile, "button_press_event", G_CALLBACK(on_entTargetFile_button_press_event), NULL); + g_signal_connect((gpointer)entUsernameFile, "button_press_event", G_CALLBACK(on_entUsernameFile_button_press_event), NULL); + g_signal_connect((gpointer)chkDisUser, "toggled", G_CALLBACK(on_chkDisUser_toggled), NULL); + g_signal_connect((gpointer)entPassFile, "button_press_event", G_CALLBACK(on_entPassFile_button_press_event), NULL); + g_signal_connect((gpointer)chkColon, "toggled", G_CALLBACK(on_chkColon_toggled), NULL); + g_signal_connect((gpointer)entColonFile, "button_press_event", G_CALLBACK(on_entColonFile_button_press_event), NULL); + g_signal_connect((gpointer)btnStart, "clicked", G_CALLBACK(on_btnStart_clicked), NULL); + g_signal_connect((gpointer)btnStop, "clicked", G_CALLBACK(on_btnStop_clicked), NULL); + g_signal_connect((gpointer)btnSave, "clicked", G_CALLBACK(on_btnSave_clicked), NULL); + g_signal_connect((gpointer)btnClear, "clicked", G_CALLBACK(on_btnClear_clicked), NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF(wndMain, wndMain, "wndMain"); + GLADE_HOOKUP_OBJECT(wndMain, vbox1, "vbox1"); + GLADE_HOOKUP_OBJECT(wndMain, menubar1, "menubar1"); + GLADE_HOOKUP_OBJECT(wndMain, quit1, "quit1"); + GLADE_HOOKUP_OBJECT(wndMain, ntbMain, "ntbMain"); + GLADE_HOOKUP_OBJECT(wndMain, vbox5, "vbox5"); + GLADE_HOOKUP_OBJECT(wndMain, frame11, "frame11"); + GLADE_HOOKUP_OBJECT(wndMain, table8, "table8"); + GLADE_HOOKUP_OBJECT(wndMain, cmbProtocol, "cmbProtocol"); + GLADE_HOOKUP_OBJECT(wndMain, entProtocol, "entProtocol"); + GLADE_HOOKUP_OBJECT(wndMain, label7, "label7"); + GLADE_HOOKUP_OBJECT(wndMain, spnPort, "spnPort"); + GLADE_HOOKUP_OBJECT(wndMain, label6, "label6"); + GLADE_HOOKUP_OBJECT(wndMain, radioTarget2, "radioTarget2"); + GLADE_HOOKUP_OBJECT(wndMain, entTargetFile, "entTargetFile"); + GLADE_HOOKUP_OBJECT(wndMain, entTarget, "entTarget"); + GLADE_HOOKUP_OBJECT(wndMain, radioTarget1, "radioTarget1"); + GLADE_HOOKUP_OBJECT(wndMain, label28, "label28"); + GLADE_HOOKUP_OBJECT(wndMain, frame12, "frame12"); + GLADE_HOOKUP_OBJECT(wndMain, table9, "table9"); + GLADE_HOOKUP_OBJECT(wndMain, chkVerbose, "chkVerbose"); + GLADE_HOOKUP_OBJECT(wndMain, chkDebug, "chkDebug"); + GLADE_HOOKUP_OBJECT(wndMain, chkAttempts, "chkAttempts"); + GLADE_HOOKUP_OBJECT(wndMain, chkIPV6, "chkIPV6"); + GLADE_HOOKUP_OBJECT(wndMain, chkSSL, "chkSSL"); + GLADE_HOOKUP_OBJECT(wndMain, chkServiceDetails, "chkServiceDetails"); + GLADE_HOOKUP_OBJECT(wndMain, chkCompleteHelp, "chkCompleteHelp"); + GLADE_HOOKUP_OBJECT(wndMain, chkOldSSL, "chkOldSSL"); + GLADE_HOOKUP_OBJECT(wndMain, label29, "label29"); + GLADE_HOOKUP_OBJECT(wndMain, label1, "label1"); + GLADE_HOOKUP_OBJECT(wndMain, vbox2, "vbox2"); + GLADE_HOOKUP_OBJECT(wndMain, frmUsername, "frmUsername"); + GLADE_HOOKUP_OBJECT(wndMain, table2, "table2"); + GLADE_HOOKUP_OBJECT(wndMain, entUsernameFile, "entUsernameFile"); + GLADE_HOOKUP_OBJECT(wndMain, entUsername, "entUsername"); + GLADE_HOOKUP_OBJECT(wndMain, radioUsername1, "radioUsername1"); + GLADE_HOOKUP_OBJECT(wndMain, chkUsernameLoop, "chkUsernameLoop"); + GLADE_HOOKUP_OBJECT(wndMain, radioUsername2, "radioUsername2"); + GLADE_HOOKUP_OBJECT(wndMain, chkDisUser, "chkDisUser"); + GLADE_HOOKUP_OBJECT(wndMain, label8, "label8"); + GLADE_HOOKUP_OBJECT(wndMain, frmPass, "frmPass"); + GLADE_HOOKUP_OBJECT(wndMain, table3, "table3"); + GLADE_HOOKUP_OBJECT(wndMain, entPassFile, "entPassFile"); + GLADE_HOOKUP_OBJECT(wndMain, entPass, "entPass"); + GLADE_HOOKUP_OBJECT(wndMain, radioPass1, "radioPass1"); + GLADE_HOOKUP_OBJECT(wndMain, radioPass2, "radioPass2"); + GLADE_HOOKUP_OBJECT(wndMain, radioGenerate, "radioGenerate"); + GLADE_HOOKUP_OBJECT(wndMain, entGeneration, "entGeneration"); + GLADE_HOOKUP_OBJECT(wndMain, labelpass, "labelpass"); + GLADE_HOOKUP_OBJECT(wndMain, frame8, "frame8"); + GLADE_HOOKUP_OBJECT(wndMain, table5, "table5"); + GLADE_HOOKUP_OBJECT(wndMain, chkColon, "chkColon"); + GLADE_HOOKUP_OBJECT(wndMain, entColonFile, "entColonFile"); + GLADE_HOOKUP_OBJECT(wndMain, label20, "label20"); + GLADE_HOOKUP_OBJECT(wndMain, table6, "table6"); + GLADE_HOOKUP_OBJECT(wndMain, chkPassLogin, "chkPassLogin"); + GLADE_HOOKUP_OBJECT(wndMain, chkPassNull, "chkPassNull"); + GLADE_HOOKUP_OBJECT(wndMain, chkPassReverse, "chkPassReverse"); + GLADE_HOOKUP_OBJECT(wndMain, label2, "label2"); + GLADE_HOOKUP_OBJECT(wndMain, table4, "table4"); + GLADE_HOOKUP_OBJECT(wndMain, frame9, "frame9"); + GLADE_HOOKUP_OBJECT(wndMain, table7, "table7"); + GLADE_HOOKUP_OBJECT(wndMain, label22, "label22"); + GLADE_HOOKUP_OBJECT(wndMain, entHTTPProxy, "entHTTPProxy"); + GLADE_HOOKUP_OBJECT(wndMain, chkProxyAuth, "chkProxyAuth"); + GLADE_HOOKUP_OBJECT(wndMain, label23, "label23"); + GLADE_HOOKUP_OBJECT(wndMain, entProxyUser, "entProxyUser"); + GLADE_HOOKUP_OBJECT(wndMain, label24, "label24"); + GLADE_HOOKUP_OBJECT(wndMain, entProxyPass, "entProxyPass"); + GLADE_HOOKUP_OBJECT(wndMain, label26, "label26"); + GLADE_HOOKUP_OBJECT(wndMain, hbox3, "hbox3"); + GLADE_HOOKUP_OBJECT(wndMain, radioProxy, "radioProxy"); + GLADE_HOOKUP_OBJECT(wndMain, radioProxy2, "radioProxy2"); + GLADE_HOOKUP_OBJECT(wndMain, radioProxy3, "radioProxy3"); + GLADE_HOOKUP_OBJECT(wndMain, label21, "label21"); + GLADE_HOOKUP_OBJECT(wndMain, frame13, "frame13"); + GLADE_HOOKUP_OBJECT(wndMain, table10, "table10"); + GLADE_HOOKUP_OBJECT(wndMain, chkExitf, "chkExitf"); + GLADE_HOOKUP_OBJECT(wndMain, spnTimeout, "spnTimeout"); + GLADE_HOOKUP_OBJECT(wndMain, spnTasks, "spnTasks"); + GLADE_HOOKUP_OBJECT(wndMain, label32, "label32"); + GLADE_HOOKUP_OBJECT(wndMain, label31, "label31"); + GLADE_HOOKUP_OBJECT(wndMain, chkExitF, "chkExitF"); + GLADE_HOOKUP_OBJECT(wndMain, chkNoErr, "chkNoErr"); + GLADE_HOOKUP_OBJECT(wndMain, label30, "label30"); + GLADE_HOOKUP_OBJECT(wndMain, label3, "label3"); + GLADE_HOOKUP_OBJECT(wndMain, vbox4, "vbox4"); + GLADE_HOOKUP_OBJECT(wndMain, frame10, "frame10"); + GLADE_HOOKUP_OBJECT(wndMain, entHTTPProxyURL, "entHTTPProxyURL"); + GLADE_HOOKUP_OBJECT(wndMain, label27, "label27"); + GLADE_HOOKUP_OBJECT(wndMain, frame3, "frame3"); + GLADE_HOOKUP_OBJECT(wndMain, entHTTPURL, "entHTTPURL"); + GLADE_HOOKUP_OBJECT(wndMain, label15, "label15"); + GLADE_HOOKUP_OBJECT(wndMain, frame4, "frame4"); + GLADE_HOOKUP_OBJECT(wndMain, entCiscoPass, "entCiscoPass"); + GLADE_HOOKUP_OBJECT(wndMain, label16, "label16"); + GLADE_HOOKUP_OBJECT(wndMain, frame5, "frame5"); + GLADE_HOOKUP_OBJECT(wndMain, entLDAPDN, "entLDAPDN"); + GLADE_HOOKUP_OBJECT(wndMain, label17, "label17"); + GLADE_HOOKUP_OBJECT(wndMain, frame6, "frame6"); + GLADE_HOOKUP_OBJECT(wndMain, hbox2, "hbox2"); + GLADE_HOOKUP_OBJECT(wndMain, chkLocal, "chkLocal"); + GLADE_HOOKUP_OBJECT(wndMain, chkDomain, "chkDomain"); + GLADE_HOOKUP_OBJECT(wndMain, chkNTLM, "chkNTLM"); + GLADE_HOOKUP_OBJECT(wndMain, label18, "label18"); + GLADE_HOOKUP_OBJECT(wndMain, frame7, "frame7"); + GLADE_HOOKUP_OBJECT(wndMain, spnSAPR3, "spnSAPR3"); + GLADE_HOOKUP_OBJECT(wndMain, label19, "label19"); + GLADE_HOOKUP_OBJECT(wndMain, frame15, "frame15"); + GLADE_HOOKUP_OBJECT(wndMain, entCVS, "entCVS"); + GLADE_HOOKUP_OBJECT(wndMain, label34, "label34"); + GLADE_HOOKUP_OBJECT(wndMain, frame17, "frame17"); + GLADE_HOOKUP_OBJECT(wndMain, alignment1, "alignment1"); + GLADE_HOOKUP_OBJECT(wndMain, entTelnet, "entTelnet"); + GLADE_HOOKUP_OBJECT(wndMain, label36, "label36"); + GLADE_HOOKUP_OBJECT(wndMain, frame16, "frame16"); + GLADE_HOOKUP_OBJECT(wndMain, entSNMP, "entSNMP"); + GLADE_HOOKUP_OBJECT(wndMain, label35, "label35"); + GLADE_HOOKUP_OBJECT(wndMain, label14, "label14"); + GLADE_HOOKUP_OBJECT(wndMain, vbox3, "vbox3"); + GLADE_HOOKUP_OBJECT(wndMain, scrolledwindow1, "scrolledwindow1"); + GLADE_HOOKUP_OBJECT(wndMain, viewport1, "viewport1"); + GLADE_HOOKUP_OBJECT(wndMain, frame14, "frame14"); + GLADE_HOOKUP_OBJECT(wndMain, txtOutput, "txtOutput"); + GLADE_HOOKUP_OBJECT(wndMain, label33, "label33"); + GLADE_HOOKUP_OBJECT(wndMain, hbox1, "hbox1"); + GLADE_HOOKUP_OBJECT(wndMain, btnStart, "btnStart"); + GLADE_HOOKUP_OBJECT(wndMain, btnStop, "btnStop"); + GLADE_HOOKUP_OBJECT(wndMain, btnSave, "btnSave"); + GLADE_HOOKUP_OBJECT(wndMain, btnClear, "btnClear"); + GLADE_HOOKUP_OBJECT(wndMain, label4, "label4"); + GLADE_HOOKUP_OBJECT(wndMain, statusbar, "statusbar"); + GLADE_HOOKUP_OBJECT_NO_REF(wndMain, tooltips, "tooltips"); + GLADE_HOOKUP_OBJECT(wndMain, entSMB2Workgroup, "entSMB2Workgroup"); + + gtk_window_add_accel_group(GTK_WINDOW(wndMain), accel_group); + + return wndMain; +} diff --git a/gtk/src/interface.h b/gtk/src/interface.h new file mode 100644 index 0000000..1b60563 --- /dev/null +++ b/gtk/src/interface.h @@ -0,0 +1,6 @@ + +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +GtkWidget *create_wndMain(void); diff --git a/gtk/xhydra.glade b/gtk/xhydra.glade new file mode 100644 index 0000000..57df9ac --- /dev/null +++ b/gtk/xhydra.glade @@ -0,0 +1,2751 @@ + + + + + + + True + HydraGTK + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + True + False + True + False + False + GDK_WINDOW_TYPE_HINT_NORMAL + GDK_GRAVITY_NORTH_WEST + + + + + True + False + 0 + + + + True + + + + True + gtk-quit + True + + + + + + 0 + False + False + + + + + + True + True + True + True + GTK_POS_TOP + False + False + + + + True + False + 0 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 5 + 2 + False + 0 + 0 + + + + True + False + True + False + True + False + + + + True + The protocol to use for the login/password cracking attempt + True + True + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + True + cisco + + + + + + True + True + cisco-enable + + + + + + True + True + cvs + + + + + + True + True + firebird + + + + + + True + True + ftp + + + + + + True + True + http-head + + + + + + True + True + http-get + + + + + + True + True + http-form-get + + + + + + True + True + http-form-post + + + + + + True + True + http-proxy + + + + + + True + True + https-head + + + + + + True + True + https-get + + + + + + True + True + icq + + + + + + True + True + imap + + + + + + True + True + ldap2 + + + + + + True + True + ldap3 + + + + + + True + True + mysql + + + + + + True + True + ncp + + + + + + True + True + nntp + + + + + + True + True + pcnfs + + + + + + True + True + pop3 + + + + + + True + True + postgres + + + + + + True + True + pcanywhere + + + + + + True + True + vmauthd + + + + + + True + True + rexec + + + + + + True + True + rlogin + + + + + + True + True + rsh + + + + + + True + True + sapr3 + + + + + + True + True + sip + + + + + + True + True + smb + + + + + + True + True + smtp + + + + + + True + True + snmp + + + + + + True + True + socks5 + + + + + + True + True + ssh2 + + + + + + True + True + svn + + + + + + True + True + teamspeak + + + + + + True + True + telnet + + + + + + True + True + vnc + + + + + + True + True + sshkey + + + + + True + True + s7-300 + + + + + True + True + + + + + + True + True + afp + + + + + True + True + ftps + + + + + True + True + http-get-form + + + + + True + True + http-post-form + + + + + True + True + http-proxy-url + + + + + True + True + https-get-form + + + + + True + True + https-post-form + + + + + True + True + irc + + + + + True + True + ldap3-crammd5 + + + + + True + True + ldap3-digestmd5 + + + + + True + True + mssql + + + + + True + True + oracle + + + + + True + True + oracle-sid + + + + + True + True + oracle-listener + + + + + True + True + rdp + + + + + True + True + ssh + + + + + True + True + xmpp + + + + + True + True + adam6500 + + + + + True + True + rpcap + + + + True + True + rtsp + + + + + + + + 1 + 2 + 4 + 5 + expand|shrink + expand + + + + + + True + Protocol + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 4 + 5 + expand|shrink + expand + + + + + + True + select the port on which the daemon you want to brute force runs, 0 means default + True + 1 + 0 + False + GTK_UPDATE_ALWAYS + False + False + 0 0 100 1 10 10 + + + 1 + 2 + 3 + 4 + expand|shrink + expand + + + + + + True + Port + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 2 + 4 + expand|shrink + expand + + + + + True + Prefer IPV6 + True + Use IPV6 + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 2 + 2 + 3 + expand|shrink + expand + + + + + + True + True + Target List + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 1 + 2 + expand|shrink + expand + + + + + + True + A file which contains the targets to attack. One entry per line. IP +addresses and/or DNS names. + True + True + True + 0 + + True + * + False + + + + 1 + 2 + 1 + 2 + expand|shrink + expand + + + + + + True + The target to attack - DNS name or IP address + True + True + True + 0 + 127.0.0.1 + True + * + False + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + + True + True + Single Target + True + GTK_RELIEF_NORMAL + True + True + False + True + radioTarget2 + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + + + True + Target + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 2 + 2 + False + 0 + 0 + + + + True + be verbose + True + Be Verbose + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + + True + Enable debug mode + True + Debug + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 1 + 2 + 1 + 2 + expand|shrink + expand + + + + + + True + Show attempts + True + Show Attempts + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 1 + 2 + expand|shrink + expand + + + + + + True + Enable to use SSL (the target must have SSL enabled! + True + Use SSL + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + + + True + Output Options + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + False + True + + + + + + True + Target + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + + True + False + 0 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 2 + 2 + False + 0 + 0 + + + + True + File with user logins, one entry per line + True + True + True + 0 + + True + * + False + + + + 1 + 2 + 1 + 2 + expand|shrink + expand|shrink + + + + + + True + The login to use + True + True + True + 0 + yourname + True + * + False + + + 1 + 2 + 0 + 1 + expand|shrink + expand|shrink + + + + + + True + True + Username + True + GTK_RELIEF_NORMAL + True + True + False + True + + + 0 + 1 + 0 + 1 + expand|shrink + expand|shrink + + + + + + True + True + Username List + True + GTK_RELIEF_NORMAL + True + False + False + True + radioUsername1 + + + 0 + 1 + 1 + 2 + expand|shrink + expand|shrink + + + + + + + + True + Username + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 2 + 2 + False + 0 + 0 + + + + True + File with passwords to try, one entry per line + True + True + True + 0 + + True + * + False + + + + 1 + 2 + 1 + 2 + expand|shrink + expand|shrink + + + + + + True + The password to try + True + True + True + 0 + yourpass + True + * + False + + + 1 + 2 + 0 + 1 + expand|shrink + expand|shrink + + + + + + True + True + Password + True + GTK_RELIEF_NORMAL + True + True + False + True + + + 0 + 1 + 0 + 1 + expand|shrink + expand|shrink + + + + + + True + True + Password List + True + GTK_RELIEF_NORMAL + True + False + False + True + radioPass1 + + + 0 + 1 + 1 + 2 + expand|shrink + expand|shrink + + + + + + + + True + Password + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 1 + 2 + False + 0 + 0 + + + + True + "Enable this option to use a colon file for login/password attempts + True + Use Colon separated file + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + True + The colon file to use, each line has to be structured like "mylogin:mypass" + True + True + True + 0 + + True + * + False + + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + + + + True + Colon separated file + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 1 + 2 + False + 0 + 0 + + + + True + Enable this option to try the login as password, in addition to the password/file + True + Try login as password + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + True + Enable this option to try an empty password, in addition to the password/file + True + Try empty password + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + 0 + True + True + + + + + False + True + + + + + + True + Passwords + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + + True + 2 + 1 + False + 0 + 0 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 5 + 2 + False + 0 + 0 + + + + True + Proxy + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 1 + 2 + expand|shrink + expand + + + + + + True + The address of the proxy. Syntax: "http://123.45.67.89:8080" + True + True + True + 0 + http://127.0.0.1:8080 + True + * + False + + + 1 + 2 + 1 + 2 + expand|shrink + expand + + + + + + True + Enable this if the proxy requires authenticatio + True + Proxy needs authentication + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 2 + 3 + expand|shrink + expand + + + + + + True + Username + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 3 + 4 + expand|shrink + expand + + + + + + True + The user name for proxy authentication + True + True + True + 0 + yourname + True + * + False + + + 1 + 2 + 3 + 4 + expand|shrink + expand + + + + + + True + Password + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 4 + 5 + expand|shrink + expand + + + + + + True + The password for proxy authentication + True + True + True + 0 + yourpass + True + * + False + + + 1 + 2 + 4 + 5 + expand|shrink + expand + + + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 1 + 2 + 2 + 3 + fill + + + + + + + True + False + 0 + + + + True + True + No Proxy + True + GTK_RELIEF_NORMAL + True + True + False + True + + + 0 + True + True + + + + + + True + Enable this to use a proxy for scanning ( Only for HTTP Module ) + True + HTTP Method + True + GTK_RELIEF_NORMAL + True + False + False + True + radioProxy + + + 0 + True + True + + + + + + True + Enable this to use a proxy for scanning + True + CONNECT Method + True + GTK_RELIEF_NORMAL + True + False + False + True + radioProxy + + + 0 + True + True + + + + + 0 + 2 + 0 + 1 + expand|shrink|fill + + + + + + + + True + Use a HTTP/HTTPS Proxy + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + 1 + 1 + 2 + expand|shrink|fill + expand|shrink|fill + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 3 + 2 + False + 0 + 0 + + + + True + Enable this to stop all attacking processes once a valid login/password pair is found + True + Exit after first found pair + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 2 + 2 + 3 + expand|shrink + expand + + + + + + True + The maximum timeout an attack process is waiting for a response from the target + True + 1 + 0 + False + GTK_UPDATE_ALWAYS + False + False + 30 0 100 1 10 10 + + + 1 + 2 + 1 + 2 + expand|shrink + expand + + + + + + True + The number of attack tasks to run in parallel. The more the faster, the most: computer lockup :-) 16-64 is a good choice + True + 1 + 0 + False + GTK_UPDATE_ALWAYS + False + False + 40 0 100 1 10 10 + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + + True + Timeout + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 1 + 2 + expand|shrink + expand + + + + + + True + Number of Tasks + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + + + True + Performance Options + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + 1 + 0 + 1 + fill + + + + + False + True + + + + + + True + Tuning + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + + True + False + 0 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + URL to connect to via the proxy + True + True + True + 0 + www.suse.com + True + * + False + + + + + + True + http-proxy module + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + The protected URL you want to access + True + True + True + 0 + /foo/bar/protected.html + True + * + False + + + + + + True + http / https url + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + The password to the cisco device + True + True + True + 0 + password + True + * + False + + + + + + True + Cisco Enable, Login for Cisco device + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + The DN scope of ldap to authenticate against + True + True + True + 0 + dn-scope + True + * + False + + + + + + True + LDAP DN + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + False + 0 + + + + True + Just attack local accounts + True + local accounts + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + True + True + + + + + + True + Attack domain and local accounts + True + domain accounts + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + True + True + + + + + + True + Interpret passes as NTML hashes + True + Interpret passes as NTLM hashes + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + + + True + SMBNT + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + The client id you want to attack, something between 0 and 99 + True + 1 + 0 + False + GTK_UPDATE_ALWAYS + False + False + 1 0 99 1 10 10 + + + + + + True + sapr3 client id + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + Directory of the CVS repository + True + True + True + 0 + /hydra-gtk + True + * + False + + + + + + True + CVS/SVN Repository + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 0.5 + 0.5 + 1 + 1 + 0 + 0 + 0 + 0 + + + + True + Insert the return string for a successful login + True + True + True + 0 + + True + * + False + + + + + + + + True + Telnet - Successful Login String + False + True + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 2 + 2 + False + 0 + 0 + + + + True + True + Write Password + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + + True + True + Read Password + True + GTK_RELIEF_NORMAL + True + False + False + True + radioSNMPRead + + + 1 + 2 + 1 + 2 + expand|shrink + expand + + + + + + True + True + Version 2 + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 1 + 2 + expand|shrink + expand + + + + + + True + True + Version 1 + True + GTK_RELIEF_NORMAL + True + False + False + True + radioSNMPVer2 + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + + + True + SNMP + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + False + True + + + + + + True + Specific + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + + True + False + 0 + + + + True + True + GTK_POLICY_AUTOMATIC + GTK_POLICY_AUTOMATIC + GTK_SHADOW_NONE + GTK_CORNER_TOP_LEFT + + + + True + GTK_SHADOW_IN + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + True + False + False + True + GTK_JUSTIFY_LEFT + GTK_WRAP_NONE + True + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + + True + Output + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + + + + + 0 + True + True + + + + + + True + False + 0 + + + + True + start hydra + True + Start + True + GTK_RELIEF_NORMAL + True + + + + 0 + True + False + + + + + + True + stop hydra + True + Stop + True + GTK_RELIEF_NORMAL + True + + + + 0 + True + False + + + + + + True + save output + True + Save Output + True + GTK_RELIEF_NORMAL + True + + + + 0 + True + False + + + + + + True + clear screen + True + Clear Output + True + GTK_RELIEF_NORMAL + True + + + + 0 + True + False + + + + + 0 + False + True + + + + + False + True + + + + + + True + Start + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + 0 + True + True + + + + + + True + True + + + 0 + False + False + + + + + + + diff --git a/gtk/xhydra.gladep b/gtk/xhydra.gladep new file mode 100644 index 0000000..8811dd2 --- /dev/null +++ b/gtk/xhydra.gladep @@ -0,0 +1,10 @@ + + + + + Hydra_gtk + xhydra + FALSE + FALSE + TRUE + diff --git a/xhydra.glade b/xhydra.glade new file mode 100644 index 0000000..57df9ac --- /dev/null +++ b/xhydra.glade @@ -0,0 +1,2751 @@ + + + + + + + True + HydraGTK + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + True + False + True + False + False + GDK_WINDOW_TYPE_HINT_NORMAL + GDK_GRAVITY_NORTH_WEST + + + + + True + False + 0 + + + + True + + + + True + gtk-quit + True + + + + + + 0 + False + False + + + + + + True + True + True + True + GTK_POS_TOP + False + False + + + + True + False + 0 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 5 + 2 + False + 0 + 0 + + + + True + False + True + False + True + False + + + + True + The protocol to use for the login/password cracking attempt + True + True + True + 0 + + True + * + False + + + + + + True + GTK_SELECTION_BROWSE + + + + True + True + cisco + + + + + + True + True + cisco-enable + + + + + + True + True + cvs + + + + + + True + True + firebird + + + + + + True + True + ftp + + + + + + True + True + http-head + + + + + + True + True + http-get + + + + + + True + True + http-form-get + + + + + + True + True + http-form-post + + + + + + True + True + http-proxy + + + + + + True + True + https-head + + + + + + True + True + https-get + + + + + + True + True + icq + + + + + + True + True + imap + + + + + + True + True + ldap2 + + + + + + True + True + ldap3 + + + + + + True + True + mysql + + + + + + True + True + ncp + + + + + + True + True + nntp + + + + + + True + True + pcnfs + + + + + + True + True + pop3 + + + + + + True + True + postgres + + + + + + True + True + pcanywhere + + + + + + True + True + vmauthd + + + + + + True + True + rexec + + + + + + True + True + rlogin + + + + + + True + True + rsh + + + + + + True + True + sapr3 + + + + + + True + True + sip + + + + + + True + True + smb + + + + + + True + True + smtp + + + + + + True + True + snmp + + + + + + True + True + socks5 + + + + + + True + True + ssh2 + + + + + + True + True + svn + + + + + + True + True + teamspeak + + + + + + True + True + telnet + + + + + + True + True + vnc + + + + + + True + True + sshkey + + + + + True + True + s7-300 + + + + + True + True + + + + + + True + True + afp + + + + + True + True + ftps + + + + + True + True + http-get-form + + + + + True + True + http-post-form + + + + + True + True + http-proxy-url + + + + + True + True + https-get-form + + + + + True + True + https-post-form + + + + + True + True + irc + + + + + True + True + ldap3-crammd5 + + + + + True + True + ldap3-digestmd5 + + + + + True + True + mssql + + + + + True + True + oracle + + + + + True + True + oracle-sid + + + + + True + True + oracle-listener + + + + + True + True + rdp + + + + + True + True + ssh + + + + + True + True + xmpp + + + + + True + True + adam6500 + + + + + True + True + rpcap + + + + True + True + rtsp + + + + + + + + 1 + 2 + 4 + 5 + expand|shrink + expand + + + + + + True + Protocol + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 4 + 5 + expand|shrink + expand + + + + + + True + select the port on which the daemon you want to brute force runs, 0 means default + True + 1 + 0 + False + GTK_UPDATE_ALWAYS + False + False + 0 0 100 1 10 10 + + + 1 + 2 + 3 + 4 + expand|shrink + expand + + + + + + True + Port + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 2 + 4 + expand|shrink + expand + + + + + True + Prefer IPV6 + True + Use IPV6 + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 2 + 2 + 3 + expand|shrink + expand + + + + + + True + True + Target List + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 1 + 2 + expand|shrink + expand + + + + + + True + A file which contains the targets to attack. One entry per line. IP +addresses and/or DNS names. + True + True + True + 0 + + True + * + False + + + + 1 + 2 + 1 + 2 + expand|shrink + expand + + + + + + True + The target to attack - DNS name or IP address + True + True + True + 0 + 127.0.0.1 + True + * + False + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + + True + True + Single Target + True + GTK_RELIEF_NORMAL + True + True + False + True + radioTarget2 + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + + + True + Target + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 2 + 2 + False + 0 + 0 + + + + True + be verbose + True + Be Verbose + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + + True + Enable debug mode + True + Debug + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 1 + 2 + 1 + 2 + expand|shrink + expand + + + + + + True + Show attempts + True + Show Attempts + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 1 + 2 + expand|shrink + expand + + + + + + True + Enable to use SSL (the target must have SSL enabled! + True + Use SSL + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + + + True + Output Options + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + False + True + + + + + + True + Target + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + + True + False + 0 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 2 + 2 + False + 0 + 0 + + + + True + File with user logins, one entry per line + True + True + True + 0 + + True + * + False + + + + 1 + 2 + 1 + 2 + expand|shrink + expand|shrink + + + + + + True + The login to use + True + True + True + 0 + yourname + True + * + False + + + 1 + 2 + 0 + 1 + expand|shrink + expand|shrink + + + + + + True + True + Username + True + GTK_RELIEF_NORMAL + True + True + False + True + + + 0 + 1 + 0 + 1 + expand|shrink + expand|shrink + + + + + + True + True + Username List + True + GTK_RELIEF_NORMAL + True + False + False + True + radioUsername1 + + + 0 + 1 + 1 + 2 + expand|shrink + expand|shrink + + + + + + + + True + Username + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 2 + 2 + False + 0 + 0 + + + + True + File with passwords to try, one entry per line + True + True + True + 0 + + True + * + False + + + + 1 + 2 + 1 + 2 + expand|shrink + expand|shrink + + + + + + True + The password to try + True + True + True + 0 + yourpass + True + * + False + + + 1 + 2 + 0 + 1 + expand|shrink + expand|shrink + + + + + + True + True + Password + True + GTK_RELIEF_NORMAL + True + True + False + True + + + 0 + 1 + 0 + 1 + expand|shrink + expand|shrink + + + + + + True + True + Password List + True + GTK_RELIEF_NORMAL + True + False + False + True + radioPass1 + + + 0 + 1 + 1 + 2 + expand|shrink + expand|shrink + + + + + + + + True + Password + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 1 + 2 + False + 0 + 0 + + + + True + "Enable this option to use a colon file for login/password attempts + True + Use Colon separated file + True + GTK_RELIEF_NORMAL + True + False + False + True + + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + True + The colon file to use, each line has to be structured like "mylogin:mypass" + True + True + True + 0 + + True + * + False + + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + + + + True + Colon separated file + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 1 + 2 + False + 0 + 0 + + + + True + Enable this option to try the login as password, in addition to the password/file + True + Try login as password + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + True + Enable this option to try an empty password, in addition to the password/file + True + Try empty password + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + 0 + True + True + + + + + False + True + + + + + + True + Passwords + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + + True + 2 + 1 + False + 0 + 0 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 5 + 2 + False + 0 + 0 + + + + True + Proxy + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 1 + 2 + expand|shrink + expand + + + + + + True + The address of the proxy. Syntax: "http://123.45.67.89:8080" + True + True + True + 0 + http://127.0.0.1:8080 + True + * + False + + + 1 + 2 + 1 + 2 + expand|shrink + expand + + + + + + True + Enable this if the proxy requires authenticatio + True + Proxy needs authentication + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 2 + 3 + expand|shrink + expand + + + + + + True + Username + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 3 + 4 + expand|shrink + expand + + + + + + True + The user name for proxy authentication + True + True + True + 0 + yourname + True + * + False + + + 1 + 2 + 3 + 4 + expand|shrink + expand + + + + + + True + Password + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 4 + 5 + expand|shrink + expand + + + + + + True + The password for proxy authentication + True + True + True + 0 + yourpass + True + * + False + + + 1 + 2 + 4 + 5 + expand|shrink + expand + + + + + + True + + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 1 + 2 + 2 + 3 + fill + + + + + + + True + False + 0 + + + + True + True + No Proxy + True + GTK_RELIEF_NORMAL + True + True + False + True + + + 0 + True + True + + + + + + True + Enable this to use a proxy for scanning ( Only for HTTP Module ) + True + HTTP Method + True + GTK_RELIEF_NORMAL + True + False + False + True + radioProxy + + + 0 + True + True + + + + + + True + Enable this to use a proxy for scanning + True + CONNECT Method + True + GTK_RELIEF_NORMAL + True + False + False + True + radioProxy + + + 0 + True + True + + + + + 0 + 2 + 0 + 1 + expand|shrink|fill + + + + + + + + True + Use a HTTP/HTTPS Proxy + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + 1 + 1 + 2 + expand|shrink|fill + expand|shrink|fill + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 3 + 2 + False + 0 + 0 + + + + True + Enable this to stop all attacking processes once a valid login/password pair is found + True + Exit after first found pair + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 2 + 2 + 3 + expand|shrink + expand + + + + + + True + The maximum timeout an attack process is waiting for a response from the target + True + 1 + 0 + False + GTK_UPDATE_ALWAYS + False + False + 30 0 100 1 10 10 + + + 1 + 2 + 1 + 2 + expand|shrink + expand + + + + + + True + The number of attack tasks to run in parallel. The more the faster, the most: computer lockup :-) 16-64 is a good choice + True + 1 + 0 + False + GTK_UPDATE_ALWAYS + False + False + 40 0 100 1 10 10 + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + + True + Timeout + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 1 + 2 + expand|shrink + expand + + + + + + True + Number of Tasks + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + + + True + Performance Options + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + 1 + 0 + 1 + fill + + + + + False + True + + + + + + True + Tuning + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + + True + False + 0 + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + URL to connect to via the proxy + True + True + True + 0 + www.suse.com + True + * + False + + + + + + True + http-proxy module + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + The protected URL you want to access + True + True + True + 0 + /foo/bar/protected.html + True + * + False + + + + + + True + http / https url + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + The password to the cisco device + True + True + True + 0 + password + True + * + False + + + + + + True + Cisco Enable, Login for Cisco device + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + The DN scope of ldap to authenticate against + True + True + True + 0 + dn-scope + True + * + False + + + + + + True + LDAP DN + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + False + 0 + + + + True + Just attack local accounts + True + local accounts + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + True + True + + + + + + True + Attack domain and local accounts + True + domain accounts + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + True + True + + + + + + True + Interpret passes as NTML hashes + True + Interpret passes as NTLM hashes + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + False + False + + + + + + + + True + SMBNT + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + The client id you want to attack, something between 0 and 99 + True + 1 + 0 + False + GTK_UPDATE_ALWAYS + False + False + 1 0 99 1 10 10 + + + + + + True + sapr3 client id + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + Directory of the CVS repository + True + True + True + 0 + /hydra-gtk + True + * + False + + + + + + True + CVS/SVN Repository + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 0.5 + 0.5 + 1 + 1 + 0 + 0 + 0 + 0 + + + + True + Insert the return string for a successful login + True + True + True + 0 + + True + * + False + + + + + + + + True + Telnet - Successful Login String + False + True + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 2 + 2 + False + 0 + 0 + + + + True + True + Write Password + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 1 + 2 + 0 + 1 + expand|shrink + expand + + + + + + True + True + Read Password + True + GTK_RELIEF_NORMAL + True + False + False + True + radioSNMPRead + + + 1 + 2 + 1 + 2 + expand|shrink + expand + + + + + + True + True + Version 2 + True + GTK_RELIEF_NORMAL + True + False + False + True + + + 0 + 1 + 1 + 2 + expand|shrink + expand + + + + + + True + True + Version 1 + True + GTK_RELIEF_NORMAL + True + False + False + True + radioSNMPVer2 + + + 0 + 1 + 0 + 1 + expand|shrink + expand + + + + + + + + True + SNMP + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + 0 + True + True + + + + + False + True + + + + + + True + Specific + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + + True + False + 0 + + + + True + True + GTK_POLICY_AUTOMATIC + GTK_POLICY_AUTOMATIC + GTK_SHADOW_NONE + GTK_CORNER_TOP_LEFT + + + + True + GTK_SHADOW_IN + + + + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + True + False + False + True + GTK_JUSTIFY_LEFT + GTK_WRAP_NONE + True + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + + True + Output + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + label_item + + + + + + + + + 0 + True + True + + + + + + True + False + 0 + + + + True + start hydra + True + Start + True + GTK_RELIEF_NORMAL + True + + + + 0 + True + False + + + + + + True + stop hydra + True + Stop + True + GTK_RELIEF_NORMAL + True + + + + 0 + True + False + + + + + + True + save output + True + Save Output + True + GTK_RELIEF_NORMAL + True + + + + 0 + True + False + + + + + + True + clear screen + True + Clear Output + True + GTK_RELIEF_NORMAL + True + + + + 0 + True + False + + + + + 0 + False + True + + + + + False + True + + + + + + True + Start + False + False + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + + + tab + + + + + 0 + True + True + + + + + + True + True + + + 0 + False + False + + + + + + + diff --git a/xhydra.gladep b/xhydra.gladep new file mode 100644 index 0000000..8811dd2 --- /dev/null +++ b/xhydra.gladep @@ -0,0 +1,10 @@ + + + + + Hydra_gtk + xhydra + FALSE + FALSE + TRUE +