gwepdecrypt.cpp

About WepDecrypt: Wepdecrypt is a Wireless LAN Tool written in c which guesses WEP Keys based o

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>

#include <FL/Fl.H>
#include <FL/Fl_Window.H>
#include <FL/Fl_Box.H>
#include <FL/Fl_Input.H>
#include <FL/Fl_Button.H>
#include <FL/Fl_Output.H>
#include <FL/Fl_Menu_Item.H>
#include <FL/Fl_Menu_Bar.H>
#include <FL/Fl_Check_Button.H>
#include <FL/Fl_Multiline_Output.H>
#include <FL/Fl_Text_Display.H>
#include <FL/Fl_Text_Buffer.H>
#include <FL/Fl_File_Chooser.H>
#include <FL/Fl_Choice.H>

#ifdef __CYGWIN__
#include <sys/cygwin.h>
#endif

#define TAM_SIZE 1024

#define VERSION "0.3"

class MainWindow {
   public:
     MainWindow();
     ~MainWindow();
   
   	 pid_t child_pid;
   
     int pipefd[2];	    
   
   	 Fl_Window *window;
     Fl_Menu_Bar *menu;
   
     Fl_Text_Display *output_window;
     Fl_Text_Buffer  *output_buffer;
     
     Fl_Input            *dumpfile_input;
     Fl_Input            *wordfile_input;
     Fl_Input            *mac_input;     
     Fl_Input            *firstkey_input;
     Fl_Input            *lastkey_input;
     Fl_Input            *server_data_input;
   
     Fl_Choice           *mode_input;
     Fl_Choice           *num_net_input;
	 Fl_Choice           *generator_mode_input;
	 Fl_Choice           *blocks_to_decrypt_input;
   
     Fl_Button			 *start;
     Fl_Button			 *stop;
   
     Fl_Check_Button     *wordfile_button;
     Fl_Check_Button     *mac_button;
     Fl_Check_Button     *mode_button;
     Fl_Check_Button     *client_button;
     Fl_Check_Button     *num_net_button;
	 Fl_Check_Button     *generator_mode_button;
	 Fl_Check_Button     *blocks_to_decrypt_button;	 
};

class LogFile{
	public:
		char directory[75];
		LogFile();
		~LogFile();
};

int show_about = 0;
int size = 0;

MainWindow::MainWindow(){
	
	window = new Fl_Window(350,460);
    menu = new Fl_Menu_Bar(0, 0, 350, 20);
	
	dumpfile_input = new Fl_Input(10, 30, 330, 20, NULL);
	dumpfile_input->value("Dump File");		
	
	wordfile_button = new Fl_Check_Button(10, 60, 20, 20, NULL);
	wordfile_button->type(FL_TOGGLE_BUTTON);
	wordfile_input = new Fl_Input(30, 60, 310, 20, NULL);
	wordfile_input->value("Word File");
	
	mac_button = new Fl_Check_Button(10, 90, 20, 20, NULL);
	mac_button->type(FL_TOGGLE_BUTTON);
	mac_input = new Fl_Input(30, 90, 190, 20, NULL);
	mac_input->value("Mac Filter");	
	
	mode_button = new Fl_Check_Button(230, 90, 20, 20, NULL);
	mode_button->type(FL_TOGGLE_BUTTON);
	mode_input = new Fl_Choice(250, 90, 90, 20, NULL);
	
	Fl_Menu_Item mode_menu[] = {
	    { "Mode", 0, 0, 0, 0 },
		{ "nall", 0, 0, 0, 0 },
		{ "n128", 0, 0, 0, 0 },
		{ "n64", 0, 0, 0, 0 },
		{ "128", 0, 0, 0, 0 },
		{ "64", 0, 0, 0, 0 },
	    { 0 },	
  	};
	
	mode_input->copy(mode_menu);
	
	client_button = new Fl_Check_Button(10, 120, 20, 20, NULL);
	client_button->type(FL_TOGGLE_BUTTON);
	server_data_input = new Fl_Input(30, 120, 190, 20, NULL);
	server_data_input->value("Client Mode");
	
	blocks_to_decrypt_button = new Fl_Check_Button(230, 120, 20, 20);
	blocks_to_decrypt_input  = new Fl_Choice(250, 120, 90, 20);
	
	Fl_Menu_Item blocks_to_decrypt_menu[] = {
	    { "Num Blocks", 0, 0, 0, 0 },
		{ "0", 0, 0, 0, 0 },
		{ "1", 0, 0, 0, 0 },
		{ "2", 0, 0, 0, 0 },
		{ "3", 0, 0, 0, 0 },
		{ "4", 0, 0, 0, 0 },
		{ "5", 0, 0, 0, 0 },
		{ "6", 0, 0, 0, 0 },
		{ "7", 0, 0, 0, 0 },
		{ "8", 0, 0, 0, 0 },
		{ "9", 0, 0, 0, 0 },
	    { 0 },	
  	};
	
	blocks_to_decrypt_input->copy(blocks_to_decrypt_menu);
	
	generator_mode_button = new Fl_Check_Button(10, 150, 20, 20, NULL);
	generator_mode_input  = new Fl_Choice(30, 150, 190, 20, NULL);
	
	Fl_Menu_Item generator_mode_menu[] = {
	    { "Generator mode", 0, 0, 0, 0 },
		{ "all", 0, 0, 0, 0 },
		{ "alpha", 0, 0, 0, 0 },
		{ "alphanumeric", 0, 0, 0, 0 },
		{ "numeric", 0, 0, 0, 0 },
		{ "random", 0, 0, 0, 0 },
		{ "printable", 0, 0, 0, 0 },
	    { 0 },	
  	};
	
	generator_mode_input->copy(generator_mode_menu);
	
    num_net_button = new Fl_Check_Button(230, 150, 20, 20, NULL);
	num_net_button->type(FL_TOGGLE_BUTTON);
	num_net_input = new Fl_Choice(250, 150, 90, 20, NULL);
	
	Fl_Menu_Item num_net_menu[] = {
	    { "Num Net", 0, 0, 0, 0 },
		{ "1", 0, 0, 0, 0 },
		{ "2", 0, 0, 0, 0 },
		{ "3", 0, 0, 0, 0 },
		{ "4", 0, 0, 0, 0 },
		{ "5", 0, 0, 0, 0 },
		{ "6", 0, 0, 0, 0 },
		{ "7", 0, 0, 0, 0 },
		{ "8", 0, 0, 0, 0 },
		{ "9", 0, 0, 0, 0 },
		{ "10", 0, 0, 0, 0 },
	    { 0 },	
  	};
	
	num_net_input->copy(num_net_menu);
	
	firstkey_input = new Fl_Input(10, 180, 150, 20, NULL);
	firstkey_input->value("First Key");	
	
	lastkey_input = new Fl_Input(175, 180, 165, 20, NULL);
	lastkey_input->value("Last Key");
	
	output_window = new Fl_Text_Display(10, 210, 330, 200, NULL);
	output_buffer = new Fl_Text_Buffer(10);
	output_window->buffer(output_buffer);
	output_window->hide_cursor();	
	output_buffer->append("- WepDecrypt Gui -\n");
		
	start = new Fl_Button(70, 420, 80, 30, "START");
	start->shortcut(FL_Enter);
	stop = new Fl_Button(195, 420, 80, 30, "STOP");
	stop->shortcut('q');
	
	child_pid = 0;
	
	Fl::focus(start);
	
}

MainWindow::~MainWindow(){
}

LogFile::LogFile(){
	directory[0] = '\0';
}

LogFile::~LogFile(){
}

void exit_cb(Fl_Widget * , void * );
void load_dumpfile_cb(Fl_Widget *, void * );
void load_wordfile_cb(Fl_Widget *, void * );
void fd_ready(int , void *);
void start_cb(Fl_Widget * , void * );
void stop_cb(Fl_Widget * , void * );

#ifndef __CYGWIN__
void about_cb(Fl_Widget *, void * );
void close_about_window_cb(Fl_Widget * v , void * );
#endif

void version_cb(Fl_Widget *, void * );
void help_cb(Fl_Widget *, void * );
void sigchld(int);
void set_log_options(LogFile *, MainWindow *);
void set_log_dir(Fl_Widget *, void *);
int manage_config_file(int , int *, char *, int *, char *, char *);


int main(int argc, char **argv) {
  MainWindow win;
  LogFile log;
	
  signal(SIGCHLD, sigchld);
	
  win.window->label("GWepDecrypt");
	
  Fl_Menu_Item menuitems[] = {
	    { "&File", 0, 0, 0, FL_SUBMENU },
		{ "Open &DumpFile", FL_CTRL + 'd', (Fl_Callback *)load_dumpfile_cb, (void *) &win, 0 },
		{ "Open &WordFile", FL_CTRL + 'w', (Fl_Callback *)load_wordfile_cb, (void *) &win, 0 },
		{ "Set &Log Dir", FL_CTRL + 'l', (Fl_Callback *)set_log_dir, (void *) &log, 0},
	    { "&Quit", FL_CTRL + 'q', (Fl_Callback *)exit_cb, (void *) &win, 0 },
	    { 0 },
		{ "&Help", 0, 0, 0, FL_SUBMENU },
#ifndef __CYGWIN__
		{ "&About", FL_CTRL + 'a', (Fl_Callback *)about_cb, 0, 0 },
#endif
		{ "&Help", FL_CTRL + 'h', (Fl_Callback *)help_cb, (void *) &win, 0 },
		{ "&Version", FL_CTRL + 'v', (Fl_Callback *)version_cb, (void *) &win, 0 },
		{ 0 },
      {0}
  };
  
  win.menu->copy(menuitems);
  win.window->end();
  
  set_log_options(&log, &win);  
  chdir(log.directory);  
  
  win.start->callback(start_cb, (void *) &win);
  win.stop->callback(stop_cb, (void *) &win);
  
  win.window->show(argc, argv);
  return Fl::run();
}

void exit_cb(Fl_Widget * , void * w){
	MainWindow * win = (MainWindow *) w;
	
	if (win->child_pid){
		kill(win->child_pid, SIGINT);
	}
	
	exit(0);
}

void load_dumpfile_cb(Fl_Widget *, void * v){	
	char * file_name;
#ifdef __CYGWIN__
	char win_file_name[100];
#endif
	MainWindow * win = (MainWindow *) v;
	
	file_name = fl_file_chooser("Choose a Dump File", NULL, NULL, 0);

#ifndef __CYGWIN__	
	if (file_name != NULL) win->dumpfile_input->value(file_name);
#else
	if (file_name != NULL){
		cygwin_conv_to_win32_path(file_name, win_file_name);
		win->dumpfile_input->value(win_file_name);
	}
#endif
	
}

void load_wordfile_cb(Fl_Widget *, void * v){	
	char * file_name;
#ifdef __CYGWIN__
	char win_file_name[100];
#endif

	MainWindow * win = (MainWindow *) v;
	
	file_name = fl_file_chooser("Choose a Word File", NULL, NULL, 0);
	
	if (file_name != NULL){
		win->wordfile_button->set();

#ifndef __CYGWIN__
		win->wordfile_input->value(file_name);
#else
		cygwin_conv_to_win32_path(file_name, win_file_name);
		win->wordfile_input->value(win_file_name);
#endif

	}
}

void fd_ready(int fd, void *data) {
	int bytes, pos = 0, erase_last_line = 0, i;
	static int erase_first_line=0;
	char string[TAM_SIZE+1], * aux_string;
	MainWindow * win = (MainWindow *) data;
	
	bytes = read(fd, string, TAM_SIZE);
	string[bytes] = '\0';
	aux_string = string;
	
	if (!bytes){
		win->child_pid = size = 0;
		Fl::remove_fd(STDIN_FILENO);
		return;
	}
	
	if (erase_first_line){
		erase_first_line = 0;
		while(string[pos] != '\n' && string[pos] != '\0') pos++;

#ifndef __CYGWIN__
		if (size < 7) aux_string = &string[pos];
		else aux_string = &string[++pos];
#else
		if (size != 8) aux_string = &string[pos];
		else aux_string = &string[++pos];
#endif

	}
	
	if (size == 8){
		win->output_buffer->remove(0, win->output_buffer->length());
		size = 0;
		if (string[bytes-1] != '\n'){
			erase_last_line = 1;
			erase_first_line = 1;
		}
#ifdef __CYGWIN__
		win->output_buffer->append(aux_string);
		
		if (erase_last_line){
			win->output_buffer->findchar_backward(win->output_buffer->length(), '\n', &pos);
			win->output_buffer->remove(pos, win->output_buffer->length());
		}
		
		return;
#endif
	}
	
#ifndef __CYGWIN__
	if (bytes == TAM_SIZE && (size == 7 || size == 3)){
		if (string[bytes-1] != '\n'){
			erase_last_line = 1;
			erase_first_line = 1;
		}
	}
#else
	if (string[bytes-1] != '\n'){
		erase_last_line = 1;
		erase_first_line = 1;
	}
#endif
		
	win->output_buffer->append(aux_string);
	
	if (erase_last_line){
		win->output_buffer->findchar_backward(win->output_buffer->length(), '\n', &pos);
		win->output_buffer->remove(pos, win->output_buffer->length());
	}
	
	size++;
}
	

void start_cb(Fl_Widget * , void * v){
	int i=0,j=0, test_file;
	char * command[10], server_data[30];
	MainWindow * Win = (MainWindow *) v;
	
	if (Win->child_pid) return;
	
	for (i=0;i<10;i++){
		command[i] = new char[100];		
	}	
	
	i=0;
	
	Win->output_buffer->remove(0, Win->output_buffer->length());
	Win->output_buffer->append("- WepDecrypt Gui -\n");
	
	if (strncmp(Win->dumpfile_input->value(), "Dump File", 9) != 0){
		if (!Win->dumpfile_input->size()){
			Win->output_buffer->append("\nDump File can't be empty");			
			return;
		}
		//fprintf(stdout, "wepdecrypt -f %s ", Win->dumpfile_input->value());
		sprintf(command[i], "wepdecrypt"); i++;
		sprintf(command[i], "-f%s", Win->dumpfile_input->value());
		i++;
	}
	else{
		Win->output_buffer->append("\nYou must supply a Dump File");
		return;
	}
	
	if (Win->wordfile_button->value()){
		if (!Win->wordfile_input->size()){
			Win->output_buffer->append("\nWord File can't be empty");
			return;
		}
		if (!strncmp(Win->wordfile_input->value(), "Word File", 9)){
			Win->output_buffer->append("\nYou must supply a Word File");
			return;
		}			
		//fprintf(stdout, "-w %s ", Win->wordfile_input->value());
		sprintf(command[i], "-w%s", Win->wordfile_input->value());
		i++;
	}
	
	if (Win->mode_button->value()){
		if (!Win->mode_input->value()){
			Win->output_buffer->append("\nYou must supply a Crack Mode");
			return;
		}
		if (Win->mode_input->value() == 1 || Win->mode_input->value() == 2 || Win->mode_input->value() == 3){
			if (!Win->wordfile_button->value()){
				Win->output_buffer->append("\nYou must supply a Word File with nmodes");
				return;
			}
		}
		switch (Win->mode_input->value()){
			case 1:
				//fprintf(stdout, "-m nall ");
				sprintf(command[i], "-mnall");
				break;
			case 2:
				//fprintf(stdout, "-m n128 ");
				sprintf(command[i], "-mn128");
				break;
			case 3:
				//fprintf(stdout, "-m n64 ");
				sprintf(command[i], "-mn64");
				break;
			case 4:
				//fprintf(stdout, "-m 128 ");
				sprintf(command[i], "-m128");
				break;
			case 5:
				//fprintf(stdout, "-m 64 ");
				sprintf(command[i], "-m64");
				break;		
		}
		i++;
	}
	
	else if(!Win->client_button->value()){