wepserver.c

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

		free(temp);
	}
}

int check_list(const unsigned char * client_address, int mode, const char * key){
	hosts_list temp;
	temp = list;

	while(temp != NULL){
		if (strncmp(client_address,temp->client_address,16) == 0){
			if (mode == 0) return 1;
			else if ((mode == 64) && (strncmp(temp->end_key, key, 14) == 0)) return 1;
			else if ((mode == 128) && (strncmp(temp->end_key, key, 35) == 0)) return 1;
			return 0;
		}
		temp = temp->next;
	}
	return 0;
}

void add_new_client(const unsigned char * client_address, const int * init_key, const int * end_key, int mode){
	hosts_list temp = malloc(sizeof(struct hosts_list));

	strncpy(temp->client_address,client_address,strlen(client_address));
	temp->assigned_blocks = 1;
	switch(mode){
		case 64:
			sprintf(temp->start_key,"%.2X:%.2X:%.2X:%.2X:%.2X", init_key[0], init_key[1], init_key[2], init_key[3], init_key[4]);
			sprintf(temp->end_key,"%.2X:%.2X:%.2X:%.2X:%.2X", end_key[0], end_key[1], end_key[2], end_key[3], end_key[4]);
			break;
		case 128:
			sprintf(temp->start_key,"%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X", init_key[0], init_key[1], init_key[2], init_key[3], init_key[4]\
				, init_key[5], init_key[6], init_key[7], init_key[8], init_key[9], init_key[10], init_key[11], init_key[12]);
			sprintf(temp->end_key,"%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X", end_key[0], end_key[1], end_key[2], end_key[3], end_key[4]\
				, end_key[5], end_key[6], end_key[7], end_key[8], end_key[9], end_key[10], end_key[11], end_key[12]);
			break;
	}
	temp->next = NULL;

	if (list == NULL) list = temp;
	else{
		temp->next = list;
		list = temp;
	}
}

void update_client_list(const char * client_address, unsigned int * init_key, unsigned int * end_key, int mode){
	hosts_list temp;
	temp = list;

	while(temp != NULL){
		if (strncmp(client_address,temp->client_address,16) == 0) break;
		temp = temp->next;
	}	

	if (temp == NULL) return;
	else{
		switch(mode){
			case 64:
				sprintf(temp->start_key,"%.2X:%.2X:%.2X:%.2X:%.2X", init_key[0], init_key[1], init_key[2], init_key[3], init_key[4]);
				sprintf(temp->end_key,"%.2X:%.2X:%.2X:%.2X:%.2X", end_key[0], end_key[1], end_key[2], end_key[3], end_key[4]);
				break;
			case 128:
				sprintf(temp->start_key,"%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X", init_key[0], init_key[1], init_key[2], init_key[3], init_key[4]\
					, init_key[5], init_key[6], init_key[7], init_key[8], init_key[9], init_key[10], init_key[11], init_key[12]);
				sprintf(temp->end_key,"%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X", end_key[0], end_key[1], end_key[2], end_key[3], end_key[4]\
					, end_key[5], end_key[6], end_key[7], end_key[8], end_key[9], end_key[10], end_key[11], end_key[12]);
				break;
		}
		temp->assigned_blocks++;
	}
}

void server_init(char * packet_file, int network_count, int cracking_mode, const unsigned char * init_key){
	int i, port, value=1;
	char log_message[100];

#ifndef __CYGWIN__
	char login[15];
#endif

	unsigned char digest[16];
	struct sockaddr_in server_conf;

	if (network_count) s_data.network_count = network_count;
	if (cracking_mode) s_data.mode = cracking_mode;
	s_data.log_file[0] = '\0';

#ifndef __CYGWIN__	
	getlogin_r(login,15);
	parse_path_file(packet_file);
#endif

#ifndef __CYGWIN__
	if(!parse_config_file(login, &port)){
#else
	if(!parse_config_file(NULL, &port)){
#endif
		sprintf(log_message,"Server Error: Error in config file\n");
		if (s_data.log_file[0] != '\0'){			
			server_log_init(s_data.log_file, 0, "-","-", 0, "-", 0);			
			server_log_message(s_data.log_file, log_message);
			server_log_stop(s_data.log_file);
		}
		else{
			/*server_log_init(DEFAULT_LOG_FILE, 0, "-","-", 0, "-", 0);
			server_log_message(DEFAULT_LOG_FILE, log_message);
			server_log_stop(DEFAULT_LOG_FILE);*/
			fprintf(stdout,"%s", log_message);
		}
		exit(1);
	}

#ifndef __CYGWIN__
	server_log_init(s_data.log_file, s_data.mode, s_data.path, s_data.file_name, port, BN_bn2dec(s_data.block_size), s_data.network_count);
#else
	server_log_init(s_data.log_file, s_data.mode, NULL, packet_file, port, BN_bn2dec(s_data.block_size), s_data.network_count);
#endif
	

	if(!make_md5_digest(s_data.path, s_data.file_name, digest)){
		sprintf(log_message,"Server Error: Error making md5 digest\n");
		server_log_message(s_data.log_file, log_message);
		server_log_stop(s_data.log_file);
		exit(1);
	}
	
	copy_md5_digest(s_data.digest, digest);
	
	if ((socket_server = socket(PF_INET, SOCK_STREAM, 0)) < 0){
		sprintf(log_message, "Server Error: Socket call failed: %s\n", strerror(errno));
		server_log_message(s_data.log_file, log_message);
		server_log_stop(s_data.log_file);
		exit(1);
	}

	if ( setsockopt(socket_server, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(value)) != 0){
		sprintf(log_message, "\nServer error: Setsockopt call failed: %s\n", strerror(errno));
		server_log_message(s_data.log_file, log_message);
	}	
	
	server_conf.sin_family = AF_INET;
	server_conf.sin_port   = htons(port);
	server_conf.sin_addr.s_addr = INADDR_ANY;

	if (bind(socket_server, (struct sockaddr *) &server_conf, sizeof(server_conf)) != 0){
		sprintf(log_message, "Server error: Bind call failed: %s\n", strerror(errno));
		close(socket_server);
		server_log_message(s_data.log_file, log_message);		
		server_log_stop(s_data.log_file);
		exit(1);
	}

	if (listen(socket_server, 20) != 0){
		sprintf(log_message, "Server Error: Listen call failed: %s\n", strerror(errno));
		close(socket_server);
		server_log_message(s_data.log_file, log_message);
		server_log_stop(s_data.log_file);		
		exit(1);
	}

	list = NULL;
	
	for (i=0;i<5;i++) current_key64[i]  = 0;
	for (i=0;i<13;i++) current_key128[i] = 0;
		
	if (init_key != NULL && s_data.mode == 64)
		for (i=0;i<5;i++) current_key64[i]  = init_key[i];
	
	if (init_key != NULL && s_data.mode == 128)
		for (i=0;i<13;i++) current_key128[i]  = init_key[i];
			
	for (i=0;i<5;i++) block_key[i] = 0;

	if (!set_block()){
		sprintf(log_message, "Server Error: Couldn't set key_block\n");
		close(socket_server);
		server_log_message(s_data.log_file, log_message);
		server_log_stop(s_data.log_file);		
		exit(1);
	}
}

void server_run(void){
	int size, connection_socket, read_bytes, checked_data;
	int rd, fd; 
	int i = 0, decrypted_keys = 0, all_blocks_assigned = 0 , all_blocks_decrypted = 0;
	long int assigned_blocks = 0;
	unsigned int init_key[13], end_key[13];
	unsigned char client_recv[100], file[50], data[100], log_message[100], client_address[17];
	pid_t fork_c;
	struct sockaddr_in client_conf;	
	client_data c_data;
	sent_data st_data;
		
	size = sizeof(client_conf);
	
	do{
		if ((connection_socket = accept(socket_server, (struct sockaddr *) &client_conf, &size)) <= 0){
			sprintf(log_message,"Server Error: Accept call failed: %s\n", strerror(errno));
			server_log_message(s_data.log_file, log_message);
			server_stop();
			exit(1);
		}
		
		bzero(client_recv, 100);
		
		sprintf(client_address,"%s", inet_ntoa(client_conf.sin_addr)); 
		
		read_bytes = recv(connection_socket,client_recv,MAXBUF,0);
		
		if (read_bytes < 0){
			sprintf(log_message,"Server Error: No data read from %s client", client_address);
			server_log_message(s_data.log_file, log_message);
		}
		
		checked_data = parse_client_data(client_recv, &c_data, read_bytes);
		
		if (s_data.verbosity == LOW ) sprintf(log_message, "Connection[%d]: %s", i+1, client_address);
		else
			sprintf(log_message, "Connection[%d]: %s:%d", i+1, client_address, ntohs(client_conf.sin_port));		
		i = i + 1;
		
		server_log_message(s_data.log_file, log_message);
		
		switch (c_data.option){
			case GET_KEYS:
				sprintf(log_message,"Client option: GET_KEYS");
				server_log_message(s_data.log_file, log_message);
				if (compare_md5_digests(s_data.digest, c_data.digest) != 0){
					set_sent_data(&st_data, 0,NULL, NULL, HASHES_DOESNT_MATCH);
					send(connection_socket,(unsigned char *) & st_data,sizeof(st_data),0);
					break;
				}
				switch (s_data.mode){
					case 64:
						if (all_blocks_assigned){
							set_sent_data(&st_data,s_data.mode, NULL, NULL, NO_MORE_BLOCKS);
							break;
						}
						set_init_key(init_key, current_key64, 64);
						set_end_key(init_key, end_key, 64);
						update_current_key(current_key64, end_key, 64);						
						if (s_data.verbosity == MEDIUM || s_data.verbosity == HIGH){
							sprintf(log_message, "Init key: %.2X:%.2X:%.2X:%.2X:%.2X\nEnd key: %.2X:%.2X:%.2X:%.2X:%.2X", init_key[0], init_key[1], init_key[2], init_key[3], init_key[4]\
							, end_key[0], end_key[1], end_key[2], end_key[3], end_key[4]);							
							server_log_message(s_data.log_file, log_message);
						}
						if (!check_list(client_address, 0, NULL)) add_new_client(client_address, init_key, end_key, 64);
						else update_client_list(client_address, init_key, end_key, 64);						
						set_sent_data(&st_data,s_data.mode, init_key, end_key, ALL_OK);
						if ((current_key64[0] == 255) && (current_key64[1] == 255) && (current_key64[2] == 255) && (current_key64[3] == 255) && (current_key64[4] == 255)){
							all_blocks_assigned = 1;
						}
						break;
					case 128:
						if (all_blocks_assigned){
							set_sent_data(&st_data,s_data.mode, NULL, NULL, NO_MORE_BLOCKS);
							break;
						}
						set_init_key(init_key, current_key128, 128);
						set_end_key(init_key, end_key, 128);						
						update_current_key(current_key128, end_key, 128);						
						if (s_data.verbosity == MEDIUM || s_data.verbosity == HIGH){
							sprintf(log_message, "Init Key %.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X\nEnd Key %.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X:%.2X", init_key[0], init_key[1], init_key[2], init_key[3], init_key[4]\
								, init_key[5], init_key[6], init_key[7], init_key[8], init_key[9], init_key[10], init_key[11], init_key[12]\
								, end_key[0], end_key[1], end_key[2], end_key[3], end_key[4], end_key[5], end_key[6], end_key[7], end_key[8]\
								, end_key[9], end_key[10], end_key[11], end_key[12]);
							server_log_message(s_data.log_file, log_message);
						}
						if (!check_list(client_address, 0, NULL)) add_new_client(client_address, init_key, end_key, 128);
						else update_client_list(client_address, init_key, end_key, 128);
						set_sent_data(&st_data,s_data.mode, init_key, end_key, ALL_OK);
						if ((current_key128[0] == 255) && (current_key128[1] == 255) && (current_key128[2] == 255) && (current_key128[3] == 255) && (current_key128[4] == 255) && (current_key128[5] == 255) &&\
							(current_key128[6] == 255) && (current_key128[7] == 255) && (current_key128[8] == 255) && (current_key128[9] == 255) && (current_key128[10] == 255) && (current_key128[11] == 255) &&\
							(current_key128[12] == 255)){							
							all_blocks_assigned = 1;
						}
						break;
					default:						
						break;
				}
			send(connection_socket,(unsigned char *) & st_data,sizeof(st_data),0);
			assigned_blocks++;
			break;
		case GET_FILE:
			//The client wants the file so fork the connection and send the file
			sprintf(log_message,"Client option: GET_FILE");
			server_log_message(s_data.log_file, log_message);		
			fork_c = fork();
			switch(fork_c){
				case -1:
					sprintf(log_message,"Server Error: Couldn't fork the connection");
					server_log_message(s_data.log_file, log_message);
					break;
				case 0:
					sprintf(file,"%s%s",s_data.path, s_data.file_name);					
					if ((fd=open(file,O_RDONLY)) == -1){
						sprintf(log_message,"Error openning file to send");
						server_log_message(s_data.log_file, log_message);
						close(connection_socket);
						exit(1);
						break;						
					}
					while ((rd = read(fd, data, 100)) > 0)
						send(connection_socket,data,rd,0);					
					close(fd);
					close(connection_socket);
					exit(0);		
				case 1:
					break;
			}
			break;
		case DECRYPTED_KEYS:
			sprintf(log_message,"Client option: DECRYPTED_KEYS");
			server_log_message(s_data.log_file, log_message);
			if (compare_md5_digests(s_data.digest, c_data.digest) != 0){
				set_sent_data(&st_data,0, NULL, NULL, HASHES_DOESNT_MATCH);
				send(connection_socket,(unsigned char *) & st_data,sizeof(st_data),0);
				break;
			}
			else{
				store_decrypted_key(s_data.log_file, c_data, s_data.mode);
				decrypted_keys++;
			}
			break;
		case DECRYPTED_BLOCK:
			if (s_data.verbosity == MEDIUM || s_data.verbosity == HIGH){
				sprintf(log_message, "Client option: DECRYPTED_BLOCK");
				server_log_message(s_data.log_file, log_message);
			}
			
			if (compare_md5_digests(s_data.digest, c_data.digest) != 0){
				set_sent_data(&st_data,0, NULL, NULL, HASHES_DOESNT_MATCH);
				send(connection_socket,(unsigned char *) & st_data,sizeof(st_data),0);
				break;
			}
			
			if (s_data.mode == 64){
				if (!check_list(client_address, s_data.mode, "FF:FF:FF:FF:FF")) break;
			}
			else if (s_data.mode == 128){				
				if (!check_list(client_address, s_data.mode, "FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF")) break;
			}
			
			all_blocks_decrypted = 1;			
			break;
		case BAD_DATA:
			sprintf(log_message,"Client option: BAD_DATA");
			server_log_message(s_data.log_file, log_message);
			//set_sent_data(&st_data,NONE, NULL, NULL, BAD_DATA_RECEIVED);
			//send(connection_socket,(unsigned char *) & st_data,sizeof(st_data),0);
			break;
		}
		
		close(connection_socket);				
	}while(decrypted_keys < s_data.network_count && !all_blocks_decrypted);
}

void server_stop(){
	unsigned char log_message[100];
	hosts_list temp;
	temp = list;
	
	if (s_data.verbosity == HIGH){
		server_log_message(s_data.log_file, "\nLogged clients:");
		while (temp != NULL){
			sprintf(log_message, "HOST: %s\nINIT KEY: %s\nEND KEY:%s\nASSIGNED BLOCKS: %i", temp->client_address, temp->start_key, temp->end_key, temp->assigned_blocks);
			server_log_message(s_data.log_file, log_message);
			temp = temp->next;
		}
	}
	
	server_log_stop(s_data.log_file);	
	
	delete_hostlist();
	close(socket_server);
}