From a980d047830755406fc27150978511b407d65829 Mon Sep 17 00:00:00 2001 From: Gerald Combs Date: Tue, 5 Dec 2006 19:24:25 +0000 Subject: From Davide Schiera and Giorgio Tino: Add initial WPA/WPA2 decryption support. WEP key preferences have been overloaded to allow WPA keys. The decryption code currently uses Windows-specific data types, but can be converted to use glib equivalents. Add a few text and whitespace fixups. svn path=/trunk/; revision=20049 --- AUTHORS | 26 +- Makefile.nmake | 2 +- airpcap.h | 5 +- airpcap_loader.c | 725 ++++++++++++++++++++++++++----------- airpcap_loader.h | 84 ++++- epan/dissectors/Makefile.nmake | 15 +- epan/dissectors/packet-ieee80211.c | 678 +++++++++++++++++++++++++++++++++- epan/libwireshark.def | 1 + gtk/Makefile.nmake | 4 +- gtk/airpcap_dlg.c | 635 ++++++++++++++++++++++---------- gtk/airpcap_dlg.h | 6 + gtk/airpcap_gui_utils.c | 336 ++++++++++++----- gtk/airpcap_gui_utils.h | 18 +- gtk/capture_dlg.c | 11 +- gtk/capture_if_dlg.c | 10 +- gtk/keys.h | 7 + gtk/main.c | 39 +- 17 files changed, 2038 insertions(+), 564 deletions(-) diff --git a/AUTHORS b/AUTHORS index b40e06cb5a..91c15582b3 100644 --- a/AUTHORS +++ b/AUTHORS @@ -23,7 +23,7 @@ Gilbert Ramirez { Hannes R. Boehm { http://hannes.boehm.org/ - OSPFv2 + OSPFv2 RIPv1, RIPv2 CDP (Cisco Discovery Protocol Version 1) } @@ -1434,7 +1434,7 @@ Solomon Peachy { Jaime Fournier { Handle DCE RPC connectionless CANCEL PDUs with no body - DCE/RPC stub dissectors for RSEC_LOGIN, RS_ACCT, RS_ATTR, RS_MISC, + DCE/RPC stub dissectors for RSEC_LOGIN, RS_ACCT, RS_ATTR, RS_MISC, RS_PGO, RS_REPLIST, RS_UNIX, RPRIV, ROVERRIDE, RS_REPADM, DTSSTIME_REQ, CDS_SOLICIT, CPRPC_SERVER, DTSPROVIDER, UBIKDISK, UBIKVOTE, BOSSVR, FTSERVER, CDS_CLERKSERVER, @@ -2154,7 +2154,7 @@ Duncan Sargeant { } Love Hörnquist Åstrand { - HAVE_HEIMDAL_KERBEROS support to allow Ethereal to use heimdal + HAVE_HEIMDAL_KERBEROS support to allow Ethereal to use heimdal libraries to decrypt kerberos encrypted blobs. } @@ -2328,7 +2328,7 @@ Stefano Pettini { } Jon Ringle { - Conversations demarked by setup frame number + Conversations demarked by setup frame number } Tim Endean { @@ -2473,7 +2473,7 @@ W. Borgert { Frederic Roudaut { IPsec ESP payload decryption -} +} Christoph Scholz { Bluetooth stack: http://affix.sourceforge.net/archive/ethereal_affix-3.patch @@ -2542,6 +2542,16 @@ Douglas Pratley { Epoch timestamps } +Giorgio Tino { + AirPcap support + WPA UI support + Static text preferences +} + +Davide Schiera { + WPA and WPA2 decryption +} + and by: Pavel Roskin @@ -2636,7 +2646,7 @@ Vladimir Kondratiev Jaap Keuter Frederic Peters Anton Ivanov -Ilya Konstantinov +Ilya Konstantinov Neil Kettle Steve Karg Steve Packet @@ -2673,7 +2683,7 @@ Ian Abel Bryant Eastham Taner Kurtulus Joe Breher -Patrick vd Lageweg +Patrick vd Lageweg Alain Magloire was kind enough to give his permission to use his version of snprintf.c. @@ -2693,7 +2703,7 @@ Henrik Brix Andersen gave permission for his webbrowser calling routine to be used. Christophe Devine gave permission for his -SHA1 routines to be used. +SHA1 routines to be used. snax gave permission to use his(?) weak key detection code from Airsnort. diff --git a/Makefile.nmake b/Makefile.nmake index 6892e5c02b..d39cf2a471 100644 --- a/Makefile.nmake +++ b/Makefile.nmake @@ -13,7 +13,7 @@ LINK= link LDFLAGS = /NOLOGO /INCREMENTAL:no /MACHINE:I386 $(LOCAL_LDFLAGS) -CFLAGS=-DHAVE_CONFIG_H $(LOCAL_CFLAGS) $(GLIB_CFLAGS) /I. /Iwiretap \ +CFLAGS=-DHAVE_CONFIG_H -DHAVE_AIRPDCAP $(LOCAL_CFLAGS) $(GLIB_CFLAGS) /I. /Iwiretap \ $(ZLIB_CFLAGS) /I$(PCAP_DIR)\include \ $(NET_SNMP_CFLAGS) \ $(ADNS_CFLAGS) $(PCRE_CFLAGS) $(GNUTLS_CFLAGS) $(LUA_CFLAGS) \ diff --git a/airpcap.h b/airpcap.h index d6df6ca1b0..1a7aeb28d4 100644 --- a/airpcap.h +++ b/airpcap.h @@ -88,6 +88,7 @@ typedef struct _AirpcapDeviceDescription #define WEP_KEY_MAX_SIZE 32 /* Maximum size of a WEP key, in bytes. This is the size of an entry in the */ /* AirpcapWepKeysCollection structure */ + #ifndef __MINGW32__ #pragma pack(push) #pragma pack(1) @@ -95,8 +96,8 @@ typedef struct _AirpcapDeviceDescription #define AIRPCAP_KEYTYPE_WEP 0 /* Key type: WEP. The key can have an arbitrary length smaller than 32 bytes. */ -#define AIRPCAP_KEYTYPE_TKIP 1 /* Key type: TKIP (WPA). NOT SUPPORTED YET. */ -#define AIRPCAP_KEYTYPE_CCMP 2 /* Key type: CCMP (WPA2). NOT SUPPORTED YET. */ +#define AIRPCAP_KEYTYPE_TKIP 1 /* Key type: TKIP (WPA_PWD). NOT SUPPORTED YET. */ +#define AIRPCAP_KEYTYPE_CCMP 2 /* Key type: CCMP (WPA_BIN). NOT SUPPORTED YET. */ /*! \brief WEP key container diff --git a/airpcap_loader.c b/airpcap_loader.c index a8d41605c8..d0ddf88f9d 100644 --- a/airpcap_loader.c +++ b/airpcap_loader.c @@ -49,6 +49,9 @@ #include #include "airpcap_loader.h" +/* AirPDcap */ +#include "../airpdcap/airpdcap_ws.h" + /* * We load dinamically the dag library in order link it only when * it's present on the system @@ -106,7 +109,9 @@ airpcap_if_info_t *airpcap_if_active = NULL; /* WLAN preferences pointer */ module_t *wlan_prefs = NULL; -/* Callback used by the load_wlan_keys() routine in order to read a WEP decryption key */ +/* + * 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 _U_) { @@ -122,45 +127,20 @@ if (g_strncasecmp(pref->name, "wep_key", 7) == 0 && pref->type == PREF_STRING) { my_string = g_strdup(*pref->varp.string); - if( my_string != NULL) + /* Here we have the string describing the key... */ + new_key = parse_key_string(my_string); + + if( new_key != NULL) { /* Key is added only if not null ... */ - if( (g_strcasecmp(my_string,"") != 0) && (wep_key_is_valid(my_string))) - { - new_key = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); - - new_key->key = g_string_new(my_string); - g_free(my_string); - - new_key->bits = new_key->key->len * 4; - - new_key->type = AIRPCAP_KEYTYPE_WEP; - - new_key->ssid = 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 load_wlan_keys() routine in order to read a WPA decryption key */ -static guint -get_wpa_key(pref_t *pref, gpointer ud _U_) -{ -return 1; -} - -/* Callback used by the load_wlan_keys() routine in order to read a WPA2 decryption key */ -static guint -get_wpa2_key(pref_t *pref, gpointer ud _U_) -{ -return 1; -} - /* Returs TRUE if the WEP key is valid, false otherwise */ gboolean wep_key_is_valid(char* key) @@ -204,6 +184,8 @@ gchar *my_string = NULL; keys_cb_data_t* user_data; gint wep_key_number = 0; +decryption_key_t* new_key; + /* Retrieve user data info */ user_data = (keys_cb_data_t*)ud; @@ -216,11 +198,19 @@ if (g_strncasecmp(pref->name, "wep_key", 7) == 0 && pref->type == PREF_STRING) { if(wep_key_number == (user_data->current_index+1)) { - my_string = g_strdup((char*)g_list_nth_data(user_data->list,user_data->current_index)); + /* Retrieve the nth decryption_key_t structure pointer */ + new_key = (decryption_key_t*)g_list_nth_data(user_data->list,user_data->current_index); + /* Free the old key string */ g_free((void *)*pref->varp.string); + + /* Create the new string describing the decryption key */ + my_string = get_key_string(new_key); + + /* Duplicate the string, and assign it to the variable pointer */ *pref->varp.string = (void *)g_strdup(my_string); + /* Free the previously allocated string */ g_free(my_string); } } @@ -237,63 +227,6 @@ if (g_strncasecmp(pref->name, "wep_key", 7) == 0 && pref->type == PREF_STRING) return 0; } -/* - * Function used to read the Decryption Keys from the preferences and store them - * properly into the airpcap adapter. - */ -BOOL -load_wlan_wep_keys(airpcap_if_info_t* info_if) -{ -keys_cb_data_t* user_data; -guint i; -gchar *tmp = NULL; - -if(info_if == NULL) return FALSE; - -/* 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 - */ -wlan_prefs->prefs_changed = TRUE; - -prefs_apply(wlan_prefs); - -write_wlan_wep_keys_to_regitry(info_if,user_data->list); - -/* FREE MEMORY */ -/* free the WEP key string */ -for(i=0;ilist);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); - -return TRUE; -} - - - /* * Function used to read the Decryption Keys from the preferences and store them * properly into the airpcap adapter. @@ -393,7 +326,7 @@ KeysCollection->nKeys = keys_in_list; for(i = 0; i < keys_in_list; i++) { - KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_WEP; + KeysCollection->Keys[i].KeyType = AIRPDCAP_KEY_TYPE_WEP; /* Retrieve the Item corresponding to the i-th key */ key_item = (decryption_key_t*)g_list_nth_data(key_list,i); @@ -446,7 +379,7 @@ return TRUE; BOOL write_wlan_driver_wep_keys_to_regitry(GList* key_list) { -UINT i,j; +UINT i,j,k,n,y; GString *new_key; gchar s[3]; PAirpcapKeysCollection KeysCollection; @@ -459,7 +392,17 @@ 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(); -keys_in_list = g_list_length(key_list); +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++ ) + if(((decryption_key_t*)g_list_nth_data(key_list,k))->type == AIRPDCAP_KEY_TYPE_WEP) + keys_in_list++; /* * Save the encryption keys, if we have any of them @@ -485,16 +428,33 @@ if(!KeysCollection) */ KeysCollection->nKeys = keys_in_list; -for(i = 0; i < keys_in_list; i++) -{ - KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_WEP; +/* + * 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); + + /* + * XXX - The AIRPDCAP_KEY_TYPE_WEP is the only supportd right now! + * 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) + */ + if(key_item->type == AIRPDCAP_KEY_TYPE_WEP) + { + KeysCollection->Keys[y].KeyType = AIRPDCAP_KEY_TYPE_WEP; + new_key = g_string_new(key_item->key->str); - KeysCollection->Keys[i].KeyLen = new_key->len / 2; - memset(&KeysCollection->Keys[i].KeyData, 0, sizeof(KeysCollection->Keys[i].KeyData)); + KeysCollection->Keys[y].KeyLen = new_key->len / 2; + memset(&KeysCollection->Keys[y].KeyData, 0, sizeof(KeysCollection->Keys[y].KeyData)); for(j = 0 ; j < new_key->len; j += 2) { @@ -502,11 +462,21 @@ for(i = 0; i < keys_in_list; i++) s[1] = new_key->str[j+1]; s[2] = '\0'; KeyByte = (UCHAR)strtol(s, NULL, 16); - KeysCollection->Keys[i].KeyData[j / 2] = KeyByte; + KeysCollection->Keys[y].KeyData[j / 2] = KeyByte; } - + /* XXX - Change when WPA will be supported!!! */ + y++; g_string_free(new_key,TRUE); } + else if(key_item->type == AIRPDCAP_KEY_TYPE_WPA_PWD) + { + /* XXX - The driver cannot deal with this kind of key yet... */ + } + else if(key_item->type == AIRPDCAP_KEY_TYPE_WPA_PMK) + { + /* XXX - The driver cannot deal with this kind of key yet... */ + } +} /* * Free the old adapter key collection! @@ -535,80 +505,6 @@ airpcap_if_info_free(fake_info_if); return TRUE; } -/* - * Function used to save to the preference file the Decryption Keys. - */ -gboolean -save_wlan_wep_keys(airpcap_if_info_t* info_if) -{ -GList* key_list = NULL; -char* tmp_key = NULL; -guint keys_in_list,i; -keys_cb_data_t* user_data; - -if(info_if == NULL) return FALSE; - -/* 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 */ -/* Number of keys in key list */ -if(info_if->keysCollectionSize != 0) - keys_in_list = (guint)(info_if->keysCollectionSize - sizeof(AirpcapKeysCollection))/sizeof(AirpcapKey); -else - keys_in_list = 0; - -for(i=0; ikeysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_WEP) - { - tmp_key = airpcap_get_key_string(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 */ -wlan_prefs->prefs_changed = TRUE; - -/* Apply changes for the specified preference */ -prefs_apply(wlan_prefs); - -/* FREE MEMORY */ -/* free the WEP key string */ -for(i=0;ilist);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); - -return TRUE; -} - /* * Function used to save to the preference file the Decryption Keys. */ @@ -624,6 +520,9 @@ 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; + /* Retrieve the wlan preferences */ wlan_prefs = prefs_find_module("wlan"); @@ -640,7 +539,7 @@ else for(i=0; ikeysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_WEP) +if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP) { tmp_key = airpcap_get_key_string(fake_info_if->keysCollection->Keys[i]); key_list = g_list_append(key_list,g_strdup(tmp_key)); @@ -698,6 +597,7 @@ char* tmp_key = NULL; guint keys_in_list,i; keys_cb_data_t* user_data; airpcap_if_info_t* fake_info_if = NULL; +decryption_key_t* tmp_dk; /* Retrieve the wlan preferences */ wlan_prefs = prefs_find_module("wlan"); @@ -731,7 +631,9 @@ prefs_apply(wlan_prefs); /* free the WEP key string */ for(i=0;ilist);i++) { - g_free(g_list_nth(user_data->list,i)->data); + 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_string_free(tmp_dk->ssid,TRUE); } /* free the (empty) list */ @@ -770,6 +672,7 @@ PAirpcapHandle airpcap_if_open(PCHAR name, PCHAR err) { if (!AirpcapLoaded) return NULL; + if (name == NULL) return NULL; return g_PAirpcapOpen(name,err); } @@ -972,8 +875,12 @@ airpcap_if_info_new(char *name, char *description) PAirpcapHandle ad; gchar ebuf[AIRPCAP_ERRBUF_SIZE]; - airpcap_if_info_t *if_info; + airpcap_if_info_t *if_info = NULL; + /* Probably I have to switch on the leds!!! */ + ad = airpcap_if_open(name, ebuf); + if(ad) + { if_info = g_malloc(sizeof (airpcap_if_info_t)); if_info->name = g_strdup(name); if (description == NULL) @@ -982,11 +889,6 @@ gchar ebuf[AIRPCAP_ERRBUF_SIZE]; if_info->description = g_strdup(description); if_info->ip_addr = NULL; if_info->loopback = FALSE; - - /* Probably I have to switch on the leds!!! */ - ad = airpcap_if_open(if_info->name, ebuf); - if(ad) - { airpcap_if_get_fcs_validation(ad,&(if_info->CrcValidationOn)); airpcap_if_get_fcs_presence(ad,&(if_info->IsFcsPresent)); airpcap_if_get_link_type(ad,&(if_info->linkType)); @@ -1016,6 +918,10 @@ airpcap_driver_fake_if_info_new() airpcap_if_info_t *if_info = NULL; airpcap_if_info_t *fake_if_info = NULL; + /* Maybe for some reason no airpcap adapter is found */ + if(airpcap_if_list == NULL) + return NULL; + /* * Retrieve the first AirPcap adapter available. If no interface is found, * it is not possible to retrieve the driver's settings, so return NULL. @@ -1024,16 +930,15 @@ airpcap_driver_fake_if_info_new() if(if_info == NULL) return NULL; + /* Open the 'fake' adapter */ + ad = airpcap_if_open(if_info->name, ebuf); + if(ad) + { fake_if_info = g_malloc(sizeof (airpcap_if_info_t)); fake_if_info->name = g_strdup(if_info->name); fake_if_info->description = g_strdup(if_info->description); fake_if_info->loopback = FALSE; fake_if_info->ip_addr = NULL; - - /* Open the 'fake' adapter */ - ad = airpcap_if_open(if_info->name, ebuf); - if(ad) - { airpcap_if_get_driver_decryption_state(ad, &(fake_if_info->DecryptionOn)); airpcap_if_get_fcs_validation(ad,&(fake_if_info->CrcValidationOn)); airpcap_if_get_fcs_presence(ad,&(fake_if_info->IsFcsPresent)); @@ -1343,9 +1248,10 @@ unsigned int j = 0; unsigned int l = 0; gchar *dst,*src; +dst = NULL; src = NULL; -if(key.KeyType == AIRPCAP_KEYTYPE_WEP) +if(key.KeyType == AIRPDCAP_KEY_TYPE_WEP) { if(key.KeyLen != 0) { @@ -1365,11 +1271,11 @@ if(key.KeyType == AIRPCAP_KEYTYPE_WEP) g_free(src); } } -else if(key.KeyType == AIRPCAP_KEYTYPE_TKIP) +else if(key.KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD) { /* XXX - Add code here */ } -else if(key.KeyType == AIRPCAP_KEYTYPE_CCMP) +else if(key.KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK) { /* XXX - Add code here */ } @@ -1656,12 +1562,12 @@ g_print("KEY : %s\n",tmp->key->str); g_print("BITS: %d\n",tmp->bits); -if(tmp->type == AIRPCAP_KEYTYPE_WEP) +if(tmp->type == AIRPDCAP_KEY_TYPE_WEP) g_print("TYPE: %s\n",AIRPCAP_WEP_KEY_STRING); -else if(tmp->type == AIRPCAP_KEYTYPE_TKIP) - g_print("TYPE: %s\n",AIRPCAP_WPA_KEY_STRING); -else if(tmp->type == AIRPCAP_KEYTYPE_CCMP) - g_print("TYPE: %s\n",AIRPCAP_WPA2_KEY_STRING); +else if(tmp->type == AIRPDCAP_KEY_TYPE_WPA_PWD) + g_print("TYPE: %s\n",AIRPCAP_WPA_PWD_KEY_STRING); +else if(tmp->type == AIRPDCAP_KEY_TYPE_WPA_PMK) + g_print("TYPE: %s\n",AIRPCAP_WPA_BIN_KEY_STRING); else g_print("TYPE: %s\n","???"); @@ -1696,7 +1602,7 @@ else for(i=0; ikeysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_WEP) +if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP) { /* allocate memory for the new key item */ new_key = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); @@ -1719,11 +1625,11 @@ if(info_if->keysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_WEP) /* Append the new element in the list */ key_list = g_list_append(key_list,(gpointer)new_key); } -else if(info_if->keysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_TKIP) +else if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD) { /* XXX - Not supported yet */ } -else if(info_if->keysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_CCMP) +else if(info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK) { /* XXX - Not supported yet */ } @@ -1768,7 +1674,7 @@ else for(i=0; ikeysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_WEP) +if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP) { /* allocate memory for the new key item */ new_key = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); @@ -1777,7 +1683,7 @@ if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_WEP) /* KEY */ tmp_key = airpcap_get_key_string(fake_info_if->keysCollection->Keys[i]); new_key->key = g_string_new(tmp_key); - g_free(tmp_key); + if(tmp_key != NULL) g_free(tmp_key); /* BITS */ new_key->bits = new_key->key->len *4; /* every char is 4 bits in WEP keys (it is an exadecimal number) */ @@ -1791,11 +1697,11 @@ if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_WEP) /* Append the new element in the list */ key_list = g_list_append(key_list,(gpointer)new_key); } -else if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_TKIP) +else if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD) { /* XXX - Not supported yet */ } -else if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_CCMP) +else if(fake_info_if->keysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WPA_PMK) { /* XXX - Not supported yet */ } @@ -1814,15 +1720,11 @@ GList* get_wireshark_keys() { keys_cb_data_t* wep_user_data = NULL; -keys_cb_data_t* wpa_user_data = NULL; -keys_cb_data_t* wpa2_user_data= NULL; gchar *tmp = NULL; GList* final_list = NULL; GList* wep_final_list = NULL; -GList* wpa_final_list = NULL; -GList* wpa2_final_list = NULL; /* Retrieve the wlan preferences */ wlan_prefs = prefs_find_module("wlan"); @@ -1838,23 +1740,15 @@ 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); -prefs_pref_foreach(wlan_prefs, get_wpa_key, (gpointer)wpa_user_data); -prefs_pref_foreach(wlan_prefs, get_wpa2_key, (gpointer)wpa2_user_data); /* Copy the list field in the user data structure pointer into the final_list */ if(wep_user_data != NULL) wep_final_list = wep_user_data->list; -if(wpa_user_data != NULL) wpa_final_list = wpa_user_data->list; -if(wpa2_user_data != NULL) wpa2_final_list = wpa2_user_data->list; /* XXX - Merge the three lists!!!!! */ final_list = wep_final_list; /* free the wep_user_data structure */ g_free(wep_user_data); -/* free the wpa_user_data structure */ -g_free(wpa_user_data); -/* free the wpa2_user_data structure */ -g_free(wpa2_user_data); return final_list; } @@ -2056,6 +1950,10 @@ 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! */ +//if( (k1->type == AIRPDCAP_KEY_TYPE_WPA_PWD) || (k2->type == AIRPDCAP_KEY_TYPE_WPA_PWD) || (k1->type == AIRPDCAP_KEY_TYPE_WPA_PMK) || (k2->type == AIRPDCAP_KEY_TYPE_WPA_PMK) ) +// 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) @@ -2085,26 +1983,68 @@ gboolean key_lists_are_equal(GList* list1, GList* list2) { guint n1=0,n2=0; -guint i; +/* 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 not implemented. + */ +for(i=0;itype == AIRPDCAP_KEY_TYPE_WEP) + { + wep_list1 = g_list_append(wep_list1,(gpointer)dk1); + wep_n1++; + } + } +for(i=0;itype == AIRPDCAP_KEY_TYPE_WEP) + { + 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(n1 != n2) return FALSE; */ +if(wep_n1 != wep_n2) return FALSE; -for(i=0;ikey,dk2->key)) return FALSE; +}*/ +for(i=0;i:[:] +* XXX - For backward compatibility, the a WEP key can be just a string of hexadecimal +* characters (if WEP key is wrong, null will be returned...). +*/ +tokens = g_strsplit(input_string,":",0); + +/* Tokens is a null termiated array of strings ... */ +while(tokens[n] != NULL) + n++; + +if(n == 0) +{ + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; +} + +/* +* 'n' contains the number of tokens. If the key string is correct, we should have +* 2 or 3 tokens... If we have 1 token, it can be an 'old style' WEP key... check for it... +*/ +if(n == 1) +{ + /* Maybe it is an 'old style' WEP key */ + key = g_strdup(tokens[0]); + + /* Create a new string */ + key_string = g_string_new(key); + + /* Check if it is a correct WEP key */ + if( ((key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WEP_KEY_MIN_CHAR_SIZE)) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + if((key_string->len % 2) != 0) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + for(i = 0; i < key_string->len; i++) + { + if(!g_ascii_isxdigit(key_string->str[i])) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + } + + /* Key is correct! It was probably an 'old style' WEP key */ + /* Create the decryption_key_t structure, fill it and return it*/ + dk = g_malloc(sizeof(decryption_key_t)); + + dk->type = AIRPDCAP_KEY_TYPE_WEP; + dk->key = g_string_new(key); + dk->bits = dk->key->len * 4; + dk->ssid = NULL; + + g_string_free(key_string, TRUE); + g_free(key); + + /* Free the array of strings */ + g_strfreev(tokens); + + return dk; +} + +/* There were at least 2 tokens... copy the type value */ +type = g_strdup(tokens[0]); + +/* +* The second token is the key (right now it doesn't matter +* if it is a passphrase or an hexadecimal one) +*/ +key = g_strdup(tokens[1]); + +/* Lower case... */ +g_strdown(type); +g_strdown(key); + +/* Maybe there is a third token (an ssid, if everything else is ok) */ +if(n >= 3) +{ + ssid = g_strdup(tokens[2]); + g_strdown(ssid); +} +else +{ + ssid = NULL; +} + +/* +* Now the initial key string has been divided in two/three tokens... let's see +* which kind of key it is, and if it is the correct form +*/ +if(g_strcasecmp(type,STRING_KEY_TYPE_WEP) == 0) /* WEP key */ +{ + /* Create a new string */ + key_string = g_string_new(key); + + /* Check if it is a correct WEP key */ + if( ((key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WEP_KEY_MIN_CHAR_SIZE)) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + if((key_string->len % 2) != 0) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + for(i = 0; i < key_string->len; i++) + { + if(!g_ascii_isxdigit(key_string->str[i])) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + } + + dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); + + dk->type = AIRPDCAP_KEY_TYPE_WEP; + dk->key = g_string_new(key); + dk->bits = dk->key->len * 4; + dk->ssid = NULL; + + g_string_free(key_string, TRUE); + g_free(key); + + /* Free the array of strings */ + g_strfreev(tokens); + return dk; +} +else if(g_strcasecmp(type,STRING_KEY_TYPE_WPA_PSK) == 0) /* WPA key */ +{ + /* Create a new string */ + key_string = g_string_new(key); + + /* Two tokens means that the user should have entered a WPA-BIN key ... */ + if( ((key_string->len) != WPA_PSK_KEY_CHAR_SIZE)) + { + g_string_free(key_string, TRUE); + + g_free(type); + g_free(key); + /* No ssid has been created ... */ + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + for(i = 0; i < key_string->len; i++) + { + if(!g_ascii_isxdigit(key_string->str[i])) + { + g_string_free(key_string, TRUE); + /* No ssid_string has been created ... */ + + g_free(type); + g_free(key); + /* No ssid has been created ... */ + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + } + + /* Key was correct!!! Create the new decryption_key_t ... */ + dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); + + dk->type = AIRPDCAP_KEY_TYPE_WPA_PMK; + dk->key = g_string_new(key); + dk->bits = dk->key->len * 4; + dk->ssid = NULL; + + g_string_free(key_string, TRUE); + g_free(key); + g_free(type); + + /* Free the array of strings */ + g_strfreev(tokens); + return dk; +} +else if(g_strcasecmp(type,STRING_KEY_TYPE_WPA_PWD) == 0) /* WPA key *//* If the number of tokens is more than three, we accept the string... if the first three tokens are correct... */ +{ + /* Create a new string */ + key_string = g_string_new(key); + ssid_string = NULL; + + + /* Three (or more) tokens mean that the user entered a WPA-PWD key ... */ + if( ((key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WPA_KEY_MIN_CHAR_SIZE)) + { + g_string_free(key_string, TRUE); + + g_free(type); + g_free(key); + g_free(ssid); + + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + if(ssid != NULL) /* more than three tokens found, means that the user specified the ssid */ + { + ssid_string = g_string_new(ssid); + + /* + * XXX - Maybe we need some check on the characters? I'm not sure if only standard ASCII are ok... + */ + if( ((ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE) || ((ssid_string->len) < WPA_SSID_MIN_CHAR_SIZE)) + { + g_string_free(key_string, TRUE); + g_string_free(ssid_string, TRUE); + + g_free(type); + g_free(key); + g_free(ssid); + + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + } + + /* Key was correct!!! Create the new decryption_key_t ... */ + dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); + + dk->type = AIRPDCAP_KEY_TYPE_WPA_PWD; + dk->key = g_string_new(key); + dk->bits = 256; /* This is the lenght of the array pf bytes that will be generated using key+ssid ...*/ + if(ssid != NULL) + dk->ssid = g_string_new(ssid); + else + dk->ssid = NULL; + + g_string_free(key_string, TRUE); + if(ssid_string != NULL) g_string_free(ssid_string, TRUE); + + g_free(type); + g_free(key); + if(ssid != NULL) g_free(ssid); + + /* Free the array of strings */ + g_strfreev(tokens); + return dk; +} + +/* Something was wrong ... free everything */ + +g_free(type); +g_free(key); +if(ssid != NULL) g_free(ssid); /* It is not always present */ +/* Free the array of strings */ +g_strfreev(tokens); + +return NULL; +} + +/* + * Returns a newly allocated string representing the given decryption_key_t struct, or NULL if + * something is wrong... + */ +gchar* +get_key_string(decryption_key_t* dk) +{ +gchar* output_string = NULL; + + if(dk == NULL) + return NULL; + +#ifdef HAVE_AIRPDCAP + if(dk->type == AIRPDCAP_KEY_TYPE_WEP) + { + if(dk->key == NULL) /* Should NOT happen at all... */ + return NULL; + + output_string = g_strdup_printf("%s:%s",STRING_KEY_TYPE_WEP,dk->key->str); + } + else if(dk->type == AIRPDCAP_KEY_TYPE_WPA_PWD) + { + if(dk->key == NULL) /* Should NOT happen at all... */ + return NULL; + + if(dk->ssid == NULL) + output_string = g_strdup_printf("%s:%s",STRING_KEY_TYPE_WPA_PWD,dk->key->str); + else + output_string = g_strdup_printf("%s:%s:%s",STRING_KEY_TYPE_WPA_PWD,dk->key->str,dk->ssid->str); + } + else if(dk->type == AIRPDCAP_KEY_TYPE_WPA_PMK) + { + if(dk->key == NULL) /* Should NOT happen at all... */ + return NULL; + + output_string = g_strdup_printf("%s:%s",STRING_KEY_TYPE_WPA_PSK,dk->key->str); + } + else + { + return NULL; + } +#else /* not HAVE_AIRPDCAP*/ +output_string = g_strdup(dk->key->str); +#endif + +return output_string; +} + #endif /* _WIN32 */ diff --git a/airpcap_loader.h b/airpcap_loader.h index 5260fe0403..70a28465dc 100644 --- a/airpcap_loader.h +++ b/airpcap_loader.h @@ -45,9 +45,51 @@ */ #define WEP_KEY_MAX_BIT_SIZE (WEP_KEY_MAX_SIZE*8) +#define WEP_KEY_MIN_CHAR_SIZE 2 +#define WEP_KEY_MIN_BIT_SIZE 8 + +/* + * XXX - The next #define should probably be moved in airpcap.h, + * near WEP_KEY_MAX_SIZE ... + */ +#define WPA_KEY_MAX_SIZE 63 /* 63 chars followed by a '\0' */ + +#define WPA_KEY_MAX_CHAR_SIZE (WPA_KEY_MAX_SIZE*1) +#define WPA_KEY_MAX_BIT_SIZE (WPA_KEY_MAX_SIZE*8) +#define WPA_KEY_MIN_CHAR_SIZE 8 +#define WPA_KEY_MIN_BIT_SIZE (WPA_KEY_MIN_CHAR_SIZE*8) + +/* + * XXX - The next #define should probably be moved in airpcap.h, + * near WEP_KEY_MAX_SIZE ... + */ +#define WPA_SSID_MAX_SIZE 32 + +#define WPA_SSID_MAX_CHAR_SIZE (WPA_SSID_MAX_SIZE*1) +#define WPA_SSID_MAX_BIT_SIZE (WPA_SSID_MAX_SIZE*8) +#define WPA_SSID_MIN_CHAR_SIZE 0 +#define WPA_SSID_MIN_BIT_SIZE (WPA_SSID_MIN_CHAR_SIZE*8) + +/* + * User can enter the binary PSK, instead of the passphrase+ssid... + */ +#define WPA_PSK_KEY_SIZE 32 /* Fixed size, 32 bytes (256bit) */ +#define WPA_PSK_KEY_CHAR_SIZE (WPA_PSK_KEY_SIZE*2) +#define WPA_PSK_KEY_BIT_SIZE (WPA_PSK_KEY_SIZE*8) + #define AIRPCAP_WEP_KEY_STRING "WEP" -#define AIRPCAP_WPA_KEY_STRING "WPA" -#define AIRPCAP_WPA2_KEY_STRING "WPA2" +/* + * XXX - WPA_PWD is the passphrase+ssid and WPA-PSK is the hexadecimal key + */ +#define AIRPCAP_WPA_PWD_KEY_STRING "WPA-PWD" +#define AIRPCAP_WPA_BIN_KEY_STRING "WPA-PSK" + +/* + * Key string defines + */ +#define STRING_KEY_TYPE_WEP "wep" +#define STRING_KEY_TYPE_WPA_PWD "wpa-pwd" +#define STRING_KEY_TYPE_WPA_PSK "wpa-psk" #define AIRPCAP_DLL_OK 0 #define AIRPCAP_DLL_OLD 1 @@ -109,15 +151,6 @@ typedef struct { gint tag; /* int for the gtk blinking callback */ } airpcap_if_info_t; -/* - * Struct used to store infos to pass to the preferences manager callbacks - */ -typedef struct { - GList *list; - int current_index; - int number_of_keys; -} keys_cb_data_t; - /* * Struct to store infos about a specific decryption key. */ @@ -128,6 +161,15 @@ typedef struct { guint type; } decryption_key_t; +/* + * Struct used to store infos to pass to the preferences manager callbacks + */ +typedef struct { + GList *list; + int current_index; + int number_of_keys; +} keys_cb_data_t; + /* Airpcap interface list */ extern GList *airpcap_if_list; @@ -140,13 +182,6 @@ extern airpcap_if_info_t *airpcap_if_active; /* WLAN preferences pointer */ //extern module_t *wlan_prefs; -/* - * Function used to read the Decryption Keys from the preferences and store them - * properly into the airpcap adapter. - */ -BOOL -load_wlan_wep_keys(airpcap_if_info_t* info_if); - /* * Function used to read the Decryption Keys from the preferences and store them * properly into the airpcap adapter. @@ -553,4 +588,17 @@ get_compiled_airpcap_version(GString *str); void get_runtime_airpcap_version(GString *str); +/* + * Returns the decryption_key_t struct given a string describing the key. + * Returns NULL if the key_string cannot be parsed. + */ +decryption_key_t* +parse_key_string(gchar* key_string); + +/* + * Returns a newly allocated string representing the given decryption_key_t struct + */ +gchar* +get_key_string(decryption_key_t* dk); + #endif diff --git a/epan/dissectors/Makefile.nmake b/epan/dissectors/Makefile.nmake index 4fc827e860..93ffda6289 100644 --- a/epan/dissectors/Makefile.nmake +++ b/epan/dissectors/Makefile.nmake @@ -9,7 +9,7 @@ include ..\..\config.nmake include Makefile.common -CFLAGS=-DHAVE_CONFIG_H /I. /I.. /I../.. $(GLIB_CFLAGS) \ +CFLAGS=-DHAVE_CONFIG_H -DHAVE_AIRPDCAP /I. /I.. /I../.. $(GLIB_CFLAGS) \ $(NET_SNMP_CFLAGS) \ $(PCRE_CFLAGS) $(GNUTLS_CFLAGS) $(NETTLE_CFLAGS) \ $(KFW_CFLAGS) \ @@ -24,9 +24,9 @@ DISSECTOR_OBJECTS = $(DISSECTOR_SRC:.c=.obj) DISSECTOR_SUPPORT_OBJECTS = $(DISSECTOR_SUPPORT_SRC:.c=.obj) -dissectors.lib: register.obj packet-ncp2222.c $(GENERATED_HEADER_FILES) ../../config.h $(DISSECTOR_OBJECTS) $(DISSECTOR_SUPPORT_OBJECTS) +dissectors.lib: airpdcap.lib register.obj packet-ncp2222.c $(GENERATED_HEADER_FILES) ../../config.h $(DISSECTOR_OBJECTS) $(DISSECTOR_SUPPORT_OBJECTS) @echo Linking dissectors.lib - link /lib /out:dissectors.lib $(DISSECTOR_OBJECTS) $(DISSECTOR_SUPPORT_OBJECTS) + link /lib /out:dissectors.lib $(DISSECTOR_OBJECTS) $(DISSECTOR_SUPPORT_OBJECTS) ..\..\airpdcap\airpdcap.lib # # The header files listed here are built from x11-fields using Perl; @@ -73,6 +73,12 @@ x11-declarations.h x11-register-info.h: x11-fields process-x11-fields.pl # a register.c file for libwireshark. # All subsequent arguments are the files to scan. # + +airpdcap.lib: + cd ..\..\airpdcap + $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake + cd ..\epan\dissectors + register.c: $(DISSECTOR_SRC) !IFDEF PYTHON @echo Making register.c (using python) @@ -95,6 +101,9 @@ packet-ncp2222.c : ncp2222.py !ENDIF clean: + cd ..\..\airpdcap + $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake clean + cd ..\epan\dissectors rm -f dissectors.lib $(PDB_FILE) \ $(DISSECTOR_OBJECTS) $(DISSECTOR_SUPPORT_OBJECTS) diff --git a/epan/dissectors/packet-ieee80211.c b/epan/dissectors/packet-ieee80211.c index 32ad7b7d8e..3cb04b54c4 100644 --- a/epan/dissectors/packet-ieee80211.c +++ b/epan/dissectors/packet-ieee80211.c @@ -76,6 +76,7 @@ #ifdef HAVE_AIRPCAP #include +#include #else /* XXX - This is probably a bit much */ #define MAX_ENCRYPTION_KEYS 64 @@ -107,6 +108,10 @@ static int *wep_keylens = NULL; static void init_wepkeys(void); static int wep_decrypt(guint8 *buf, guint32 len, int key_override); static tvbuff_t *try_decrypt_wep(tvbuff_t *tvb, guint32 offset, guint32 len); +#ifdef HAVE_AIRPDCAP +/* Davide Schiera (2006-11-26): created function to decrypt WEP and WPA/WPA2 */ +static tvbuff_t *try_decrypt(tvbuff_t *tvb, guint32 offset, guint32 len, guint8 *algorithm, guint32 *sec_header, guint32 *sec_trailer); +#endif static int weak_iv(guchar *iv); #define SSWAP(a,b) {guint8 tmp = s[a]; s[a] = s[b]; s[b] = tmp;} @@ -786,6 +791,15 @@ static dissector_handle_t data_handle; static int wlan_tap = -1; +/* Davide Schiera (2006-11-22): including AirPDcap project */ +#ifdef HAVE_AIRPDCAP +#include "..\..\airpdcap\airpdcap_ws.h" +AIRPDCAP_CONTEXT airpdcap_ctx; +#else +int airpdcap_ctx; +#endif +/* Davide Schiera (2006-11-22) ---------------------------------------------- */ + /* ************************************************************************* */ /* Return the length of the current header (in bytes) */ /* ************************************************************************* */ @@ -3286,6 +3300,17 @@ dissect_ieee80211_common (tvbuff_t * tvb, packet_info * pinfo, } /* end of qos control field */ +#ifdef HAVE_AIRPDCAP + /* Davide Schiera (2006-11-21): process handshake packet with AirPDcap */ + /* the processing will take care of 4-way handshake sessions for WPA */ + /* and WPA2 decryption */ + if (enable_decryption && !pinfo->fd->flags.visited) { + const guint8 *enc_data = tvb_get_ptr(tvb, 0, hdr_len+reported_len); + AirPDcapPacketProcess(&airpdcap_ctx, enc_data, hdr_len+reported_len, NULL, 0, NULL, FALSE, FALSE, TRUE, FALSE); + } + /* Davide Schiera -------------------------------------------------------- */ +#endif + /* * No-data frames don't have a body. */ @@ -3303,37 +3328,92 @@ dissect_ieee80211_common (tvbuff_t * tvb, packet_info * pinfo, if (IS_PROTECTED(FCF_FLAGS(fcf))) { /* - * It's a WEP-encrypted frame; dissect the WEP parameters and decrypt - * the data, if we have a matching key. Otherwise display it as data. + * It's a WEP or WPA encrypted frame; dissect the protections parameters + * and decrypt the data, if we have a matching key. Otherwise display it as data. */ + gboolean can_decrypt = FALSE; proto_tree *wep_tree = NULL; guint32 iv; guint8 key, keybyte; + /* Davide Schiera (2006-11-27): define algorithms constants and macros */ +#ifdef HAVE_AIRPDCAP +#define PROTECTION_ALG_TKIP AIRPDCAP_KEY_TYPE_TKIP +#define PROTECTION_ALG_CCMP AIRPDCAP_KEY_TYPE_CCMP +#define PROTECTION_ALG_WEP AIRPDCAP_KEY_TYPE_WEP +#define PROTECTION_ALG_RSNA PROTECTION_ALG_CCMP | PROTECTION_ALG_TKIP +#else +#define PROTECTION_ALG_WEP 0 +#define PROTECTION_ALG_TKIP 1 +#define PROTECTION_ALG_CCMP 2 +#define PROTECTION_ALG_RSNA PROTECTION_ALG_CCMP | PROTECTION_ALG_TKIP +#endif + guint8 algorithm=-1; + /* Davide Schiera (2006-11-27): added macros to check the algorithm */ + /* used could be TKIP or CCMP */ +#define IS_TKIP(tvb, hdr_len) (tvb_get_guint8(tvb, hdr_len + 1) & 0x20) +#define IS_CCMP(tvb, hdr_len) (tvb_get_guint8(tvb, hdr_len + 2) == 0) + /* Davide Schiera ----------------------------------------------------- */ + +#ifdef HAVE_AIRPDCAP + /* Davide Schiera (2006-11-21): recorded original lengths to pass them */ + /* to the packets process function */ + guint32 sec_header=0; + guint32 sec_trailer=0; + + next_tvb = try_decrypt(tvb, hdr_len, reported_len, &algorithm, &sec_header, &sec_trailer); +#endif + /* Davide Schiera ----------------------------------------------------- */ + keybyte = tvb_get_guint8(tvb, hdr_len + 3); key = KEY_OCTET_WEP_KEY(keybyte); if ((keybyte & KEY_EXTIV) && (len >= EXTIV_LEN)) { /* Extended IV; this frame is likely encrypted with TKIP or CCMP */ + + if (tree) { proto_item *extiv_fields; +#ifdef HAVE_AIRPDCAP + /* Davide Schiera (2006-11-27): differentiated CCMP and TKIP if */ + /* it's possible */ + if (algorithm==PROTECTION_ALG_TKIP) + extiv_fields = proto_tree_add_text(hdr_tree, tvb, hdr_len, 8, + "TKIP parameters"); + else if (algorithm==PROTECTION_ALG_CCMP) + extiv_fields = proto_tree_add_text(hdr_tree, tvb, hdr_len, 8, + "CCMP parameters"); + else { + /* Davide Schiera -------------------------------------------- */ +#endif + /* Davide Schiera (2006-11-27): differentiated CCMP and TKIP if*/ + /* it's possible */ + if (IS_TKIP(tvb, hdr_len)) { + algorithm=PROTECTION_ALG_TKIP; + extiv_fields = proto_tree_add_text(hdr_tree, tvb, hdr_len, 8, + "TKIP parameters"); + } else if (IS_CCMP(tvb, hdr_len)) { + algorithm=PROTECTION_ALG_CCMP; + extiv_fields = proto_tree_add_text(hdr_tree, tvb, hdr_len, 8, + "CCMP parameters"); + } else extiv_fields = proto_tree_add_text(hdr_tree, tvb, hdr_len, 8, "TKIP/CCMP parameters"); +#ifdef HAVE_AIRPDCAP + } +#endif + wep_tree = proto_item_add_subtree (extiv_fields, ett_wep_parameters); - /* It is unknown whether this is a TKIP or CCMP encrypted packet, so - * display both packet number alternatives unless the ExtIV can be - * determined to be possible only with one of the encryption protocols. - */ - if (tvb_get_guint8(tvb, hdr_len + 1) & 0x20) { + + if (algorithm==PROTECTION_ALG_TKIP) { g_snprintf(out_buff, SHORT_STR, "0x%08X%02X%02X", tvb_get_letohl(tvb, hdr_len + 4), tvb_get_guint8(tvb, hdr_len), tvb_get_guint8(tvb, hdr_len + 2)); proto_tree_add_string(wep_tree, hf_tkip_extiv, tvb, hdr_len, EXTIV_LEN, out_buff); - } - if (tvb_get_guint8(tvb, hdr_len + 2) == 0) { + } else if (algorithm==PROTECTION_ALG_CCMP) { g_snprintf(out_buff, SHORT_STR, "0x%08X%02X%02X", tvb_get_letohl(tvb, hdr_len + 4), tvb_get_guint8(tvb, hdr_len + 1), @@ -3341,6 +3421,7 @@ dissect_ieee80211_common (tvbuff_t * tvb, packet_info * pinfo, proto_tree_add_string(wep_tree, hf_ccmp_extiv, tvb, hdr_len, EXTIV_LEN, out_buff); } + proto_tree_add_uint(wep_tree, hf_wep_key, tvb, hdr_len + 3, 1, key); } @@ -3350,6 +3431,31 @@ dissect_ieee80211_common (tvbuff_t * tvb, packet_info * pinfo, ivlen = EXTIV_LEN; /* It is unknown whether this is TKIP or CCMP, so let's not even try to * parse TKIP Michael MIC+ICV or CCMP MIC. */ + +#ifdef HAVE_AIRPDCAP + /* Davide Schiera (2006-11-21): enable TKIP and CCMP decryption */ + /* checking for the trailer */ + if (next_tvb!=NULL) { + if (reported_len < sec_trailer) { + /* There is no space for a trailer, ignore it and don't decrypt */ + ; + } else if (len < reported_len) { + /* There is space for a trailer, but we haven't capture all the */ + /* packet. Slice off the trailer, but don't try to decrypt */ + reported_len -= sec_trailer; + if (len > reported_len) + len = reported_len; + } else { + /* Ok, we have a trailer and the whole packet. Decrypt it! */ + /* TODO: At the moment we won't add the trailer to the tree, */ + /* so don't remove the trailer from the packet */ + len -= sec_trailer; + reported_len -= sec_trailer; + can_decrypt = TRUE; + } + } + /* Davide Schiera -------------------------------------------------- */ +#endif } else { /* No Ext. IV - WEP packet */ /* @@ -3386,6 +3492,10 @@ dissect_ieee80211_common (tvbuff_t * tvb, packet_info * pinfo, reported_len -= 4; ivlen = 4; + /* Davide Schiera (2006-11-27): Even if the decryption was not */ + /* successful, set the algorithm */ + algorithm=PROTECTION_ALG_WEP; + /* * Well, this packet should, in theory, have an ICV. * Do we have the entire packet, and does it have enough data for @@ -3427,19 +3537,33 @@ dissect_ieee80211_common (tvbuff_t * tvb, packet_info * pinfo, } } - if (!can_decrypt || (next_tvb = try_decrypt_wep(tvb, hdr_len, reported_len + 8)) == NULL) { +#ifndef HAVE_AIRPDCAP + if (can_decrypt) + next_tvb = try_decrypt_wep(tvb, hdr_len, reported_len + 8); +#else + /* Davide Schiera (2006-11-26): decrypted before parsing header and */ + /* protection header */ +#endif + if (!can_decrypt || next_tvb == NULL) { /* * WEP decode impossible or failed, treat payload as raw data * and don't attempt fragment reassembly or further dissection. */ next_tvb = tvb_new_subset(tvb, hdr_len + ivlen, len, reported_len); - if (tree && can_decrypt) + if (tree) { + /* Davide Schiera (2006-11-21): added WEP or WPA separation */ + if (algorithm==PROTECTION_ALG_WEP) { + if (can_decrypt) proto_tree_add_uint_format (wep_tree, hf_wep_icv, tvb, hdr_len + ivlen + len, 4, tvb_get_ntohl(tvb, hdr_len + ivlen + len), "WEP ICV: 0x%08x (not verified)", tvb_get_ntohl(tvb, hdr_len + ivlen + len)); + } else if (algorithm==PROTECTION_ALG_CCMP) { + } else if (algorithm==PROTECTION_ALG_TKIP) { + } + /* Davide Schiera (2006-11-21) ---------------------------------- */ if (pinfo->ethertype != ETHERTYPE_CENTRINO_PROMISC) { @@ -3447,8 +3571,10 @@ dissect_ieee80211_common (tvbuff_t * tvb, packet_info * pinfo, call_dissector(data_handle, next_tvb, pinfo, tree); goto end_of_wlan; } + } } else { - + /* Davide Schiera (2006-11-21): added WEP or WPA separation */ + if (algorithm==PROTECTION_ALG_WEP) { if (tree) proto_tree_add_uint_format (wep_tree, hf_wep_icv, tvb, hdr_len + ivlen + len, 4, @@ -3457,6 +3583,19 @@ dissect_ieee80211_common (tvbuff_t * tvb, packet_info * pinfo, tvb_get_ntohl(tvb, hdr_len + ivlen + len)); add_new_data_source(pinfo, next_tvb, "Decrypted WEP data"); + } else if (algorithm==PROTECTION_ALG_CCMP) { + add_new_data_source(pinfo, next_tvb, "Decrypted CCMP data"); + } else if (algorithm==PROTECTION_ALG_TKIP) { + add_new_data_source(pinfo, next_tvb, "Decrypted TKIP data"); + } + /* Davide Schiera (2006-11-21) ------------------------------------- */ + /* Davide Schiera (2006-11-27): undefine macros and definitions */ +#undef IS_TKIP(tvb, hdr_len) +#undef IS_CCMP(tvb, hdr_len) +#undef PROTECTION_ALG_CCMP +#undef PROTECTION_ALG_TKIP +#undef PROTECTION_ALG_WEP + /* Davide Schiera -------------------------------------------------- */ } /* @@ -4805,18 +4944,42 @@ proto_register_ieee80211 (void) "Some 802.11 cards include the FCS at the end of a packet, others do not.", &wlan_check_fcs); + /* Davide Schiera (2006-11-26): changed "WEP bit" in "Protection bit" */ + /* (according to the document IEEE Std 802.11i-2004) */ prefs_register_bool_preference(wlan_module, "ignore_wep", - "Ignore the WEP bit", - "Some 802.11 cards leave the WEP bit set even though the packet is decrypted.", + "Ignore the Protection bit", + "Some 802.11 cards leave the Protection bit set even though the packet is decrypted.", &wlan_ignore_wep); #ifndef USE_ENV prefs_register_obsolete_preference(wlan_module, "wep_keys"); +#ifdef HAVE_AIRPDCAP + /* Davide Schiera (2006-11-26): added reference to WPA/WPA2 decryption */ + prefs_register_bool_preference(wlan_module, "enable_decryption", + "Enable decryption", "Enable WEP and WPA/WPA2 decryption", + &enable_decryption); +#else prefs_register_bool_preference(wlan_module, "enable_decryption", "Enable decryption", "Enable WEP decryption", &enable_decryption); +#endif + +#ifdef HAVE_AIRPDCAP + prefs_register_static_text_preference(wlan_module, "info_decryption_key", + "Key examples: 01:02:03:04:05 (40/64-bit WEP),\n" + "010203040506070809101111213 (104/128-bit WEP),\n" + "wpa-pwd:MyPassword[:MyAP]> (WPA + plaintext password [+ SSID]),\n" + "wpa-psk:0102030405...6061626364 (WPA + 256-bit key). " + "Invalid keys will be ignored.", + "This is just a static text"); +#else + prefs_register_static_text_preference(wlan_module, "info_decryption_key", + "Key examples: 01:02:03:04:05 (40/64-bit WEP),\n" + "010203040506070809101111213 (104/128-bit WEP)" + "This is just a static text"); +#endif for (i = 0; i < MAX_ENCRYPTION_KEYS; i++) { key_name = g_string_new(""); @@ -4826,11 +4989,23 @@ proto_register_ieee80211 (void) /* prefs_register_*_preference() expects unique strings, so * we build them using g_string_sprintf and just leave them * allocated. */ +#ifdef HAVE_AIRPDCAP + g_string_sprintf(key_name, "wep_key%d", i + 1); + g_string_sprintf(key_title, "Key #%d", i + 1); + /* Davide Schiera (2006-11-26): modified keys input tooltip */ + g_string_sprintf(key_desc, + "Key #%d string can be:" + " ;" + " WEP:;" + " WPA-PWD:[:];" + " WPA-PSK:", i + 1); +#else g_string_sprintf(key_name, "wep_key%d", i + 1); g_string_sprintf(key_title, "WEP key #%d", i + 1); g_string_sprintf(key_desc, "WEP key #%d bytes in hexadecimal (A:B:C:D:E) " "[40bit], (A:B:C:D:E:F:G:H:I:J:K:L:M) [104bit], or whatever key " "length you're using", i + 1); +#endif prefs_register_string_preference(wlan_module, key_name->str, key_title->str, key_desc->str, &wep_keystr[i]); @@ -4865,6 +5040,65 @@ proto_reg_handoff_ieee80211(void) dissector_add("ethertype", ETHERTYPE_CENTRINO_PROMISC, ieee80211_handle); } +#ifdef HAVE_AIRPDCAP +/* Davide Schiera (2006-11-26): this function will try to decrypt with WEP or */ +/* WPA and return a tvb to the caller to add a new tab. It returns the */ +/* algorithm used for decryption (WEP, TKIP, CCMP) and the header and */ +/* trailer lengths. */ +static tvbuff_t *try_decrypt(tvbuff_t *tvb, guint32 offset, guint32 len, guint8 *algorithm, guint32 *sec_header, guint32 *sec_trailer) { + const guint8 *enc_data; + guint8 *tmp = NULL; + tvbuff_t *decr_tvb = NULL; + guint32 dec_caplen; + guchar dec_data[AIRPDCAP_MAX_CAPLEN]; + AIRPDCAP_KEY_ITEM used_key; + + if (!enable_decryption) + return NULL; + + /* get the entire packet */ + enc_data = tvb_get_ptr(tvb, 0, len+offset); + + /* process packet with AirPDcap */ + if (AirPDcapPacketProcess(&airpdcap_ctx, enc_data, len+offset, dec_data, &dec_caplen, &used_key, FALSE, FALSE, FALSE, TRUE)==AIRPDCAP_RET_SUCCESS) + { + *algorithm=used_key.KeyType; + switch (*algorithm) { + case AIRPDCAP_KEY_TYPE_WEP: + *sec_header=AIRPDCAP_WEP_HEADER; + *sec_trailer=AIRPDCAP_WEP_TRAILER; + break; + case AIRPDCAP_KEY_TYPE_CCMP: + *sec_header=AIRPDCAP_RSNA_HEADER; + *sec_trailer=AIRPDCAP_CCMP_TRAILER; + break; + case AIRPDCAP_KEY_TYPE_TKIP: + *sec_header=AIRPDCAP_RSNA_HEADER; + *sec_trailer=AIRPDCAP_TKIP_TRAILER; + break; + default: + return NULL; + } + + /* allocate buffer for decrypted payload */ + if ((tmp = g_malloc(dec_caplen-offset)) == NULL) + return NULL; /* krap! */ + memcpy(tmp, dec_data+offset, dec_caplen-offset); + + len=dec_caplen-offset; + + /* decrypt successful, let's set up a new data tvb. */ + decr_tvb = tvb_new_real_data(tmp, len, len); + tvb_set_free_cb(decr_tvb, g_free); + tvb_set_child_real_data_tvbuff(tvb, decr_tvb); + } else + g_free(tmp); + + return decr_tvb; +} +/* Davide Schiera ----------------------------------------------------------- */ +#endif + static tvbuff_t *try_decrypt_wep(tvbuff_t *tvb, guint32 offset, guint32 len) { const guint8 *enc_data; guint8 *tmp = NULL; @@ -4907,6 +5141,410 @@ static tvbuff_t *try_decrypt_wep(tvbuff_t *tvb, guint32 offset, guint32 len) { return decr_tvb; } +#ifdef HAVE_AIRPDCAP +/* +* Returns the decryption_key_t struct given a string describing the key. +* Returns NULL if the key_string cannot be parsed. +*/ +static decryption_key_t* +parse_key(gchar* input_string) +{ + gchar *type; + gchar *key; + gchar *ssid; + + GString *key_string, + *ssid_string; + + gchar **tokens; + guint n = 0; + guint i; + + decryption_key_t *dk; + + if(input_string == NULL) + return NULL; + + /* + * Parse the input_string. It should be in the form :[:] + * XXX - For backward compatibility, the a WEP key can be just a string of hexadecimal + * characters (if WEP key is wrong, null will be returned...). + */ + tokens = g_strsplit(input_string,":",0); + + /* Tokens is a null termiated array of strings ... */ + while(tokens[n] != NULL) + n++; + + if(n == 0) + { + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + /* + * 'n' contains the number of tokens. If the key string is correct, we should have + * 2 or 3 tokens... If we have 1 token, it can be an 'old style' WEP key... check for it... + */ + if(n == 1) + { + /* Maybe it is an 'old style' WEP key */ + key = g_strdup(tokens[0]); + + /* Create a new string */ + key_string = g_string_new(key); + + /* Check if it is a correct WEP key */ + if( ((key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WEP_KEY_MIN_CHAR_SIZE)) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + if((key_string->len % 2) != 0) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + for(i = 0; i < key_string->len; i++) + { + if(!g_ascii_isxdigit(key_string->str[i])) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + } + + /* Key is correct! It was probably an 'old style' WEP key */ + /* Create the decryption_key_t structure, fill it and return it*/ + dk = g_malloc(sizeof(decryption_key_t)); + + dk->type = AIRPDCAP_KEY_TYPE_WEP; + dk->key = g_string_new(key); + dk->bits = dk->key->len * 4; + dk->ssid = NULL; + + g_string_free(key_string, TRUE); + g_free(key); + + /* Free the array of strings */ + g_strfreev(tokens); + + return dk; + } + + /* There were at least 2 tokens... copy the type value */ + type = g_strdup(tokens[0]); + + /* + * The second token is the key (right now it doesn't matter + * if it is a passphrase or an hexadecimal one) + */ + key = g_strdup(tokens[1]); + + /* Lower case... */ + g_strdown(type); + g_strdown(key); + + /* Maybe there is a third token (an ssid, if everything else is ok) */ + if(n >= 3) + { + ssid = g_strdup(tokens[2]); + g_strdown(ssid); + } + else + { + ssid = NULL; + } + + /* + * Now the initial key string has been divided in two/three tokens... let's see + * which kind of key it is, and if it is the correct form + */ + if(g_strcasecmp(type,STRING_KEY_TYPE_WEP) == 0) /* WEP key */ + { + /* Create a new string */ + key_string = g_string_new(key); + + /* Check if it is a correct WEP key */ + if( ((key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WEP_KEY_MIN_CHAR_SIZE)) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + if((key_string->len % 2) != 0) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + for(i = 0; i < key_string->len; i++) + { + if(!g_ascii_isxdigit(key_string->str[i])) + { + g_string_free(key_string, TRUE); + g_free(key); + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + } + + dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); + + dk->type = AIRPDCAP_KEY_TYPE_WEP; + dk->key = g_string_new(key); + dk->bits = dk->key->len * 4; + dk->ssid = NULL; + + g_string_free(key_string, TRUE); + g_free(key); + + /* Free the array of strings */ + g_strfreev(tokens); + return dk; + } + else if(g_strcasecmp(type,STRING_KEY_TYPE_WPA_PSK) == 0) /* WPA key */ + { + /* Create a new string */ + key_string = g_string_new(key); + + /* Two tokens means that the user should have entered a WPA-BIN key ... */ + if( ((key_string->len) != WPA_PSK_KEY_CHAR_SIZE)) + { + g_string_free(key_string, TRUE); + + g_free(type); + g_free(key); + /* No ssid has been created ... */ + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + for(i = 0; i < key_string->len; i++) + { + if(!g_ascii_isxdigit(key_string->str[i])) + { + g_string_free(key_string, TRUE); + /* No ssid_string has been created ... */ + + g_free(type); + g_free(key); + /* No ssid has been created ... */ + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + } + + /* Key was correct!!! Create the new decryption_key_t ... */ + dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); + + dk->type = AIRPDCAP_KEY_TYPE_WPA_PMK; + dk->key = g_string_new(key); + dk->bits = dk->key->len * 4; + dk->ssid = NULL; + + g_string_free(key_string, TRUE); + g_free(key); + g_free(type); + + /* Free the array of strings */ + g_strfreev(tokens); + return dk; + } + else if(g_strcasecmp(type,STRING_KEY_TYPE_WPA_PWD) == 0) /* WPA key *//* If the number of tokens is more than three, we accept the string... if the first three tokens are correct... */ + { + /* Create a new string */ + key_string = g_string_new(key); + ssid_string = NULL; + + + /* Three (or more) tokens mean that the user entered a WPA-PWD key ... */ + if( ((key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WPA_KEY_MIN_CHAR_SIZE)) + { + g_string_free(key_string, TRUE); + + g_free(type); + g_free(key); + g_free(ssid); + + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + + if(ssid != NULL) /* more than three tokens found, means that the user specified the ssid */ + { + ssid_string = g_string_new(ssid); + + /* + * XXX - Maybe we need some check on the characters? I'm not sure if only standard ASCII are ok... + */ + if( ((ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE) || ((ssid_string->len) < WPA_SSID_MIN_CHAR_SIZE)) + { + g_string_free(key_string, TRUE); + g_string_free(ssid_string, TRUE); + + g_free(type); + g_free(key); + g_free(ssid); + + /* Free the array of strings */ + g_strfreev(tokens); + return NULL; + } + } + + /* Key was correct!!! Create the new decryption_key_t ... */ + dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); + + dk->type = AIRPDCAP_KEY_TYPE_WPA_PWD; + dk->key = g_string_new(key); + dk->bits = 256; /* This is the lenght of the array pf bytes that will be generated using key+ssid ...*/ + if(ssid != NULL) + dk->ssid = g_string_new(ssid); + else + dk->ssid = NULL; + + g_string_free(key_string, TRUE); + if(ssid_string != NULL) g_string_free(ssid_string, TRUE); + + g_free(type); + g_free(key); + if(ssid != NULL) g_free(ssid); + + /* Free the array of strings */ + g_strfreev(tokens); + return dk; + } + + /* Something was wrong ... free everything */ + + g_free(type); + g_free(key); + if(ssid != NULL) g_free(ssid); /* It is not always present */ + /* Free the array of strings */ + g_strfreev(tokens); + + return NULL; +} + +#endif + +#ifdef HAVE_AIRPDCAP +static +void set_airpdcap_keys() +{ + guint n = 0; + guint i = 0; + guint nKeys = 0; + AIRPDCAP_KEY_ITEM key; + PAIRPDCAP_KEYS_COLLECTION keys; + decryption_key_t* dk = NULL; + GByteArray *bytes; + gboolean res; + gchar* tmpk = NULL; + + keys=(PAIRPDCAP_KEYS_COLLECTION)malloc(sizeof(AIRPDCAP_KEYS_COLLECTION)); + keys->nKeys = 0; + + for(i = 0; i < MAX_ENCRYPTION_KEYS; i++) + { + tmpk = g_strdup(wep_keystr[i]); + + dk = parse_key(tmpk); + + if(dk != NULL) + { + if(dk->type == AIRPDCAP_KEY_TYPE_WEP) + { + key.KeyType = AIRPDCAP_KEY_TYPE_WEP; + + bytes = g_byte_array_new(); + res = hex_str_to_bytes(dk->key->str, bytes, FALSE); + + if (dk->key->str && res && bytes->len > 0) + { + /* + * WEP key is correct (well, the can be even or odd, so it is not + * a real check, I think... is a check performed somewhere in the + * AirPDcap function??? ) + */ + memcpy(key.KeyData.Wep.WepKey,bytes->data,bytes->len); + key.KeyData.Wep.WepKeyLen = bytes->len; + keys->Keys[keys->nKeys] = key; + keys->nKeys++; + } + } + else if(dk->type == AIRPDCAP_KEY_TYPE_WPA_PWD) + { + key.KeyType = AIRPDCAP_KEY_TYPE_WPA_PWD; + + /* XXX - Maybe check the lenght passed... */ + memcpy(key.KeyData.Wpa.UserPwd.Passphrase,dk->key->str,dk->key->len+1); + + if(dk->ssid != NULL) + { + if(dk->ssid->len > 0) + { + memcpy(key.KeyData.Wpa.UserPwd.Ssid,dk->ssid->str,dk->ssid->len+1); + key.KeyData.Wpa.UserPwd.SsidLen = dk->ssid->len; + } + else /* The GString is not NULL, but the 'ssid' name is just "\0" */ + { + key.KeyData.Wpa.UserPwd.SsidLen = 0; + } + } + else + { + key.KeyData.Wpa.UserPwd.SsidLen = 0; + } + + keys->Keys[keys->nKeys] = key; + keys->nKeys++; + } + else if(dk->type == AIRPDCAP_KEY_TYPE_WPA_PMK) + { + key.KeyType = AIRPDCAP_KEY_TYPE_WPA_PMK; + + bytes = g_byte_array_new(); + res = hex_str_to_bytes(dk->key->str, bytes, FALSE); + + /* XXX - PAss the correct array of bytes... */ + memcpy(key.KeyData.Wpa.Pmk,bytes->data,bytes->len); + + keys->Keys[keys->nKeys] = key; + keys->nKeys++; + } + } + } + + /* Now set the keys */ + AirPDcapSetKeys(&airpdcap_ctx,keys->Keys,keys->nKeys); + + if(tmpk != NULL) g_free(tmpk); +} +#endif /* de-weps the block. if successful, buf* will point to the data start. */ static int wep_decrypt(guint8 *buf, guint32 len, int keyidx) { @@ -5030,6 +5668,18 @@ static void init_wepkeys(void) { } } +#ifdef HAVE_AIRPDCAP + /* + * XXX - AirPDcap - That God sends it to us beautiful (che dio ce la mandi bona) + * The next lines will add a key to the AirPDcap context. The keystring will be added + * to the old WEP array too, but we don't care, because the packets will come here + * already decrypted... One of these days we will fix this too + */ + set_airpdcap_keys(); + + /* END AirPDcap */ +#endif + wep_keys = g_malloc0(num_wepkeys * sizeof(guint8*)); wep_keylens = g_malloc(num_wepkeys * sizeof(int)); diff --git a/epan/libwireshark.def b/epan/libwireshark.def index 137959803a..e658bc0117 100644 --- a/epan/libwireshark.def +++ b/epan/libwireshark.def @@ -16,6 +16,7 @@ add_new_data_source add_oid_name add_oid_str_name AdmissionRejectReason_vals DATA +airpdcap_ctx DATA ansi_a_bsmap_strings DATA ansi_a_dtap_strings DATA ansi_a_ios401_bsmap_strings DATA diff --git a/gtk/Makefile.nmake b/gtk/Makefile.nmake index 0472fa5a18..457cf24c72 100644 --- a/gtk/Makefile.nmake +++ b/gtk/Makefile.nmake @@ -7,7 +7,7 @@ include ..\config.nmake ############### no need to modify below this line ######### -CFLAGS=-DHAVE_CONFIG_H /I.. /I../wiretap $(GTK_CFLAGS) $(GNUTLS_CFLAGS) \ +CFLAGS=-DHAVE_CONFIG_H -DHAVE_AIRPDCAP /I.. /I../wiretap $(GTK_CFLAGS) $(GNUTLS_CFLAGS) \ /I$(PCAP_DIR)\WPCAP\LIBPCAP /I$(PCAP_DIR)\WPCAP\LIBPCAP\bpf \ /I$(PCAP_DIR)\WPCAP\LIBPCAP\lbl \ /I$(PCAP_DIR)\include $(NET_SNMP_CFLAGS) \ @@ -55,7 +55,7 @@ WIRESHARK_WIN32_GTK_OBJECTS = $(WIRESHARK_WIN32_GTK_SRC:.c=.obj) libui.lib : ..\config.h $(WIRESHARK_WIN32_GTK_OBJECTS) $(WIRESHARK_TAP_OBJECTS) - link /lib /out:libui.lib $(WIRESHARK_WIN32_GTK_OBJECTS) $(WIRESHARK_TAP_OBJECTS) winmm.lib + link /lib /out:libui.lib $(WIRESHARK_WIN32_GTK_OBJECTS) $(WIRESHARK_TAP_OBJECTS) winmm.lib ..\airpdcap\airpdcap.lib wireshark-tap-register.c: $(WIRESHARK_TAP_SRC) ../make-tapreg-dotc Makefile.common @echo Making wireshark-tap-register.c diff --git a/gtk/airpcap_dlg.c b/gtk/airpcap_dlg.c index ecde5677af..ec1451023c 100644 --- a/gtk/airpcap_dlg.c +++ b/gtk/airpcap_dlg.c @@ -135,14 +135,14 @@ airpcap_if_info_t* if_info = NULL; * Callback for the select row event in the key list widget */ void -on_key_ls_select_row(GtkWidget *widget, +on_key_ls_select_row(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data) { airpcap_key_ls_selected_info_t* selected_item; - + selected_item = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY); selected_item->row = row; @@ -160,7 +160,7 @@ on_key_ls_unselect_row(GtkWidget *widget, gpointer data) { airpcap_key_ls_selected_info_t* selected_item; - + selected_item = OBJECT_GET_DATA(GTK_WIDGET(data),AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY); selected_item->row = NO_ROW_SELECTED; @@ -208,6 +208,8 @@ on_edit_type_en_changed(GtkWidget *w, gpointer data) GtkWidget *edit_key_w; GtkWidget *edit_ssid_te; GtkWidget *type_te; +GtkWidget *key_lb; +GtkWidget *ssid_lb; gchar* type_text = NULL; @@ -215,22 +217,49 @@ edit_key_w = GTK_WIDGET(data); type_te = w; edit_ssid_te = OBJECT_GET_DATA(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY); +key_lb = OBJECT_GET_DATA(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY); +ssid_lb = OBJECT_GET_DATA(edit_key_w,AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY); type_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(type_te))); if(string_is_not_empty(type_text)) { - /* - * If it is a WEP key, no SSID is required! Gray out rhe entry text so + /* + * If it is a WEP key, no SSID is required! Gray out rhe entry text so * it doesn't create confusion ... */ if(g_strcasecmp(type_text,AIRPCAP_WEP_KEY_STRING) == 0) { gtk_widget_set_sensitive(edit_ssid_te,FALSE); + /* + * Maybe the user has already entered some text into the SSID field + * and then switched to WEP... + */ + gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),""); + gtk_label_set_text(GTK_LABEL(key_lb),"Key"); + gtk_label_set_text(GTK_LABEL(ssid_lb),""); } - else + else if(g_strcasecmp(type_text,AIRPCAP_WPA_BIN_KEY_STRING) == 0) + { + gtk_widget_set_sensitive(edit_ssid_te,FALSE); + /* + * Maybe the user has already entered some text into the SSID field + * and then switched to WEP... + */ + gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),""); + gtk_label_set_text(GTK_LABEL(key_lb),"Key"); + gtk_label_set_text(GTK_LABEL(ssid_lb),""); + } + else if(g_strcasecmp(type_text,AIRPCAP_WPA_PWD_KEY_STRING) == 0) { gtk_widget_set_sensitive(edit_ssid_te,TRUE); + /* + * Maybe the user has already entered some text into the SSID field + * and then switched to WEP... + */ + gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),""); + gtk_label_set_text(GTK_LABEL(key_lb),"Passphrase"); + gtk_label_set_text(GTK_LABEL(ssid_lb),"SSID"); } } gtk_widget_show(edit_ssid_te); @@ -247,6 +276,8 @@ on_add_type_en_changed(GtkWidget *w, gpointer data) GtkWidget *add_key_w; GtkWidget *add_ssid_te; GtkWidget *type_te; +GtkWidget *key_lb; +GtkWidget *ssid_lb; gchar* type_text = NULL; @@ -254,22 +285,49 @@ add_key_w = GTK_WIDGET(data); type_te = w; add_ssid_te = OBJECT_GET_DATA(add_key_w,AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY); +key_lb = OBJECT_GET_DATA(add_key_w,AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY); +ssid_lb = OBJECT_GET_DATA(add_key_w,AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY); type_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(type_te))); if(string_is_not_empty(type_text)) { - /* - * If it is a WEP key, no SSID is required! Gray out rhe entry text so + /* + * If it is a WEP key, no SSID is required! Gray out rhe entry text so * it doesn't create confusion ... */ if(g_strcasecmp(type_text,AIRPCAP_WEP_KEY_STRING) == 0) { gtk_widget_set_sensitive(add_ssid_te,FALSE); + /* + * Maybe the user has already entered some text into the SSID field + * and then switched to WEP... + */ + gtk_entry_set_text(GTK_ENTRY(add_ssid_te),""); + gtk_label_set_text(GTK_LABEL(key_lb),"Key"); + gtk_label_set_text(GTK_LABEL(ssid_lb),""); } - else + else if(g_strcasecmp(type_text,AIRPCAP_WPA_BIN_KEY_STRING) == 0) + { + gtk_widget_set_sensitive(add_ssid_te,FALSE); + /* + * Maybe the user has already entered some text into the SSID field + * and then switched to WEP... + */ + gtk_entry_set_text(GTK_ENTRY(add_ssid_te),""); + gtk_label_set_text(GTK_LABEL(key_lb),"Key"); + gtk_label_set_text(GTK_LABEL(ssid_lb),""); + } + else if(g_strcasecmp(type_text,AIRPCAP_WPA_PWD_KEY_STRING) == 0) { gtk_widget_set_sensitive(add_ssid_te,TRUE); + /* + * Maybe the user has already entered some text into the SSID field + * and then switched to WEP... + */ + gtk_entry_set_text(GTK_ENTRY(add_ssid_te),""); + gtk_label_set_text(GTK_LABEL(key_lb),"Passphrase"); + gtk_label_set_text(GTK_LABEL(ssid_lb),"SSID"); } } gtk_widget_show(add_ssid_te); @@ -278,7 +336,7 @@ g_free(type_text); } /* - * Returns FALSE if a text string has lenght 0, i.e. the first char + * Returns FALSE if a text string has lenght 0, i.e. the first char * is '\0', TRUE otherwise */ gboolean @@ -650,7 +708,7 @@ on_key_management_destroy(GtkWidget *w _U_, gpointer data _U_) { GtkWidget *airpcap_advanced_w, *toolbar; - + gint *from_widget = NULL; /* Retrieve the GUI object pointers */ @@ -665,23 +723,28 @@ if( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR) gtk_widget_set_sensitive(toolbar,TRUE); else gtk_widget_set_sensitive(toolbar,FALSE); + g_free(from_widget); /* reload the configuration!!! Configuration has not been saved but the corresponding structure has been modified probably...*/ +if(airpcap_if_selected != NULL) +{ if(!airpcap_if_selected->saved) { airpcap_load_selected_if_configuration(airpcap_if_selected); } } +} + /* the Advenced wireless Settings window was closed, cleanup things */ static void on_airpcap_advanced_destroy(GtkWidget *w _U_, gpointer data _U_) { GtkWidget *airpcap_advanced_w, *toolbar; - + gint *from_widget = NULL; /* Retrieve the GUI object pointers */ @@ -696,6 +759,7 @@ if( *from_widget == AIRPCAP_ADVANCED_FROM_TOOLBAR) gtk_widget_set_sensitive(toolbar,TRUE); else gtk_widget_set_sensitive(toolbar,FALSE); + g_free(from_widget); /* reload the configuration!!! Configuration has not been saved but @@ -754,19 +818,13 @@ else if(g_strcasecmp(gtk_entry_get_text(GTK_ENTRY(decryption_en)),AIRPCAP_DECRYP } /* Save the configuration */ -if( (airpcap_if_selected != NULL) ) - { airpcap_read_and_save_decryption_keys_from_clist(key_ls,airpcap_if_selected,airpcap_if_list); /* This will save the keys for every adapter */ - - /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/ - if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0) - { + +/* The update will make redissect al the packets... no need to do it here again */ update_decryption_mode_cm(toolbar_cm); - } - } /* Redissect all the packets, and re-evaluate the display filter. */ -cf_redissect_packets(&cfile); +//cf_redissect_packets(&cfile); } /* @@ -783,7 +841,7 @@ on_advanced_apply_bt_clicked(GtkWidget *button, gpointer data _U_) *toolbar_if_lb, *toolbar_channel_cm, *toolbar_wrong_crc_cm; - + /* retrieve main window */ main_w = GTK_WIDGET(data); @@ -807,7 +865,7 @@ on_advanced_apply_bt_clicked(GtkWidget *button, gpointer data _U_) } /* - * Callback for the 'Ok' button. + * Callback for the 'OK' button. */ static void airpcap_advanced_ok_cb(GtkWidget *w, gpointer data _U_) @@ -872,16 +930,16 @@ return; * Callback used to add a WEP key in the add new key box; */ static void -add_key(GtkWidget *widget, gpointer data _U_) +on_add_key_ok_bt_clicked(GtkWidget *widget, gpointer data _U_) { GtkWidget *type_cm, *key_en, *ssid_en; - + GtkWidget *key_ls; -GString *new_type_string, - *new_key_string, +GString *new_type_string, + *new_key_string, *new_ssid_string; gchar *type_entered = NULL; @@ -926,15 +984,15 @@ g_strchomp(new_ssid_string->str); /* Check which type of key the user has entered */ if(g_strcasecmp(new_type_string->str,AIRPCAP_WEP_KEY_STRING) == 0) /* WEP key */ { - -if( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < 2)) + +if( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WEP_KEY_MIN_CHAR_SIZE)) { - simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is 2-%d characters (8-%d bits).",WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MAX_SIZE*8); - + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is %d-%d characters (%d-%d bits).",WEP_KEY_MIN_CHAR_SIZE,WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MIN_BIT_SIZE,WEP_KEY_MAX_BIT_SIZE); + g_string_free(new_type_string,TRUE); g_string_free(new_key_string, TRUE); g_string_free(new_ssid_string,TRUE); - + g_free(type_entered); g_free(key_entered ); g_free(ssid_entered); @@ -944,11 +1002,11 @@ if( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < if((new_key_string->len % 2) != 0) { simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nThe number of characters must be even."); - + g_string_free(new_type_string,TRUE); g_string_free(new_key_string, TRUE); g_string_free(new_ssid_string,TRUE); - + g_free(type_entered); g_free(key_entered ); g_free(ssid_entered); @@ -960,11 +1018,11 @@ for(i = 0; i < new_key_string->len; i++) if(!g_ascii_isxdigit(new_key_string->str[i])) { simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nA WEP key must be a hexadecimal number.\nThe valid characters are: 0123456789ABCDEF."); - + g_string_free(new_type_string,TRUE); g_string_free(new_key_string, TRUE); g_string_free(new_ssid_string,TRUE); - + g_free(type_entered); g_free(key_entered ); g_free(ssid_entered); @@ -972,28 +1030,96 @@ for(i = 0; i < new_key_string->len; i++) } } -/* If so... Modify key */ +/* If so... add key */ airpcap_add_key_to_list(key_ls, new_type_string->str, new_key_string->str, new_ssid_string->str); -airpcap_if_selected->saved = FALSE; +if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE; } -else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_KEY_STRING) == 0) /* WPA Key */ +else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_PWD_KEY_STRING) == 0) /* WPA Key */ { /* XXX - Perform some WPA related input fields check */ /* If everything is ok, modify the entry int he list */ -airpcap_if_selected->saved = FALSE; +if( ((new_key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WPA_KEY_MIN_CHAR_SIZE)) + { + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA key size out of range!\nValid key size range is %d-%d ASCII characters (%d-%d bits).",WPA_KEY_MIN_CHAR_SIZE,WPA_KEY_MAX_CHAR_SIZE,WPA_KEY_MIN_BIT_SIZE,WPA_KEY_MAX_BIT_SIZE); + + g_string_free(new_type_string,TRUE); + g_string_free(new_key_string, TRUE); + g_string_free(new_ssid_string,TRUE); + + g_free(type_entered); + g_free(key_entered ); + g_free(ssid_entered); + return; + } + +/* + * XXX - Maybe we need some check on the characters? I'm not sure if only stabdard ASCII are ok... + */ +if( ((new_ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE) || ((new_ssid_string->len) < WPA_SSID_MIN_CHAR_SIZE)) + { + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"SSID key size out of range!\nValid SSID size range is %d-%d ASCII characters (%d-%d bits).",WPA_SSID_MIN_CHAR_SIZE,WPA_SSID_MAX_CHAR_SIZE,WPA_SSID_MIN_BIT_SIZE,WPA_SSID_MAX_BIT_SIZE); + + g_string_free(new_type_string,TRUE); + g_string_free(new_key_string, TRUE); + g_string_free(new_ssid_string,TRUE); + + g_free(type_entered); + g_free(key_entered ); + g_free(ssid_entered); + return; + } + +/* If so... add key */ +airpcap_add_key_to_list(key_ls, new_type_string->str, new_key_string->str, new_ssid_string->str); + +if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE; } -else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA2_KEY_STRING) == 0) /* WPA2 Key */ +else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_BIN_KEY_STRING) == 0) /* WPA_BIN Key */ { -/* XXX - Perform some WPA2 related input fields check */ +/* XXX - Perform some WPA_BIN related input fields check */ /* If everything is ok, modify the entry int he list */ -airpcap_if_selected->saved = FALSE; +if( ((new_key_string->len) != WPA_PSK_KEY_CHAR_SIZE)) + { + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA PSK/PMK key size is wrong!\nValid key size is %d characters (%d bits).",WPA_PSK_KEY_CHAR_SIZE,WPA_PSK_KEY_BIT_SIZE); + + g_string_free(new_type_string,TRUE); + g_string_free(new_key_string, TRUE); + g_string_free(new_ssid_string,TRUE); + + g_free(type_entered); + g_free(key_entered ); + g_free(ssid_entered); + return; + } + +for(i = 0; i < new_key_string->len; i++) + { + if(!g_ascii_isxdigit(new_key_string->str[i])) + { + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WPA PSK/PMK key!\nKey must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF."); + + g_string_free(new_type_string,TRUE); + g_string_free(new_key_string, TRUE); + g_string_free(new_ssid_string,TRUE); + + g_free(type_entered); + g_free(key_entered ); + g_free(ssid_entered); + return; + } + } + +/* If so... add key */ +airpcap_add_key_to_list(key_ls, new_type_string->str, new_key_string->str, new_ssid_string->str); + +if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE; } else /* Should never happen!!! */ -{ -simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!"); +{ +simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!"); } g_string_free(new_type_string,TRUE); @@ -1002,7 +1128,7 @@ g_string_free(new_ssid_string,TRUE); g_free(type_entered); g_free(key_entered ); -g_free(ssid_entered); +g_free(ssid_entered); window_destroy(GTK_WIDGET(data)); return; @@ -1017,11 +1143,11 @@ on_edit_key_ok_bt_clicked(GtkWidget *widget, gpointer data _U_) GtkWidget *type_cm, *key_en, *ssid_en; - + GtkWidget *key_ls; -GString *new_type_string, - *new_key_string, +GString *new_type_string, + *new_key_string, *new_ssid_string; gchar *type_entered = NULL; @@ -1066,15 +1192,15 @@ g_strchomp(new_ssid_string->str); /* Check which type of key the user has entered */ if(g_strcasecmp(new_type_string->str,AIRPCAP_WEP_KEY_STRING) == 0) /* WEP key */ { - -if( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < 2)) + +if( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WEP_KEY_MIN_CHAR_SIZE)) { - simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is 2-%d characters (8-%d bits).",WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MAX_SIZE*8); - + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is %d-%d characters (%d-%d bits).",WEP_KEY_MIN_CHAR_SIZE,WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MIN_BIT_SIZE,WEP_KEY_MAX_BIT_SIZE); + g_string_free(new_type_string,TRUE); g_string_free(new_key_string, TRUE); g_string_free(new_ssid_string,TRUE); - + g_free(type_entered); g_free(key_entered ); g_free(ssid_entered); @@ -1084,11 +1210,11 @@ if( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < if((new_key_string->len % 2) != 0) { simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nThe number of characters must be even."); - + g_string_free(new_type_string,TRUE); g_string_free(new_key_string, TRUE); g_string_free(new_ssid_string,TRUE); - + g_free(type_entered); g_free(key_entered ); g_free(ssid_entered); @@ -1100,11 +1226,11 @@ for(i = 0; i < new_key_string->len; i++) if(!g_ascii_isxdigit(new_key_string->str[i])) { simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nA WEP key must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF."); - + g_string_free(new_type_string,TRUE); g_string_free(new_key_string, TRUE); g_string_free(new_ssid_string,TRUE); - + g_free(type_entered); g_free(key_entered ); g_free(ssid_entered); @@ -1115,25 +1241,93 @@ for(i = 0; i < new_key_string->len; i++) /* If so... Modify key */ airpcap_modify_key_in_list(key_ls, r, new_type_string->str, new_key_string->str, new_ssid_string->str); -airpcap_if_selected->saved = FALSE; +if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE; } -else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_KEY_STRING) == 0) /* WPA Key */ +else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_PWD_KEY_STRING) == 0) /* WPA Key */ { /* XXX - Perform some WPA related input fields check */ /* If everything is ok, modify the entry int he list */ -airpcap_if_selected->saved = FALSE; +if( ((new_key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WPA_KEY_MIN_CHAR_SIZE)) + { + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA key size out of range!\nValid key size range is %d-%d ASCII characters (%d-%d bits).",WPA_KEY_MIN_CHAR_SIZE,WPA_KEY_MAX_CHAR_SIZE,WPA_KEY_MIN_BIT_SIZE,WPA_KEY_MAX_BIT_SIZE); + + g_string_free(new_type_string,TRUE); + g_string_free(new_key_string, TRUE); + g_string_free(new_ssid_string,TRUE); + + g_free(type_entered); + g_free(key_entered ); + g_free(ssid_entered); + return; +} + +/* + * XXX - Maybe we need some check on the characters? I'm not sure if only stabdard ASCII are ok... + */ +if( ((new_ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE) || ((new_ssid_string->len) < WPA_SSID_MIN_CHAR_SIZE)) +{ + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"SSID key size out of range!\nValid SSID size range is %d-%d ASCII characters (%d-%d bits).",WPA_SSID_MIN_CHAR_SIZE,WPA_SSID_MAX_CHAR_SIZE,WPA_SSID_MIN_BIT_SIZE,WPA_SSID_MAX_BIT_SIZE); + + g_string_free(new_type_string,TRUE); + g_string_free(new_key_string, TRUE); + g_string_free(new_ssid_string,TRUE); + + g_free(type_entered); + g_free(key_entered ); + g_free(ssid_entered); + return; + } + +/* If so... Modify key */ +airpcap_modify_key_in_list(key_ls, r, new_type_string->str, new_key_string->str, new_ssid_string->str); + +if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE; } -else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA2_KEY_STRING) == 0) /* WPA2 Key */ +else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_BIN_KEY_STRING) == 0) /* WPA_BIN Key */ { -/* XXX - Perform some WPA2 related input fields check */ +/* XXX - Perform some WPA_BIN related input fields check */ /* If everything is ok, modify the entry int he list */ -airpcap_if_selected->saved = FALSE; +if( ((new_key_string->len) != WPA_PSK_KEY_CHAR_SIZE)) + { + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA PSK/PMK key size is wrong!\nValid key size is %d characters (%d bits).",WPA_PSK_KEY_CHAR_SIZE,WPA_PSK_KEY_BIT_SIZE); + + g_string_free(new_type_string,TRUE); + g_string_free(new_key_string, TRUE); + g_string_free(new_ssid_string,TRUE); + + g_free(type_entered); + g_free(key_entered ); + g_free(ssid_entered); + return; + } + +for(i = 0; i < new_key_string->len; i++) + { + if(!g_ascii_isxdigit(new_key_string->str[i])) + { + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WPA PSK/PMK key!\nKey must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF."); + + g_string_free(new_type_string,TRUE); + g_string_free(new_key_string, TRUE); + g_string_free(new_ssid_string,TRUE); + + g_free(type_entered); + g_free(key_entered ); + g_free(ssid_entered); + return; + } + } + +/* If so... Modify key */ +airpcap_modify_key_in_list(key_ls, r, new_type_string->str, new_key_string->str, new_ssid_string->str); + +if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE; } else /* Should never happen!!! */ -{ -simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!"); +{ +simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!"); } g_string_free(new_type_string,TRUE); @@ -1142,7 +1336,7 @@ g_string_free(new_ssid_string,TRUE); g_free(type_entered); g_free(key_entered ); -g_free(ssid_entered); +g_free(ssid_entered); window_destroy(GTK_WIDGET(data)); return; @@ -1200,14 +1394,14 @@ keys_in_list = GTK_CLIST(key_ls)->rows; if(keys_in_list >= MAX_ENCRYPTION_KEYS) /* Check if we have already reached the maximum number of allowed keys... */ { - simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Maximum number (%d) of decryption keys reached! You cannot add another key!\n",MAX_ENCRYPTION_KEYS); + simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Maximum number (%d) of decryption keys reached! You cannot add another key!\n",MAX_ENCRYPTION_KEYS); return; } /* Gray out the Advanced Wireless Setting window */ gtk_widget_set_sensitive(airpcap_advanced_w,FALSE); -/* Pop-up a new window */ +/* Pop-up a new window */ add_key_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (add_key_window, "add_key_window"); gtk_container_set_border_width (GTK_CONTAINER (add_key_window), 5); @@ -1251,16 +1445,17 @@ gtk_table_attach (GTK_TABLE (add_tb), add_type_cm, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); #if GTK_MAJOR_VERSION >= 2 -gtk_widget_set_size_request (add_type_cm, 63, -1); +gtk_widget_set_size_request (add_type_cm, 83, -1); #else -gtk_widget_set_usize (add_type_cm, 63, -1); +gtk_widget_set_usize (add_type_cm, 83, -1); #endif add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WEP_KEY_STRING); -/* XXX - DEcomment only when WPA and WPA2 will be ready */ -/* -add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA_KEY_STRING); -add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA2_KEY_STRING);*/ +/* XXX - DEcomment only when WPA and WPA_BIN will be ready */ +#ifdef HAVE_AIRPDCAP +add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA_PWD_KEY_STRING); +add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA_BIN_KEY_STRING); +#endif gtk_combo_set_popdown_strings (GTK_COMBO (add_type_cm), add_type_cm_items); g_list_free (add_type_cm_items); @@ -1285,8 +1480,8 @@ gtk_widget_set_usize (add_key_te, 178, -1); add_ssid_te = gtk_entry_new (); gtk_widget_set_name (add_ssid_te, "add_ssid_te"); gtk_widget_set_sensitive(add_ssid_te,FALSE); -/* XXX - Decomment only when WPA and WPA2 will be ready */ -/* gtk_widget_show (add_ssid_te); */ +/* XXX - Decomment only when WPA and WPA_BIN will be ready */ +gtk_widget_show (add_ssid_te); gtk_table_attach (GTK_TABLE (add_tb), add_ssid_te, 2, 3, 1, 2, (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0); @@ -1300,16 +1495,16 @@ gtk_label_set_justify (GTK_LABEL (add_type_lb), GTK_JUSTIFY_CENTER); add_key_lb = gtk_label_new ("Key"); gtk_widget_set_name (add_key_lb, "add_key_lb"); -gtk_widget_show (add_key_lb); +gtk_widget_show (add_key_lb); gtk_table_attach (GTK_TABLE (add_tb), add_key_lb, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (add_key_lb), GTK_JUSTIFY_CENTER); -add_ssid_lb = gtk_label_new ("SSID"); +add_ssid_lb = gtk_label_new (""); gtk_widget_set_name (add_ssid_lb, "add_ssid_lb"); -/* XXX - Decomment only when WPA and WPA2 will be ready */ -/* gtk_widget_show (add_ssid_lb); */ +/* XXX - Decomment only when WPA and WPA_BIN will be ready */ +gtk_widget_show (add_ssid_lb); gtk_table_attach (GTK_TABLE (add_tb), add_ssid_lb, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); @@ -1324,9 +1519,9 @@ gtk_button_box_set_layout (GTK_BUTTON_BOX (low_h_button_box), GTK_BUTTONBOX_END); #if GTK_MAJOR_VERISON >= 2 -ok_bt = gtk_button_new_with_mnemonic ("Ok"); +ok_bt = gtk_button_new_with_mnemonic ("OK"); #else -ok_bt = gtk_button_new_with_label ("Ok"); +ok_bt = gtk_button_new_with_label ("OK"); #endif gtk_widget_set_name (ok_bt, "ok_bt"); gtk_widget_show (ok_bt); @@ -1354,7 +1549,7 @@ gtk_frame_set_label (GTK_FRAME (add_frame), "Modify Selected Key"); #endif /* Add callbacks */ -SIGNAL_CONNECT(ok_bt, "clicked", add_key, add_key_window ); +SIGNAL_CONNECT(ok_bt, "clicked", on_add_key_ok_bt_clicked, add_key_window ); SIGNAL_CONNECT(cancel_bt, "clicked", window_cancel_button_cb, add_key_window ); SIGNAL_CONNECT(add_type_en, "changed",on_add_type_en_changed, add_key_window); SIGNAL_CONNECT(add_key_window, "delete_event",window_delete_event_cb, add_key_window); @@ -1366,6 +1561,8 @@ OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY,selec OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY,add_type_cm); OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY,add_key_te); OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY,add_ssid_te); +OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY,add_key_lb); +OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY,add_ssid_lb); gtk_widget_show(add_key_window); } @@ -1431,8 +1628,8 @@ airpcap_advanced_w = GTK_WIDGET(data); key_ls = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY); selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY); -/* - * Better to store the selected_item data in two new variables, because maybe some +/* + * Better to store the selected_item data in two new variables, because maybe some * select_row signal will be emitted somewhere... */ r = selected_item->row; @@ -1450,10 +1647,10 @@ gtk_clist_remove(GTK_CLIST(key_ls),r); if( r < (keys_in_list-1) ) gtk_clist_select_row(GTK_CLIST(key_ls),r,c); else - gtk_clist_select_row(GTK_CLIST(key_ls),r-1,c); + gtk_clist_select_row(GTK_CLIST(key_ls),r-1,c); /* Need to save config... */ -airpcap_if_selected->saved = FALSE; +if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE; } /* @@ -1511,11 +1708,11 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) gtk_clist_get_text(GTK_CLIST(key_ls),r,0,&row_type); gtk_clist_get_text(GTK_CLIST(key_ls),r,1,&row_key); gtk_clist_get_text(GTK_CLIST(key_ls),r,2,&row_ssid); - + /* Gray out the Advanced Wireless Setting window */ gtk_widget_set_sensitive(airpcap_advanced_w,FALSE); - - /* Pop-up a new window */ + + /* Pop-up a new window */ edit_key_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (edit_key_window, "edit_key_window"); gtk_container_set_border_width (GTK_CONTAINER (edit_key_window), 5); @@ -1525,17 +1722,17 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) #else gtk_window_set_policy(GTK_WINDOW(edit_key_window), FALSE, FALSE, TRUE); #endif - + main_v_box = gtk_vbox_new (FALSE, 0); gtk_widget_set_name (main_v_box, "main_v_box"); gtk_widget_show (main_v_box); gtk_container_add (GTK_CONTAINER (edit_key_window), main_v_box); - + edit_frame = gtk_frame_new (NULL); gtk_widget_set_name (edit_frame, "edit_frame"); gtk_widget_show (edit_frame); gtk_box_pack_start (GTK_BOX (main_v_box), edit_frame, TRUE, TRUE, 0); - + edit_frame_al = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_set_name (edit_frame_al, "edit_frame_al"); gtk_widget_show (edit_frame_al); @@ -1545,13 +1742,13 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) #else gtk_alignment_set (GTK_ALIGNMENT (edit_frame_al), 0, 0, 12, 0); #endif - + edit_tb = gtk_table_new (2, 3, FALSE); gtk_widget_set_name (edit_tb, "edit_tb"); gtk_container_set_border_width(GTK_CONTAINER(edit_tb),5); gtk_widget_show (edit_tb); gtk_container_add (GTK_CONTAINER (edit_frame_al), edit_tb); - + edit_type_cm = gtk_combo_new (); gtk_widget_set_name (edit_type_cm, "edit_type_cm"); gtk_widget_show (edit_type_cm); @@ -1559,25 +1756,27 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); #if GTK_MAJOR_VERSION >= 2 - gtk_widget_set_size_request (edit_type_cm, 63, -1); + gtk_widget_set_size_request (edit_type_cm, 83, -1); #else - gtk_widget_set_usize (edit_type_cm, 63, -1); + gtk_widget_set_usize (edit_type_cm, 83, -1); #endif edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WEP_KEY_STRING); - /* XXX - Decomment only when WPA and WPA2 support will be ready!!! */ -/* edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA_KEY_STRING); - edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA2_KEY_STRING);*/ + /* XXX - Decomment only when WPA and WPA_BIN support will be ready!!! */ + #ifdef HAVE_AIRPDCAP + edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA_PWD_KEY_STRING); + edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA_BIN_KEY_STRING); + #endif gtk_combo_set_popdown_strings (GTK_COMBO (edit_type_cm), edit_type_cm_items); g_list_free (edit_type_cm_items); - + edit_type_en = GTK_COMBO (edit_type_cm)->entry; gtk_widget_set_name (edit_type_en, "edit_type_en"); /* Set current type */ gtk_entry_set_text(GTK_ENTRY(edit_type_en),row_type); gtk_editable_set_editable (GTK_EDITABLE (edit_type_en), FALSE); gtk_widget_show (edit_type_en); - + edit_key_te = gtk_entry_new (); gtk_widget_set_name (edit_key_te, "edit_key_te"); /* Set current key */ @@ -1590,7 +1789,7 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) #else gtk_widget_set_usize (edit_key_te, 178, -1); #endif - + edit_ssid_te = gtk_entry_new (); gtk_widget_set_name (edit_ssid_te, "edit_ssid_te"); @@ -1604,12 +1803,14 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) gtk_widget_set_sensitive(edit_ssid_te,TRUE); gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),row_ssid); } - + /* XXX - Decomment only when WPA and WPA@ will be ready */ - /* gtk_widget_show (edit_ssid_te); */ +#ifdef HAVE_AIRPDCAP + gtk_widget_show (edit_ssid_te); +#endif gtk_table_attach (GTK_TABLE (edit_tb), edit_ssid_te, 2, 3, 1, 2, (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0); - + edit_type_lb = gtk_label_new ("Type"); gtk_widget_set_name (edit_type_lb, "edit_type_lb"); gtk_widget_show (edit_type_lb); @@ -1617,7 +1818,7 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (edit_type_lb), GTK_JUSTIFY_CENTER); - + edit_key_lb = gtk_label_new ("Key"); gtk_widget_set_name (edit_key_lb, "edit_key_lb"); gtk_widget_show (edit_key_lb); @@ -1625,16 +1826,16 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (edit_key_lb), GTK_JUSTIFY_CENTER); - - edit_ssid_lb = gtk_label_new ("SSID"); + + edit_ssid_lb = gtk_label_new (""); gtk_widget_set_name (edit_ssid_lb, "edit_ssid_lb"); - /* XXX - Decomment only when WPA and WPA2 will be ready */ - /* gtk_widget_show (edit_ssid_lb); */ + /* XXX - Decomment only when WPA and WPA_BIN will be ready */ + gtk_widget_show (edit_ssid_lb); gtk_table_attach (GTK_TABLE (edit_tb), edit_ssid_lb, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (edit_ssid_lb), GTK_JUSTIFY_CENTER); - + low_h_button_box = gtk_hbutton_box_new (); gtk_widget_set_name (low_h_button_box, "low_h_button_box"); gtk_container_set_border_width (GTK_CONTAINER (low_h_button_box), 5); @@ -1642,17 +1843,17 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) gtk_box_pack_end (GTK_BOX (main_v_box), low_h_button_box, FALSE, FALSE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (low_h_button_box), GTK_BUTTONBOX_END); - + #if GTK_MAJOR_VERISON >= 2 - ok_bt = gtk_button_new_with_mnemonic ("Ok"); + ok_bt = gtk_button_new_with_mnemonic ("OK"); #else - ok_bt = gtk_button_new_with_label ("Ok"); + ok_bt = gtk_button_new_with_label ("OK"); #endif gtk_widget_set_name (ok_bt, "ok_bt"); gtk_widget_show (ok_bt); gtk_container_add (GTK_CONTAINER (low_h_button_box), ok_bt); GTK_WIDGET_SET_FLAGS (ok_bt, GTK_CAN_DEFAULT); - + #if GTK_MAJOR_VERISON >= 2 cancel_bt = gtk_button_new_with_mnemonic ("Cancel"); #else @@ -1662,7 +1863,7 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) gtk_widget_show (cancel_bt); gtk_container_add (GTK_CONTAINER (low_h_button_box), cancel_bt); GTK_WIDGET_SET_FLAGS (cancel_bt, GTK_CAN_DEFAULT); - + edit_frame_lb = gtk_label_new ("Modify Selected Key"); gtk_widget_set_name (edit_frame_lb, "edit_frame_lb"); gtk_widget_show (edit_frame_lb); @@ -1672,21 +1873,23 @@ if((r != NO_ROW_SELECTED) && (c != NO_COLUMN_SELECTED)) #else gtk_frame_set_label (GTK_FRAME (edit_frame), "Modify Selected Key"); #endif - + /* Add callbacks */ SIGNAL_CONNECT(ok_bt, "clicked", on_edit_key_ok_bt_clicked, edit_key_window ); SIGNAL_CONNECT(cancel_bt, "clicked", window_cancel_button_cb, edit_key_window ); SIGNAL_CONNECT(edit_type_en, "changed",on_edit_type_en_changed, edit_key_window); SIGNAL_CONNECT(edit_key_window, "delete_event",window_delete_event_cb, edit_key_window); SIGNAL_CONNECT(edit_key_window, "destroy",on_edit_key_w_destroy, data); - + /* Add widget data */ OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY,key_ls); OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SELECTED_KEY,selected_item); OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY,edit_type_cm); OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY,edit_key_te); OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY,edit_ssid_te); - + OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY,edit_key_lb); + OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY,edit_ssid_lb); + gtk_widget_show(edit_key_window); } } @@ -1715,8 +1918,8 @@ airpcap_advanced_w = GTK_WIDGET(data); key_ls = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY); selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY); -/* - * Better to store the selected_item data in two new variables, because maybe some +/* + * Better to store the selected_item data in two new variables, because maybe some * select_row signal will be emitted somewhere... */ r = selected_item->row; @@ -1733,14 +1936,14 @@ if( r == 0 ) /* Cannot move up the first row */ /* Move up selected key */ gtk_clist_swap_rows (GTK_CLIST(key_ls),r-1,r); -/* +/* * Re-select the just moved key... so the user can keep pressing 'Move Key Up' * without re-select the row... */ gtk_clist_select_row (GTK_CLIST(key_ls),r-1,c); /* Need to save config... */ -airpcap_if_selected->saved = FALSE; +if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE; } /* @@ -1767,8 +1970,8 @@ airpcap_advanced_w = GTK_WIDGET(data); key_ls = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY); selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY); -/* - * Better to store the selected_item data in two new variables, because maybe some +/* + * Better to store the selected_item data in two new variables, because maybe some * select_row signal will be emitted somewhere... */ r = selected_item->row; @@ -1785,14 +1988,14 @@ if( (r+1) == keys_in_list ) /* Cannot move down the last row */ /* Move down selected key */ gtk_clist_swap_rows (GTK_CLIST(key_ls),r,r+1); -/* +/* * Re-select the just moved key... so the user can keep pressing 'Move Key Down' * without re-select the row... */ gtk_clist_select_row (GTK_CLIST(key_ls),r+1,c); /* Need to save config... */ -airpcap_if_selected->saved = FALSE; +if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE; } /* Turns the decryption on or off */ @@ -1805,6 +2008,14 @@ char* decryption_mode_string = NULL; decryption_en = GTK_ENTRY(w); +/* + * This callback is called twice: when the current text is canceled ("") + * and then when the 'new text' is added ("new text"). We don't really + * care about the first time, and we just return. + */ +if(g_strcasecmp(gtk_entry_get_text(decryption_en),"") == 0) + return; + if(g_strcasecmp(gtk_entry_get_text(decryption_en),AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK) == 0) { set_wireshark_decryption(TRUE); @@ -1831,7 +2042,13 @@ cf_redissect_packets(&cfile); void update_decryption_mode_cm(GtkWidget *w) { -/* Wireshark decryption is on */ +/* + * This ensures that the entry tet changes... the callback will return immediately, but + * at least next time packets will be redissected... + */ +gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),""); + +/* Wireshark decryption is on */ if(wireshark_decryption_on()) { gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK); @@ -1848,9 +2065,61 @@ else { gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),AIRPCAP_DECRYPTION_TYPE_STRING_NONE); } + return; } +/* + * Creates the list of available decryption modes, depending on the adapters found + */ +void +update_decryption_mode_list(GtkWidget *w) +{ +GList *enable_decryption_cb_items = NULL; +GtkWidget *entry; +gchar *current_text; + +if(w == NULL) +return; + +entry = GTK_COMBO(w)->entry; +current_text = NULL; + +/* + * XXX - Retrieve the current 'decryption mode'. It would be better just block the + * signal handler, but it doesn't work... one of these days I'll try to figure otu why... + */ +current_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry))); + +enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_NONE); +enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK); + +if(airpcap_if_list != NULL) +{ +enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP); +} +else +{ + /* The last decryption mode was 'Driver', but no more AirPcap adapter are found */ + if(g_strcasecmp(current_text,AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0) + { + if(current_text != NULL) g_free(current_text); + + current_text = g_strdup(AIRPCAP_DECRYPTION_TYPE_STRING_NONE); + } +} + +gtk_signal_handler_block_by_data(GTK_OBJECT(entry),(gpointer)airpcap_tb); +gtk_combo_set_popdown_strings (GTK_COMBO (w), enable_decryption_cb_items); +/* The 'changed' callback will be called twice */ +gtk_entry_set_text(GTK_ENTRY(entry),current_text); +gtk_signal_handler_unblock_by_data(GTK_OBJECT(entry),(gpointer)airpcap_tb); + +if(current_text != NULL) g_free(current_text); + +g_list_free (enable_decryption_cb_items); +} + /* Called to create the airpcap settings' window */ void display_airpcap_advanced_cb(GtkWidget *w, gpointer data) @@ -1927,7 +2196,7 @@ gtk_window_set_title (GTK_WINDOW (airpcap_advanced_w), "Advanced Wireless Settings"); gtk_window_set_position (GTK_WINDOW (airpcap_advanced_w), GTK_WIN_POS_CENTER); - + #if GTK_MAJOR_VERSION >= 2 gtk_window_set_resizable (GTK_WINDOW (airpcap_advanced_w), FALSE); gtk_window_set_type_hint (GTK_WINDOW (airpcap_advanced_w), GDK_WINDOW_TYPE_HINT_DIALOG); @@ -1978,7 +2247,7 @@ else interface_name_lb = gtk_label_new("No airpcap interface found!"); gtk_widget_set_sensitive(main_box,FALSE); } - + gtk_widget_set_name (interface_name_lb, "interface_name_lb"); gtk_widget_show (interface_name_lb); gtk_box_pack_start (GTK_BOX (interface_sub_h_box), interface_name_lb, TRUE, @@ -2013,7 +2282,7 @@ gtk_frame_set_label_widget (GTK_FRAME (interface_fr), interface_frame_lb); gtk_label_set_use_markup (GTK_LABEL (interface_frame_lb), TRUE); #else gtk_frame_set_label(GTK_FRAME(interface_fr),"Interface"); -#endif +#endif basic_parameters_fr = gtk_frame_new (NULL); gtk_widget_set_name (basic_parameters_fr, "basic_parameters_fr"); @@ -2082,7 +2351,7 @@ if(airpcap_if_selected != NULL) { airpcap_update_channel_combo(GTK_WIDGET(channel_cm), airpcap_if_selected); } - + g_list_free (channel_cm_items); channel_en = GTK_COMBO (channel_cm)->entry; @@ -2102,7 +2371,7 @@ capture_type_cm_items = g_list_append (capture_type_cm_items, (gpointer) AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO); gtk_combo_set_popdown_strings (GTK_COMBO (capture_type_cm), capture_type_cm_items); - + /* Current interface value */ capture_s = NULL; if(airpcap_if_selected != NULL) @@ -2110,7 +2379,7 @@ if(airpcap_if_selected != NULL) if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11) capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_ONLY); else if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO) - capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO); + capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO); if(capture_s != NULL) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_type_cm)->entry), capture_s); } g_free(capture_s); @@ -2136,7 +2405,7 @@ if(airpcap_if_selected != NULL) else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fcs_ck),FALSE); } - + gtk_widget_show (fcs_ck); gtk_table_attach (GTK_TABLE (basic_parameters_tb), fcs_ck, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), @@ -2185,7 +2454,7 @@ if(airpcap_if_selected != NULL) { airpcap_validation_type_combo_set_by_type(fcs_filter_cm,airpcap_if_selected->CrcValidationOn); } - + gtk_widget_show (fcs_filter_en); basic_parameters_frame_lb = gtk_label_new ("Basic Parameters"); @@ -2350,9 +2619,9 @@ gtk_timeout_remove(airpcap_if_selected->tag); if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0) { gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected))); - + airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected); - + airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn); } @@ -2473,7 +2742,7 @@ GtkWidget *right_h_button_box; GtkWidget *ok_bt; GtkWidget *apply_bt; GtkWidget *cancel_bt; - + /* widgets in the toolbar */ GtkWidget *toolbar, *toolbar_decryption_ck; @@ -2481,7 +2750,7 @@ GtkWidget *toolbar, /* other stuff */ /*GList *channel_list,*capture_list;*/ GList *linktype_list = NULL; - + /* Selected row/column structure */ airpcap_key_ls_selected_info_t *key_ls_selected_item; key_ls_selected_item = (airpcap_key_ls_selected_info_t*)g_malloc(sizeof(airpcap_key_ls_selected_info_t)); @@ -2507,13 +2776,12 @@ airpcap_if_selected = airpcap_if_active; /* Create the new window */ key_management_w = window_new(GTK_WINDOW_TOPLEVEL, "Decryption Keys Management"); - gtk_container_set_border_width (GTK_CONTAINER (key_management_w), 5); gtk_window_set_title (GTK_WINDOW (key_management_w), "Decryption Keys Management"); gtk_window_set_position (GTK_WINDOW (key_management_w), GTK_WIN_POS_CENTER); - + #if GTK_MAJOR_VERSION >= 2 gtk_window_set_resizable (GTK_WINDOW (key_management_w), FALSE); gtk_window_set_type_hint (GTK_WINDOW (key_management_w), GDK_WINDOW_TYPE_HINT_DIALOG); @@ -2575,11 +2843,7 @@ gtk_widget_set_size_request (enable_decryption_cb, 83, -1); #else gtk_widget_set_usize (enable_decryption_cb, 83, -1); #endif -enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_NONE); -enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK); -enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP); -gtk_combo_set_popdown_strings (GTK_COMBO (enable_decryption_cb), enable_decryption_cb_items); -g_list_free (enable_decryption_cb_items); +update_decryption_mode_list(enable_decryption_cb); enable_decryption_en = GTK_COMBO (enable_decryption_cb)->entry; gtk_widget_set_name (enable_decryption_en, "enable_decryption_en"); @@ -2602,14 +2866,21 @@ gtk_box_pack_start (GTK_BOX (keys_v_sub_box), keys_scrolled_w, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (keys_scrolled_w), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); +#ifdef HAVE_AIRPDCAP key_ls = gtk_clist_new (3); +#else +key_ls = gtk_clist_new (2); +#endif + gtk_widget_set_name (key_ls, "key_ls"); gtk_widget_show (key_ls); gtk_container_add (GTK_CONTAINER (keys_scrolled_w), key_ls); gtk_clist_set_column_width (GTK_CLIST (key_ls), 0, 54); gtk_clist_set_column_width (GTK_CLIST (key_ls), 1, 113); +#ifdef HAVE_AIRPDCAP gtk_clist_set_column_width (GTK_CLIST (key_ls), 2, 80); +#endif gtk_clist_column_titles_show (GTK_CLIST (key_ls)); gtk_clist_set_shadow_type (GTK_CLIST (key_ls), GTK_SHADOW_ETCHED_IN); gtk_clist_set_column_justification(GTK_CLIST (key_ls),0,GTK_JUSTIFY_CENTER); @@ -2627,15 +2898,15 @@ gtk_widget_show (key_list_decryption_key_col_lb); gtk_clist_set_column_widget (GTK_CLIST (key_ls), 1, key_list_decryption_key_col_lb); +#ifdef HAVE_AIRPDCAP key_ls_decryption_ssid_col_lb = gtk_label_new ("SSID"); gtk_widget_set_name (key_ls_decryption_ssid_col_lb, "key_ls_decryption_ssid_col_lb"); gtk_widget_show (key_ls_decryption_ssid_col_lb); gtk_clist_set_column_widget (GTK_CLIST (key_ls), 2, key_ls_decryption_ssid_col_lb); +#endif -/* XXX - USED ONLY BECAUSE WPA and WPA2 are note ready YET... */ -gtk_clist_set_column_visibility(GTK_CLIST (key_ls), 2, FALSE); key_v_button_box = gtk_vbutton_box_new (); gtk_widget_set_name (key_v_button_box, "key_v_button_box"); @@ -2721,7 +2992,6 @@ cancel_bt = OBJECT_GET_DATA(right_h_button_box, GTK_STOCK_CANCEL); /* Connect the callbacks */ SIGNAL_CONNECT (key_management_w, "delete_event", window_delete_event_cb, key_management_w); SIGNAL_CONNECT (key_management_w, "destroy", on_key_management_destroy, key_management_w); -/*SIGNAL_CONNECT (enable_decryption_en, "changed",on_enable_decryption_en_changed, toolbar);*/ SIGNAL_CONNECT (add_new_key_bt, "clicked",on_add_new_key_bt_clicked, key_management_w); SIGNAL_CONNECT (remove_key_bt, "clicked",on_remove_key_bt_clicked, key_management_w); SIGNAL_CONNECT (edit_key_bt, "clicked",on_edit_key_bt_clicked, key_management_w); @@ -2755,9 +3025,9 @@ OBJECT_SET_DATA(key_management_w,AIRPCAP_TOOLBAR_KEY,toolbar); OBJECT_SET_DATA (key_management_w, AIRPCAP_TOOLBAR_DECRYPTION_KEY, toolbar_decryption_ck); /* FIRST OF ALL, CHECK THE KEY COLLECTIONS */ -/* - * This will read the decryption keys from the preferences file, and will store - * them into the registry... +/* + * This will read the decryption keys from the preferences file, and will store + * them into the registry... */ if(!airpcap_check_decryption_keys(airpcap_if_list)) { @@ -2769,7 +3039,7 @@ else /* Keys from lists are equals, or wireshark has got no keys */ airpcap_load_decryption_keys(airpcap_if_list); airpcap_fill_key_list(key_ls); /* At the end, so that it appears completely all together ... */ - gtk_widget_show (key_management_w); + gtk_widget_show (key_management_w); } } @@ -2817,24 +3087,22 @@ else if(g_strcasecmp(gtk_entry_get_text(GTK_ENTRY(decryption_en)),AIRPCAP_DECRYP } /* Save the configuration */ -if( (airpcap_if_selected != NULL) ) - { airpcap_read_and_save_decryption_keys_from_clist(key_ls,airpcap_if_selected,airpcap_if_list); /* This will save the keys for every adapter */ - - /* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/ - if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0) - { + +/* The update will make redissect al the packets... no need to do it here again */ update_decryption_mode_cm(toolbar_cm); - } - } /* Redissect all the packets, and re-evaluate the display filter. */ -cf_redissect_packets(&cfile); +//cf_redissect_packets(&cfile); /* Save the preferences to preferences file!!! */ write_prefs_to_file(); /* If interface active is airpcap, set sensitive TRUE for airpcap toolbar */ +if(airpcap_if_list != NULL) +{ + if(airpcap_if_active != NULL) + { if( get_airpcap_if_by_name(airpcap_if_list,airpcap_if_active->description) != NULL) { airpcap_set_toolbar_start_capture(airpcap_if_active); @@ -2843,6 +3111,8 @@ else { airpcap_set_toolbar_stop_capture(airpcap_if_active); } + } +} gtk_widget_destroy(key_management_w); } @@ -2865,7 +3135,7 @@ GtkWidget *key_ls; GtkWidget *toolbar, *toolbar_decryption_ck, *key_management_bt; - + /* Row selected structure */ airpcap_key_ls_selected_info_t *selected_item; @@ -2890,7 +3160,7 @@ gtk_widget_destroy(key_management_w); } /* - * Dialog box that appears whenever keys are not consistent between wireshark and AirPcap + * Dialog box that appears whenever keys are not consistent between wireshark and AirPcap */ void airpcap_keys_check_w(GtkWidget *w, gpointer data) @@ -3061,9 +3331,9 @@ gtk_button_box_set_layout (GTK_BUTTON_BOX (low_h_button_box), GTK_BUTTONBOX_SPREAD); #if GTK_MAJOR_VERSION >= 2 -ok_bt = gtk_button_new_with_mnemonic ("Ok"); +ok_bt = gtk_button_new_with_mnemonic ("OK"); #else -ok_bt = gtk_button_new_with_label ("Ok"); +ok_bt = gtk_button_new_with_label ("OK"); #endif gtk_widget_set_name (ok_bt, "ok_bt"); gtk_widget_show (ok_bt); @@ -3108,7 +3378,7 @@ keys_check_w = GTK_WIDGET(user_data); key_management_w = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY); -/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading, +/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading, and is not NULL if it was called when the Key Management widget has been clicked */ if(key_management_w != NULL) { @@ -3193,12 +3463,11 @@ write_prefs_to_file(); /* Free the memory */ free_key_list(wireshark_keys); -free_key_list(merged_keys); /* Close the window */ gtk_widget_destroy(keys_check_w); -/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading, +/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading, and is not NULL if it was called when the Key Management widget has been clicked */ if(key_management_w != NULL) { @@ -3259,11 +3528,11 @@ for(i = 0; iCrcValidationOn); airpcap_update_channel_combo(GTK_WIDGET(airpcap_toolbar_channel),if_info); /*decription check box*/ @@ -137,27 +148,24 @@ if(if_info != NULL) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(airpcap_toolbar_decryption),FALSE); gtk_signal_handler_unblock_by_func (GTK_OBJECT(airpcap_toolbar_decryption),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), airpcap_tb); - if_label_text = g_strdup_printf("AirPcap Interface: #%s", airpcap_get_if_string_number(if_info)); + 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); } -else - { - if(airpcap_if_list != NULL) +else /* Current interface is NOT an AirPcap one... */ { gtk_widget_set_sensitive(airpcap_tb,FALSE); - gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_crc_filter_combo)->entry),""); - gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_channel)->entry),""); - gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),"AirPcap interface: Not selected"); - } - else - { - /* this shouldn't be visible as the toolbar is hidden if no AirPcap available */ - gtk_widget_set_sensitive(airpcap_tb,FALSE); - gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_crc_filter_combo)->entry),""); - gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_channel)->entry),""); - gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),"AirPcap interface: None available"); - } + gtk_widget_set_sensitive(airpcap_toolbar_label,FALSE); + gtk_widget_set_sensitive(airpcap_toolbar_channel,FALSE); + gtk_widget_set_sensitive(airpcap_toolbar_channel_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); + airpcap_set_toolbar_no_if(airpcap_tb); } } @@ -170,8 +178,12 @@ airpcap_set_toolbar_stop_capture(airpcap_if_info_t* if_info) GtkWidget *airpcap_toolbar_crc_filter_combo; GtkWidget *airpcap_toolbar_label; GtkWidget *airpcap_toolbar_channel; +GtkWidget *airpcap_toolbar_channel_lb; 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; @@ -179,19 +191,27 @@ gchar *if_label_text; airpcap_toolbar_crc_filter_combo = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_FCS_FILTER_KEY); airpcap_toolbar_label = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_INTERFACE_KEY); airpcap_toolbar_channel = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_KEY); +airpcap_toolbar_channel_lb = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY); +airpcap_toolbar_fcs = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_FCS_FILTER_KEY); +airpcap_toolbar_fcs_lb = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY); airpcap_toolbar_button = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_ADVANCED_KEY); airpcap_toolbar_decryption = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_KEY); +airpcap_toolbar_decryption_lb = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY); airpcap_toolbar_keys_button = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_KEY_MANAGEMENT_KEY); /* The current interface is an airpcap interface */ if(if_info != NULL) { gtk_widget_set_sensitive(airpcap_tb,TRUE); + gtk_widget_set_sensitive(airpcap_toolbar_label,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_channel,TRUE); + gtk_widget_set_sensitive(airpcap_toolbar_channel_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_button,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(GTK_WIDGET(airpcap_toolbar_crc_filter_combo),if_info->CrcValidationOn); airpcap_update_channel_combo(GTK_WIDGET(airpcap_toolbar_channel),if_info); @@ -205,27 +225,24 @@ if(if_info != NULL) gtk_signal_handler_unblock_by_func (GTK_OBJECT(airpcap_toolbar_decryption),GTK_SIGNAL_FUNC(airpcap_toolbar_encryption_cb), airpcap_tb); - if_label_text = g_strdup_printf("AirPcap Interface: #%s", airpcap_get_if_string_number(if_info)); + 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); } else { - if(airpcap_if_list != NULL) - { - gtk_widget_set_sensitive(airpcap_tb,FALSE); - gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_crc_filter_combo)->entry),""); - gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_channel)->entry),""); - gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),"AirPcap interface: Not selected"); - } - else - { - /* this shouldn't be visible as the toolbar is hidden if no AirPcap available */ - gtk_widget_set_sensitive(airpcap_tb,FALSE); - gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_crc_filter_combo)->entry),""); - gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(airpcap_toolbar_channel)->entry),""); - gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),"AirPcap interface: None available"); - } + gtk_widget_set_sensitive(airpcap_tb,TRUE); + gtk_widget_set_sensitive(airpcap_toolbar_label,FALSE); + gtk_widget_set_sensitive(airpcap_toolbar_channel,FALSE); + gtk_widget_set_sensitive(airpcap_toolbar_channel_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); + airpcap_set_toolbar_no_if(airpcap_tb); } } @@ -271,12 +288,16 @@ g_free(new_row[2]); } /* - * Fill the list with the keys + * 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) */ void airpcap_fill_key_list(GtkWidget *keylist) { -gchar* s; +gchar* s = NULL; +gchar* s2 = NULL; unsigned int i,n; gchar* new_row[3]; airpcap_if_info_t* fake_if_info; @@ -288,40 +309,44 @@ n = 0; fake_if_info = airpcap_driver_fake_if_info_new(); /* We can retrieve the driver's key list (i.e. we have the right .dll)*/ - if( (fake_if_info != NULL) && (fake_if_info->keysCollection != NULL)) - { - n = fake_if_info->keysCollection->nKeys; + wireshark_key_list = get_wireshark_keys(); + n = g_list_length(wireshark_key_list); + for(i = 0; i < n; i++) { - s = airpcap_get_key_string(fake_if_info->keysCollection->Keys[i]); + curr_key = (decryption_key_t*)g_list_nth_data(wireshark_key_list,i); - if(fake_if_info->keysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_WEP) + if(curr_key->type == AIRPDCAP_KEY_TYPE_WEP) { + s = g_strdup(curr_key->key->str); + new_row[0] = g_strdup(AIRPCAP_WEP_KEY_STRING); new_row[1] = g_strdup(s); new_row[2] = g_strdup(""); + + gtk_clist_append(GTK_CLIST(keylist),new_row); + + g_free(new_row[0]); + g_free(new_row[1]); + g_free(new_row[2]); + + g_free(s); } - else if(fake_if_info->keysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_TKIP) - { - new_row[0] = g_strdup(AIRPCAP_WPA_KEY_STRING); - new_row[1] = g_strdup(s); - /* XXX - Put here the SSID */ - new_row[2] = g_strdup(""); - } - else if(fake_if_info->keysCollection->Keys[i].KeyType == AIRPCAP_KEYTYPE_CCMP) + else if(curr_key->type == AIRPDCAP_KEY_TYPE_WPA_PWD) { - new_row[0] = g_strdup(AIRPCAP_WPA2_KEY_STRING); + s = g_strdup(curr_key->key->str); + if(curr_key->ssid != NULL) + s2= g_strdup(curr_key->ssid->str); + else + s2 = NULL; + + new_row[0] = g_strdup(AIRPCAP_WPA_PWD_KEY_STRING); new_row[1] = g_strdup(s); - /* XXX - Put here the SSID */ - new_row[2] = g_strdup(""); - } + + if(curr_key->ssid != NULL) + new_row[2] = g_strdup(s2); else - { - /* This should never happen... but just in case... */ - new_row[0] = g_strdup(""); - new_row[1] = g_strdup(""); new_row[2] = g_strdup(""); - } gtk_clist_append(GTK_CLIST(keylist),new_row); @@ -330,19 +355,13 @@ fake_if_info = airpcap_driver_fake_if_info_new(); g_free(new_row[2]); g_free(s); + if(s2 != NULL) g_free(s2); } - } - else - { - wireshark_key_list = get_wireshark_keys(); - n = g_list_length(wireshark_key_list); - - for(i = 0; i < n; i++) + else if(curr_key->type == AIRPDCAP_KEY_TYPE_WPA_PMK) { - curr_key = (decryption_key_t*)g_list_nth_data(wireshark_key_list,i); s = g_strdup(curr_key->key->str); - new_row[0] = g_strdup(AIRPCAP_WEP_KEY_STRING); + new_row[0] = g_strdup(AIRPCAP_WPA_BIN_KEY_STRING); new_row[1] = g_strdup(s); new_row[2] = g_strdup(""); @@ -628,10 +647,10 @@ for(i = 0; i < keys_in_list; i++) gtk_clist_get_text(GTK_CLIST(key_ls),i,2,&row_ssid); if(g_strcasecmp(row_type,AIRPCAP_WEP_KEY_STRING) == 0) - KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_WEP; - else if(g_strcasecmp(row_type,AIRPCAP_WPA_KEY_STRING) == 0) + KeysCollection->Keys[i].KeyType = AIRPDCAP_KEY_TYPE_WEP; + else if(g_strcasecmp(row_type,AIRPCAP_WPA_PWD_KEY_STRING) == 0) KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_TKIP; - else if(g_strcasecmp(row_type,AIRPCAP_WPA2_KEY_STRING) == 0) + else if(g_strcasecmp(row_type,AIRPCAP_WPA_BIN_KEY_STRING) == 0) KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_CCMP; /* Retrieve the Item corresponding to the i-th key */ @@ -727,11 +746,11 @@ for(i = 0; i < keys_in_list; i++) gtk_clist_get_text(GTK_CLIST(key_ls),i,2,&row_ssid); if(g_strcasecmp(row_type,AIRPCAP_WEP_KEY_STRING) == 0) - KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_WEP; - else if(g_strcasecmp(row_type,AIRPCAP_WPA_KEY_STRING) == 0) - KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_TKIP; - else if(g_strcasecmp(row_type,AIRPCAP_WPA2_KEY_STRING) == 0) - KeysCollection->Keys[i].KeyType = AIRPCAP_KEYTYPE_CCMP; + KeysCollection->Keys[i].KeyType = AIRPDCAP_KEY_TYPE_WEP; + else if(g_strcasecmp(row_type,AIRPCAP_WPA_PWD_KEY_STRING) == 0) + KeysCollection->Keys[i].KeyType = AIRPDCAP_KEY_TYPE_WPA_PWD; + else if(g_strcasecmp(row_type,AIRPCAP_WPA_BIN_KEY_STRING) == 0) + KeysCollection->Keys[i].KeyType = AIRPDCAP_KEY_TYPE_WPA_PMK; /* Retrieve the Item corresponding to the i-th key */ new_key = g_string_new(row_key); @@ -739,6 +758,9 @@ for(i = 0; i < keys_in_list; i++) KeysCollection->Keys[i].KeyLen = new_key->len / 2; memset(&KeysCollection->Keys[i].KeyData, 0, sizeof(KeysCollection->Keys[i].KeyData)); + /* Key must be saved in adifferent way, depending on its type... */ + if(KeysCollection->Keys[i].KeyType == AIRPDCAP_KEY_TYPE_WEP) + { for(j = 0 ; j < new_key->len; j += 2) { s[0] = new_key->str[j]; @@ -748,6 +770,8 @@ for(i = 0; i < keys_in_list; i++) KeysCollection->Keys[i].KeyData[j / 2] = KeyByte; } } + /* XXX - Save the keys that are not WEP!!! */ +} /* * Free the old adapter key collection! @@ -777,19 +801,70 @@ gint n = 0; airpcap_if_info_t* curr_if = NULL; airpcap_if_info_t* fake_info_if = NULL; GList* key_list=NULL; + +char* tmp_type = NULL; char* tmp_key = NULL; +char* tmp_ssid = NULL; + +decryption_key_t* tmp_dk=NULL; + +/* + * Save the keys for Wireshark... + */ + +/* Create a list of keys from the list widget... */ +n = GTK_CLIST(key_ls)->rows; + +for(i = 0; i < n; i++) + { + /* XXX - Create a decryption_key_t struct, and pass a list of those structs!!! */ + gtk_clist_get_text(GTK_CLIST(key_ls),i,0,&tmp_type); + gtk_clist_get_text(GTK_CLIST(key_ls),i,1,&tmp_key); + gtk_clist_get_text(GTK_CLIST(key_ls),i,2,&tmp_ssid); + + if(g_strcasecmp(tmp_type,AIRPCAP_WEP_KEY_STRING) == 0) + { + tmp_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); + tmp_dk->key = g_string_new(tmp_key); + tmp_dk->ssid = NULL; + tmp_dk->type = AIRPDCAP_KEY_TYPE_WEP; + tmp_dk->bits = tmp_dk->key->len * 4; + key_list = g_list_append(key_list,tmp_dk); + } + else if(g_strcasecmp(tmp_type,AIRPCAP_WPA_PWD_KEY_STRING) == 0) + { + tmp_dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t)); + tmp_dk->key = g_string_new(tmp_key); + tmp_dk->ssid = g_string_new(tmp_ssid); + tmp_dk->type = AIRPDCAP_KEY_TYPE_WPA_PWD; + tmp_dk->bits = 256; + key_list = g_list_append(key_list,tmp_dk); + } + else if(g_strcasecmp(tmp_type,AIRPCAP_WPA_BIN_KEY_STRING) == 0) + { + 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 */ + tmp_dk->type = AIRPDCAP_KEY_TYPE_WPA_PMK; + tmp_dk->bits = 256; + key_list = g_list_append(key_list,tmp_dk); + } + } + +r = save_wlan_wireshark_wep_keys(key_list); +/* The key_list has been freed!!! */ /* * Save the key list for driver. */ +if( (if_list == NULL) || (info_if == NULL) ) return; + fake_info_if = airpcap_driver_fake_if_info_new(); airpcap_add_keys_to_driver_from_list(key_ls,fake_info_if); airpcap_save_driver_if_configuration(fake_info_if); airpcap_if_info_free(fake_info_if); -if( (if_list == NULL) || (info_if == NULL) ) return; - if_n = g_list_length(if_list); /* For all the adapters in the list, empty the key list */ @@ -806,28 +881,11 @@ for(i = 0; i < if_n; i++) airpcap_save_selected_if_configuration(curr_if); } } - -/* Save the settings of the given interface as default for Wireshark... - * By the way, now all the adapters have the same keys, so it is not - * really necessary to use THIS specific one... - */ -if( (r = save_wlan_driver_wep_keys()) == 0) - { - /* Create a list of keys from the list widget... */ - n = GTK_CLIST(key_ls)->rows; - for(i = 0; i < n; i++) - { - gtk_clist_get_text(GTK_CLIST(key_ls),i,1,&tmp_key); - key_list = g_list_append(key_list,(gpointer)g_strdup(tmp_key)); - } - - r = save_wlan_wireshark_wep_keys(key_list); - } } /* * This function will load from the preferences file ALL the - * keys (WEP, WPA and WPA2) and will set them as default for + * keys (WEP, WPA and WPA_BIN) and will set them as default for * 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 * registry and keys found in Wireshark preferences are the same. If not, @@ -892,7 +950,7 @@ return equals; /* * This function will load from the preferences file ALL the - * keys (WEP, WPA and WPA2) and will set them as default for + * keys (WEP, WPA_PWD and WPA_BIN) and will set them as default for * 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 * registry and keys found in Wireshark preferences are the same. If not, @@ -952,7 +1010,85 @@ for(i = 0; i < if_n; i++) * 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_driver_wep_keys(); +save_wlan_wireshark_wep_keys(key_list); +} + +/* + * 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) +{ +GtkWidget *toolbar_tb, + *if_description_lb, + *channel_cb, + *channel_lb, + *fcs_cb, + *fcs_lb, + *advanced_bt; + +if(w == NULL) + return; + +toolbar_tb = w; + +if_description_lb = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_INTERFACE_KEY); +channel_lb = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY); +channel_cb = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_KEY); +fcs_lb = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY); +fcs_cb = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_FCS_FILTER_KEY); +advanced_bt = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_ADVANCED_KEY); + + +if(if_description_lb != NULL) gtk_widget_set_sensitive(if_description_lb,en); +if(channel_lb != NULL) gtk_widget_set_sensitive(channel_lb,en); +if(channel_cb != NULL) gtk_widget_set_sensitive(channel_cb,en); +if(fcs_lb != NULL) gtk_widget_set_sensitive(fcs_lb,en); +if(fcs_cb != NULL) gtk_widget_set_sensitive(fcs_cb,en); +if(advanced_bt != NULL) gtk_widget_set_sensitive(advanced_bt,en); + +return; +} + +/* + * This function sets up the correct airpcap toolbar that must + * be displayed when no airpcap if is found on the system... + */ +void +airpcap_set_toolbar_no_if(GtkWidget* w) +{ +GtkWidget *toolbar_tb, + *if_description_lb, + *channel_cb, + *channel_lb, + *fcs_cb, + *fcs_lb, + *advanced_bt; + +if(w == NULL) + return; + +toolbar_tb = w; + +if_description_lb = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_INTERFACE_KEY); +channel_lb = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY); +channel_cb = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_CHANNEL_KEY); +fcs_lb = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY); +fcs_cb = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_FCS_FILTER_KEY); +advanced_bt = OBJECT_GET_DATA(toolbar_tb,AIRPCAP_TOOLBAR_ADVANCED_KEY); + +if(fcs_cb != NULL) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(fcs_cb)->entry),""); +if(channel_cb != NULL) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(channel_cb)->entry),""); +if(if_description_lb != NULL) gtk_label_set_text(GTK_LABEL(if_description_lb),"Current Wireless Interface: None"); + +/*if(if_description_lb != NULL) gtk_widget_set_sensitive(if_description_lb,FALSE); +if(channel_lb != NULL) gtk_widget_set_sensitive(channel_lb,FALSE); +if(channel_cb != NULL) gtk_widget_set_sensitive(channel_cb,FALSE); +if(fcs_lb != NULL) gtk_widget_set_sensitive(fcs_lb,FALSE); +if(fcs_cb != NULL) gtk_widget_set_sensitive(fcs_cb,FALSE); +if(advanced_bt != NULL) gtk_widget_set_sensitive(advanced_bt,FALSE);*/ } #endif /* HAVE_AIRPCAP */ diff --git a/gtk/airpcap_gui_utils.h b/gtk/airpcap_gui_utils.h index ab01366ef4..d4e4e7c604 100755 --- a/gtk/airpcap_gui_utils.h +++ b/gtk/airpcap_gui_utils.h @@ -191,7 +191,7 @@ airpcap_read_and_save_decryption_keys_from_clist(GtkWidget* key_ls, airpcap_if_i /* * This function will load from the preferences file ALL the - * keys (WEP, WPA and WPA2) and will set them as default for + * keys (WEP, WPA and WPA_BIN) and will set them as default for * each adapter. To do this, it will save the keys in the registry... */ void @@ -199,7 +199,7 @@ airpcap_load_decryption_keys(GList* if_list); /* * This function will load from the preferences file ALL the - * keys (WEP, WPA and WPA2) and will set them as default for + * keys (WEP, WPA and WPA_BIN) and will set them as default for * each adapter. To do this, it will save the keys in the registry... */ gboolean @@ -212,4 +212,18 @@ airpcap_check_decryption_keys(GList* if_list); void airpcap_save_decryption_keys(GList* key_list, GList* adapters_list); +/* + * This function is used to enable/disable the toolbar widgets + * depending on the type of interface selected... + */ +void +airpcap_enable_toolbar_widgets(GtkWidget* w, gboolean en); + +/* + * This function sets up the correct airpcap toolbar that must + * be displayed when no airpcap if is found on the system... + */ +void +airpcap_set_toolbar_no_if(GtkWidget* w); + #endif diff --git a/gtk/capture_dlg.c b/gtk/capture_dlg.c index 32478983f4..aa202d26d7 100644 --- a/gtk/capture_dlg.c +++ b/gtk/capture_dlg.c @@ -202,7 +202,7 @@ set_link_type_list(GtkWidget *linktype_om, GtkWidget *entry) /* retrieve the advanced button pointer */ advanced_bt = OBJECT_GET_DATA(entry,AIRPCAP_OPTIONS_ADVANCED_KEY); airpcap_if_selected = get_airpcap_if_by_name(airpcap_if_list,if_name); - gtk_widget_set_sensitive(airpcap_tb,FALSE); + airpcap_enable_toolbar_widgets(airpcap_tb,FALSE); if( airpcap_if_selected != NULL) { gtk_widget_set_sensitive(advanced_bt,TRUE); @@ -530,7 +530,7 @@ from_widget = (gint*)g_malloc(sizeof(gint)); OBJECT_SET_DATA(airpcap_tb,AIRPCAP_ADVANCED_FROM_KEY,from_widget); airpcap_if_active = airpcap_if_selected; -gtk_widget_set_sensitive(airpcap_tb,FALSE); +airpcap_enable_toolbar_widgets(airpcap_tb,FALSE); display_airpcap_advanced_cb(w,d); } #endif @@ -580,8 +580,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_) GtkAdjustment *snap_adj, *ringbuffer_nbf_adj, *stop_packets_adj, *stop_filesize_adj, *stop_duration_adj, *stop_files_adj, *ring_filesize_adj, *file_duration_adj; GList *if_list, *combo_list, *cfilter_list; - int err; int row; + int err; char err_str[CAPTURE_PCAP_ERRBUF_SIZE]; gchar *cant_get_if_list_errstr; #ifdef _WIN32 @@ -592,6 +592,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_) gchar *cap_title; gchar *if_device; + GtkWidget *decryption_cm; + if (cap_open_w != NULL) { /* There's already a "Capture Options" dialog box; reactivate it. */ reactivate_window(cap_open_w); @@ -623,6 +625,9 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_) /* load the airpcap interfaces */ airpcap_if_list = get_airpcap_interface_list(&err, err_str); + decryption_cm = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_KEY); + update_decryption_mode_list(decryption_cm); + if (airpcap_if_list == NULL && err == CANT_GET_AIRPCAP_INTERFACE_LIST) { cant_get_if_list_errstr = cant_get_airpcap_if_list_error_message(err_str); simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", diff --git a/gtk/capture_if_dlg.c b/gtk/capture_if_dlg.c index 0c0dccd101..340206b02d 100644 --- a/gtk/capture_if_dlg.c +++ b/gtk/capture_if_dlg.c @@ -401,6 +401,8 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_) *help_bt, *icon; + GtkWidget *decryption_cm; + GtkWidget *if_tb; GtkWidget *if_lb; #if GTK_MAJOR_VERSION < 2 @@ -453,6 +455,10 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_) /* LOAD AIRPCAP INTERFACES */ /* load the airpcap interfaces */ airpcap_if_list = get_airpcap_interface_list(&err, err_str); + if(airpcap_if_list == NULL) airpcap_if_active = airpcap_if_selected = NULL; + + decryption_cm = OBJECT_GET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_KEY); + update_decryption_mode_list(decryption_cm); if (airpcap_if_list == NULL && err == CANT_GET_AIRPCAP_INTERFACE_LIST) { cant_get_if_list_errstr = cant_get_airpcap_if_list_error_message(err_str); @@ -467,13 +473,13 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_) if(airpcap_if_list == NULL) { /*No airpcap device found */ - gtk_widget_set_sensitive(airpcap_tb,FALSE); + airpcap_enable_toolbar_widgets(airpcap_tb,FALSE); } else { /* default adapter is not airpcap... or is airpcap but is not found*/ airpcap_set_toolbar_stop_capture(airpcap_if_active); - gtk_widget_set_sensitive(airpcap_tb,FALSE); + airpcap_enable_toolbar_widgets(airpcap_tb,FALSE); } } diff --git a/gtk/keys.h b/gtk/keys.h index 5a5ca43833..23dfd554ff 100644 --- a/gtk/keys.h +++ b/gtk/keys.h @@ -52,11 +52,14 @@ #define AIRPCAP_TOOLBAR_INTERFACE_KEY "airpcap_toolbar_if_key" #define AIRPCAP_TOOLBAR_LINK_TYPE_KEY "airpcap_toolbar_lt_key" #define AIRPCAP_TOOLBAR_CHANNEL_KEY "airpcap_toolbar_ch_key" +#define AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY "airpcap_toolbar_ch_lb_key" #define AIRPCAP_TOOLBAR_FCS_CHECK_KEY "airpcap_toolbar_fcs_check_key" +#define AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY "airpcap_toolbar_fcs_filter_lb_key" #define AIRPCAP_TOOLBAR_FCS_FILTER_KEY "airpcap_toolbar_fcs_filter_key" #define AIRPCAP_TOOLBAR_ADVANCED_KEY "airpcap_toolbar_advanced_key" #define AIRPCAP_TOOLBAR_KEY_MANAGEMENT_KEY "airpcap_toolbar_key_management_key" #define AIRPCAP_TOOLBAR_DECRYPTION_KEY "airpcap_toolbar_decryption_key" +#define AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY "airpcap_toolbar_decryption_lb_key" #define AIRPCAP_ADVANCED_KEY "airpcap_advanced_key" #define AIRPCAP_ADVANCED_INTERFACE_KEY "airpcap_advanced_if_key" @@ -71,12 +74,16 @@ #define AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY "airpcap_advanced_add_key_type_key" #define AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY "airpcap_advanced_add_key_key_key" #define AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY "airpcap_advanced_add_key_ssid_key" +#define AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY "airpcap_advanced_add_key_key_label_key" +#define AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY "airpcap_advanced_add_key_ssid_label_key" #define AIRPCAP_ADVANCED_EDIT_KEY_SELECTED_KEY "airpcap_advanced_edit_key_selected_key" #define AIRPCAP_ADVANCED_EDIT_KEY_OK_KEY "airpcap_advanced_edit_key_ok_key" #define AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY "airpcap_advanced_edit_key_list_key" #define AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY "airpcap_advanced_edit_key_type_key" #define AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY "airpcap_advanced_edit_key_key_key" #define AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY "airpcap_advanced_edit_key_ssid_key" +#define AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY "airpcap_advanced_edit_key_key_label_key" +#define AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY "airpcap_advanced_edit_key_ssid_label_key" #define AIRPCAP_ADVANCED_WEP_DECRYPTION_KEY "airpcap_advanced_wep_decryption_key" #define AIRPCAP_ADVANCED_WPA_DECRYPTION_KEY "airpcap_advanced_wpa_decryption_key" #define AIRPCAP_ADVANCED_NOTEBOOK_KEY "airpcap_advanced_notebook_key" diff --git a/gtk/main.c b/gtk/main.c index 08905fb5d2..150f7eb5d4 100644 --- a/gtk/main.c +++ b/gtk/main.c @@ -172,6 +172,12 @@ #include "./image/toolbar/wep_closed_24.xpm" #endif +#ifdef HAVE_AIRPDCAP +/* Davide Schiera (2006-11-22): including AirPDcap project */ +#include "..\airpdcap\airpdcap_ws.h" +/* Davide Schiera (2006-11-22) ---------------------------------------------- */ +#endif + /* * Files under personal and global preferences directories in which * GTK settings for Wireshark are stored. @@ -2116,6 +2122,12 @@ main(int argc, char *argv[]) char optstring[sizeof(OPTSTRING_INIT) + sizeof(OPTSTRING_WIN32) - 1] = OPTSTRING_INIT OPTSTRING_WIN32; +#ifdef HAVE_AIRPDCAP + /* Davide Schiera (2006-11-18): init AirPDcap context */ + AirPDcapInitContext(&airpdcap_ctx); + /* Davide Schiera (2006-11-18) ------------------------------------------- */ +#endif + /* * Attempt to get the pathname of the executable file. */ @@ -2995,6 +3007,12 @@ main(int argc, char *argv[]) epan_cleanup(); g_free(rc_file); +#ifdef HAVE_AIRPDCAP + /* Davide Schiera (2006-11-18): destroy AirPDcap context */ + AirPDcapDestroyContext(&airpdcap_ctx); + /* Davide Schiera (2006-11-18) ------------------------------------------- */ +#endif + #ifdef _WIN32 /* hide the (unresponsive) main window, while asking the user to close the console window */ gtk_widget_hide(top_level); @@ -3991,6 +4009,7 @@ create_main_window (gint pl_size, gint tv_size, gint bv_size, e_prefs *prefs) /* Create the "802.11 Channel:" label */ channel_lb = gtk_label_new(" 802.11 Channel: "); + OBJECT_SET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY,channel_lb); gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), channel_lb, "Current 802.11 Channel", "Private"); gtk_widget_show(channel_lb); @@ -4040,6 +4059,7 @@ create_main_window (gint pl_size, gint tv_size, gint bv_size, e_prefs *prefs) /* Wrong CRC Label */ wrong_crc_lb = gtk_label_new(" FCS Filter: "); + OBJECT_SET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY,wrong_crc_lb); gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), wrong_crc_lb, "", "Private"); gtk_widget_show(wrong_crc_lb); @@ -4058,7 +4078,7 @@ create_main_window (gint pl_size, gint tv_size, gint bv_size, e_prefs *prefs) linktype_list = g_list_append(linktype_list, AIRPCAP_VALIDATION_TYPE_NAME_CORRUPT); gtk_combo_set_popdown_strings( GTK_COMBO(wrong_crc_cm), linktype_list) ; - gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(GTK_COMBO(wrong_crc_cm)->entry), + gtk_tooltips_set_tip(airpcap_tooltips, GTK_WIDGET(GTK_COMBO(wrong_crc_cm)->entry), "Select the 802.11 FCS filter that the wireless adapter will apply.", NULL); @@ -4074,6 +4094,7 @@ create_main_window (gint pl_size, gint tv_size, gint bv_size, e_prefs *prefs) /* Decryption mode combo box */ enable_decryption_lb = gtk_label_new ("Decryption Mode: "); + OBJECT_SET_DATA(airpcap_tb,AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY,enable_decryption_lb); gtk_widget_set_name (enable_decryption_lb, "enable_decryption_lb"); gtk_widget_show (enable_decryption_lb); gtk_toolbar_append_widget(GTK_TOOLBAR(airpcap_tb), enable_decryption_lb, @@ -4083,11 +4104,7 @@ create_main_window (gint pl_size, gint tv_size, gint bv_size, e_prefs *prefs) gtk_widget_set_name (enable_decryption_cb, "enable_decryption_cb"); gtk_widget_show (enable_decryption_cb); WIDGET_SET_SIZE (enable_decryption_cb, 83, -1); - enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_NONE); - enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK); - enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP); - gtk_combo_set_popdown_strings (GTK_COMBO (enable_decryption_cb), enable_decryption_cb_items); - g_list_free (enable_decryption_cb_items); + update_decryption_mode_list(enable_decryption_cb); enable_decryption_en = GTK_COMBO (enable_decryption_cb)->entry; gtk_widget_set_name (enable_decryption_en, "enable_decryption_en"); @@ -4130,17 +4147,17 @@ create_main_window (gint pl_size, gint tv_size, gint bv_size, e_prefs *prefs) if(airpcap_if_active == NULL) { if(airpcap_if_list == NULL) { /*No airpcap device found */ - gtk_widget_set_sensitive(airpcap_tb,FALSE); - recent.airpcap_toolbar_show = FALSE; + airpcap_enable_toolbar_widgets(airpcap_tb,FALSE); + //recent.airpcap_toolbar_show = TRUE; } else { /* default adapter is not airpcap... or is airpcap but is not found*/ airpcap_set_toolbar_stop_capture(airpcap_if_active); - gtk_widget_set_sensitive(airpcap_tb,FALSE); - recent.airpcap_toolbar_show = TRUE; + airpcap_enable_toolbar_widgets(airpcap_tb,FALSE); + //recent.airpcap_toolbar_show = TRUE; } } else { airpcap_set_toolbar_stop_capture(airpcap_if_active); - recent.airpcap_toolbar_show = TRUE; + //recent.airpcap_toolbar_show = TRUE; } #endif -- cgit v1.2.3