2006-08-16 18:01:25 +00:00
/* airpcap_gui_utils.c
*
2006-08-21 19:22:33 +00:00
* Giorgio Tino < giorgio . tino @ cacetech . com >
* Copyright ( c ) CACE Technologies , LLC 2006
2006-08-16 18:01:25 +00:00
*
* Wireshark - Network traffic analyzer
* By Gerald Combs < gerald @ wireshark . org >
* Copyright 2000 Gerald Combs
*
* This program is free software ; you can redistribute it and / or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation ; either version 2
* of the License , or ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program ; if not , write to the Free Software
2012-06-28 22:56:06 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA .
2006-08-16 18:01:25 +00:00
*/
2012-09-20 01:48:30 +00:00
# include "config.h"
2006-08-16 18:01:25 +00:00
# include <gtk/gtk.h>
# include <glib.h>
2009-08-27 04:47:28 +00:00
# include <stdio.h>
2013-11-10 15:59:37 +00:00
# include <stdlib.h>
2006-08-16 18:01:25 +00:00
# include <string.h>
2013-11-17 02:55:14 +00:00
# include <wsutil/filesystem.h>
2015-06-11 22:05:44 +00:00
# include <wsutil/frequency-utils.h>
# include <epan/prefs.h>
# include <epan/prefs-int.h>
# include <epan/uat-int.h>
2007-01-11 22:12:33 +00:00
# include <epan/strutil.h>
2018-02-23 17:43:29 +00:00
# include <epan/crypt/dot11decrypt_ws.h>
2015-06-11 22:05:44 +00:00
# include <epan/crypt/wep-wpadefs.h>
# include <epan/packet.h>
# include <epan/dissectors/packet-ieee80211.h>
2006-08-16 18:01:25 +00:00
2015-06-11 22:05:44 +00:00
# include "ui/capture_ui_utils.h"
2012-01-16 01:07:52 +00:00
# include "ui/simple_dialog.h"
2008-04-13 00:55:59 +00:00
2012-01-15 21:59:11 +00:00
# include "ui/gtk/main.h"
# include "ui/gtk/dlg_utils.h"
# include "ui/gtk/gui_utils.h"
# include "ui/gtk/dfilter_expr_dlg.h"
# include "ui/gtk/help_dlg.h"
# include "ui/gtk/keys.h"
# include "ui/gtk/old-gtk-compat.h"
2006-08-16 18:01:25 +00:00
2014-08-01 00:29:36 +00:00
# include <caputils/airpcap.h>
# include <caputils/airpcap_loader.h>
2006-08-16 18:01:25 +00:00
# include "airpcap_gui_utils.h"
2007-05-18 21:06:20 +00:00
/* Controls the releay of settings back to the adapter. */
gboolean change_airpcap_settings = FALSE ;
2015-06-11 22:05:44 +00:00
/* WLAN preferences pointer */
module_t * wlan_prefs = NULL ;
2006-08-16 18:01:25 +00:00
/*
* Set up the airpcap toolbar for the new capture interface
*/
void
airpcap_set_toolbar_start_capture ( airpcap_if_info_t * if_info )
{
2007-01-11 22:12:33 +00:00
GtkWidget * airpcap_toolbar_label ;
2009-05-13 16:14:28 +00:00
GtkWidget * toolbar_channel_cb ;
2007-01-11 22:12:33 +00:00
GtkWidget * airpcap_toolbar_channel_lb ;
2007-05-18 21:06:20 +00:00
GtkWidget * airpcap_toolbar_channel_offset ;
GtkWidget * airpcap_toolbar_channel_offset_lb ;
2007-01-11 22:12:33 +00:00
GtkWidget * airpcap_toolbar_button ;
GtkWidget * airpcap_toolbar_fcs ;
GtkWidget * airpcap_toolbar_fcs_lb ;
GtkWidget * airpcap_toolbar_decryption ;
GtkWidget * airpcap_toolbar_decryption_lb ;
GtkWidget * airpcap_toolbar_keys_button ;
gchar * if_label_text ;
2013-03-08 22:10:06 +00:00
airpcap_toolbar_label = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_INTERFACE_KEY ) ;
toolbar_channel_cb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_CHANNEL_KEY ) ;
airpcap_toolbar_channel_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY ) ;
airpcap_toolbar_channel_offset = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY ) ;
airpcap_toolbar_channel_offset_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY ) ;
airpcap_toolbar_fcs = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_FCS_FILTER_KEY ) ;
airpcap_toolbar_fcs_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY ) ;
airpcap_toolbar_button = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_ADVANCED_KEY ) ;
airpcap_toolbar_decryption = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_DECRYPTION_KEY ) ;
airpcap_toolbar_decryption_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY ) ;
airpcap_toolbar_keys_button = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_KEY_MANAGEMENT_KEY ) ;
2007-01-11 22:12:33 +00:00
/* The current interface is an airpcap interface */
2013-02-25 23:35:13 +00:00
if ( if_info ! = NULL )
2007-01-11 22:12:33 +00:00
{
2012-06-19 14:37:46 +00:00
gtk_widget_set_sensitive ( wireless_tb , TRUE ) ;
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( airpcap_toolbar_label , TRUE ) ;
gtk_widget_set_sensitive ( toolbar_channel_cb , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_lb , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_offset , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_offset_lb , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_fcs , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_fcs_lb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_button , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_button , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_decryption , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_decryption_lb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_keys_button , FALSE ) ;
/*decryption check box*/
2012-06-19 14:37:46 +00:00
g_signal_handlers_block_by_func ( airpcap_toolbar_decryption , airpcap_toolbar_encryption_cb , wireless_tb ) ;
2013-02-25 23:35:13 +00:00
if ( if_info - > DecryptionOn = = AIRPCAP_DECRYPTION_ON )
2010-11-28 00:41:47 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( airpcap_toolbar_decryption ) , TRUE ) ;
else
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( airpcap_toolbar_decryption ) , FALSE ) ;
2012-06-19 14:37:46 +00:00
g_signal_handlers_unblock_by_func ( airpcap_toolbar_decryption , airpcap_toolbar_encryption_cb , wireless_tb ) ;
2010-11-28 00:41:47 +00:00
if_label_text = g_strdup_printf ( " Current Wireless Interface: #%s " , airpcap_get_if_string_number ( if_info ) ) ;
gtk_label_set_text ( GTK_LABEL ( airpcap_toolbar_label ) , if_label_text ) ;
g_free ( if_label_text ) ;
change_airpcap_settings = FALSE ;
2013-02-25 23:35:13 +00:00
if ( if_info - > pSupportedChannels ! = NULL & & if_info - > numSupportedChannels > 0 ) {
2010-11-28 00:41:47 +00:00
guint i = 0 ;
2013-02-25 23:35:13 +00:00
for ( ; i < if_info - > numSupportedChannels ; i + + ) {
2011-07-24 15:22:21 +00:00
gtk_combo_box_text_append_text ( GTK_COMBO_BOX_TEXT ( toolbar_channel_cb ) , ieee80211_mhz_to_str ( if_info - > pSupportedChannels [ i ] . Frequency ) ) ;
2010-11-28 00:41:47 +00:00
}
}
airpcap_update_channel_combo ( GTK_WIDGET ( toolbar_channel_cb ) , if_info ) ;
airpcap_update_channel_offset_combo ( if_info , if_info - > channelInfo . Frequency , airpcap_toolbar_channel_offset , TRUE ) ;
change_airpcap_settings = TRUE ;
2007-01-11 22:12:33 +00:00
}
else /* Current interface is NOT an AirPcap one... */
{
2012-06-19 14:37:46 +00:00
gtk_widget_set_sensitive ( wireless_tb , FALSE ) ;
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( airpcap_toolbar_label , FALSE ) ;
gtk_widget_set_sensitive ( toolbar_channel_cb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_lb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_offset , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_offset_lb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_fcs , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_fcs_lb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_button , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_button , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_decryption , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_decryption_lb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_keys_button , FALSE ) ;
2007-01-11 22:12:33 +00:00
}
2006-08-16 18:01:25 +00:00
}
/*
* Set up the airpcap toolbar for the new capture interface
*/
void
airpcap_set_toolbar_stop_capture ( airpcap_if_info_t * if_info )
{
2007-01-11 22:12:33 +00:00
GtkWidget * airpcap_toolbar_crc_filter_combo ;
GtkWidget * airpcap_toolbar_label ;
2009-05-13 16:14:28 +00:00
GtkWidget * toolbar_channel_cb ;
2007-01-11 22:12:33 +00:00
GtkWidget * airpcap_toolbar_channel_lb ;
2007-05-18 21:06:20 +00:00
GtkWidget * airpcap_toolbar_channel_offset ;
GtkWidget * airpcap_toolbar_channel_offset_lb ;
2007-01-11 22:12:33 +00:00
GtkWidget * airpcap_toolbar_button ;
GtkWidget * airpcap_toolbar_fcs ;
GtkWidget * airpcap_toolbar_fcs_lb ;
GtkWidget * airpcap_toolbar_decryption ;
GtkWidget * airpcap_toolbar_decryption_lb ;
GtkWidget * airpcap_toolbar_keys_button ;
gchar * if_label_text ;
2013-03-08 22:10:06 +00:00
airpcap_toolbar_crc_filter_combo = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_FCS_FILTER_KEY ) ;
airpcap_toolbar_label = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_INTERFACE_KEY ) ;
toolbar_channel_cb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_CHANNEL_KEY ) ;
airpcap_toolbar_channel_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY ) ;
airpcap_toolbar_channel_offset = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY ) ;
airpcap_toolbar_channel_offset_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY ) ;
airpcap_toolbar_fcs = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_FCS_FILTER_KEY ) ;
airpcap_toolbar_fcs_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY ) ;
airpcap_toolbar_button = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_ADVANCED_KEY ) ;
airpcap_toolbar_decryption = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_DECRYPTION_KEY ) ;
airpcap_toolbar_decryption_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY ) ;
airpcap_toolbar_keys_button = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( wireless_tb ) , AIRPCAP_TOOLBAR_KEY_MANAGEMENT_KEY ) ;
2007-01-11 22:12:33 +00:00
/* The current interface is an airpcap interface */
2013-02-25 23:35:13 +00:00
if ( if_info ! = NULL )
2007-01-11 22:12:33 +00:00
{
2012-06-19 14:37:46 +00:00
gtk_widget_set_sensitive ( wireless_tb , TRUE ) ;
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( airpcap_toolbar_label , TRUE ) ;
gtk_widget_set_sensitive ( toolbar_channel_cb , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_lb , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_offset , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_offset_lb , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_fcs , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_fcs_lb , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_button , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_crc_filter_combo , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_decryption , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_decryption_lb , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_keys_button , TRUE ) ;
airpcap_validation_type_combo_set_by_type ( airpcap_toolbar_crc_filter_combo , if_info - > CrcValidationOn ) ;
/*decription check box*/
2012-06-19 14:37:46 +00:00
g_signal_handlers_block_by_func ( airpcap_toolbar_decryption , airpcap_toolbar_encryption_cb , wireless_tb ) ;
2013-02-25 23:35:13 +00:00
if ( if_info - > DecryptionOn = = AIRPCAP_DECRYPTION_ON )
2010-11-28 00:41:47 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( airpcap_toolbar_decryption ) , TRUE ) ;
else
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( airpcap_toolbar_decryption ) , FALSE ) ;
2012-06-19 14:37:46 +00:00
g_signal_handlers_unblock_by_func ( airpcap_toolbar_decryption , airpcap_toolbar_encryption_cb , wireless_tb ) ;
2010-11-28 00:41:47 +00:00
if_label_text = g_strdup_printf ( " Current Wireless Interface: #%s " , airpcap_get_if_string_number ( if_info ) ) ;
gtk_label_set_text ( GTK_LABEL ( airpcap_toolbar_label ) , if_label_text ) ;
g_free ( if_label_text ) ;
change_airpcap_settings = FALSE ;
2013-02-25 23:35:13 +00:00
if ( if_info - > pSupportedChannels ! = NULL & & if_info - > numSupportedChannels > 0 ) {
2010-11-28 00:41:47 +00:00
guint i = 0 ;
2013-02-25 23:35:13 +00:00
for ( ; i < if_info - > numSupportedChannels ; i + + ) {
2011-07-24 15:22:21 +00:00
gtk_combo_box_text_append_text ( GTK_COMBO_BOX_TEXT ( toolbar_channel_cb ) , ieee80211_mhz_to_str ( if_info - > pSupportedChannels [ i ] . Frequency ) ) ;
2010-11-28 00:41:47 +00:00
}
}
airpcap_update_channel_combo ( GTK_WIDGET ( toolbar_channel_cb ) , if_info ) ;
airpcap_update_channel_offset_combo ( if_info , if_info - > channelInfo . Frequency , airpcap_toolbar_channel_offset , TRUE ) ;
change_airpcap_settings = TRUE ;
}
2007-01-11 22:12:33 +00:00
else
{
2012-06-19 14:37:46 +00:00
gtk_widget_set_sensitive ( wireless_tb , TRUE ) ;
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( airpcap_toolbar_label , FALSE ) ;
gtk_widget_set_sensitive ( toolbar_channel_cb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_lb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_offset , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_channel_offset_lb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_fcs , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_fcs_lb , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_button , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_crc_filter_combo , FALSE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_decryption , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_decryption_lb , TRUE ) ;
gtk_widget_set_sensitive ( airpcap_toolbar_keys_button , TRUE ) ;
change_airpcap_settings = FALSE ;
2007-01-11 22:12:33 +00:00
}
2006-08-16 18:01:25 +00:00
}
2015-06-11 22:05:44 +00:00
#if 0
/* Returs TRUE if the WEP key is valid, false otherwise */
gboolean
wep_key_is_valid ( char * key )
{
size_t strsize , i ;
if ( key = = NULL )
return FALSE ;
strsize = strlen ( key ) ;
if ( ( strsize > WEP_KEY_MAX_CHAR_SIZE ) | | ( strsize < 2 ) )
{
return FALSE ;
}
if ( ( strsize % 2 ) ! = 0 )
{
return FALSE ;
}
for ( i = 0 ; i < strsize ; i + + )
{
if ( ! g_ascii_isxdigit ( key [ i ] ) )
{
return FALSE ;
}
}
return TRUE ;
}
# endif
/*
* Callback used by the load_wlan_keys ( ) routine in order to read a WEP decryption key
*/
static guint
get_wep_key ( pref_t * pref , gpointer ud )
{
gchar * key_string = NULL ;
2018-02-23 17:43:29 +00:00
guint8 key_type = DOT11DECRYPT_KEY_TYPE_WEP ;
2015-06-11 22:05:44 +00:00
keys_cb_data_t * user_data ;
uat_t * uat ;
guint i ;
char * err = NULL ;
uat_wep_key_record_t * wep_keys ;
decryption_key_t * new_key ;
/* Retrieve user data info */
user_data = ( keys_cb_data_t * ) ud ;
2017-01-07 13:52:23 +00:00
if ( g_ascii_strcasecmp ( prefs_get_name ( pref ) , " wep_key_table " ) = = 0 & & prefs_get_type ( pref ) = = PREF_UAT )
2015-06-11 22:05:44 +00:00
{
2017-01-07 13:52:23 +00:00
uat = prefs_get_uat_value ( pref ) ;
2015-06-11 22:05:44 +00:00
/* This is just a sanity check. UAT should be loaded */
if ( ! uat - > loaded )
{
if ( ! uat_load ( uat , & err ) )
{
/* XXX - report the error */
g_free ( err ) ;
return 1 ;
}
}
for ( i = 0 , wep_keys = ( uat_wep_key_record_t * ) * uat - > user_ptr ; i < * uat - > nrows_p ; i + + , wep_keys + + )
{
/* strip out key type if present */
if ( g_ascii_strncasecmp ( wep_keys - > string , STRING_KEY_TYPE_WEP " : " , 4 ) = = 0 ) {
2018-02-23 17:43:29 +00:00
key_type = DOT11DECRYPT_KEY_TYPE_WEP ;
2015-06-11 22:05:44 +00:00
key_string = ( gchar * ) wep_keys - > string + 4 ;
}
else if ( g_ascii_strncasecmp ( wep_keys - > string , STRING_KEY_TYPE_WPA_PWD " : " , 8 ) = = 0 ) {
key_string = ( gchar * ) wep_keys - > string + 8 ;
2018-02-23 17:43:29 +00:00
key_type = DOT11DECRYPT_KEY_TYPE_WPA_PWD ;
2015-06-11 22:05:44 +00:00
}
else if ( g_ascii_strncasecmp ( wep_keys - > string , STRING_KEY_TYPE_WPA_PSK " : " , 8 ) = = 0 ) {
key_string = ( gchar * ) wep_keys - > string + 8 ;
2018-02-23 17:43:29 +00:00
key_type = DOT11DECRYPT_KEY_TYPE_WPA_PSK ;
2015-06-11 22:05:44 +00:00
}
else {
key_type = wep_keys - > key ;
key_string = ( gchar * ) wep_keys - > string ;
}
/* Here we have the string describing the key... */
new_key = parse_key_string ( key_string , key_type ) ;
if ( new_key ! = NULL )
{
/* Key is added only if not null ... */
user_data - > list = g_list_append ( user_data - > list , new_key ) ;
user_data - > number_of_keys + + ;
user_data - > current_index + + ;
}
}
}
return 0 ;
}
/* Callback used by the save_wlan_keys() routine in order to write a decryption key */
static guint
set_wep_key ( pref_t * pref , gpointer ud _U_ )
{
keys_cb_data_t * user_data ;
uat_t * uat ;
gint i ;
char * err = NULL ;
uat_wep_key_record_t uat_key ;
decryption_key_t * new_key ;
/* Retrieve user data info */
user_data = ( keys_cb_data_t * ) ud ;
2017-01-07 13:52:23 +00:00
if ( g_ascii_strcasecmp ( prefs_get_name ( pref ) , " wep_key_table " ) = = 0 & & prefs_get_type ( pref ) = = PREF_UAT )
2015-06-11 22:05:44 +00:00
{
2017-01-07 13:52:23 +00:00
uat = prefs_get_uat_value ( pref ) ;
2015-06-11 22:05:44 +00:00
if ( ! uat - > loaded )
{
/* UAT will only be loaded if previous keys exist, so it may need
to be loaded now */
if ( ! uat_load ( uat , & err ) )
{
/* XXX - report the error */
g_free ( err ) ;
return 1 ;
}
uat - > loaded = 1 ;
}
/* Free the old records */
uat_clear ( uat ) ;
for ( i = 0 ; i < user_data - > number_of_keys ; i + + )
{
new_key = ( decryption_key_t * ) g_list_nth_data ( user_data - > list , i ) ;
uat_key . string = get_key_string ( new_key ) ;
uat_key . key = new_key - > type ;
uat_add_record ( uat , & uat_key , TRUE ) ;
}
if ( ! uat_save ( uat , & err ) )
{
/* XXX - report the error */
g_free ( err ) ;
return 1 ;
}
}
return 0 ;
}
/*
* This function will tell the airpcap driver the key list to use
* This will be stored into the registry . . .
*/
static gboolean
write_wlan_driver_wep_keys_to_registry ( GList * key_list )
{
guint i , j , k , n , y ;
GString * new_key ;
gchar s [ 3 ] ;
PAirpcapKeysCollection KeysCollection ;
guint KeysCollectionSize ;
guint8 KeyByte ;
guint keys_in_list = 0 ;
decryption_key_t * key_item = NULL ;
airpcap_if_info_t * fake_info_if = NULL ;
/* Create the fake_info_if from the first adapter of the list */
fake_info_if = airpcap_driver_fake_if_info_new ( ) ;
if ( fake_info_if = = NULL )
return FALSE ;
/*
* XXX - When WPA will be supported , change this to : keys_in_list = g_list_length ( key_list ) ;
* but right now we will have to count only the WEP keys ( or we will have a malloc - mess : - ) )
*/
n = g_list_length ( key_list ) ;
for ( k = 0 ; k < n ; k + + )
2018-02-23 17:43:29 +00:00
if ( ( ( decryption_key_t * ) g_list_nth_data ( key_list , k ) ) - > type = = DOT11DECRYPT_KEY_TYPE_WEP )
2015-06-11 22:05:44 +00:00
keys_in_list + + ;
/*
* Calculate the size of the keys collection
*/
KeysCollectionSize = ( guint ) AirpcapKeysCollectionSize ( keys_in_list ) ;
/*
* Allocate the collection
*/
KeysCollection = ( PAirpcapKeysCollection ) g_malloc ( KeysCollectionSize ) ;
if ( ! KeysCollection )
{
return FALSE ;
}
/*
* Populate the key collection
*/
KeysCollection - > nKeys = keys_in_list ;
/*
* XXX - If we have , let ' s say , six keys , the first three are WEP , then two are WPA , and the
* last is WEP , we have to scroll the whole list ( n ) but increment the array counter only
* when a WEP key is found ( y ) . . When WPA will be supported by the driver , I ' ll have to change
* this
*/
y = 0 ; /* Current position in the key list */
for ( i = 0 ; i < n ; i + + )
{
/* Retrieve the Item corresponding to the i-th key */
key_item = ( decryption_key_t * ) g_list_nth_data ( key_list , i ) ;
/*
2018-02-23 17:43:29 +00:00
* XXX - The DOT11DECRYPT_KEY_TYPE_WEP is the only supported right now !
2015-06-11 22:05:44 +00:00
* We will have to modify the AirpcapKey structure in order to
* support the other two types ! What happens now , is that simply the
* not supported keys will just be discarded ( they will be saved in Wireshark though )
*/
2018-02-23 17:43:29 +00:00
if ( key_item - > type = = DOT11DECRYPT_KEY_TYPE_WEP )
2015-06-11 22:05:44 +00:00
{
2018-02-23 17:43:29 +00:00
KeysCollection - > Keys [ y ] . KeyType = DOT11DECRYPT_KEY_TYPE_WEP ;
2015-06-11 22:05:44 +00:00
new_key = g_string_new ( key_item - > key - > str ) ;
KeysCollection - > Keys [ y ] . KeyLen = ( guint ) new_key - > len / 2 ;
memset ( & KeysCollection - > Keys [ y ] . KeyData , 0 , sizeof ( KeysCollection - > Keys [ y ] . KeyData ) ) ;
for ( j = 0 ; j < new_key - > len ; j + = 2 )
{
s [ 0 ] = new_key - > str [ j ] ;
s [ 1 ] = new_key - > str [ j + 1 ] ;
s [ 2 ] = ' \0 ' ;
KeyByte = ( guint8 ) strtol ( s , NULL , 16 ) ;
KeysCollection - > Keys [ y ] . KeyData [ j / 2 ] = KeyByte ;
}
/* XXX - Change when WPA will be supported!!! */
y + + ;
g_string_free ( new_key , TRUE ) ;
}
2018-02-23 17:43:29 +00:00
else if ( key_item - > type = = DOT11DECRYPT_KEY_TYPE_WPA_PWD )
2015-06-11 22:05:44 +00:00
{
/* XXX - The driver cannot deal with this kind of key yet... */
}
2018-02-23 17:43:29 +00:00
else if ( key_item - > type = = DOT11DECRYPT_KEY_TYPE_WPA_PMK )
2015-06-11 22:05:44 +00:00
{
/* XXX - The driver cannot deal with this kind of key yet... */
}
}
/*
* Free the old adapter key collection !
*/
2017-08-26 08:30:47 +00:00
g_free ( fake_info_if - > keysCollection ) ;
2015-06-11 22:05:44 +00:00
/*
* Set this collection ad the new one
*/
fake_info_if - > keysCollection = KeysCollection ;
fake_info_if - > keysCollectionSize = KeysCollectionSize ;
/*
* Configuration must be saved
*/
fake_info_if - > saved = FALSE ;
/*
* Write down the changes to the registry
*/
airpcap_save_driver_if_configuration ( fake_info_if ) ;
airpcap_if_info_free ( fake_info_if ) ;
return TRUE ;
}
/*
* Function used to read the Decryption Keys from the preferences and store them
* properly into the airpcap adapter .
*/
static gboolean
load_wlan_driver_wep_keys ( void )
{
keys_cb_data_t * user_data ;
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
/* Allocate a structure used to keep infos between the callbacks */
user_data = ( keys_cb_data_t * ) g_malloc ( sizeof ( keys_cb_data_t ) ) ;
/* Fill the structure */
user_data - > list = NULL ;
user_data - > current_index = 0 ;
user_data - > number_of_keys = 0 ; /* Still unknown */
/* Run the callback on each 802.11 preference */
prefs_pref_foreach ( wlan_prefs , get_wep_key , ( gpointer ) user_data ) ;
/* Now the key list should be filled */
/*
* Signal that we ' ve changed things , and run the 802.11 dissector ' s
* callback
*/
2018-01-06 04:39:55 +00:00
wlan_prefs - > prefs_changed_flags | = PREF_EFFECT_DISSECTION ;
2015-06-11 22:05:44 +00:00
prefs_apply ( wlan_prefs ) ;
write_wlan_driver_wep_keys_to_registry ( user_data - > list ) ;
/* FREE MEMORY */
/* free the WEP key string */
2015-10-07 12:24:56 +00:00
g_list_foreach ( user_data - > list , ( GFunc ) free_key_string , NULL ) ;
2015-06-11 22:05:44 +00:00
/* free the (empty) list */
g_list_free ( user_data - > list ) ;
/* free the user_data structure */
g_free ( user_data ) ;
/* airpcap_if_info_free(fake_info_if); */
return TRUE ;
}
/*
* This function will tell the airpcap driver the key list to use
* This will be stored into the registry . . .
*/
static gboolean
write_wlan_wep_keys_to_registry ( airpcap_if_info_t * info_if , GList * key_list )
{
guint i , j ;
GString * new_key ;
gchar s [ 3 ] ;
PAirpcapKeysCollection KeysCollection ;
guint KeysCollectionSize ;
guint8 KeyByte ;
guint keys_in_list = 0 ;
decryption_key_t * key_item = NULL ;
keys_in_list = g_list_length ( key_list ) ;
/*
* Calculate the size of the keys collection
*/
KeysCollectionSize = ( guint ) AirpcapKeysCollectionSize ( keys_in_list ) ;
/*
* Allocate the collection
*/
KeysCollection = ( PAirpcapKeysCollection ) g_malloc ( KeysCollectionSize ) ;
if ( ! KeysCollection )
{
return FALSE ;
}
/*
* Populate the key collection
*/
KeysCollection - > nKeys = keys_in_list ;
for ( i = 0 ; i < keys_in_list ; i + + )
{
2018-02-23 17:43:29 +00:00
KeysCollection - > Keys [ i ] . KeyType = DOT11DECRYPT_KEY_TYPE_WEP ;
2015-06-11 22:05:44 +00:00
/* Retrieve the Item corresponding to the i-th key */
key_item = ( decryption_key_t * ) g_list_nth_data ( key_list , i ) ;
new_key = g_string_new ( key_item - > key - > str ) ;
KeysCollection - > Keys [ i ] . KeyLen = ( guint ) new_key - > len / 2 ;
memset ( & KeysCollection - > Keys [ i ] . KeyData , 0 , sizeof ( KeysCollection - > Keys [ i ] . KeyData ) ) ;
for ( j = 0 ; j < new_key - > len ; j + = 2 )
{
s [ 0 ] = new_key - > str [ j ] ;
s [ 1 ] = new_key - > str [ j + 1 ] ;
s [ 2 ] = ' \0 ' ;
KeyByte = ( guint8 ) strtol ( s , NULL , 16 ) ;
KeysCollection - > Keys [ i ] . KeyData [ j / 2 ] = KeyByte ;
}
g_string_free ( new_key , TRUE ) ;
}
/*
* Free the old adapter key collection !
*/
2017-08-26 08:30:47 +00:00
g_free ( info_if - > keysCollection ) ;
2015-06-11 22:05:44 +00:00
/*
* Set this collection ad the new one
*/
info_if - > keysCollection = KeysCollection ;
info_if - > keysCollectionSize = KeysCollectionSize ;
/*
* Configuration must be saved
*/
info_if - > saved = FALSE ;
/*
* Write down the changes to the registry
*/
airpcap_save_selected_if_configuration ( info_if ) ;
return TRUE ;
}
/*
* Returns the ASCII string of a key given the key bytes
*/
static gchar *
airpcap_get_key_string ( AirpcapKey key )
{
unsigned int j = 0 ;
gchar * dst , * src ;
dst = NULL ;
src = NULL ;
2018-02-23 17:43:29 +00:00
if ( key . KeyType = = DOT11DECRYPT_KEY_TYPE_WEP )
2015-06-11 22:05:44 +00:00
{
if ( key . KeyLen ! = 0 )
{
/* Allocate the string used to store the ASCII representation of the WEP key */
dst = ( gchar * ) g_malloc ( sizeof ( gchar ) * WEP_KEY_MAX_CHAR_SIZE + 1 ) ;
/* Make sure that the first char is '\0' in order to make g_strlcat() work */
dst [ 0 ] = ' \0 ' ;
for ( j = 0 ; j < key . KeyLen ; j + + )
{
src = g_strdup_printf ( " %.2x " , key . KeyData [ j ] ) ;
/*
* XXX - use g_strconcat ( ) or GStrings instead ? ? ?
*/
g_strlcat ( dst , src , WEP_KEY_MAX_CHAR_SIZE + 1 ) ;
}
g_free ( src ) ;
}
}
2018-02-23 17:43:29 +00:00
else if ( key . KeyType = = DOT11DECRYPT_KEY_TYPE_WPA_PWD )
2015-06-11 22:05:44 +00:00
{
/* XXX - Add code here */
}
2018-02-23 17:43:29 +00:00
else if ( key . KeyType = = DOT11DECRYPT_KEY_TYPE_WPA_PMK )
2015-06-11 22:05:44 +00:00
{
/* XXX - Add code here */
}
else
{
/* XXX - Add code here */
}
return dst ;
}
/*
* Function used to save to the preference file the Decryption Keys .
*/
static int
save_wlan_driver_wep_keys ( void )
{
GList * key_list = NULL ;
char * tmp_key = NULL ;
guint keys_in_list , i ;
keys_cb_data_t * user_data ;
airpcap_if_info_t * fake_info_if = NULL ;
/* Create the fake_info_if from the first adapter of the list */
fake_info_if = airpcap_driver_fake_if_info_new ( ) ;
if ( fake_info_if = = NULL )
return 0 ;
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
/* Allocate a structure used to keep infos between the callbacks */
user_data = ( keys_cb_data_t * ) g_malloc ( sizeof ( keys_cb_data_t ) ) ;
/* Number of keys in key list */
if ( fake_info_if - > keysCollectionSize ! = 0 )
keys_in_list = AirpcapKeysCollectionSizeToKeyCount ( fake_info_if - > keysCollectionSize ) ;
else
keys_in_list = 0 ;
for ( i = 0 ; i < keys_in_list ; i + + )
{
/* Only if it is a WEP key... */
2018-02-23 17:43:29 +00:00
if ( fake_info_if - > keysCollection - > Keys [ i ] . KeyType = = DOT11DECRYPT_KEY_TYPE_WEP )
2015-06-11 22:05:44 +00:00
{
tmp_key = airpcap_get_key_string ( fake_info_if - > keysCollection - > Keys [ i ] ) ;
key_list = g_list_append ( key_list , g_strdup ( tmp_key ) ) ;
g_free ( tmp_key ) ;
}
}
/* Now we know the exact number of WEP keys in the list, so store it ... */
keys_in_list = g_list_length ( key_list ) ;
/* Fill the structure */
user_data - > list = key_list ;
user_data - > current_index = 0 ;
user_data - > number_of_keys = keys_in_list ;
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
/* Run the callback on each 802.11 preference */
prefs_pref_foreach ( wlan_prefs , set_wep_key , ( gpointer ) user_data ) ;
/* Signal that we've changed things, and run the 802.11 dissector's
* callback */
2018-01-06 04:39:55 +00:00
wlan_prefs - > prefs_changed_flags | = PREF_EFFECT_DISSECTION ;
2015-06-11 22:05:44 +00:00
/* Apply changes for the specified preference */
prefs_apply ( wlan_prefs ) ;
/* FREE MEMORY */
/* free the WEP key string */
for ( i = 0 ; i < g_list_length ( user_data - > list ) ; i + + )
{
g_free ( g_list_nth ( user_data - > list , i ) - > data ) ;
}
/* free the (empty) list */
g_list_free ( user_data - > list ) ;
/* free the user_data structure */
g_free ( user_data ) ;
airpcap_if_info_free ( fake_info_if ) ;
return keys_in_list ;
}
/*
* Function used to save to the preference file the Decryption Keys .
*/
static int
save_wlan_wireshark_wep_keys ( GList * key_ls )
{
GList * key_list = NULL ;
guint keys_in_list , i ;
keys_cb_data_t * user_data ;
decryption_key_t * tmp_dk ;
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
/* Allocate a structure used to keep infos between the callbacks */
user_data = ( keys_cb_data_t * ) g_malloc ( sizeof ( keys_cb_data_t ) ) ;
keys_in_list = g_list_length ( key_ls ) ;
key_list = key_ls ;
/* Fill the structure */
user_data - > list = key_list ;
user_data - > current_index = 0 ;
user_data - > number_of_keys = keys_in_list ;
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
/* Run the callback on each 802.11 preference */
prefs_pref_foreach ( wlan_prefs , set_wep_key , ( gpointer ) user_data ) ;
/* Signal that we've changed things, and run the 802.11 dissector's
* callback */
2018-01-06 04:39:55 +00:00
wlan_prefs - > prefs_changed_flags | = PREF_EFFECT_DISSECTION ;
2015-06-11 22:05:44 +00:00
/* Apply changes for the specified preference */
prefs_apply ( wlan_prefs ) ;
/* FREE MEMORY */
/* free the WEP key string */
for ( i = 0 ; i < g_list_length ( user_data - > list ) ; i + + )
{
tmp_dk = ( decryption_key_t * ) g_list_nth ( user_data - > list , i ) - > data ;
g_string_free ( tmp_dk - > key , TRUE ) ;
if ( tmp_dk - > ssid ! = NULL ) g_byte_array_free ( tmp_dk - > ssid , TRUE ) ;
}
/* free the (empty) list */
g_list_free ( user_data - > list ) ;
/* free the user_data structure */
g_free ( user_data ) ;
return keys_in_list ;
}
/*
* Returns the default airpcap interface of a list , NULL if list is empty
*/
airpcap_if_info_t *
airpcap_get_default_if ( GList * airpcap_if_list_p )
{
airpcap_if_info_t * if_info = NULL ;
if ( ( prefs . capture_device ! = NULL ) & & ( * prefs . capture_device ! = ' \0 ' ) )
{
if_info = get_airpcap_if_from_name ( airpcap_if_list_p ,
get_if_name ( prefs . capture_device ) ) ;
}
return if_info ;
}
/*
* DECRYPTION KEYS FUNCTIONS
*/
#if 0
/*
* This function is used for DEBUG POURPOSES ONLY ! ! !
*/
void
print_key_list ( GList * key_list )
{
gint n , i ;
decryption_key_t * tmp ;
2017-01-31 03:38:20 +00:00
gchar * ssid ;
2015-06-11 22:05:44 +00:00
if ( key_list = = NULL )
{
g_print ( " \n \n ******* KEY LIST NULL ******* \n \n " ) ;
return ;
}
n = g_list_length ( key_list ) ;
g_print ( " \n \n ********* KEY LIST ********** \n \n " ) ;
g_print ( " NUMBER OF KEYS IN LIST : %d \n \n " , n ) ;
for ( i = 0 ; i < n ; i + + )
{
g_print ( " [%d] : \n " , i + 1 ) ;
tmp = ( decryption_key_t * ) ( g_list_nth_data ( key_list , i ) ) ;
g_print ( " KEY : %s \n " , tmp - > key - > str ) ;
g_print ( " BITS: %d \n " , tmp - > bits ) ;
2018-02-23 17:43:29 +00:00
if ( tmp - > type = = DOT11DECRYPT_KEY_TYPE_WEP )
2015-06-11 22:05:44 +00:00
g_print ( " TYPE: %s \n " , AIRPCAP_WEP_KEY_STRING ) ;
2018-02-23 17:43:29 +00:00
else if ( tmp - > type = = DOT11DECRYPT_KEY_TYPE_WPA_PWD )
2015-06-11 22:05:44 +00:00
g_print ( " TYPE: %s \n " , AIRPCAP_WPA_PWD_KEY_STRING ) ;
2018-02-23 17:43:29 +00:00
else if ( tmp - > type = = DOT11DECRYPT_KEY_TYPE_WPA_PMK )
2015-06-11 22:05:44 +00:00
g_print ( " TYPE: %s \n " , AIRPCAP_WPA_BIN_KEY_STRING ) ;
else
g_print ( " TYPE: %s \n " , " ??? " ) ;
2017-01-31 12:51:19 +00:00
ssid = format_text ( NULL , ( guchar * ) tmp - > ssid - > data , tmp - > ssid - > len ) ;
2017-01-31 03:38:20 +00:00
g_print ( " SSID: %s \n " , ( tmp - > ssid ! = NULL ) ? ssid : " --- " ) ;
2015-06-11 22:05:44 +00:00
g_print ( " \n " ) ;
2017-01-31 03:38:20 +00:00
wmem_free ( NULL , ssid ) ;
2015-06-11 22:05:44 +00:00
}
g_print ( " \n ***************************** \n \n " ) ;
}
# endif
/*
* Retrieves a GList of decryption_key_t structures containing infos about the
* keys for the given adapter . . . returns NULL if no keys are found .
*/
GList *
get_airpcap_device_keys ( airpcap_if_info_t * info_if )
{
/* tmp vars */
char * tmp_key = NULL ;
guint i , keys_in_list = 0 ;
/* real vars*/
decryption_key_t * new_key = NULL ;
GList * key_list = NULL ;
/* Number of keys in key list */
if ( info_if - > keysCollectionSize ! = 0 )
keys_in_list = AirpcapKeysCollectionSizeToKeyCount ( info_if - > keysCollectionSize ) ;
else
keys_in_list = 0 ;
for ( i = 0 ; i < keys_in_list ; i + + )
{
/* Different things to do depending on the key type */
2018-02-23 17:43:29 +00:00
if ( info_if - > keysCollection - > Keys [ i ] . KeyType = = DOT11DECRYPT_KEY_TYPE_WEP )
2015-06-11 22:05:44 +00:00
{
/* allocate memory for the new key item */
new_key = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
/* fill the fields */
/* KEY */
tmp_key = airpcap_get_key_string ( info_if - > keysCollection - > Keys [ i ] ) ;
new_key - > key = g_string_new ( tmp_key ) ;
g_free ( tmp_key ) ;
/* BITS */
new_key - > bits = ( guint ) new_key - > key - > len * 4 ; /* every char is 4 bits in WEP keys (it is an hexadecimal number) */
/* SSID not used in WEP keys */
new_key - > ssid = NULL ;
/* TYPE (WEP in this case) */
new_key - > type = info_if - > keysCollection - > Keys [ i ] . KeyType ;
/* Append the new element in the list */
key_list = g_list_append ( key_list , ( gpointer ) new_key ) ;
}
2018-02-23 17:43:29 +00:00
else if ( info_if - > keysCollection - > Keys [ i ] . KeyType = = DOT11DECRYPT_KEY_TYPE_WPA_PWD )
2015-06-11 22:05:44 +00:00
{
/* XXX - Not supported yet */
}
2018-02-23 17:43:29 +00:00
else if ( info_if - > keysCollection - > Keys [ i ] . KeyType = = DOT11DECRYPT_KEY_TYPE_WPA_PMK )
2015-06-11 22:05:44 +00:00
{
/* XXX - Not supported yet */
}
}
return key_list ;
}
/*
* Retrieves a GList of decryption_key_t structures containing infos about the
* keys for the global AirPcap driver . . . returns NULL if no keys are found .
*/
GList *
get_airpcap_driver_keys ( void )
{
/* tmp vars */
char * tmp_key = NULL ;
guint i , keys_in_list = 0 ;
/* real vars*/
decryption_key_t * new_key = NULL ;
GList * key_list = NULL ;
/*
* To read the drivers general settings we need to create and use one airpcap adapter . . .
* The only way to do that is to instantiate a fake adapter , and then close it and delete it .
*/
airpcap_if_info_t * fake_info_if = NULL ;
/* Create the fake_info_if from the first adapter of the list */
fake_info_if = airpcap_driver_fake_if_info_new ( ) ;
if ( fake_info_if = = NULL )
return NULL ;
/* Number of keys in key list */
if ( fake_info_if - > keysCollectionSize ! = 0 )
keys_in_list = AirpcapKeysCollectionSizeToKeyCount ( fake_info_if - > keysCollectionSize ) ;
else
keys_in_list = 0 ;
for ( i = 0 ; i < keys_in_list ; i + + )
{
/* Different things to do depending on the key type */
2018-02-23 17:43:29 +00:00
if ( fake_info_if - > keysCollection - > Keys [ i ] . KeyType = = DOT11DECRYPT_KEY_TYPE_WEP )
2015-06-11 22:05:44 +00:00
{
/* allocate memory for the new key item */
new_key = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
/* fill the fields */
/* KEY */
tmp_key = airpcap_get_key_string ( fake_info_if - > keysCollection - > Keys [ i ] ) ;
new_key - > key = g_string_new ( tmp_key ) ;
2017-08-26 08:30:47 +00:00
g_free ( tmp_key ) ;
2015-06-11 22:05:44 +00:00
/* BITS */
new_key - > bits = ( guint ) new_key - > key - > len * 4 ; /* every char is 4 bits in WEP keys (it is an hexadecimal number) */
/* SSID not used in WEP keys */
new_key - > ssid = NULL ;
/* TYPE (WEP in this case) */
new_key - > type = fake_info_if - > keysCollection - > Keys [ i ] . KeyType ;
/* Append the new element in the list */
key_list = g_list_append ( key_list , ( gpointer ) new_key ) ;
}
2018-02-23 17:43:29 +00:00
else if ( fake_info_if - > keysCollection - > Keys [ i ] . KeyType = = DOT11DECRYPT_KEY_TYPE_WPA_PWD )
2015-06-11 22:05:44 +00:00
{
/* XXX - Not supported yet */
}
2018-02-23 17:43:29 +00:00
else if ( fake_info_if - > keysCollection - > Keys [ i ] . KeyType = = DOT11DECRYPT_KEY_TYPE_WPA_PMK )
2015-06-11 22:05:44 +00:00
{
/* XXX - Not supported yet */
}
}
airpcap_if_info_free ( fake_info_if ) ;
return key_list ;
}
/*
* Returns the list of the decryption keys specified for wireshark , NULL if
* no key is found
*/
GList *
get_wireshark_keys ( void )
{
keys_cb_data_t * wep_user_data = NULL ;
GList * final_list = NULL ;
GList * wep_final_list = NULL ;
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
/* Allocate a structure used to keep infos between the callbacks */
wep_user_data = ( keys_cb_data_t * ) g_malloc ( sizeof ( keys_cb_data_t ) ) ;
/* Fill the structure */
wep_user_data - > list = NULL ;
wep_user_data - > current_index = 0 ;
wep_user_data - > number_of_keys = 0 ; /* Still unknown */
/* Run the callback on each 802.11 preference */
/* XXX - Right now, only WEP keys will be loaded */
prefs_pref_foreach ( wlan_prefs , get_wep_key , ( gpointer ) wep_user_data ) ;
/* Copy the list field in the user data structure pointer into the final_list */
wep_final_list = wep_user_data - > list ;
/* XXX - Merge the three lists!!!!! */
final_list = wep_final_list ;
/* free the wep_user_data structure */
g_free ( wep_user_data ) ;
return final_list ;
}
static guint
test_if_on ( pref_t * pref , gpointer ud )
{
gboolean * is_on ;
/* Retrieve user data info */
is_on = ( gboolean * ) ud ;
2017-01-07 13:52:23 +00:00
if ( g_ascii_strncasecmp ( prefs_get_name ( pref ) , " enable_decryption " , 17 ) = = 0 & & prefs_get_gui_type ( pref ) = = PREF_BOOL )
2015-06-11 22:05:44 +00:00
{
2017-01-07 13:52:23 +00:00
* is_on = prefs_get_bool_value ( pref , pref_current ) ;
2015-06-11 22:05:44 +00:00
return 1 ;
}
return 0 ;
}
/*
* Merges two lists of keys and return a newly created GList . If a key is
* found multiple times , it will just appear once !
* list1 and list 2 pointer will have to be freed manually if needed ! ! !
* If the total number of keys exceeeds the maximum number allowed ,
* exceeding keys will be discarded . . .
*/
GList *
merge_key_list ( GList * list1 , GList * list2 )
{
guint n1 = 0 , n2 = 0 ;
guint i ;
decryption_key_t * dk1 = NULL ,
* dk2 = NULL ,
* new_dk = NULL ;
GList * merged_list = NULL ;
if ( ( list1 = = NULL ) & & ( list2 = = NULL ) )
return NULL ;
if ( list1 = = NULL )
{
n2 = g_list_length ( list2 ) ;
for ( i = 0 ; i < n2 ; i + + )
{
new_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
dk2 = ( decryption_key_t * ) g_list_nth_data ( list2 , i ) ;
new_dk - > bits = dk2 - > bits ;
new_dk - > type = dk2 - > type ;
new_dk - > key = g_string_new ( dk2 - > key - > str ) ;
new_dk - > ssid = byte_array_dup ( dk2 - > ssid ) ;
/* Check the total length of the merged list */
if ( g_list_length ( merged_list ) < MAX_ENCRYPTION_KEYS )
merged_list = g_list_append ( merged_list , ( gpointer ) new_dk ) ;
}
}
else if ( list2 = = NULL )
{
n1 = g_list_length ( list1 ) ;
for ( i = 0 ; i < n1 ; i + + )
{
new_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
dk1 = ( decryption_key_t * ) g_list_nth_data ( list1 , i ) ;
new_dk - > bits = dk1 - > bits ;
new_dk - > type = dk1 - > type ;
new_dk - > key = g_string_new ( dk1 - > key - > str ) ;
new_dk - > ssid = byte_array_dup ( dk1 - > ssid ) ;
/* Check the total length of the merged list */
if ( g_list_length ( merged_list ) < MAX_ENCRYPTION_KEYS )
merged_list = g_list_append ( merged_list , ( gpointer ) new_dk ) ;
}
}
else
{
n1 = g_list_length ( list1 ) ;
n2 = g_list_length ( list2 ) ;
/* Copy the whole list1 into merged_list */
for ( i = 0 ; i < n1 ; i + + )
{
new_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
dk1 = ( decryption_key_t * ) g_list_nth_data ( list1 , i ) ;
new_dk - > bits = dk1 - > bits ;
new_dk - > type = dk1 - > type ;
new_dk - > key = g_string_new ( dk1 - > key - > str ) ;
new_dk - > ssid = byte_array_dup ( dk1 - > ssid ) ;
/* Check the total length of the merged list */
if ( g_list_length ( merged_list ) < MAX_ENCRYPTION_KEYS )
merged_list = g_list_append ( merged_list , ( gpointer ) new_dk ) ;
}
/* Look for keys that are present in list2 but aren't in list1 yet...
* Add them to merged_list
*/
for ( i = 0 ; i < n2 ; i + + )
{
dk2 = ( decryption_key_t * ) g_list_nth_data ( list2 , i ) ;
if ( ! key_is_in_list ( dk2 , merged_list ) )
{
new_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
new_dk - > bits = dk2 - > bits ;
new_dk - > type = dk2 - > type ;
new_dk - > key = g_string_new ( dk2 - > key - > str ) ;
new_dk - > ssid = byte_array_dup ( dk2 - > ssid ) ;
/* Check the total length of the merged list */
if ( g_list_length ( merged_list ) < MAX_ENCRYPTION_KEYS )
merged_list = g_list_append ( merged_list , ( gpointer ) new_dk ) ;
}
}
}
return merged_list ;
}
/*
* Use this function to free a key list .
*/
void
free_key_list ( GList * list )
{
guint i , n ;
decryption_key_t * curr_key ;
if ( list = = NULL )
return ;
n = g_list_length ( list ) ;
for ( i = 0 ; i < n ; i + + )
{
curr_key = ( decryption_key_t * ) g_list_nth_data ( list , i ) ;
/* Free all the strings */
if ( curr_key - > key ! = NULL )
g_string_free ( curr_key - > key , TRUE ) ;
if ( curr_key - > ssid ! = NULL )
2017-08-26 08:30:47 +00:00
g_byte_array_free ( curr_key - > ssid , TRUE ) ;
2015-06-11 22:05:44 +00:00
/* free the decryption_key_t structure*/
g_free ( curr_key ) ;
curr_key = NULL ;
}
/* Free the list */
g_list_free ( list ) ;
return ;
}
/*
* If the given key is contained in the list , returns TRUE .
* Returns FALSE otherwise .
*/
gboolean
key_is_in_list ( decryption_key_t * dk , GList * list )
{
guint i , n ;
decryption_key_t * curr_key = NULL ;
gboolean found = FALSE ;
if ( ( list = = NULL ) | | ( dk = = NULL ) )
return FALSE ;
n = g_list_length ( list ) ;
if ( n < 1 )
return FALSE ;
for ( i = 0 ; i < n ; i + + )
{
curr_key = ( decryption_key_t * ) g_list_nth_data ( list , i ) ;
if ( keys_are_equals ( dk , curr_key ) )
found = TRUE ;
}
return found ;
}
/*
* Returns TRUE if keys are equals , FALSE otherwise
*/
gboolean
keys_are_equals ( decryption_key_t * k1 , decryption_key_t * k2 )
{
if ( ( k1 = = NULL ) | | ( k2 = = NULL ) )
return FALSE ;
/* XXX - Remove this check when we will have the WPA/WPA2 decryption in the Driver! */
2018-02-23 17:43:29 +00:00
/** if ( (k1->type == DOT11DECRYPT_KEY_TYPE_WPA_PWD) || (k2->type == DOT11DECRYPT_KEY_TYPE_WPA_PWD) || (k1->type == DOT11DECRYPT_KEY_TYPE_WPA_PMK) || (k2->type == DOT11DECRYPT_KEY_TYPE_WPA_PMK) ) **/
2015-06-11 22:05:44 +00:00
/** return TRUE; **/
if ( g_string_equal ( k1 - > key , k2 - > key ) & &
( k1 - > bits = = k2 - > bits ) & & /* If the previous is TRUE, this must be TRUE as well */
( k1 - > type = = k2 - > type ) )
{
/* Check the ssid... if the key type is WEP, the two fields should be NULL */
if ( ( k1 - > ssid = = NULL ) & & ( k2 - > ssid = = NULL ) )
return TRUE ;
/* If they are not null, they must share the same ssid */
return byte_array_equal ( k1 - > ssid , k2 - > ssid ) ;
}
/* Some field is not equal ... */
return FALSE ;
}
/*
* Tests if two collection of keys are equal or not , to be considered equals , they have to
* contain the same keys in the SAME ORDER ! ( If both lists are NULL , which means empty will
* return TRUE )
*/
gboolean
key_lists_are_equal ( GList * list1 , GList * list2 )
{
guint n1 = 0 , n2 = 0 ;
/* XXX - Remove */
guint wep_n1 = 0 , wep_n2 = 0 ;
GList * wep_list1 = NULL ;
GList * wep_list2 = NULL ;
/* XXX - END*/
guint i /*,j*/ ;
decryption_key_t * dk1 = NULL , * dk2 = NULL ;
n1 = g_list_length ( list1 ) ;
n2 = g_list_length ( list2 ) ;
/*
* XXX - START : Retrieve the aublists of WEP keys ! ! ! This is needed only ' till Driver WPA decryption
* is implemented .
*/
for ( i = 0 ; i < n1 ; i + + )
{
dk1 = ( decryption_key_t * ) g_list_nth_data ( list1 , i ) ;
2018-02-23 17:43:29 +00:00
if ( dk1 - > type = = DOT11DECRYPT_KEY_TYPE_WEP )
2015-06-11 22:05:44 +00:00
{
wep_list1 = g_list_append ( wep_list1 , ( gpointer ) dk1 ) ;
wep_n1 + + ;
}
}
for ( i = 0 ; i < n2 ; i + + )
{
dk2 = ( decryption_key_t * ) g_list_nth_data ( list2 , i ) ;
2018-02-23 17:43:29 +00:00
if ( dk2 - > type = = DOT11DECRYPT_KEY_TYPE_WEP )
2015-06-11 22:05:44 +00:00
{
wep_list2 = g_list_append ( wep_list2 , ( gpointer ) dk2 ) ;
wep_n2 + + ;
}
}
/*
* XXX - END : Remove from START to END when the WPA / WPA2 decryption will be implemented in
* the Driver
*/
/*
* Commented , because in the new AirPcap version all the keys will be saved
* into the driver , and all the keys for every specific adapter will be
* removed . This means that this check will always fail . . . and the user will
* always be asked what to do . . . and it doesn ' t make much sense .
*/
/* if (n1 != n2) return FALSE; */
if ( wep_n1 ! = wep_n2 ) return FALSE ;
n2 = wep_n2 ;
/*for(i=0;i<n1;i++)
{
dk1 = ( decryption_key_t * ) g_list_nth_data ( list1 , i ) ;
dk2 = ( decryption_key_t * ) g_list_nth_data ( list2 , i ) ;
if ( ! g_string_equal ( dk1 - > key , dk2 - > key ) ) return FALSE ;
} */
for ( i = 0 ; i < n2 ; i + + )
{
dk2 = ( decryption_key_t * ) g_list_nth_data ( wep_list2 , i ) ;
if ( ! key_is_in_list ( dk2 , wep_list1 ) ) return FALSE ;
}
return TRUE ;
}
/*
* Returns TRUE if the Wireshark decryption is active , false otherwise
* XXX - Should we just add a routine to packet - ieee80211 . c to grab this directly ?
*/
gboolean
wireshark_decryption_on ( void )
{
gboolean is_on ;
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
/* Run the callback on each 802.11 preference */
prefs_pref_foreach ( wlan_prefs , test_if_on , ( gpointer ) & is_on ) ;
return is_on ;
}
/*
* Returns TRUE if the AirPcap decryption for the current adapter is active , false otherwise
*/
gboolean
airpcap_decryption_on ( void )
{
gboolean is_on = FALSE ;
airpcap_if_info_t * fake_if_info = NULL ;
fake_if_info = airpcap_driver_fake_if_info_new ( ) ;
if ( fake_if_info ! = NULL )
{
if ( fake_if_info - > DecryptionOn = = AIRPCAP_DECRYPTION_ON )
is_on = TRUE ;
else if ( fake_if_info - > DecryptionOn = = AIRPCAP_DECRYPTION_OFF )
is_on = FALSE ;
}
airpcap_if_info_free ( fake_if_info ) ;
return is_on ;
}
static guint
set_on_off ( pref_t * pref , gpointer ud )
{
gboolean * is_on ;
/* Retrieve user data info */
is_on = ( gboolean * ) ud ;
2017-01-07 13:52:23 +00:00
if ( g_ascii_strncasecmp ( prefs_get_name ( pref ) , " enable_decryption " , 17 ) = = 0 & & prefs_get_type ( pref ) = = PREF_BOOL )
2015-06-11 22:05:44 +00:00
{
2017-01-07 13:52:23 +00:00
prefs_set_bool_value ( pref , * is_on , pref_current ) ;
2015-06-11 22:05:44 +00:00
return 1 ;
}
return 0 ;
}
/*
* Enables decryption for Wireshark if on_off is TRUE , disables it otherwise .
*/
void
set_wireshark_decryption ( gboolean on_off )
{
gboolean is_on ;
is_on = on_off ;
/* Retrieve the wlan preferences */
wlan_prefs = prefs_find_module ( " wlan " ) ;
/* Run the callback on each 802.11 preference */
prefs_pref_foreach ( wlan_prefs , set_on_off , ( gpointer ) & is_on ) ;
/*
* Signal that we ' ve changed things , and run the 802.11 dissector ' s
* callback
*/
2018-01-06 04:39:55 +00:00
wlan_prefs - > prefs_changed_flags | = PREF_EFFECT_DISSECTION ;
2015-06-11 22:05:44 +00:00
prefs_apply ( wlan_prefs ) ;
}
/*
* Enables decryption for all the adapters if on_off is TRUE , disables it otherwise .
*/
gboolean
set_airpcap_decryption ( gboolean on_off )
{
/* We need to directly access the .dll functions here... */
gchar ebuf [ AIRPCAP_ERRBUF_SIZE ] ;
PAirpcapHandle ad , ad_driver ;
gboolean success = TRUE ;
gint n = 0 ;
gint i = 0 ;
airpcap_if_info_t * curr_if = NULL ;
airpcap_if_info_t * fake_if_info = NULL ;
fake_if_info = airpcap_driver_fake_if_info_new ( ) ;
if ( fake_if_info = = NULL )
/* We apparently don't have any adapters installed.
* This isn ' t a failure , so return TRUE
*/
return TRUE ;
/* Set the driver decryption */
ad_driver = airpcap_if_open ( fake_if_info - > name , ebuf ) ;
if ( ad_driver )
{
if ( on_off )
airpcap_if_set_driver_decryption_state ( ad_driver , AIRPCAP_DECRYPTION_ON ) ;
else
airpcap_if_set_driver_decryption_state ( ad_driver , AIRPCAP_DECRYPTION_OFF ) ;
airpcap_if_close ( ad_driver ) ;
}
airpcap_if_info_free ( fake_if_info ) ;
2015-07-02 10:19:02 +00:00
n = g_list_length ( g_airpcap_if_list ) ;
2015-06-11 22:05:44 +00:00
/* Set to FALSE the decryption for all the adapters */
/* Apply this change to all the adapters !!! */
for ( i = 0 ; i < n ; i + + )
{
2015-07-02 10:19:02 +00:00
curr_if = ( airpcap_if_info_t * ) g_list_nth_data ( g_airpcap_if_list , i ) ;
2015-06-11 22:05:44 +00:00
if ( curr_if ! = NULL )
{
ad = airpcap_if_open ( curr_if - > name , ebuf ) ;
if ( ad )
{
curr_if - > DecryptionOn = AIRPCAP_DECRYPTION_OFF ;
airpcap_if_set_decryption_state ( ad , curr_if - > DecryptionOn ) ;
/* Save configuration for the curr_if */
if ( ! airpcap_if_store_cur_config_as_adapter_default ( ad ) )
{
success = FALSE ;
}
airpcap_if_close ( ad ) ;
}
}
}
return success ;
}
2006-08-16 18:01:25 +00:00
/*
* Add a key ( string ) to the given list
*/
void
2011-05-31 21:34:23 +00:00
airpcap_add_key_to_list ( GtkListStore * key_list_store , gchar * type , gchar * key , gchar * ssid )
2006-08-16 18:01:25 +00:00
{
2011-02-07 20:24:42 +00:00
GtkTreeIter iter ;
2006-08-16 18:01:25 +00:00
2011-02-07 20:24:42 +00:00
gtk_list_store_insert_with_values ( key_list_store , & iter , G_MAXINT ,
KL_COL_TYPE , type ,
KL_COL_KEY , key ,
KL_COL_SSID , ssid ,
- 1 ) ;
2006-08-16 18:01:25 +00:00
}
/*
2006-12-05 19:24:25 +00:00
* Fill the list with the keys . BEWARE ! At this point , Wireshark and Drivers
* keys should be EQUALS ! But is better to load keys from Wireshark , because
* the driver is not always present , and maybe that cannot support some keys
* ( i . e . the WPA problem )
2006-08-16 18:01:25 +00:00
*/
void
2011-02-07 20:24:42 +00:00
airpcap_fill_key_list ( GtkListStore * key_list_store )
2006-08-16 18:01:25 +00:00
{
2017-01-31 13:29:53 +00:00
gchar * s = NULL ;
2013-02-25 23:35:13 +00:00
unsigned int i , n ;
2007-01-11 22:12:33 +00:00
airpcap_if_info_t * fake_if_info ;
2013-02-25 23:35:13 +00:00
GList * wireshark_key_list = NULL ;
decryption_key_t * curr_key = NULL ;
GtkTreeIter iter ;
2007-01-11 22:12:33 +00:00
fake_if_info = airpcap_driver_fake_if_info_new ( ) ;
/* We can retrieve the driver's key list (i.e. we have the right .dll)*/
wireshark_key_list = get_wireshark_keys ( ) ;
n = g_list_length ( wireshark_key_list ) ;
for ( i = 0 ; i < n ; i + + )
{
2010-11-28 00:41:47 +00:00
curr_key = ( decryption_key_t * ) g_list_nth_data ( wireshark_key_list , i ) ;
2018-02-23 17:43:29 +00:00
if ( curr_key - > type = = DOT11DECRYPT_KEY_TYPE_WEP )
2010-11-28 00:41:47 +00:00
{
2011-02-07 20:24:42 +00:00
gtk_list_store_insert_with_values ( key_list_store , & iter , G_MAXINT ,
KL_COL_TYPE , AIRPCAP_WEP_KEY_STRING ,
KL_COL_KEY , curr_key - > key - > str ,
KL_COL_SSID , " " ,
- 1 ) ;
2010-11-28 00:41:47 +00:00
}
2018-02-23 17:43:29 +00:00
else if ( curr_key - > type = = DOT11DECRYPT_KEY_TYPE_WPA_PWD )
2010-11-28 00:41:47 +00:00
{
2013-02-25 23:35:13 +00:00
if ( curr_key - > ssid ! = NULL )
2017-01-31 13:29:53 +00:00
{
s = format_uri ( NULL , curr_key - > ssid , " : " ) ;
gtk_list_store_insert_with_values ( key_list_store , & iter , G_MAXINT ,
KL_COL_TYPE , AIRPCAP_WPA_PWD_KEY_STRING ,
KL_COL_KEY , curr_key - > key - > str ,
KL_COL_SSID , s ,
- 1 ) ;
wmem_free ( NULL , s ) ;
}
2010-11-28 00:41:47 +00:00
else
2017-01-31 13:29:53 +00:00
{
2011-02-07 20:24:42 +00:00
gtk_list_store_insert_with_values ( key_list_store , & iter , G_MAXINT ,
KL_COL_TYPE , AIRPCAP_WPA_PWD_KEY_STRING ,
KL_COL_KEY , curr_key - > key - > str ,
2017-01-31 13:29:53 +00:00
KL_COL_SSID , " " ,
2011-02-07 20:24:42 +00:00
- 1 ) ;
2017-01-31 13:29:53 +00:00
}
2010-11-28 00:41:47 +00:00
}
2018-02-23 17:43:29 +00:00
else if ( curr_key - > type = = DOT11DECRYPT_KEY_TYPE_WPA_PMK )
2010-11-28 00:41:47 +00:00
{
2011-02-07 20:24:42 +00:00
gtk_list_store_insert_with_values ( key_list_store , & iter , G_MAXINT ,
KL_COL_TYPE , AIRPCAP_WPA_BIN_KEY_STRING ,
KL_COL_KEY , curr_key - > key - > str ,
KL_COL_SSID , " " ,
- 1 ) ;
2010-11-28 00:41:47 +00:00
}
2007-01-11 22:12:33 +00:00
}
airpcap_if_info_free ( fake_if_info ) ;
return ;
2006-08-16 18:01:25 +00:00
}
/*
* Function used to retrieve the AirpcapValidationType given the string name .
*/
AirpcapValidationType
airpcap_get_validation_type ( const gchar * name )
{
2013-02-25 23:35:13 +00:00
if ( ! ( g_ascii_strcasecmp ( AIRPCAP_VALIDATION_TYPE_NAME_ALL , name ) ) )
2010-11-28 00:41:47 +00:00
{
return AIRPCAP_VT_ACCEPT_EVERYTHING ;
}
2013-02-25 23:35:13 +00:00
else if ( ! ( g_ascii_strcasecmp ( AIRPCAP_VALIDATION_TYPE_NAME_CORRECT , name ) ) )
2010-11-28 00:41:47 +00:00
{
return AIRPCAP_VT_ACCEPT_CORRECT_FRAMES ;
}
2013-02-25 23:35:13 +00:00
else if ( ! ( g_ascii_strcasecmp ( AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT , name ) ) )
2010-11-28 00:41:47 +00:00
{
return AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES ;
}
return AIRPCAP_VT_UNKNOWN ;
2006-08-16 18:01:25 +00:00
}
/*
* Function used to retrieve the string name given an AirpcapValidationType ,
* or NULL in case of error
*/
2012-04-18 12:35:36 +00:00
const gchar *
2006-08-16 18:01:25 +00:00
airpcap_get_validation_name ( AirpcapValidationType vt )
{
2013-02-25 23:35:13 +00:00
if ( vt = = AIRPCAP_VT_ACCEPT_EVERYTHING )
2010-11-28 00:41:47 +00:00
{
return AIRPCAP_VALIDATION_TYPE_NAME_ALL ;
}
2013-02-25 23:35:13 +00:00
else if ( vt = = AIRPCAP_VT_ACCEPT_CORRECT_FRAMES )
2010-11-28 00:41:47 +00:00
{
return AIRPCAP_VALIDATION_TYPE_NAME_CORRECT ;
}
2013-02-25 23:35:13 +00:00
else if ( vt = = AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES )
2010-11-28 00:41:47 +00:00
{
return AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT ;
}
2013-02-25 23:35:13 +00:00
else if ( vt = = AIRPCAP_VT_UNKNOWN )
2010-11-28 00:41:47 +00:00
{
return AIRPCAP_VALIDATION_TYPE_NAME_UNKNOWN ;
}
return NULL ;
2006-08-16 18:01:25 +00:00
}
2009-05-13 16:14:28 +00:00
/*
* Return an appropriate combo box entry number for the given an AirpcapValidationType ,
* defaulting to 0
*/
gint
airpcap_get_validation_combo_entry ( AirpcapValidationType vt )
{
switch ( vt ) {
case AIRPCAP_VT_ACCEPT_CORRECT_FRAMES :
return 1 ;
break ;
case AIRPCAP_VT_ACCEPT_CORRUPT_FRAMES :
return 2 ;
break ;
default :
return 0 ;
break ;
}
}
2006-08-16 18:01:25 +00:00
/*
* Returns the AirpcapLinkType corresponding to the given string name .
*/
AirpcapLinkType
airpcap_get_link_type ( const gchar * name )
{
2013-02-25 23:35:13 +00:00
if ( ! ( g_ascii_strcasecmp ( AIRPCAP_LINK_TYPE_NAME_802_11_ONLY , name ) ) ) {
2010-11-28 00:41:47 +00:00
return AIRPCAP_LT_802_11 ;
2013-02-25 23:35:13 +00:00
} else if ( ! ( g_ascii_strcasecmp ( AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO , name ) ) ) {
2010-11-28 00:41:47 +00:00
return AIRPCAP_LT_802_11_PLUS_RADIO ;
2013-02-25 23:35:13 +00:00
} else if ( ! ( g_ascii_strcasecmp ( AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_PPI , name ) ) ) {
2010-11-28 00:41:47 +00:00
return AIRPCAP_LT_802_11_PLUS_PPI ;
2007-05-18 21:06:20 +00:00
} else {
2010-11-28 00:41:47 +00:00
return AIRPCAP_LT_UNKNOWN ;
2007-01-11 22:12:33 +00:00
}
2006-08-16 18:01:25 +00:00
}
/*
* Returns the string name corresponding to the given AirpcapLinkType , or
* NULL in case of error .
*/
2012-12-26 05:57:06 +00:00
const gchar *
2006-08-16 18:01:25 +00:00
airpcap_get_link_name ( AirpcapLinkType lt )
{
2013-02-25 23:35:13 +00:00
if ( lt = = AIRPCAP_LT_802_11 ) {
2010-11-28 00:41:47 +00:00
return AIRPCAP_LINK_TYPE_NAME_802_11_ONLY ;
2013-02-25 23:35:13 +00:00
} else if ( lt = = AIRPCAP_LT_802_11_PLUS_RADIO ) {
2010-11-28 00:41:47 +00:00
return AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO ;
2013-02-25 23:35:13 +00:00
} else if ( lt = = AIRPCAP_LT_802_11_PLUS_PPI ) {
2010-11-28 00:41:47 +00:00
return AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_PPI ;
2013-02-25 23:35:13 +00:00
} else if ( lt = = AIRPCAP_LT_UNKNOWN ) {
2010-11-28 00:41:47 +00:00
return AIRPCAP_LINK_TYPE_NAME_UNKNOWN ;
2007-01-11 22:12:33 +00:00
}
return NULL ;
2006-08-16 18:01:25 +00:00
}
/*
* Sets the entry of the validation combo using the AirpcapValidationType .
*/
void
airpcap_validation_type_combo_set_by_type ( GtkWidget * c , AirpcapValidationType type )
{
2009-05-13 16:14:28 +00:00
gtk_combo_box_set_active ( GTK_COMBO_BOX ( c ) , airpcap_get_validation_combo_entry ( type ) ) ;
2006-08-16 18:01:25 +00:00
}
/*
2009-05-13 17:43:03 +00:00
* Returns the string corresponding to the given guint ( 1 - 14 , for channel only )
2006-08-16 18:01:25 +00:00
*/
gchar *
2009-05-13 17:43:03 +00:00
airpcap_get_channel_name ( guint n )
2006-08-16 18:01:25 +00:00
{
2007-01-11 22:12:33 +00:00
return g_strdup_printf ( " %d " , n ) ;
2006-08-16 18:01:25 +00:00
}
2008-01-24 22:26:05 +00:00
2006-08-16 18:01:25 +00:00
/*
2009-05-13 16:14:28 +00:00
* Set the combo box entry string given a channel frequency
2006-08-16 18:01:25 +00:00
*/
void
2009-05-13 16:14:28 +00:00
airpcap_channel_combo_set_by_frequency ( GtkWidget * cb , guint chan_freq )
2007-05-18 21:06:20 +00:00
{
2009-05-13 16:14:28 +00:00
guint i ;
2007-05-18 21:06:20 +00:00
2009-05-13 16:14:28 +00:00
for ( i = 0 ; i < airpcap_if_selected - > numSupportedChannels ; i + + ) {
if ( airpcap_if_selected - > pSupportedChannels [ i ] . Frequency = = chan_freq ) {
gtk_combo_box_set_active ( GTK_COMBO_BOX ( cb ) , i ) ;
break ;
}
}
2007-05-18 21:06:20 +00:00
}
/*
* Change channel of Airpcap Adapter
*/
2009-06-29 23:08:05 +00:00
static gboolean
2007-05-18 21:06:20 +00:00
airpcap_update_frequency_and_offset ( airpcap_if_info_t * if_info )
2006-08-16 18:01:25 +00:00
{
2007-05-18 21:06:20 +00:00
gchar ebuf [ AIRPCAP_ERRBUF_SIZE ] ;
PAirpcapHandle ad ;
gboolean return_value = FALSE ;
2013-02-25 23:35:13 +00:00
if ( if_info ! = NULL ) {
2007-05-18 21:06:20 +00:00
ad = airpcap_if_open ( if_info - > name , ebuf ) ;
2013-02-25 23:35:13 +00:00
if ( ad ! = NULL ) {
2007-05-18 21:06:20 +00:00
return_value = airpcap_if_set_device_channel_ex ( ad , if_info - > channelInfo ) ;
airpcap_if_close ( ad ) ;
}
}
return return_value ;
}
/*
2009-06-29 23:08:05 +00:00
* Changed callback for the channel combobox - common routine
2007-05-18 21:06:20 +00:00
*/
2009-06-29 23:08:05 +00:00
static void
airpcap_channel_changed_common ( GtkWidget * channel_cb , gpointer channel_offset_cb , gboolean set )
2007-05-18 21:06:20 +00:00
{
2009-05-13 16:14:28 +00:00
gint cur_chan_idx ;
if ( channel_cb & & channel_offset_cb & & change_airpcap_settings & & airpcap_if_active ) {
cur_chan_idx = gtk_combo_box_get_active ( GTK_COMBO_BOX ( channel_cb ) ) ;
if ( cur_chan_idx > = 0 & & cur_chan_idx < ( gint ) airpcap_if_active - > numSupportedChannels ) {
2009-06-29 23:08:05 +00:00
if ( set ) {
airpcap_if_active - > channelInfo . Frequency = airpcap_if_active - > pSupportedChannels [ cur_chan_idx ] . Frequency ;
}
2009-05-13 16:14:28 +00:00
airpcap_update_channel_offset_combo ( airpcap_if_active ,
airpcap_if_active - > channelInfo . Frequency ,
2009-06-29 23:08:05 +00:00
GTK_WIDGET ( channel_offset_cb ) , set ) ;
2010-11-28 00:41:47 +00:00
}
2009-05-13 16:14:28 +00:00
}
}
2007-05-18 21:06:20 +00:00
2009-06-29 23:08:05 +00:00
/*
* Changed callback for the channel combobox - set channel and offset
*/
void
airpcap_channel_changed_set_cb ( GtkWidget * channel_cb , gpointer channel_offset_cb )
{
airpcap_channel_changed_common ( channel_cb , channel_offset_cb , TRUE ) ;
}
/*
* Changed callback for the channel combobox - don ' t set channel and offset
*/
void
airpcap_channel_changed_noset_cb ( GtkWidget * channel_cb , gpointer channel_offset_cb )
{
airpcap_channel_changed_common ( channel_cb , channel_offset_cb , FALSE ) ;
}
2009-05-13 16:14:28 +00:00
static int
airpcap_get_selected_channel_offset ( GtkWidget * channel_offset_cb ) {
2013-02-25 23:35:13 +00:00
int offset ;
2009-05-13 16:14:28 +00:00
gchar * off_str ;
2013-02-25 23:35:13 +00:00
int retval = 0 ;
2011-07-11 19:10:57 +00:00
2007-05-18 21:06:20 +00:00
2011-07-24 15:22:21 +00:00
if ( channel_offset_cb = = NULL | | ! gtk_widget_get_sensitive ( channel_offset_cb ) ) {
2009-05-13 16:14:28 +00:00
return 0 ;
}
2011-07-11 19:10:57 +00:00
2011-07-24 15:22:21 +00:00
off_str = gtk_combo_box_text_get_active_text ( GTK_COMBO_BOX_TEXT ( channel_offset_cb ) ) ;
2009-05-13 16:14:28 +00:00
if ( off_str & & ( g_ascii_strcasecmp ( " " , off_str ) ) )
{
if ( airpcap_if_selected ! = NULL )
{
2016-07-16 17:06:28 +00:00
if ( sscanf ( off_str , " %d " , & offset ) = = 1 ) {
if ( offset > = - 1 & & offset < = 1 ) {
retval = offset ;
}
2009-05-13 16:14:28 +00:00
}
}
}
g_free ( off_str ) ;
return retval ;
}
2007-05-18 21:06:20 +00:00
2009-05-13 16:14:28 +00:00
/*
* Changed callback for the channel offset combobox
*/
void
airpcap_channel_offset_changed_cb ( GtkWidget * channel_offset_cb , gpointer data _U_ )
{
airpcap_if_selected - > channelInfo . ExtChannel = airpcap_get_selected_channel_offset ( channel_offset_cb ) ;
airpcap_if_selected - > saved = FALSE ;
2010-11-28 00:41:47 +00:00
change_airpcap_settings = TRUE ;
2013-02-25 23:35:13 +00:00
if ( ! airpcap_update_frequency_and_offset ( airpcap_if_selected ) ) {
2010-11-28 00:41:47 +00:00
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK ,
" Unable to set extension channel %d " ,
airpcap_if_selected - > channelInfo . ExtChannel ) ;
}
2009-05-13 16:14:28 +00:00
}
/*
* Update the channel offset of the given combobox according to the given frequency .
*/
void
2009-11-12 23:48:11 +00:00
airpcap_update_channel_offset_combo ( airpcap_if_info_t * if_info , guint chan_freq , GtkWidget * channel_offset_cb , gboolean set )
2009-05-13 16:14:28 +00:00
{
2013-02-25 23:35:13 +00:00
gint current_offset ;
gint new_offset ;
2009-05-13 16:14:28 +00:00
guint i ;
2013-02-25 23:35:13 +00:00
gint active_idx = 0 ;
gint idx_count = - 1 ;
2009-05-13 16:14:28 +00:00
if ( ! if_info | | airpcap_if_is_any ( if_info ) | | if_info - > pSupportedChannels = = NULL | | if_info - > numSupportedChannels < 1 ) {
gtk_widget_set_sensitive ( GTK_WIDGET ( channel_offset_cb ) , FALSE ) ;
gtk_combo_box_set_active ( GTK_COMBO_BOX ( channel_offset_cb ) , - 1 ) ;
return ;
}
2007-05-18 21:06:20 +00:00
2009-06-29 23:08:05 +00:00
new_offset = current_offset = if_info - > channelInfo . ExtChannel ;
2009-05-13 16:14:28 +00:00
/* Clear out the list */
while ( gtk_tree_model_iter_n_children ( gtk_combo_box_get_model ( GTK_COMBO_BOX ( channel_offset_cb ) ) , NULL ) > 0 ) {
2011-07-24 15:22:21 +00:00
gtk_combo_box_text_remove ( GTK_COMBO_BOX_TEXT ( channel_offset_cb ) , 0 ) ;
2009-05-13 16:14:28 +00:00
}
2009-06-29 23:08:05 +00:00
gtk_widget_set_sensitive ( GTK_WIDGET ( channel_offset_cb ) , TRUE ) ;
2009-05-13 16:14:28 +00:00
for ( i = 0 ; i < if_info - > numSupportedChannels ; i + + ) {
if ( if_info - > pSupportedChannels [ i ] . Frequency = = chan_freq ) {
/* If we can't be low or high, nudge the offset to 0 */
if ( current_offset = = - 1 & & ! ( if_info - > pSupportedChannels [ i ] . Flags & FLAG_CAN_BE_LOW ) ) {
new_offset = 0 ;
} else if ( current_offset = = 1 & & ! ( if_info - > pSupportedChannels [ i ] . Flags & FLAG_CAN_BE_HIGH ) ) {
new_offset = 0 ;
}
2007-05-18 21:06:20 +00:00
2009-05-13 16:14:28 +00:00
if ( ( if_info - > pSupportedChannels [ i ] . Flags & FLAG_CAN_BE_LOW ) ) {
2011-07-24 15:22:21 +00:00
gtk_combo_box_text_append_text ( GTK_COMBO_BOX_TEXT ( channel_offset_cb ) , " -1 " ) ;
2009-05-13 16:14:28 +00:00
idx_count + + ;
if ( new_offset = = - 1 ) {
active_idx = idx_count ;
}
}
2011-07-24 15:22:21 +00:00
gtk_combo_box_text_append_text ( GTK_COMBO_BOX_TEXT ( channel_offset_cb ) , " 0 " ) ;
2009-05-13 16:14:28 +00:00
idx_count + + ;
if ( new_offset = = 0 ) {
active_idx = idx_count ;
}
2013-02-25 23:35:13 +00:00
if ( ( if_info - > pSupportedChannels [ i ] . Flags & FLAG_CAN_BE_HIGH ) ) {
2011-07-24 15:22:21 +00:00
gtk_combo_box_text_append_text ( GTK_COMBO_BOX_TEXT ( channel_offset_cb ) , " +1 " ) ;
2009-05-13 16:14:28 +00:00
idx_count + + ;
if ( new_offset = = 1 ) {
active_idx = idx_count ;
}
}
break ;
}
}
gtk_combo_box_set_active ( GTK_COMBO_BOX ( channel_offset_cb ) , active_idx ) ;
2009-06-29 23:08:05 +00:00
if ( set ) {
change_airpcap_settings = TRUE ;
2011-07-11 19:10:57 +00:00
2009-06-29 23:08:05 +00:00
if_info - > channelInfo . ExtChannel = new_offset ;
2013-02-25 23:35:13 +00:00
if ( ! airpcap_update_frequency_and_offset ( if_info ) ) {
2009-06-29 23:08:05 +00:00
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK , " Adapter failed to be set with the following settings: Frequency - %d Extension Channel - %d " , if_info - > channelInfo . Frequency , if_info - > channelInfo . ExtChannel ) ;
}
2009-05-13 16:14:28 +00:00
}
2011-07-11 19:10:57 +00:00
2009-05-13 16:14:28 +00:00
if ( idx_count < 1 ) {
gtk_widget_set_sensitive ( channel_offset_cb , FALSE ) ;
}
2006-08-16 18:01:25 +00:00
}
2006-10-02 23:44:10 +00:00
/*
* Returns ' 1 ' if this is the " Any " adapter , ' 0 ' otherwise
*/
int
airpcap_if_is_any ( airpcap_if_info_t * if_info )
{
2013-02-25 23:35:13 +00:00
if ( g_ascii_strcasecmp ( if_info - > name , AIRPCAP_DEVICE_ANY_EXTRACT_STRING ) = = 0 )
2010-11-28 00:41:47 +00:00
return 1 ;
2007-01-11 22:12:33 +00:00
else
2010-11-28 00:41:47 +00:00
return 0 ;
2006-10-02 23:44:10 +00:00
}
/*
* Update channel combo box . If the airpcap interface is " Any " , the combo box will be disabled .
*/
2006-12-28 17:22:12 +00:00
void
2009-05-13 16:14:28 +00:00
airpcap_update_channel_combo ( GtkWidget * channel_cb , airpcap_if_info_t * if_info )
2006-10-02 23:44:10 +00:00
{
2013-02-25 23:35:13 +00:00
if ( ! if_info | | airpcap_if_is_any ( if_info ) | | ! airpcap_if_selected )
2006-10-02 23:44:10 +00:00
{
2009-05-13 16:14:28 +00:00
gtk_combo_box_set_active ( GTK_COMBO_BOX ( channel_cb ) , - 1 ) ;
2007-08-17 19:34:14 +00:00
change_airpcap_settings = FALSE ;
2009-05-13 16:14:28 +00:00
gtk_widget_set_sensitive ( GTK_WIDGET ( channel_cb ) , FALSE ) ;
2006-10-02 23:44:10 +00:00
}
2007-01-11 22:12:33 +00:00
else
2006-10-02 23:44:10 +00:00
{
2009-05-13 16:14:28 +00:00
while ( gtk_tree_model_iter_n_children ( gtk_combo_box_get_model ( GTK_COMBO_BOX ( channel_cb ) ) , NULL ) > 0 ) {
2011-07-24 15:22:21 +00:00
gtk_combo_box_text_remove ( GTK_COMBO_BOX_TEXT ( channel_cb ) , 0 ) ;
2009-05-13 16:14:28 +00:00
}
2011-07-11 19:10:57 +00:00
2013-02-25 23:35:13 +00:00
if ( if_info - > pSupportedChannels ! = NULL & & if_info - > numSupportedChannels > 0 ) {
2009-05-13 16:14:28 +00:00
guint i ;
2013-02-25 23:35:13 +00:00
for ( i = 0 ; i < ( if_info - > numSupportedChannels ) ; i + + ) {
2011-07-24 15:22:21 +00:00
gtk_combo_box_text_append_text ( GTK_COMBO_BOX_TEXT ( channel_cb ) , ieee80211_mhz_to_str ( airpcap_if_selected - > pSupportedChannels [ i ] . Frequency ) ) ;
2009-05-13 16:14:28 +00:00
}
2011-07-11 19:10:57 +00:00
}
2009-05-13 16:14:28 +00:00
airpcap_channel_combo_set_by_frequency ( channel_cb , if_info - > channelInfo . Frequency ) ;
2007-08-17 19:34:14 +00:00
change_airpcap_settings = TRUE ;
2009-05-13 16:14:28 +00:00
gtk_widget_set_sensitive ( GTK_WIDGET ( channel_cb ) , TRUE ) ;
2006-10-02 23:44:10 +00:00
}
}
2006-10-30 06:34:31 +00:00
/*
* Takes the keys from the GtkList widget , and add them to the interface list
*/
2011-02-07 20:24:42 +00:00
static void
airpcap_add_keys_to_driver_from_list ( GtkListStore * key_list_store , airpcap_if_info_t * fake_if_info )
2006-10-30 06:34:31 +00:00
{
2013-02-25 23:35:13 +00:00
GtkTreePath * path ;
GtkTreeIter iter ;
2011-02-07 20:24:42 +00:00
GtkTreeModel * model = GTK_TREE_MODEL ( key_list_store ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 22:12:33 +00:00
/* airpcap stuff */
2009-05-13 17:43:03 +00:00
guint i , j ;
2007-01-11 22:12:33 +00:00
gchar s [ 3 ] ;
PAirpcapKeysCollection KeysCollection ;
2009-11-12 23:48:11 +00:00
guint KeysCollectionSize ;
2009-05-13 17:43:03 +00:00
guint8 KeyByte ;
2006-10-30 06:34:31 +00:00
2009-05-13 17:43:03 +00:00
guint keys_in_list = 0 ;
2006-10-30 06:34:31 +00:00
2011-02-07 20:24:42 +00:00
gchar * row_type , * row_key ; /* SSID not needed for AirPcap */
size_t key_len ;
2006-10-30 06:34:31 +00:00
2013-02-25 23:35:13 +00:00
if ( fake_if_info = = NULL )
2010-11-28 00:41:47 +00:00
return ;
2006-10-30 06:34:31 +00:00
2011-02-07 20:24:42 +00:00
keys_in_list = gtk_tree_model_iter_n_children ( model , NULL ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 22:12:33 +00:00
/*
* Calculate the size of the keys collection
*/
2013-02-17 03:45:06 +00:00
KeysCollectionSize = ( guint ) AirpcapKeysCollectionSize ( keys_in_list ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 22:12:33 +00:00
/*
* Allocate the collection
*/
KeysCollection = ( PAirpcapKeysCollection ) g_malloc ( KeysCollectionSize ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 22:12:33 +00:00
/*
* Populate the key collection
*/
KeysCollection - > nKeys = keys_in_list ;
2006-10-30 06:34:31 +00:00
2007-01-11 22:12:33 +00:00
for ( i = 0 ; i < keys_in_list ; i + + )
{
2011-02-07 20:24:42 +00:00
path = gtk_tree_path_new_from_indices ( i , - 1 ) ;
gtk_tree_model_get_iter ( model , & iter , path ) ;
gtk_tree_path_free ( path ) ;
gtk_tree_model_get ( model , & iter ,
KL_COL_TYPE , & row_type ,
KL_COL_KEY , & row_key ,
- 1 ) ;
2010-11-28 00:41:47 +00:00
2013-02-25 23:35:13 +00:00
if ( g_ascii_strcasecmp ( row_type , AIRPCAP_WEP_KEY_STRING ) = = 0 )
2018-02-23 17:43:29 +00:00
KeysCollection - > Keys [ i ] . KeyType = DOT11DECRYPT_KEY_TYPE_WEP ;
2013-02-25 23:35:13 +00:00
else if ( g_ascii_strcasecmp ( row_type , AIRPCAP_WPA_PWD_KEY_STRING ) = = 0 )
2018-02-23 17:43:29 +00:00
KeysCollection - > Keys [ i ] . KeyType = DOT11DECRYPT_KEY_TYPE_WPA_PWD ;
2013-02-25 23:35:13 +00:00
else if ( g_ascii_strcasecmp ( row_type , AIRPCAP_WPA_BIN_KEY_STRING ) = = 0 )
2018-02-23 17:43:29 +00:00
KeysCollection - > Keys [ i ] . KeyType = DOT11DECRYPT_KEY_TYPE_WPA_PMK ;
2010-11-28 00:41:47 +00:00
/* Retrieve the Item corresponding to the i-th key */
2011-02-07 20:24:42 +00:00
key_len = strlen ( row_key ) ;
2010-11-28 00:41:47 +00:00
2011-02-07 20:24:42 +00:00
KeysCollection - > Keys [ i ] . KeyLen = ( guint ) key_len / 2 ;
2010-11-28 00:41:47 +00:00
memset ( & KeysCollection - > Keys [ i ] . KeyData , 0 , sizeof ( KeysCollection - > Keys [ i ] . KeyData ) ) ;
2013-02-25 23:35:13 +00:00
/* Key must be saved in a different way, depending on its type... */
2018-02-23 17:43:29 +00:00
if ( KeysCollection - > Keys [ i ] . KeyType = = DOT11DECRYPT_KEY_TYPE_WEP )
2010-11-28 00:41:47 +00:00
{
2011-02-07 20:24:42 +00:00
for ( j = 0 ; j < key_len ; j + = 2 )
2010-11-28 00:41:47 +00:00
{
2011-02-07 20:24:42 +00:00
s [ 0 ] = row_key [ j ] ;
s [ 1 ] = row_key [ j + 1 ] ;
2010-11-28 00:41:47 +00:00
s [ 2 ] = ' \0 ' ;
KeyByte = ( guint8 ) strtol ( s , NULL , 16 ) ;
KeysCollection - > Keys [ i ] . KeyData [ j / 2 ] = KeyByte ;
}
}
2011-02-07 20:24:42 +00:00
g_free ( row_type ) ;
g_free ( row_key ) ;
2007-01-11 22:12:33 +00:00
}
2006-10-30 06:34:31 +00:00
2007-01-11 22:12:33 +00:00
/*
* Free the old adapter key collection !
*/
2017-08-26 08:30:47 +00:00
g_free ( fake_if_info - > keysCollection ) ;
2007-01-11 22:12:33 +00:00
/*
* Set this collection ad the new one
*/
fake_if_info - > keysCollection = KeysCollection ;
fake_if_info - > keysCollectionSize = KeysCollectionSize ;
return ;
2006-10-30 06:34:31 +00:00
}
2006-10-19 00:48:03 +00:00
/*
* This function will take the current keys ( widget list ) , specified for the
* current adapter , and save them as default for ALL the others .
*/
void
2011-02-07 20:24:42 +00:00
airpcap_read_and_save_decryption_keys_from_list_store ( GtkListStore * key_list_store , airpcap_if_info_t * info_if , GList * if_list )
2006-10-19 00:48:03 +00:00
{
2011-02-07 20:24:42 +00:00
GtkTreeIter iter ;
GtkTreeModel * model = GTK_TREE_MODEL ( key_list_store ) ;
gboolean items_left ;
2007-01-11 22:12:33 +00:00
gint if_n = 0 ;
2013-02-25 23:35:13 +00:00
gint i = 0 ;
2007-01-11 22:12:33 +00:00
airpcap_if_info_t * curr_if = NULL ;
airpcap_if_info_t * fake_info_if = NULL ;
2013-02-25 23:35:13 +00:00
GList * key_list = NULL ;
2006-12-05 19:24:25 +00:00
2007-01-11 22:12:33 +00:00
char * tmp_type = NULL ;
2013-02-25 23:35:13 +00:00
char * tmp_key = NULL ;
2012-12-26 05:57:06 +00:00
char * tmp_ssid = NULL ;
2006-12-05 19:24:25 +00:00
2007-01-11 22:12:33 +00:00
decryption_key_t * tmp_dk = NULL ;
2006-12-05 19:24:25 +00:00
2007-01-11 22:12:33 +00:00
/*
* Save the keys for Wireshark . . .
*/
2006-12-05 19:24:25 +00:00
2011-02-07 20:24:42 +00:00
/* Create a list of keys from the list store */
for ( items_left = gtk_tree_model_get_iter_first ( model , & iter ) ;
items_left ;
items_left = gtk_tree_model_iter_next ( model , & iter ) ) {
2006-12-05 19:24:25 +00:00
2011-02-07 20:24:42 +00:00
gtk_tree_model_get ( model , & iter ,
KL_COL_TYPE , & tmp_type ,
KL_COL_KEY , & tmp_key ,
KL_COL_SSID , & tmp_ssid ,
- 1 ) ;
2010-11-28 00:41:47 +00:00
2013-02-25 23:35:13 +00:00
if ( g_ascii_strcasecmp ( tmp_type , AIRPCAP_WEP_KEY_STRING ) = = 0 )
2010-11-28 00:41:47 +00:00
{
tmp_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
tmp_dk - > key = g_string_new ( tmp_key ) ;
tmp_dk - > ssid = NULL ;
2018-02-23 17:43:29 +00:00
tmp_dk - > type = DOT11DECRYPT_KEY_TYPE_WEP ;
2010-11-28 00:41:47 +00:00
tmp_dk - > bits = ( guint ) tmp_dk - > key - > len * 4 ;
key_list = g_list_append ( key_list , tmp_dk ) ;
}
2013-02-25 23:35:13 +00:00
else if ( g_ascii_strcasecmp ( tmp_type , AIRPCAP_WPA_PWD_KEY_STRING ) = = 0 )
2010-11-28 00:41:47 +00:00
{
tmp_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
tmp_dk - > key = g_string_new ( tmp_key ) ;
tmp_dk - > ssid = g_byte_array_new ( ) ;
2012-12-26 05:57:06 +00:00
uri_str_to_bytes ( tmp_ssid ? tmp_ssid : " " , tmp_dk - > ssid ) ;
2018-02-23 17:43:29 +00:00
tmp_dk - > type = DOT11DECRYPT_KEY_TYPE_WPA_PWD ;
2010-11-28 00:41:47 +00:00
tmp_dk - > bits = 256 ;
key_list = g_list_append ( key_list , tmp_dk ) ;
}
2013-02-25 23:35:13 +00:00
else if ( g_ascii_strcasecmp ( tmp_type , AIRPCAP_WPA_BIN_KEY_STRING ) = = 0 )
2010-11-28 00:41:47 +00:00
{
tmp_dk = ( decryption_key_t * ) g_malloc ( sizeof ( decryption_key_t ) ) ;
tmp_dk - > key = g_string_new ( tmp_key ) ;
tmp_dk - > ssid = NULL ; /* No SSID in this case */
2018-02-23 17:43:29 +00:00
tmp_dk - > type = DOT11DECRYPT_KEY_TYPE_WPA_PMK ;
2010-11-28 00:41:47 +00:00
tmp_dk - > bits = 256 ;
key_list = g_list_append ( key_list , tmp_dk ) ;
}
2011-02-07 20:24:42 +00:00
g_free ( tmp_type ) ;
g_free ( tmp_ssid ) ;
2007-01-11 22:12:33 +00:00
}
2006-12-05 19:24:25 +00:00
2012-04-16 07:59:48 +00:00
save_wlan_wireshark_wep_keys ( key_list ) ;
2007-01-11 22:12:33 +00:00
/* The key_list has been freed!!! */
2006-10-30 06:34:31 +00:00
2007-01-11 22:12:33 +00:00
/*
* Save the key list for driver .
*/
2013-02-25 23:35:13 +00:00
if ( ( if_list = = NULL ) | | ( info_if = = NULL ) ) return ;
2006-12-05 19:24:25 +00:00
2007-01-11 22:12:33 +00:00
fake_info_if = airpcap_driver_fake_if_info_new ( ) ;
2006-10-30 06:34:31 +00:00
2011-02-07 20:24:42 +00:00
airpcap_add_keys_to_driver_from_list ( key_list_store , fake_info_if ) ;
2007-01-11 22:12:33 +00:00
airpcap_save_driver_if_configuration ( fake_info_if ) ;
airpcap_if_info_free ( fake_info_if ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
if_n = g_list_length ( if_list ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
/* For all the adapters in the list, empty the key list */
for ( i = 0 ; i < if_n ; i + + )
{
2010-11-28 00:41:47 +00:00
curr_if = ( airpcap_if_info_t * ) g_list_nth_data ( if_list , i ) ;
2006-12-28 17:22:12 +00:00
2013-02-25 23:35:13 +00:00
if ( curr_if ! = NULL )
2010-11-28 00:41:47 +00:00
{
/* XXX - Set an empty collection */
airpcap_if_clear_decryption_settings ( curr_if ) ;
2006-12-28 17:22:12 +00:00
2010-11-28 00:41:47 +00:00
/* Save to registry */
airpcap_save_selected_if_configuration ( curr_if ) ;
}
2007-01-11 22:12:33 +00:00
}
2006-10-19 00:48:03 +00:00
}
/*
* This function will load from the preferences file ALL the
2006-12-28 17:22:12 +00:00
* keys ( WEP , WPA and WPA_BIN ) and will set them as default for
2006-10-19 00:48:03 +00:00
* each adapter . To do this , it will save the keys in the registry . . .
* A check will be performed , to make sure that keys found in
2006-12-28 17:22:12 +00:00
* registry and keys found in Wireshark preferences are the same . If not ,
2006-10-19 00:48:03 +00:00
* the user will be asked to choose if use all keys ( merge them ) ,
* or use Wireshark preferences ones . In the last case , registry keys will
* be overwritten for all the connected AirPcap adapters .
* In the first case , adapters will use their own keys , but those
* keys will not be accessible via Wireshark . . .
*/
gboolean
airpcap_check_decryption_keys ( GList * if_list )
{
2013-02-25 23:35:13 +00:00
gint if_n = 0 ;
gint i = 0 ;
2007-01-11 22:12:33 +00:00
gint n_adapters_keys = 0 ;
2013-02-25 23:35:13 +00:00
gint n_driver_keys = 0 ;
2007-01-11 22:12:33 +00:00
airpcap_if_info_t * curr_if = NULL ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
GList * wireshark_key_list ;
GList * driver_key_list ;
GList * curr_adapter_key_list ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
gboolean equals = TRUE ;
gboolean adapters_keys_equals = TRUE ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
/*
* If no AirPcap interface is found , return TRUE , so Wireshark
* will use HIS OWN keys .
*/
2013-02-25 23:35:13 +00:00
if ( if_list = = NULL )
2010-11-28 00:41:47 +00:00
return TRUE ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
if_n = g_list_length ( if_list ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
/* Get Wireshark preferences keys */
wireshark_key_list = get_wireshark_keys ( ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 22:12:33 +00:00
/* Retrieve AirPcap driver's keys */
driver_key_list = get_airpcap_driver_keys ( ) ;
n_driver_keys = g_list_length ( driver_key_list ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 22:12:33 +00:00
equals & = key_lists_are_equal ( wireshark_key_list , driver_key_list ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
for ( i = 0 ; i < if_n ; i + + )
{
2010-11-28 00:41:47 +00:00
curr_if = ( airpcap_if_info_t * ) g_list_nth_data ( if_list , i ) ;
curr_adapter_key_list = get_airpcap_device_keys ( curr_if ) ;
n_adapters_keys + = g_list_length ( curr_adapter_key_list ) ;
adapters_keys_equals & = key_lists_are_equal ( wireshark_key_list , curr_adapter_key_list ) ;
2007-01-11 22:12:33 +00:00
}
2006-10-19 00:48:03 +00:00
2013-02-25 23:35:13 +00:00
if ( n_adapters_keys ! = 0 ) /* If for some reason at least one specific key has been found */
2010-11-28 00:41:47 +00:00
equals & = adapters_keys_equals ; /* */
2006-10-30 06:34:31 +00:00
2013-02-25 23:35:13 +00:00
if ( n_driver_keys = = 0 ) /* No keys set in any of the AirPcap adapters... */
2010-11-28 00:41:47 +00:00
return TRUE ; /* Use Wireshark keys and set them ad default for airpcap devices */
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
return equals ;
2006-10-19 00:48:03 +00:00
}
/*
* This function will load from the preferences file ALL the
2006-12-28 17:22:12 +00:00
* keys ( WEP , WPA_PWD and WPA_BIN ) and will set them as default for
2006-10-19 00:48:03 +00:00
* each adapter . To do this , it will save the keys in the registry . . .
* A check will be performed , to make sure that keys found in
2006-12-28 17:22:12 +00:00
* registry and keys found in Wireshark preferences are the same . If not ,
2006-10-19 00:48:03 +00:00
* the user will be asked to choose if use all keys ( merge them ) ,
* or use Wireshark preferences ones . In the last case , registry keys will
* be overwritten for all the connected AirPcap adapters .
* In the first case , adapters will use their own keys , but those
* keys will not be accessible via Wireshark . . .
*/
void
airpcap_load_decryption_keys ( GList * if_list )
{
2007-01-11 22:12:33 +00:00
gint if_n = 0 ;
2013-02-25 23:35:13 +00:00
gint i = 0 ;
2006-10-19 00:48:03 +00:00
2013-02-25 23:35:13 +00:00
if ( if_list = = NULL ) return ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
if_n = g_list_length ( if_list ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
for ( i = 0 ; i < if_n ; i + + )
{
2010-11-28 00:41:47 +00:00
load_wlan_driver_wep_keys ( ) ;
2007-01-11 22:12:33 +00:00
}
2006-10-19 00:48:03 +00:00
}
/*
2006-12-28 17:22:12 +00:00
* This function will set the gibven GList of decryption_key_t structures
2006-10-19 00:48:03 +00:00
* as the defoult for both Wireshark and the AirPcap adapters . . .
*/
void
airpcap_save_decryption_keys ( GList * key_list , GList * adapters_list )
{
2007-01-11 22:12:33 +00:00
gint if_n = 0 ;
2013-02-25 23:35:13 +00:00
gint i = 0 ;
2007-01-11 22:12:33 +00:00
airpcap_if_info_t * curr_if = NULL ;
GList * empty_key_list = NULL ;
2006-10-19 00:48:03 +00:00
2013-02-25 23:35:13 +00:00
if ( ( key_list = = NULL ) | | ( adapters_list = = NULL ) ) return ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
if_n = g_list_length ( adapters_list ) ;
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
/* Set the driver's global list of keys. */
2007-01-26 06:45:12 +00:00
write_wlan_driver_wep_keys_to_registry ( key_list ) ;
2006-10-30 06:34:31 +00:00
2007-01-11 22:12:33 +00:00
/* Empty the key list for each interface */
for ( i = 0 ; i < if_n ; i + + )
{
2010-11-28 00:41:47 +00:00
curr_if = ( airpcap_if_info_t * ) g_list_nth_data ( adapters_list , i ) ;
write_wlan_wep_keys_to_registry ( curr_if , empty_key_list ) ;
2007-01-11 22:12:33 +00:00
}
2006-10-19 00:48:03 +00:00
2007-01-11 22:12:33 +00:00
/*
* This will set the keys of the current adapter as Wireshark default . . .
* Now all the adapters have the same keys , so curr_if is ok as any other . . .
*/
save_wlan_wireshark_wep_keys ( key_list ) ;
2006-12-05 19:24:25 +00:00
}
/*
* This function is used to enable / disable the toolbar widgets
* depending on the type of interface selected . . . Not the whole
* toolbar must be grayed / enabled . . . Only some widgets . . .
*/
void
airpcap_enable_toolbar_widgets ( GtkWidget * w , gboolean en )
{
2010-11-28 00:41:47 +00:00
GtkWidget * toolbar_tb ,
* if_description_lb ,
* toolbar_channel_cb ,
* channel_lb ,
* channel_offset_cb ,
* channel_offset_lb ,
* fcs_cb ,
* fcs_lb ,
* advanced_bt ;
2007-01-11 22:12:33 +00:00
2013-02-25 23:35:13 +00:00
if ( w = = NULL )
2010-11-28 00:41:47 +00:00
return ;
2006-12-05 19:24:25 +00:00
2007-01-11 22:12:33 +00:00
toolbar_tb = w ;
2006-12-05 19:24:25 +00:00
2013-03-08 22:10:06 +00:00
if_description_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( toolbar_tb ) , AIRPCAP_TOOLBAR_INTERFACE_KEY ) ;
channel_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( toolbar_tb ) , AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY ) ;
toolbar_channel_cb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( toolbar_tb ) , AIRPCAP_TOOLBAR_CHANNEL_KEY ) ;
channel_offset_cb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( toolbar_tb ) , AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY ) ;
channel_offset_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( toolbar_tb ) , AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY ) ;
fcs_lb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( toolbar_tb ) , AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY ) ;
fcs_cb = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( toolbar_tb ) , AIRPCAP_TOOLBAR_FCS_FILTER_KEY ) ;
advanced_bt = ( GtkWidget * ) g_object_get_data ( G_OBJECT ( toolbar_tb ) , AIRPCAP_TOOLBAR_ADVANCED_KEY ) ;
2010-11-28 00:41:47 +00:00
2013-02-25 23:35:13 +00:00
if ( if_description_lb ! = NULL )
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( if_description_lb , en ) ;
2013-02-25 23:35:13 +00:00
if ( channel_lb ! = NULL )
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( channel_lb , en ) ;
2013-02-25 23:35:13 +00:00
if ( toolbar_channel_cb ! = NULL )
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( toolbar_channel_cb , en ) ;
2013-02-25 23:35:13 +00:00
if ( channel_offset_cb ! = NULL )
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( channel_offset_cb , en ) ;
2013-02-25 23:35:13 +00:00
if ( channel_offset_lb ! = NULL )
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( channel_offset_lb , en ) ;
2013-02-25 23:35:13 +00:00
if ( fcs_lb ! = NULL )
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( fcs_lb , en ) ;
2013-02-25 23:35:13 +00:00
if ( fcs_cb ! = NULL )
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( fcs_cb , en ) ;
2013-02-25 23:35:13 +00:00
if ( advanced_bt ! = NULL )
2010-11-28 00:41:47 +00:00
gtk_widget_set_sensitive ( advanced_bt , en ) ;
2006-12-05 19:24:25 +00:00
2007-01-11 22:12:33 +00:00
return ;
2006-12-05 19:24:25 +00:00
}
2009-06-29 23:08:05 +00:00
/*
* Editor modelines - http : //www.wireshark.org/tools/modelines.html
*
* Local variables :
* c - basic - offset : 4
2011-09-21 16:44:10 +00:00
* tab - width : 8
2009-06-29 23:08:05 +00:00
* indent - tabs - mode : nil
* End :
*
2011-09-21 16:44:10 +00:00
* vi : set shiftwidth = 4 tabstop = 8 expandtab :
* : indentSize = 4 : tabSize = 8 : noTabs = true :
2009-06-30 00:32:20 +00:00
*/