diff options
author | sahlberg <sahlberg@f5534014-38df-0310-8fa8-9805f1628bb7> | 2006-06-27 13:36:10 +0000 |
---|---|---|
committer | sahlberg <sahlberg@f5534014-38df-0310-8fa8-9805f1628bb7> | 2006-06-27 13:36:10 +0000 |
commit | e60a25002482c8a864ff8f3ed38dd5c09783f78a (patch) | |
tree | b2576b3bc27926dabb97d9f50a8cc6752a8507c7 /epan/dissectors/packet-dtls.c | |
parent | 688e1cff01c60e70fb853223f48931d6eee2c9fd (diff) |
from Authesserre Samuel
SSL updates and DTLS support
git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@18582 f5534014-38df-0310-8fa8-9805f1628bb7
Diffstat (limited to 'epan/dissectors/packet-dtls.c')
-rw-r--r-- | epan/dissectors/packet-dtls.c | 3871 |
1 files changed, 3871 insertions, 0 deletions
diff --git a/epan/dissectors/packet-dtls.c b/epan/dissectors/packet-dtls.c new file mode 100644 index 0000000000..c1927b97d5 --- /dev/null +++ b/epan/dissectors/packet-dtls.c @@ -0,0 +1,3871 @@ +/* packet-dtls.c + * Routines for dtls dissection + * Copyright (c) 2006, Authesserre Samuel <sauthess@gmail.com> + * + * $Id$ + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@ethereal.com> + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <glib.h> + +#include <epan/conversation.h> +#include <epan/prefs.h> +#include <epan/inet_v6defs.h> +#include <epan/dissectors/packet-x509af.h> +#include <epan/emem.h> +#include <epan/tap.h> +#include "packet-ssl-utils.h" + +static gboolean ssl_desegment = TRUE; + +/********************************************************************* + * + * Protocol Constants, Variables, Data Structures + * + *********************************************************************/ + +/* Initialize the protocol and registered fields */ +static int dtls_tap = -1; +static int proto_dtls = -1; +static int hf_dtls_record = -1; +static int hf_dtls_record_content_type = -1; +static int hf_dtls_record_version = -1; +static int hf_dtls_record_epoch = -1; +static int hf_dtls_record_sequence_number = -1; +static int hf_dtls_record_length = -1; +static int hf_dtls_record_appdata = -1; +static int hf_dtls_record_appdata_decrypted = -1; +static int hf_ssl2_record = -1; +static int hf_ssl2_record_is_escape = -1; +static int hf_ssl2_record_padding_length = -1; +static int hf_ssl2_msg_type = -1; +static int hf_pct_msg_type = -1; +static int hf_dtls_change_cipher_spec = -1; +static int hf_dtls_alert_message = -1; +static int hf_dtls_alert_message_level = -1; +static int hf_dtls_alert_message_description = -1; +static int hf_dtls_handshake_protocol = -1; +static int hf_dtls_handshake_type = -1; +static int hf_dtls_handshake_length = -1; +static int hf_dtls_handshake_message_seq = -1; +static int hf_dtls_handshake_fragment_offset = -1; +static int hf_dtls_handshake_fragment_length = -1; +static int hf_dtls_handshake_client_version = -1; +static int hf_dtls_handshake_server_version = -1; +static int hf_dtls_handshake_random_time = -1; +static int hf_dtls_handshake_random_bytes = -1; +static int hf_dtls_handshake_cookie_len = -1; +static int hf_dtls_handshake_cookie = -1; +static int hf_dtls_handshake_cipher_suites_len = -1; +static int hf_dtls_handshake_cipher_suites = -1; +static int hf_dtls_handshake_cipher_suite = -1; +static int hf_dtls_handshake_session_id = -1; +static int hf_dtls_handshake_comp_methods_len = -1; +static int hf_dtls_handshake_comp_methods = -1; +static int hf_dtls_handshake_comp_method = -1; +static int hf_dtls_handshake_extensions_len = -1; +static int hf_dtls_handshake_extension_type = -1; +static int hf_dtls_handshake_extension_len = -1; +static int hf_dtls_handshake_extension_data = -1; +static int hf_dtls_handshake_certificates_len = -1; +static int hf_dtls_handshake_certificates = -1; +static int hf_dtls_handshake_certificate = -1; +static int hf_dtls_handshake_certificate_len = -1; +static int hf_dtls_handshake_cert_types_count = -1; +static int hf_dtls_handshake_cert_types = -1; +static int hf_dtls_handshake_cert_type = -1; +static int hf_dtls_handshake_finished = -1; +static int hf_dtls_handshake_md5_hash = -1; +static int hf_dtls_handshake_sha_hash = -1; +static int hf_dtls_handshake_session_id_len = -1; +static int hf_dtls_handshake_dnames_len = -1; +static int hf_dtls_handshake_dnames = -1; +static int hf_dtls_handshake_dname_len = -1; +static int hf_dtls_handshake_dname = -1; +static int hf_ssl2_handshake_cipher_spec_len = -1; +static int hf_ssl2_handshake_session_id_len = -1; +static int hf_ssl2_handshake_challenge_len = -1; +static int hf_ssl2_handshake_cipher_spec = -1; +static int hf_ssl2_handshake_challenge = -1; +static int hf_ssl2_handshake_clear_key_len = -1; +static int hf_ssl2_handshake_enc_key_len = -1; +static int hf_ssl2_handshake_key_arg_len = -1; +static int hf_ssl2_handshake_clear_key = -1; +static int hf_ssl2_handshake_enc_key = -1; +static int hf_ssl2_handshake_key_arg = -1; +static int hf_ssl2_handshake_session_id_hit = -1; +static int hf_ssl2_handshake_cert_type = -1; +static int hf_ssl2_handshake_connection_id_len = -1; +static int hf_ssl2_handshake_connection_id = -1; +static int hf_pct_handshake_cipher_spec = -1; +static int hf_pct_handshake_hash_spec = -1; +static int hf_pct_handshake_cert_spec = -1; +static int hf_pct_handshake_cert = -1; +static int hf_pct_handshake_server_cert = -1; +static int hf_pct_handshake_exch_spec = -1; +static int hf_pct_handshake_hash = -1; +static int hf_pct_handshake_cipher = -1; +static int hf_pct_handshake_exch = -1; +static int hf_pct_handshake_sig = -1; +static int hf_pct_msg_error_type = -1; + +/* Initialize the subtree pointers */ +static gint ett_dtls = -1; +static gint ett_dtls_record = -1; +static gint ett_dtls_alert = -1; +static gint ett_dtls_handshake = -1; +static gint ett_dtls_cipher_suites = -1; +static gint ett_dtls_comp_methods = -1; +static gint ett_dtls_extension = -1; +static gint ett_dtls_certs = -1; +static gint ett_dtls_cert_types = -1; +static gint ett_dtls_dnames = -1; +static gint ett_pct_cipher_suites = -1; +static gint ett_pct_hash_suites = -1; +static gint ett_pct_cert_suites = -1; +static gint ett_pct_exch_suites = -1; + +typedef struct { + unsigned int ssl_port; + unsigned int decrypted_port; + dissector_handle_t handle; + char* info; +} SslAssociation; + +static char* dtls_keys_list = NULL; +static char* dtls_ports_list = NULL; +static char* dtls_debug_file_name = NULL; + +typedef struct _SslService { + address addr; + guint port; +} SslService; + +static GHashTable *ssl_session_hash = NULL; +static GHashTable *ssl_key_hash = NULL; +static GTree* ssl_associations = NULL; +static dissector_handle_t dtls_handle = NULL; +static StringInfo ssl_decrypted_data = {NULL, 0}; +static int ssl_decrypted_data_avail = 0; + +/* Hash Functions for ssl sessions table and private keys table*/ +static gint +ssl_equal (gconstpointer v, gconstpointer v2) +{ + const StringInfo *val1 = (const StringInfo *)v; + const StringInfo *val2 = (const StringInfo *)v2; + + if (val1->data_len == val2->data_len && + !memcmp(val1->data, val2->data, val2->data_len)) { + return 1; + } + return 0; +} + +static guint +ssl_hash (gconstpointer v) +{ + guint l,hash = 0; + StringInfo* id = (StringInfo*) v; + guint* cur = (guint*) id->data; + for (l=4; (l<id->data_len); l+=4, cur++) + hash = hash ^ (*cur); + + return hash; +} + +static gint +ssl_private_key_equal (gconstpointer v, gconstpointer v2) +{ + const SslService *val1 = (const SslService *)v; + const SslService *val2 = (const SslService *)v2; + + if ((val1->port == val2->port) && + ! CMP_ADDRESS(&val1->addr, &val2->addr)) { + return 1; + } + return 0; +} + +static guint +ssl_private_key_hash (gconstpointer v) +{ + const SslService *key = (const SslService *)v; + guint l,hash = key->port, len = key->addr.len; + + guint* cur = (guint*) key->addr.data; + for (l=4; (l<len); l+=4, cur++) + hash = hash ^ (*cur); + + return hash; +} + +/* private key table entries have a scope 'larger' then packet capture, + * so we can't relay on se_alloc** function */ +static void +ssl_private_key_free(gpointer id, gpointer key, gpointer dummy _U_) +{ + g_free(id); + ssl_free_key((SSL_PRIVATE_KEY*) key); +} + +/* handling of association between ssl ports and clear text protocol */ +static void +ssl_association_add(unsigned int port, unsigned int ctport, + const char* info) +{ + dissector_table_t udp_dissectors = find_dissector_table( "udp.port"); + SslAssociation* assoc = g_malloc(sizeof(SslAssociation)+strlen(info)+1); + + assoc->info = (char*) assoc+sizeof(SslAssociation); + strcpy(assoc->info, info); + assoc->ssl_port = port; + assoc->decrypted_port = ctport; + assoc->handle = dissector_get_port_handle(udp_dissectors, ctport); + + ssl_debug_printf("ssl_association_add port %d ctport %d info %s handle %p\n", + port, ctport, info, assoc->handle); + + dissector_add("udp.port", port, dtls_handle); + g_tree_insert(ssl_associations, (gpointer)port, assoc); +} + +static gint +ssl_association_cmp(gconstpointer a, gconstpointer b) +{ + return (gint)a-(gint)b; +} + +static inline +SslAssociation* ssl_association_find(unsigned int port) +{ + register SslAssociation* ret = g_tree_lookup(ssl_associations, (gpointer)port); + ssl_debug_printf("ssl_association_find: port %d found %p\n", port, ret); + return ret; +} + +static gint +ssl_association_remove_handle (gpointer key _U_, + gpointer data, gpointer user_data _U_) +{ + SslAssociation* assoc = (SslAssociation*) data; + ssl_debug_printf("ssl_association_remove_handle removing ptr %p handle %p\n", + data, assoc->handle); + if (assoc->handle) + dissector_delete("tcp.port", assoc->ssl_port, assoc->handle); + g_free(data); + return 0; +} + +static inline int +ssl_packet_from_server(unsigned int port) +{ + register int ret = ssl_association_find(port) != 0; + ssl_debug_printf("ssl_packet_from_server: is from server %d\n", ret); + return ret; +} + +/* add to packet data a newly allocated tvb with the specified real data*/ +static void +ssl_add_record_info(packet_info *pinfo, unsigned char* data, int data_len, int record_id) +{ + unsigned char* real_data = se_alloc(data_len); + SslRecordInfo* rec = se_alloc(sizeof(SslRecordInfo)); + SslPacketInfo* pi = p_get_proto_data(pinfo->fd, proto_dtls); + if (!pi) + { + pi = se_alloc0(sizeof(SslPacketInfo)); + p_add_proto_data(pinfo->fd, proto_dtls,pi); + } + + rec->id = record_id; + rec->tvb = tvb_new_real_data(real_data, data_len, data_len); + memcpy(real_data, data, data_len); + + /* head insertion */ + rec->next= pi->handshake_data; + pi->handshake_data = rec; +} + +/* search in packet data the tvbuff associated to the specified id */ +static tvbuff_t* +ssl_get_record_info(packet_info *pinfo, int record_id) +{ + SslRecordInfo* rec; + SslPacketInfo* pi = p_get_proto_data(pinfo->fd, proto_dtls); + if (!pi) + return NULL; + + for (rec = pi->handshake_data; rec; rec = rec->next) + if (rec->id == record_id) + return rec->tvb; + + return NULL; +} + +/* initialize/reset per capture state data (ssl sessions cache) */ +static void +ssl_init(void) +{ + if (ssl_session_hash) + g_hash_table_destroy(ssl_session_hash); + ssl_session_hash = g_hash_table_new(ssl_hash, ssl_equal); + if (ssl_decrypted_data.data) + g_free(ssl_decrypted_data.data); + ssl_decrypted_data.data = g_malloc0(32); + ssl_decrypted_data.data_len = 32; +} + +/* parse ssl related preferences (private keys and ports association strings) */ +static void +ssl_parse(void) +{ + if (ssl_key_hash) + { + g_hash_table_foreach(ssl_key_hash, ssl_private_key_free, NULL); + g_hash_table_destroy(ssl_key_hash); + } + if (ssl_associations) + { + g_tree_traverse(ssl_associations, ssl_association_remove_handle, G_IN_ORDER, NULL); + g_tree_destroy(ssl_associations); + } + + /* parse private keys string, load available keys and put them in key hash*/ + ssl_key_hash = g_hash_table_new(ssl_private_key_hash,ssl_private_key_equal); + ssl_associations = g_tree_new(ssl_association_cmp); + + if (dtls_keys_list && (dtls_keys_list[0] != 0)) + { + char* end; + char* start = strdup(dtls_keys_list); + char* tmp = start; + + ssl_debug_printf("ssl_init keys string %s\n", start); + do { + char* addr, *port, *filename; + unsigned char* ip; + SslService* service; + SSL_PRIVATE_KEY * private_key; + FILE* fp; + + addr = start; + /* split ip/file couple with ',' separator*/ + end = strchr(start, ','); + if (end) { + *end = 0; + start = end+1; + } + + /* for each entry split ip, port, filename with ':' separator */ + ssl_debug_printf("ssl_init found host entry %s\n", addr); + port = strchr(addr, ':'); + if (!port) + { + ssl_debug_printf("ssl_init entry malformed can't find port in %s\n", addr); + break; + } + *port = 0; + port++; + + filename = strchr(port,':'); + if (!filename) + { + ssl_debug_printf("ssl_init entry malformed can't find filename in %s\n", port); + break; + } + *filename=0; + filename++; + + /* convert ip and port string to network rappresentation*/ + service = g_malloc(sizeof(SslService) + 4); + service->addr.type = AT_IPv4; + service->addr.len = 4; + service->addr.data = ip = ((unsigned char*)service) + sizeof(SslService); + sscanf(addr, "%hhu.%hhu.%hhu.%hhu", &ip[0], &ip[1], &ip[2], &ip[3]); + service->port = atoi(port); + ssl_debug_printf("ssl_init addr %hhu.%hhu.%hhu.%hhu port %d filename %s\n", + ip[0], ip[1], ip[2], ip[3], service->port, filename); + + /* try to load pen file*/ + fp = fopen(filename, "rb"); + if (!fp) { + fprintf(stderr, "can't open file %s \n",filename); + break; + } + + private_key = ssl_load_key(fp); + if (!private_key) { + fprintf(stderr,"can't load private key from %s\n", + filename); + break; + } + fclose(fp); + + ssl_debug_printf("ssl_init private key file %s successfully loaded\n", + filename); + g_hash_table_insert(ssl_key_hash, service, private_key); + + } while (end != NULL); + free(tmp); + } + + /* parse ssl ports string and add ssl dissector to specifed port[s]*/ + if (dtls_ports_list && (dtls_ports_list[0] != 0)) + { + char* end; + char* start = strdup(dtls_ports_list); + char* tmp = start; + + ssl_debug_printf("ssl_init ports string %s\n", start); + do { + char* port, *ctport, *info; + unsigned int portn, ctportn; + + port = start; + /* split ip/file couple with ',' separator*/ + end = strchr(start, ','); + if (end) { + *end = 0; + start = end+1; + } + + /* for each entry split ip, port, filename with ':' separator */ + ssl_debug_printf("ssl_init found port entry %s\n", port); + ctport = strchr(port, ':'); + if (!ctport) + break; + *ctport = 0; + ctport++; + + info = strchr(ctport,':'); + if (!info) + break; + *info=0; + info++; + + /* add dissector to this port */ + portn = atoi(port); + ctportn = atoi(ctport); + if (!portn || !ctportn) + break; + + ssl_debug_printf("ssl_init adding dissector to port %d (ct port %d)\n", portn, ctportn); + ssl_association_add(portn, ctportn, info); + } while (end != NULL); + free(tmp); + } + + ssl_set_debug(dtls_debug_file_name); + + /* [re] add ssl dissection to defaults ports */ + ssl_association_add(4433, 80, "OpenSSL Implementation"); +} + +/* store master secret into session data cache */ +static void +ssl_save_session(SslDecryptSession* ssl) +{ + /* allocate stringinfo chunks for session id and master secret data*/ + StringInfo* session_id = se_alloc0(sizeof(StringInfo) + ssl->session_id.data_len); + StringInfo* master_secret = se_alloc0(48 + sizeof(StringInfo)); + + master_secret->data = ((unsigned char*)master_secret+sizeof(StringInfo)); + session_id->data = ((unsigned char*)session_id+sizeof(StringInfo)); + + ssl_data_set(session_id, ssl->session_id.data, ssl->session_id.data_len); + ssl_data_set(master_secret, ssl->master_secret.data, ssl->master_secret.data_len); + g_hash_table_insert(ssl_session_hash, session_id, master_secret); + ssl_print_string("ssl_save_session stored session id", session_id); + ssl_print_string("ssl_save_session stored master secret", master_secret); +} + +static void +ssl_restore_session(SslDecryptSession* ssl) +{ + StringInfo* ms = g_hash_table_lookup(ssl_session_hash, &ssl->session_id); + if (!ms) { + ssl_debug_printf("ssl_restore_session can't find stored session\n"); + return; + } + ssl_data_set(&ssl->master_secret, ms->data, ms->data_len); + ssl->state |= SSL_MASTER_SECRET; + ssl_debug_printf("ssl_restore_session master key retrived\n"); +} + + +/********************************************************************* + * + * Forward Declarations + * + *********************************************************************/ + +/* + * SSL version 3 and TLS dissectors + * + */ +/* record layer dissector */ +static int dissect_ssl3_record(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, guint32 offset, + guint *conv_version, + gboolean *need_desegmentation, + SslDecryptSession *conv_data); + +/* change cipher spec dissector */ +static void dissect_ssl3_change_cipher_spec(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset, + guint *conv_version, guint8 content_type); + +/* alert message dissector */ +static void dissect_ssl3_alert(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, guint32 offset, + guint *conv_version); + +/* handshake protocol dissector */ +static void dissect_ssl3_handshake(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, guint32 offset, + guint32 record_length, + guint *conv_version, + SslDecryptSession *conv_data, guint8 content_type); + + +static void dissect_ssl3_hnd_cli_hello(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset, guint32 length, + SslDecryptSession* ssl); + +static void dissect_ssl3_hnd_hello_verify_request(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset, guint32 length, + SslDecryptSession* ssl); + +static void dissect_ssl3_hnd_srv_hello(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset, guint32 length, + SslDecryptSession* ssl); + +static void dissect_ssl3_hnd_cert(tvbuff_t *tvb, + proto_tree *tree, guint32 offset, packet_info *pinfo); + +static void dissect_ssl3_hnd_cert_req(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset); + +static void dissect_ssl3_hnd_finished(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset, + guint* conv_version); + + +/* + * SSL version 2 dissectors + * + */ + +/* record layer dissector */ +static int dissect_ssl2_record(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, guint32 offset, + guint *conv_version, + gboolean *need_desegmentation, + SslDecryptSession* ssl); + +/* client hello dissector */ +static void dissect_ssl2_hnd_client_hello(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset, + SslDecryptSession* ssl); + +static void dissect_pct_msg_client_hello(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset); + +/* client master key dissector */ +static void dissect_ssl2_hnd_client_master_key(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset); +static void dissect_pct_msg_client_master_key(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset); + +/* server hello dissector */ +static void dissect_ssl2_hnd_server_hello(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset, packet_info *pinfo); +static void dissect_pct_msg_server_hello(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset, packet_info *pinfo); + + +static void dissect_pct_msg_server_verify(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset); + +static void dissect_pct_msg_error(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset); + +/* + * Support Functions + * + */ +/*static void ssl_set_conv_version(packet_info *pinfo, guint version);*/ +static int ssl_is_valid_handshake_type(guint8 type); +static int ssl_is_valid_content_type(guint8 type); +static int ssl_is_valid_ssl_version(guint16 version); +static int ssl_is_authoritative_version_message(guint8 content_type, + guint8 next_byte); +static int ssl_is_v2_client_hello(tvbuff_t *tvb, guint32 offset); +static int ssl_looks_like_sslv2(tvbuff_t *tvb, guint32 offset); +static int ssl_looks_like_sslv3(tvbuff_t *tvb, guint32 offset); +static int ssl_looks_like_valid_v2_handshake(tvbuff_t *tvb, + guint32 offset, + guint32 record_length); +static int ssl_looks_like_valid_pct_handshake(tvbuff_t *tvb, + guint32 offset, + guint32 record_length); +/********************************************************************* + * + * Main dissector + * + *********************************************************************/ +/* + * Code to actually dissect the packets + */ +static void +dissect_dtls(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + + conversation_t *conversation; + void *conv_data; + proto_item *ti = NULL; + proto_tree *dtls_tree = NULL; + guint32 offset = 0; + gboolean first_record_in_frame = TRUE; + gboolean need_desegmentation; + SslDecryptSession* ssl_session = NULL; + guint* conv_version; + + /* Track the version using conversations to reduce the + * chance that a packet that simply *looks* like a v2 or + * v3 packet is dissected improperly. This also allows + * us to more frequently set the protocol column properly + * for continuation data frames. + * + * Also: We use the copy in conv_version as our cached copy, + * so that we don't have to search the conversation + * table every time we want the version; when setting + * the conv_version, must set the copy in the conversation + * in addition to conv_version + */ + conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst, pinfo->ptype, + pinfo->srcport, pinfo->destport, 0); + if (!conversation) + { + /* create a new conversation */ + conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst, pinfo->ptype, + pinfo->srcport, pinfo->destport, 0); + } + conv_data = conversation_get_proto_data(conversation, proto_dtls); + + /* PAOLO: manage ssl decryption data */ + /*get a valid ssl session pointer*/ + if (conv_data != NULL) + ssl_session = conv_data; + else { + SslService dummy; + + ssl_session = se_alloc0(sizeof(SslDecryptSession)); + ssl_session_init(ssl_session); + ssl_session->version = SSL_VER_UNKNOWN; + conversation_add_proto_data(conversation, proto_dtls, ssl_session); + + /* we need to know witch side of conversation is speaking*/ + if (ssl_packet_from_server(pinfo->srcport)) { + dummy.addr = pinfo->src; + dummy.port = pinfo->srcport; + } + else { + dummy.addr = pinfo->dst; + dummy.port = pinfo->destport; + } + ssl_debug_printf("dissect_ssl server %hhd.%hhd.%hhd.%hhd:%d\n", + dummy.addr.data[0], + dummy.addr.data[1],dummy.addr.data[2], + dummy.addr.data[3],dummy.port); + + /* try to retrive private key for this service. Do it now 'cause pinfo + * is not always available + * Note that with HAVE_LIBGNUTLS undefined private_key is allways 0 + * and thus decryption never engaged*/ + ssl_session->private_key = g_hash_table_lookup(ssl_key_hash, &dummy); + if (!ssl_session->private_key) + ssl_debug_printf("dissect_ssl can't find private key for this server!\n"); + } + conv_version= & ssl_session->version; + + /* try decryption only the first time we see this packet + * (to keep cipher syncronized)and only if we have + * the server private key*/ + if (!ssl_session->private_key || pinfo->fd->flags.visited) + ssl_session = NULL; + + /* Initialize the protocol column; we'll set it later when we + * figure out what flavor of SSL it is (assuming we don't + * throw an exception before we get the chance to do so). */ + if (check_col(pinfo->cinfo, COL_PROTOCOL)) + { + col_set_str(pinfo->cinfo, COL_PROTOCOL, "DTLS"); + } + + /* clear the the info column */ + if (check_col(pinfo->cinfo, COL_INFO)) + col_clear(pinfo->cinfo, COL_INFO); + + /* TCP packets and SSL records are orthogonal. + * A tcp packet may contain multiple ssl records and an ssl + * record may be spread across multiple tcp packets. + * + * This loop accounts for multiple ssl records in a single + * frame, but not a single ssl record across multiple tcp + * packets. + * + * Handling the single ssl record across multiple packets + * may be possible using ethereal conversations, but + * probably not cleanly. May have to wait for tcp stream + * reassembly. + */ + + /* Create display subtree for SSL as a whole */ + if (tree) + { + ti = proto_tree_add_item(tree, proto_dtls, tvb, 0, -1, FALSE); + dtls_tree = proto_item_add_subtree(ti, ett_dtls); + } + + /* iterate through the records in this tvbuff */ + while (tvb_reported_length_remaining(tvb, offset) != 0) + { + /* on second and subsequent records per frame + * add a delimiter on info column + */ + if (!first_record_in_frame + && check_col(pinfo->cinfo, COL_INFO)) + { + col_append_str(pinfo->cinfo, COL_INFO, ", "); + } + + /* + * Assume, for now, that this doesn't need desegmentation. + */ + need_desegmentation = FALSE; + + /* first try to dispatch off the cached version + * known to be associated with the conversation + */ + switch(*conv_version) { + case SSL_VER_SSLv2: + case SSL_VER_PCT: + offset = dissect_ssl2_record(tvb, pinfo, dtls_tree, + offset, conv_version, + &need_desegmentation, + ssl_session); + break; + + case SSL_VER_SSLv3: + case SSL_VER_TLS: + case SSL_VER_DTLS: + /* the version tracking code works too well ;-) + * at times, we may visit a v2 client hello after + * we already know the version of the connection; + * work around that here by detecting and calling + * the v2 dissector instead + */ + if (ssl_is_v2_client_hello(tvb, offset)) + { + offset = dissect_ssl2_record(tvb, pinfo, dtls_tree, + offset, conv_version, + &need_desegmentation, + ssl_session); + } + else + { + offset = dissect_ssl3_record(tvb, pinfo, dtls_tree, + offset, conv_version, + &need_desegmentation, + ssl_session); + } + break; + + /* that failed, so apply some heuristics based + * on this individual packet + */ + default: + if (ssl_looks_like_sslv2(tvb, offset)) + { + /* looks like sslv2 or pct client hello */ + offset = dissect_ssl2_record(tvb, pinfo, dtls_tree, + offset, conv_version, + &need_desegmentation, + ssl_session); + } + else if (ssl_looks_like_sslv3(tvb, offset)) + { + /* looks like sslv3 or tls */ + offset = dissect_ssl3_record(tvb, pinfo, dtls_tree, + offset, conv_version, + &need_desegmentation, + ssl_session); + } + else + { + /* looks like something unknown, so lump into + * continuation data + */ + offset = tvb_length(tvb); + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_str(pinfo->cinfo, COL_INFO, + "Continuation Data"); + + /* Set the protocol column */ + if (check_col(pinfo->cinfo, COL_PROTOCOL)) + { + col_set_str(pinfo->cinfo, COL_PROTOCOL, + ssl_version_short_names[*conv_version]); + } + } + break; + } + + /* Desegmentation return check */ + if (need_desegmentation) + return; + /* set up for next record in frame, if any */ + first_record_in_frame = FALSE; + } + tap_queue_packet(dtls_tap, pinfo, (gpointer)proto_dtls); +} + +static int +decrypt_ssl3_record(tvbuff_t *tvb, packet_info *pinfo, guint32 offset, + guint32 record_length, guint8 content_type, SslDecryptSession* ssl, + gboolean save_plaintext) +{ + int ret = 0; + int direction; + SslDecoder* decoder; + + /* if we can decrypt and decryption have success + * add decrypted data to this packet info*/ + ssl_debug_printf("decrypt_ssl3_record: app_data len %d ssl state %X\n", + record_length, ssl->state); + if (!(ssl->state & SSL_HAVE_SESSION_KEY)) { + ssl_debug_printf("decrypt_ssl3_record: no session key\n"); + return ret; + } + + /* retrive decoder for this packet direction*/ + if ((direction = ssl_packet_from_server(pinfo->srcport)) != 0) { + ssl_debug_printf("decrypt_ssl3_record: using server decoder\n"); + decoder = &ssl->server; + } + else { + ssl_debug_printf("decrypt_ssl3_record: using client decoder\n"); + decoder = &ssl->client; + } + + /* ensure we have enough storage space for decrypted data */ + if (record_length > ssl_decrypted_data.data_len) + { + ssl_debug_printf("decrypt_ssl3_record: allocating %d bytes" + " for decrypt data (old len %d)\n", + record_length + 32, ssl_decrypted_data.data_len); + ssl_decrypted_data.data = g_realloc(ssl_decrypted_data.data, + record_length + 32); + ssl_decrypted_data.data_len = record_length + 32; + } + + /* run decryption and add decrypted payload to protocol data, if decryption + * is successful*/ + ssl_decrypted_data_avail = ssl_decrypted_data.data_len; + if (ssl_decrypt_record(ssl, decoder, + content_type, tvb_get_ptr(tvb, offset, record_length), + record_length, ssl_decrypted_data.data, &ssl_decrypted_data_avail) == 0) + ret = 1; + if (ret && save_plaintext) + { + SslPacketInfo* pi = p_get_proto_data(pinfo->fd, proto_dtls); + if (!pi) + { + ssl_debug_printf("decrypt_ssl3_record: allocating app_data %d " + "bytes for app data\n", ssl_decrypted_data_avail); + /* first app data record: allocate and put packet data*/ + pi = se_alloc0(sizeof(SslPacketInfo)); + pi->app_data.data = se_alloc(ssl_decrypted_data_avail); + pi->app_data.data_len = ssl_decrypted_data_avail; + memcpy(pi->app_data.data, ssl_decrypted_data.data, ssl_decrypted_data_avail); + } + else { + unsigned char* store; + /* update previus record*/ + ssl_debug_printf("decrypt_ssl3_record: reallocating app_data " + "%d bytes for app data (total %d appdata bytes)\n", + ssl_decrypted_data_avail, pi->app_data.data_len + ssl_decrypted_data_avail); + store = se_alloc(pi->app_data.data_len + ssl_decrypted_data_avail); + memcpy(store, pi->app_data.data, pi->app_data.data_len); + memcpy(&store[pi->app_data.data_len], ssl_decrypted_data.data, ssl_decrypted_data_avail); + pi->app_data.data_len += (ssl_decrypted_data_avail); + + /* old decrypted data ptr here appare to be leaked, but it's + * collected by emem allocator */ + pi->app_data.data = store; + + /* data ptr is changed, so remove old one and re-add the new one*/ + ssl_debug_printf("decrypt_ssl3_record: removing old app_data ptr\n"); + p_remove_proto_data(pinfo->fd, proto_dtls); + } + + ssl_debug_printf("decrypt_ssl3_record: setting decrypted app_data ptr %p\n",pi); + p_add_proto_data(pinfo->fd, proto_dtls, pi); + } + return ret; +} + + + + + +/********************************************************************* + * + * SSL version 3 and TLS Dissection Routines + * + *********************************************************************/ +static int +dissect_ssl3_record(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, guint32 offset, + guint *conv_version, gboolean *need_desegmentation, + SslDecryptSession* ssl) +{ + + /* + * struct { + * uint8 major, minor; + * } ProtocolVersion; + * + * + * enum { + * change_cipher_spec(20), alert(21), handshake(22), + * application_data(23), (255) + * } ContentType; + * + * struct { + * ContentType type; + * ProtocolVersion version; + * uint16 epoch; // New field + * uint48 sequence_number; // New field + * uint16 length; + * opaque fragment[TLSPlaintext.length]; + * } TLSPlaintext; + */ + guint32 record_length; + guint16 version; + guint16 epoch; + gdouble sequence_number; + guint64 sequence_number_temp; + + guint8 content_type; + guint8 next_byte; + proto_tree *ti = NULL; + proto_tree *dtls_record_tree = NULL; + guint32 available_bytes = 0; + SslPacketInfo* pi; + SslAssociation* association; + + available_bytes = tvb_length_remaining(tvb, offset); + + /* + * Can we do reassembly? + */ + if (ssl_desegment && pinfo->can_desegment) { + /* + * Yes - is the record header split across segment boundaries? + */ + if (available_bytes < 13) { + /* + * Yes. Tell the TCP dissector where the data for this + * message starts in the data it handed us, and how many + * more bytes we need, and return. + */ + pinfo->desegment_offset = offset; + pinfo->desegment_len = 13 - available_bytes; + *need_desegmentation = TRUE; + return offset; + } + } + + /* + * Get the record layer fields of interest + */ + content_type = tvb_get_guint8(tvb, offset); + version = tvb_get_ntohs(tvb, offset + 1); + epoch = tvb_get_ntohs(tvb, offset + 3); + sequence_number = tvb_get_ntohl(tvb, offset + 7); + sequence_number_temp=tvb_get_ntohs(tvb, offset + 5); + sequence_number_temp=sequence_number_temp<<32; + sequence_number+=sequence_number_temp; + record_length = tvb_get_ntohs(tvb, offset + 11); + + if(ssl){ + if(ssl_packet_from_server(pinfo->srcport)){ + ssl->server.seq=sequence_number; + ssl->server.epoch=epoch; + } + else{ + ssl->client.seq=sequence_number; + ssl->client.epoch=epoch; + } + } + if (ssl_is_valid_content_type(content_type)) { + + /* + * Can we do reassembly? + */ + if (ssl_desegment && pinfo->can_desegment) { + /* + * Yes - is the record split across segment boundaries? + */ + if (available_bytes < record_length + 13) { + /* + * Yes. Tell the TCP dissector where the data for this + * message starts in the data it handed us, and how many + * more bytes we need, and return. + */ + pinfo->desegment_offset = offset; + pinfo->desegment_len = (record_length + 13) - available_bytes; + *need_desegmentation = TRUE; + return offset; + } + } + + } else { + + /* if we don't have a valid content_type, there's no sense + * continuing any further + */ + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_str(pinfo->cinfo, COL_INFO, "Continuation Data"); + + /* Set the protocol column */ + if (check_col(pinfo->cinfo, COL_PROTOCOL)) + { + col_set_str(pinfo->cinfo, COL_PROTOCOL, + ssl_version_short_names[*conv_version]); + } + return offset + 13 + record_length; + } + + /* + * If GUI, fill in record layer part of tree + */ + + if (tree) + { + /* add the record layer subtree header */ + tvb_ensure_bytes_exist(tvb, offset, 13 + record_length); + ti = proto_tree_add_item(tree, hf_dtls_record, tvb, + offset, 13 + record_length, 0); + dtls_record_tree = proto_item_add_subtree(ti, ett_dtls_record); + } + + if (dtls_record_tree) + { + + /* show the one-byte content type */ + proto_tree_add_item(dtls_record_tree, hf_dtls_record_content_type, + tvb, offset, 1, FALSE); + offset++; + + /* add the version */ + proto_tree_add_item(dtls_record_tree, hf_dtls_record_version, tvb, + offset, 2, FALSE); + offset += 2; + + /* show epoch */ + proto_tree_add_uint(dtls_record_tree, hf_dtls_record_epoch, tvb, offset, 2, epoch); + + offset += 2; + + /* add sequence_number */ + + proto_tree_add_double(dtls_record_tree, hf_dtls_record_sequence_number, tvb, offset, 6, sequence_number); + + offset += 6; + + /* add the length */ + proto_tree_add_uint(dtls_record_tree, hf_dtls_record_length, tvb, + offset, 2, record_length); + offset += 2; /* move past length field itself */ + + + } + else + { + /* if no GUI tree, then just skip over those fields */ + offset += 13; + } + + + + /* + * if we don't already have a version set for this conversation, + * but this message's version is authoritative (i.e., it's + * not client_hello, then save the version to to conversation + * structure and print the column version + */ + next_byte = tvb_get_guint8(tvb, offset); + if (*conv_version == SSL_VER_UNKNOWN + && ssl_is_authoritative_version_message(content_type, next_byte)) + { + if (version == SSLV3_VERSION) + { + *conv_version = SSL_VER_SSLv3; + if (ssl) { + ssl->version_netorder = version; + ssl->state |= SSL_VERSION; + } + /*ssl_set_conv_version(pinfo, ssl->version);*/ + } + else if (version == TLSV1_VERSION) + { + + *conv_version = SSL_VER_TLS; + if (ssl) { + ssl->version_netorder = version; + ssl->state |= SSL_VERSION; + } + /*ssl_set_conv_version(pinfo, ssl->version);*/ + } + else if (version == TLSV1DOT1_VERSION) + { + + *conv_version = SSL_VER_TLSv1DOT1; + if (ssl) { + ssl->version_netorder = version; + ssl->state |= SSL_VERSION; + } + /*ssl_set_conv_version(pinfo, ssl->version);*/ + } + else if (version == DTLSV1DOT0_VERSION) + { + + *conv_version = SSL_VER_DTLS; + if (ssl) { + ssl->version_netorder = version; + ssl->state |= SSL_VERSION; + } + /*ssl_set_conv_version(pinfo, ssl->version);*/ + } + } + if (check_col(pinfo->cinfo, COL_PROTOCOL)) + { + if (version == DTLSV1DOT0_VERSION) + { + col_set_str(pinfo->cinfo, COL_PROTOCOL, + ssl_version_short_names[SSL_VER_DTLS]); + } + else + { + col_set_str(pinfo->cinfo, COL_PROTOCOL, + ssl_version_short_names[*conv_version]); + } + } + + /* + * now dissect the next layer + */ + ssl_debug_printf("dissect_ssl3_record: content_type %d\n",content_type); + + /* PAOLO try to decrypt each record (we must keep ciphers "in sync") + * store plain text only for app data */ + + switch (content_type) { + case SSL_ID_CHG_CIPHER_SPEC: + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_str(pinfo->cinfo, COL_INFO, "Change Cipher Spec"); + dissect_ssl3_change_cipher_spec(tvb, dtls_record_tree, + offset, conv_version, content_type); + ssl_debug_printf("dissect_ssl3_change_cipher_spec\n"); + break; + case SSL_ID_ALERT: + { + tvbuff_t* decrypted=0; + if (ssl&&decrypt_ssl3_record(tvb, pinfo, offset, + record_length, content_type, ssl, FALSE)) + ssl_add_record_info(pinfo, ssl_decrypted_data.data, + ssl_decrypted_data_avail, offset); + + /* try to retrive and use decrypted alert record, if any. */ + decrypted = ssl_get_record_info(pinfo, offset); + if (decrypted) + dissect_ssl3_alert(decrypted, pinfo, dtls_record_tree, 0, + conv_version); + else + dissect_ssl3_alert(tvb, pinfo, dtls_record_tree, offset, + conv_version); + break; + } + case SSL_ID_HANDSHAKE: + { + tvbuff_t* decrypted=0; + /* try to decrypt handshake record, if possible. Store decrypted + * record for later usage. The offset is used as 'key' to itentify + * this record into the packet (we can have multiple handshake records + * in the same frame) */ + if (ssl && decrypt_ssl3_record(tvb, pinfo, offset, + record_length, content_type, ssl, FALSE)) + ssl_add_record_info(pinfo, ssl_decrypted_data.data, + ssl_decrypted_data_avail, offset); + + /* try to retrive and use decrypted handshake record, if any. */ + decrypted = ssl_get_record_info(pinfo, offset); + if (decrypted) + dissect_ssl3_handshake(decrypted, pinfo, dtls_record_tree, 0, + decrypted->length, conv_version, ssl, content_type); + else + dissect_ssl3_handshake(tvb, pinfo, dtls_record_tree, offset, + record_length, conv_version, ssl, content_type); + break; + } + case SSL_ID_APP_DATA: + if (ssl) + decrypt_ssl3_record(tvb, pinfo, offset, + record_length, content_type, ssl, TRUE); + + /* show on info colum what we are decoding */ + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_str(pinfo->cinfo, COL_INFO, "Application Data"); + + if (!dtls_record_tree) + break; + + /* we need dissector information when the selected packet is shown. + * ssl session pointer is NULL at that time, so we can't access + * info cached there*/ + association = ssl_association_find(pinfo->srcport); + association = association ? association: ssl_association_find(pinfo->destport); + + proto_item_set_text(dtls_record_tree, + "%s Record Layer: %s Protocol: %s", + ssl_version_short_names[*conv_version], + val_to_str(content_type, ssl_31_content_type, "unknown"), + association?association->info:"Application Data"); + + /* show decrypted data info, if available */ + pi = p_get_proto_data(pinfo->fd, proto_dtls); + if (pi && pi->app_data.data) + { + tvbuff_t* new_tvb; + + /* try to dissect decrypted data*/ + ssl_debug_printf("dissect_ssl3_record decrypted len %d\n", + pi->app_data.data_len); + + /* create new tvbuff for the decrypted data */ + new_tvb = tvb_new_real_data(pi->app_data.data, + pi->app_data.data_len, pi->app_data.data_len); + tvb_set_free_cb(new_tvb, g_free); + /* tvb_set_child_real_data_tvbuff(tvb, new_tvb); */ + + /* find out a dissector using server port*/ + if (association && association->handle) { + ssl_debug_printf("dissect_ssl3_record found association %p\n", association); + ssl_print_text_data("decrypted app data",pi->app_data.data, + pi->app_data.data_len); + + call_dissector(association->handle, new_tvb, pinfo, dtls_record_tree); + } + /* add raw decrypted data only if a decoder is not found*/ + else + proto_tree_add_string(dtls_record_tree, hf_dtls_record_appdata_decrypted, tvb, + offset, pi->app_data.data_len, (char*) pi->app_data.data); + } + else { + tvb_ensure_bytes_exist(tvb, offset, record_length); + proto_tree_add_item(dtls_record_tree, hf_dtls_record_appdata, tvb, + offset, record_length, 0); + } + break; + + default: + /* shouldn't get here since we check above for valid types */ + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_str(pinfo->cinfo, COL_INFO, "Bad SSLv3 Content Type"); + break; + } + offset += record_length; /* skip to end of record */ + + return offset; +} + +/* dissects the change cipher spec procotol, filling in the tree */ +static void +dissect_ssl3_change_cipher_spec(tvbuff_t *tvb, + proto_tree *tree, guint32 offset, + guint* conv_version, guint8 content_type) +{ + /* + * struct { + * enum { change_cipher_spec(1), (255) } type; + * } ChangeCipherSpec; + * + */ + if (tree) + { + proto_item_set_text(tree, + "%s Record Layer: %s Protocol: Change Cipher Spec", + ssl_version_short_names[*conv_version], + val_to_str(content_type, ssl_31_content_type, "unknown")); + proto_tree_add_item(tree, hf_dtls_change_cipher_spec, tvb, + offset++, 1, FALSE); + } +} + +/* dissects the alert message, filling in the tree */ +static void +dissect_ssl3_alert(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, guint32 offset, + guint* conv_version) +{ + /* struct { + * AlertLevel level; + * AlertDescription description; + * } Alert; + */ + proto_tree *ti; + proto_tree *ssl_alert_tree = NULL; + const gchar *level; + const gchar *desc; + guint8 byte; + + if (tree) + { + ti = proto_tree_add_item(tree, hf_dtls_alert_message, tvb, + offset, 2, 0); + ssl_alert_tree = proto_item_add_subtree(ti, ett_dtls_alert); + } + + /* + * set the record layer label + */ + + /* first lookup the names for the alert level and description */ + byte = tvb_get_guint8(tvb, offset); /* grab the level byte */ + level = match_strval(byte, ssl_31_alert_level); + + byte = tvb_get_guint8(tvb, offset+1); /* grab the desc byte */ + desc = match_strval(byte, ssl_31_alert_description); + + /* now set the text in the record layer line */ + if (level && desc) + { + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_fstr(pinfo->cinfo, COL_INFO, + "Alert (Level: %s, Description: %s)", + level, desc); + } + else + { + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_str(pinfo->cinfo, COL_INFO, "Encrypted Alert"); + } + + if (tree) + { + if (level && desc) + { + proto_item_set_text(tree, "%s Record Layer: Alert " + "(Level: %s, Description: %s)", + ssl_version_short_names[*conv_version], + level, desc); + proto_tree_add_item(ssl_alert_tree, hf_dtls_alert_message_level, + tvb, offset++, 1, FALSE); + + proto_tree_add_item(ssl_alert_tree, hf_dtls_alert_message_description, + tvb, offset++, 1, FALSE); + } + else + { + proto_item_set_text(tree, + "%s Record Layer: Encrypted Alert", + ssl_version_short_names[*conv_version]); + proto_item_set_text(ssl_alert_tree, + "Alert Message: Encrypted Alert"); + } + } +} + + +/* dissects the handshake protocol, filling the tree */ +static void +dissect_ssl3_handshake(tvbuff_t *tvb, packet_info *pinfo, + proto_tree *tree, guint32 offset, + guint32 record_length, guint *conv_version, + SslDecryptSession* ssl, guint8 content_type) +{ + /* struct { + * HandshakeType msg_type; + * uint24 length; + * uint16 message_seq; //new field + * uint24 fragment_offset; //new field + * uint24 fragment_length; //new field + * select (HandshakeType) { + * case hello_request: HelloRequest; + * case client_hello: ClientHello; + * case server_hello: ServerHello; + * case hello_verify_request: HelloVerifyRequest; //new field + * case certificate: Certificate; + * case server_key_exchange: ServerKeyExchange; + * case certificate_request: CertificateRequest; + * case server_hello_done: ServerHelloDone; + * case certificate_verify: CertificateVerify; + * case client_key_exchange: ClientKeyExchange; + * case finished: Finished; + * } body; + * } Handshake; + */ + proto_tree *ti = NULL; + proto_tree *ssl_hand_tree = NULL; + const gchar *msg_type_str = NULL; + guint8 msg_type; + guint32 length; + guint16 message_seq; + guint32 fragment_offset; + guint32 fragment_length; + + gboolean first_iteration = TRUE; + + + /* just as there can be multiple records per packet, there + * can be multiple messages per record as long as they have + * the same content type + * + * we really only care about this for handshake messages + */ + + /* set record_length to the max offset */ + record_length += offset; + while (offset < record_length) + { + msg_type = tvb_get_guint8(tvb, offset); + msg_type_str = match_strval(msg_type, ssl_31_handshake_type); + length = tvb_get_ntoh24(tvb, offset + 1); + message_seq = tvb_get_ntohs(tvb,offset + 4); + fragment_offset = tvb_get_ntoh24(tvb, offset + 6); + fragment_length = tvb_get_ntoh24(tvb, offset + 9); + + if (!msg_type_str && !first_iteration) + { + /* only dissect / report messages if they're + * either the first message in this record + * or they're a valid message type + */ + return; + } + + /* on second and later iterations, add comma to info col */ + if (!first_iteration) + { + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_fstr(pinfo->cinfo, COL_INFO, ", "); + } + + /* + * Update our info string + */ + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_fstr(pinfo->cinfo, COL_INFO, "%s", (msg_type_str != NULL) + ? msg_type_str : "Encrypted Handshake Message"); + + if (tree) + { + /* set the label text on the record layer expanding node */ + if (first_iteration) + { + proto_item_set_text(tree, "%s Record Layer: %s Protocol: %s", + ssl_version_short_names[*conv_version], + val_to_str(content_type, ssl_31_content_type, "unknown"), + (msg_type_str!=NULL) ? msg_type_str : + "Encrypted Handshake Message"); + } + else + { + proto_item_set_text(tree, "%s Record Layer: %s Protocol: %s", + ssl_version_short_names[*conv_version], + val_to_str(content_type, ssl_31_content_type, "unknown"), + "Multiple Handshake Messages"); + } + + /* add a subtree for the handshake protocol */ + ti = proto_tree_add_item(tree, hf_dtls_handshake_protocol, tvb, + offset, length + 12, 0); + ssl_hand_tree = proto_item_add_subtree(ti, ett_dtls_handshake); + + if (ssl_hand_tree) + { + /* set the text label on the subtree node */ + proto_item_set_text(ssl_hand_tree, "Handshake Protocol: %s", + (msg_type_str != NULL) ? msg_type_str : + "Encrypted Handshake Message"); + } + } + + /* if we don't have a valid handshake type, just quit dissecting */ + if (!msg_type_str) + return; + + /* PAOLO: if we are doing ssl decryption we must dissect some requests type */ + if (ssl_hand_tree || ssl) + { + /* add nodes for the message type and message length */ + if (ssl_hand_tree) + proto_tree_add_item(ssl_hand_tree, hf_dtls_handshake_type, + tvb, offset, 1, msg_type); + offset++; + if (ssl_hand_tree) + proto_tree_add_uint(ssl_hand_tree, hf_dtls_handshake_length, + tvb, offset, 3, length); + offset += 3; + + if (ssl_hand_tree) + proto_tree_add_uint(ssl_hand_tree, hf_dtls_handshake_message_seq, + tvb, offset, 2, message_seq); + offset += 2; + if (ssl_hand_tree) + proto_tree_add_uint(ssl_hand_tree, hf_dtls_handshake_fragment_offset, + tvb, offset, 3, fragment_offset); + offset += 3; + if (ssl_hand_tree) + proto_tree_add_uint(ssl_hand_tree, hf_dtls_handshake_fragment_length, + tvb, offset, 3, fragment_length); + offset += 3; + + /* now dissect the handshake message, if necessary */ + switch (msg_type) { + case SSL_HND_HELLO_REQUEST: + /* hello_request has no fields, so nothing to do! */ + break; + + case SSL_HND_CLIENT_HELLO: + dissect_ssl3_hnd_cli_hello(tvb, ssl_hand_tree, offset, length, ssl); + break; + + case SSL_HND_HELLO_VERIFY_REQUEST: + dissect_ssl3_hnd_hello_verify_request(tvb, ssl_hand_tree, offset, length, ssl); + break; + + case SSL_HND_SERVER_HELLO: + dissect_ssl3_hnd_srv_hello(tvb, ssl_hand_tree, offset, length, ssl); + break; + + case SSL_HND_CERTIFICATE: + dissect_ssl3_hnd_cert(tvb, ssl_hand_tree, offset, pinfo); + break; + + case SSL_HND_SERVER_KEY_EXCHG: + /* unimplemented */ + break; + + case SSL_HND_CERT_REQUEST: + dissect_ssl3_hnd_cert_req(tvb, ssl_hand_tree, offset); + break; + + case SSL_HND_SVR_HELLO_DONE: + /* server_hello_done has no fields, so nothing to do! */ + break; + + case SSL_HND_CERT_VERIFY: + /* unimplemented */ + break; + + case SSL_HND_CLIENT_KEY_EXCHG: + { + /* PAOLO: here we can have all the data to build session key*/ + StringInfo encrypted_pre_master; + int ret; + unsigned encrlen = length, skip = 0; + + if (!ssl) + break; + + /* check for required session data */ + ssl_debug_printf("dissect_ssl3_handshake found SSL_HND_CLIENT_KEY_EXCHG state %X\n", + ssl->state); + if ((ssl->state & (SSL_CIPHER|SSL_CLIENT_RANDOM|SSL_SERVER_RANDOM|SSL_VERSION)) != + (SSL_CIPHER|SSL_CLIENT_RANDOM|SSL_SERVER_RANDOM|SSL_VERSION)) { + ssl_debug_printf("dissect_ssl3_handshake not enough data to generate key (required %X)\n", + (SSL_CIPHER|SSL_CLIENT_RANDOM|SSL_SERVER_RANDOM|SSL_VERSION)); + break; + } + + encrypted_pre_master.data = se_alloc(encrlen); + encrypted_pre_master.data_len = encrlen; + tvb_memcpy(tvb, encrypted_pre_master.data, offset+skip, encrlen); + + if (!ssl->private_key) { + ssl_debug_printf("dissect_ssl3_handshake can't find private key\n"); + break; + } + + /* go with ssl key processessing; encrypted_pre_master + * will be used for master secret store*/ + ret = ssl_decrypt_pre_master_secret(ssl, &encrypted_pre_master, ssl->private_key); + if (ret < 0) { + ssl_debug_printf("dissect_ssl3_handshake can't decrypt pre master secret\n"); + break; + } + if (ssl_generate_keyring_material(ssl)<0) { + ssl_debug_printf("dissect_ssl3_handshake can't generate keyring material\n"); + break; + } + ssl->state |= SSL_HAVE_SESSION_KEY; + ssl_save_session(ssl); + ssl_debug_printf("dissect_ssl3_handshake session keys succesfully generated\n"); + } + break; + + case SSL_HND_FINISHED: + dissect_ssl3_hnd_finished(tvb, ssl_hand_tree, + offset, conv_version); + break; + } + + } + else{ + offset += 12; /* skip the handshake header when handshake is not processed*/ + } + offset += length; + first_iteration = FALSE; /* set up for next pass, if any */ + } +} + +static int +dissect_ssl3_hnd_hello_common(tvbuff_t *tvb, proto_tree *tree, + guint32 offset, SslDecryptSession* ssl, gint from_server) +{ + /* show the client's random challenge */ + nstime_t gmt_unix_time; + guint8 session_id_length = 0; + + if (ssl) + { + /* PAOLO: get proper peer information*/ + StringInfo* rnd; + if (from_server) + rnd = &ssl->server_random; + else + rnd = &ssl->client_random; + + /* get provided random for keyring generation*/ + tvb_memcpy(tvb, rnd->data, offset, 32); + rnd->data_len = 32; + if (from_server) + ssl->state |= SSL_SERVER_RANDOM; + else + ssl->state |= SSL_CLIENT_RANDOM; + ssl_debug_printf("dissect_ssl3_hnd_hello_common found random state %X\n", + ssl->state); + + session_id_length = tvb_get_guint8(tvb, offset + 32); + /* check stored session id info */ + if (from_server && (session_id_length == ssl->session_id.data_len) && + (tvb_memeql(tvb, offset+33, ssl->session_id.data, session_id_length) == 0)) + { + /* clinet/server id match: try to restore a previous cached session*/ + ssl_restore_session(ssl); + } + else { + tvb_memcpy(tvb,ssl->session_id.data, offset+33, session_id_length); + ssl->session_id.data_len = session_id_length; + } + } + + if (tree) + { + /* show the time */ + gmt_unix_time.secs = tvb_get_ntohl(tvb, offset); + gmt_unix_time.nsecs = 0; + proto_tree_add_time(tree, hf_dtls_handshake_random_time, + tvb, offset, 4, &gmt_unix_time); + offset += 4; + + /* show the random bytes */ + proto_tree_add_item(tree, hf_dtls_handshake_random_bytes, + tvb, offset, 28, 0); + offset += 28; + + /* show the session id */ + session_id_length = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_dtls_handshake_session_id_len, + tvb, offset++, 1, 0); + if (session_id_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, session_id_length); + proto_tree_add_bytes_format(tree, hf_dtls_handshake_session_id, + tvb, offset, session_id_length, + tvb_get_ptr(tvb, offset, session_id_length), + "Session ID (%u byte%s)", + session_id_length, + plurality(session_id_length, "", "s")); + offset += session_id_length; + } + + } + + /* XXXX */ + return session_id_length+33; +} + +static int +dissect_ssl3_hnd_hello_ext(tvbuff_t *tvb, + proto_tree *tree, guint32 offset, guint32 left) +{ + guint16 extension_length; + guint16 ext_type; + guint16 ext_len; + proto_item *pi; + proto_tree *ext_tree; + + if (left < 2) + return offset; + + extension_length = tvb_get_ntohs(tvb, offset); + proto_tree_add_uint(tree, hf_dtls_handshake_extensions_len, + tvb, offset, 2, extension_length); + offset += 2; + left -= 2; + + while (left >= 4) + { + ext_type = tvb_get_ntohs(tvb, offset); + ext_len = tvb_get_ntohs(tvb, offset + 2); + + pi = proto_tree_add_text(tree, tvb, offset, 4 + ext_len, + "Extension: %s", + val_to_str(ext_type, + tls_hello_extension_types, + "Unknown %u")); + ext_tree = proto_item_add_subtree(pi, ett_dtls_extension); + if (!ext_tree) + ext_tree = tree; + + proto_tree_add_uint(ext_tree, hf_dtls_handshake_extension_type, + tvb, offset, 2, ext_type); + offset += 2; + + proto_tree_add_uint(ext_tree, hf_dtls_handshake_extension_len, + tvb, offset, 2, ext_len); + offset += 2; + + proto_tree_add_bytes_format(ext_tree, hf_dtls_handshake_extension_data, + tvb, offset, ext_len, + tvb_get_ptr(tvb, offset, ext_len), + "Data (%u byte%s)", + ext_len, plurality(ext_len, "", "s")); + offset += ext_len; + left -= 2 + 2 + ext_len; + } + + return offset; +} + +static void +dissect_ssl3_hnd_cli_hello(tvbuff_t *tvb, + proto_tree *tree, guint32 offset, guint32 length, + SslDecryptSession*ssl) +{ + /* struct { + * ProtocolVersion client_version; + * Random random; + * SessionID session_id; + * opaque cookie<0..32>; //new field + * CipherSuite cipher_suites<2..2^16-1>; + * CompressionMethod compression_methods<1..2^8-1>; + * Extension client_hello_extension_list<0..2^16-1>; + * } ClientHello; + * + */ + proto_tree *ti; + proto_tree *cs_tree; + guint16 cipher_suite_length = 0; + guint8 compression_methods_length = 0; + guint8 compression_method; + guint16 start_offset = offset; + guint8 cookie_length = 0; + + if (tree || ssl) + { + /* show the client version */ + if (tree) + proto_tree_add_item(tree, hf_dtls_handshake_client_version, tvb, + offset, 2, FALSE); + offset += 2; + + /* show the fields in common with server hello */ + offset += dissect_ssl3_hnd_hello_common(tvb, tree, offset, ssl, 0); + + /* look for a cookie */ + cookie_length = tvb_get_guint8(tvb, offset); + if (!tree) + return; + + proto_tree_add_uint(tree, hf_dtls_handshake_cookie_len, + tvb, offset, 1, cookie_length); + offset ++; /* skip opaque length */ + + if (cookie_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, cookie_length); + proto_tree_add_bytes_format(tree, hf_dtls_handshake_cookie, + tvb, offset, cookie_length, + tvb_get_ptr(tvb, offset, cookie_length), + "Cookie (%u byte%s)", + cookie_length, + plurality(cookie_length, "", "s")); + offset += cookie_length; + } + + /* tell the user how many cipher suites there are */ + cipher_suite_length = tvb_get_ntohs(tvb, offset); + + proto_tree_add_uint(tree, hf_dtls_handshake_cipher_suites_len, + tvb, offset, 2, cipher_suite_length); + offset += 2; /* skip opaque length */ + + if (cipher_suite_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, cipher_suite_length); + ti = proto_tree_add_none_format(tree, + hf_dtls_handshake_cipher_suites, + tvb, offset, cipher_suite_length, + "Cipher Suites (%u suite%s)", + cipher_suite_length / 2, + plurality(cipher_suite_length/2, "", "s")); + + /* make this a subtree */ + cs_tree = proto_item_add_subtree(ti, ett_dtls_cipher_suites); + if (!cs_tree) + { + cs_tree = tree; /* failsafe */ + } + + while (cipher_suite_length > 0) + { + proto_tree_add_item(cs_tree, hf_dtls_handshake_cipher_suite, + tvb, offset, 2, FALSE); + offset += 2; + cipher_suite_length -= 2; + } + } + + /* tell the user how man compression methods there are */ + compression_methods_length = tvb_get_guint8(tvb, offset); + proto_tree_add_uint(tree, hf_dtls_handshake_comp_methods_len, + tvb, offset, 1, compression_methods_length); + offset++; + + if (compression_methods_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, compression_methods_length); + ti = proto_tree_add_none_format(tree, + hf_dtls_handshake_comp_methods, + tvb, offset, compression_methods_length, + "Compression Methods (%u method%s)", + compression_methods_length, + plurality(compression_methods_length, + "", "s")); + + /* make this a subtree */ + cs_tree = proto_item_add_subtree(ti, ett_dtls_comp_methods); + if (!cs_tree) + { + cs_tree = tree; /* failsafe */ + } + + while (compression_methods_length > 0) + { + compression_method = tvb_get_guint8(tvb, offset); + if (compression_method < 64) + proto_tree_add_uint(cs_tree, hf_dtls_handshake_comp_method, + tvb, offset, 1, compression_method); + else if (compression_method > 63 && compression_method < 193) + proto_tree_add_text(cs_tree, tvb, offset, 1, + "Compression Method: Reserved - to be assigned by IANA (%u)", + compression_method); + else + proto_tree_add_text(cs_tree, tvb, offset, 1, + "Compression Method: Private use range (%u)", + compression_method); + offset++; + compression_methods_length--; + } + } + + if (length > offset - start_offset) + { + offset = dissect_ssl3_hnd_hello_ext(tvb, tree, offset, + length - + (offset - start_offset)); + } + } +} + + +static void dissect_ssl3_hnd_hello_verify_request(tvbuff_t *tvb, + proto_tree *tree, + guint32 offset, guint32 length, + SslDecryptSession* ssl) +{ + /* + * struct { + * ProtocolVersion server_version; + * opaque cookie<0..32>; + * } HelloVerifyRequest; + */ + + proto_tree *ti; + proto_tree *cs_tree; + guint8 cookie_length = 0; + + if (tree || ssl) + { + /* show the client version */ + if (tree) + proto_tree_add_item(tree, hf_dtls_handshake_server_version, tvb, + offset, 2, FALSE); + offset += 2; + + + /* look for a cookie */ + cookie_length = tvb_get_guint8(tvb, offset); + if (!tree) + return; + + proto_tree_add_uint(tree, hf_dtls_handshake_cookie_len, + tvb, offset, 1, cookie_length); + offset ++; /* skip opaque length */ + + if (cookie_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, cookie_length); + proto_tree_add_bytes_format(tree, hf_dtls_handshake_cookie, + tvb, offset, cookie_length, + tvb_get_ptr(tvb, offset, cookie_length), + "Cookie (%u byte%s)", + cookie_length, + plurality(cookie_length, "", "s")); + offset += cookie_length; + } + } + +} + +static void +dissect_ssl3_hnd_srv_hello(tvbuff_t *tvb, + proto_tree *tree, guint32 offset, guint32 length, SslDecryptSession* ssl) +{ + /* struct { + * ProtocolVersion server_version; + * Random random; + * SessionID session_id; + * CipherSuite cipher_suite; + * CompressionMethod compression_method; + * Extension server_hello_extension_list<0..2^16-1>; + * } ServerHello; + */ + guint16 start_offset = offset; + + if (tree || ssl) + { + /* show the server version */ + if (tree) + proto_tree_add_item(tree, hf_dtls_handshake_server_version, tvb, + offset, 2, FALSE); + offset += 2; + + /* first display the elements conveniently in + * common with client hello + */ + offset += dissect_ssl3_hnd_hello_common(tvb, tree, offset, ssl, 1); + + /* PAOLO: handle session cipher suite */ + if (ssl) { + /* store selected cipher suite for decryption */ + ssl->cipher = tvb_get_ntohs(tvb, offset); + if (ssl_find_cipher(ssl->cipher,&ssl->cipher_suite) < 0) { + ssl_debug_printf("dissect_ssl3_hnd_srv_hello can't find cipher suite %X\n", ssl->cipher); + goto no_cipher; + } + + ssl->state |= SSL_CIPHER; + ssl_debug_printf("dissect_ssl3_hnd_srv_hello found cipher %X, state %X\n", + ssl->cipher, ssl->state); + + /* if we have restored a session now we can have enought material + * to build session key, check it out*/ + if ((ssl->state & + (SSL_CIPHER|SSL_CLIENT_RANDOM|SSL_SERVER_RANDOM|SSL_VERSION|SSL_MASTER_SECRET)) != + (SSL_CIPHER|SSL_CLIENT_RANDOM|SSL_SERVER_RANDOM|SSL_VERSION|SSL_MASTER_SECRET)) { + ssl_debug_printf("dissect_ssl3_hnd_srv_hello not enough data to generate key (required %X)\n", + (SSL_CIPHER|SSL_CLIENT_RANDOM|SSL_SERVER_RANDOM|SSL_VERSION|SSL_MASTER_SECRET)); + goto no_cipher; + } + + ssl_debug_printf("dissect_ssl3_hnd_srv_hello trying to generate keys\n"); + if (ssl_generate_keyring_material(ssl)<0) { + ssl_debug_printf("dissect_ssl3_hnd_srv_hello can't generate keyring material\n"); + goto no_cipher; + } + ssl->state |= SSL_HAVE_SESSION_KEY; + } +no_cipher: + if (!tree) + return; + + /* now the server-selected cipher suite */ + proto_tree_add_item(tree, hf_dtls_handshake_cipher_suite, + tvb, offset, 2, FALSE); + offset += 2; + + /* and the server-selected compression method */ + proto_tree_add_item(tree, hf_dtls_handshake_comp_method, + tvb, offset, 1, FALSE); + offset++; + + if (length > offset - start_offset) + { + offset = dissect_ssl3_hnd_hello_ext(tvb, tree, offset, + length - + (offset - start_offset)); + } + } +} + +static void +dissect_ssl3_hnd_cert(tvbuff_t *tvb, + proto_tree *tree, guint32 offset, packet_info *pinfo) +{ + + /* opaque ASN.1Cert<2^24-1>; + * + * struct { + * ASN.1Cert certificate_list<1..2^24-1>; + * } Certificate; + */ + guint32 certificate_list_length; + proto_tree *ti; + proto_tree *subtree; + + if (tree) + { + certificate_list_length = tvb_get_ntoh24(tvb, offset); + proto_tree_add_uint(tree, hf_dtls_handshake_certificates_len, + tvb, offset, 3, certificate_list_length); + offset += 3; /* 24-bit length value */ + + if (certificate_list_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, certificate_list_length); + ti = proto_tree_add_none_format(tree, + hf_dtls_handshake_certificates, + tvb, offset, certificate_list_length, + "Certificates (%u byte%s)", + certificate_list_length, + plurality(certificate_list_length, + "", "s")); + + /* make it a subtree */ + subtree = proto_item_add_subtree(ti, ett_dtls_certs); + if (!subtree) + { + subtree = tree; /* failsafe */ + } + + /* iterate through each certificate */ + while (certificate_list_length > 0) + { + /* get the length of the current certificate */ + guint32 cert_length = tvb_get_ntoh24(tvb, offset); + certificate_list_length -= 3 + cert_length; + + proto_tree_add_item(subtree, hf_dtls_handshake_certificate_len, + tvb, offset, 3, FALSE); + offset += 3; + + dissect_x509af_Certificate(FALSE, tvb, offset, pinfo, subtree, hf_dtls_handshake_certificate); + offset += cert_length; + } + } + + } +} + +static void +dissect_ssl3_hnd_cert_req(tvbuff_t *tvb, + proto_tree *tree, guint32 offset) +{ + /* + * enum { + * rsa_sign(1), dss_sign(2), rsa_fixed_dh(3), dss_fixed_dh(4), + * (255) + * } ClientCertificateType; + * + * opaque DistinguishedName<1..2^16-1>; + * + * struct { + * ClientCertificateType certificate_types<1..2^8-1>; + * DistinguishedName certificate_authorities<3..2^16-1>; + * } CertificateRequest; + * + */ + proto_tree *ti; + proto_tree *subtree; + guint8 cert_types_count = 0; + int dnames_length = 0; + + if (tree) + { + cert_types_count = tvb_get_guint8(tvb, offset); + proto_tree_add_uint(tree, hf_dtls_handshake_cert_types_count, + tvb, offset, 1, cert_types_count); + offset++; + + if (cert_types_count > 0) + { + ti = proto_tree_add_none_format(tree, + hf_dtls_handshake_cert_types, + tvb, offset, cert_types_count, + "Certificate types (%u type%s)", + cert_types_count, + plurality(cert_types_count, "", "s")); + subtree = proto_item_add_subtree(ti, ett_dtls_cert_types); + if (!subtree) + { + subtree = tree; + } + + while (cert_types_count > 0) + { + proto_tree_add_item(subtree, hf_dtls_handshake_cert_type, + tvb, offset, 1, FALSE); + offset++; + cert_types_count--; + } + } + + dnames_length = tvb_get_ntohs(tvb, offset); + proto_tree_add_uint(tree, hf_dtls_handshake_dnames_len, + tvb, offset, 2, dnames_length); + offset += 2; + + if (dnames_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, dnames_length); + ti = proto_tree_add_none_format(tree, + hf_dtls_handshake_dnames, + tvb, offset, dnames_length, + "Distinguished Names (%d byte%s)", + dnames_length, + plurality(dnames_length, "", "s")); + subtree = proto_item_add_subtree(ti, ett_dtls_dnames); + if (!subtree) + { + subtree = tree; + } + + while (dnames_length > 0) + { + /* get the length of the current certificate */ + guint16 name_length = tvb_get_ntohs(tvb, offset); + dnames_length -= 2 + name_length; + + proto_tree_add_item(subtree, hf_dtls_handshake_dname_len, + tvb, offset, 2, FALSE); + offset += 2; + + tvb_ensure_bytes_exist(tvb, offset, name_length); + proto_tree_add_bytes_format(subtree, + hf_dtls_handshake_dname, + tvb, offset, name_length, + tvb_get_ptr(tvb, offset, name_length), + "Distinguished Name (%u byte%s)", + name_length, + plurality(name_length, "", "s")); + offset += name_length; + } + } + } + +} + +static void +dissect_ssl3_hnd_finished(tvbuff_t *tvb, + proto_tree *tree, guint32 offset, + guint* conv_version) +{ + /* For TLS: + * struct { + * opaque verify_data[12]; + * } Finished; + * + * For SSLv3: + * struct { + * opaque md5_hash[16]; + * opaque sha_hash[20]; + * } Finished; + */ + + /* this all needs a tree, so bail if we don't have one */ + if (!tree) + { + return; + } + + switch(*conv_version) { + case SSL_VER_DTLS: + case SSL_VER_TLS: + proto_tree_add_item(tree, hf_dtls_handshake_finished, + tvb, offset, 12, FALSE); + break; + + case SSL_VER_SSLv3: + proto_tree_add_item(tree, hf_dtls_handshake_md5_hash, + tvb, offset, 16, FALSE); + offset += 16; + proto_tree_add_item(tree, hf_dtls_handshake_sha_hash, + tvb, offset, 20, FALSE); + offset += 20; + break; + } +} + +/********************************************************************* + * + * SSL version 2 Dissectors + * + *********************************************************************/ + + +/* record layer dissector */ +static int +dissect_ssl2_record(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint32 offset, guint* conv_version, + gboolean *need_desegmentation, + SslDecryptSession* ssl) +{ + guint32 initial_offset = offset; + guint8 byte = 0; + guint8 record_length_length = 0; + guint32 record_length = 0; + gint is_escape = -1; + gint16 padding_length = -1; + guint8 msg_type = 0; + const gchar *msg_type_str = NULL; + guint32 available_bytes = 0; + + proto_tree *ti; + proto_tree *dtls_record_tree = NULL; + + /* pull first byte; if high bit is set, then record + * length is three bytes due to padding; otherwise + * record length is two bytes + */ + byte = tvb_get_guint8(tvb, offset); + record_length_length = (byte & 0x80) ? 2 : 3; + + /* + * Can we do reassembly? + */ + available_bytes = tvb_length_remaining(tvb, offset); + + if (ssl_desegment && pinfo->can_desegment) { + /* + * Yes - is the record header split across segment boundaries? + */ + if (available_bytes < record_length_length) { + /* + * Yes. Tell the TCP dissector where the data for this + * message starts in the data it handed us, and how many + * more bytes we need, and return. + */ + pinfo->desegment_offset = offset; + pinfo->desegment_len = record_length_length - available_bytes; + *need_desegmentation = TRUE; + return offset; + } + } + + /* parse out the record length */ + switch(record_length_length) { + case 2: /* two-byte record length */ + record_length = (byte & 0x7f) << 8; + byte = tvb_get_guint8(tvb, offset + 1); + record_length += byte; + break; + case 3: /* three-byte record length */ + is_escape = (byte & 0x40) ? TRUE : FALSE; + record_length = (byte & 0x3f) << 8; + byte = tvb_get_guint8(tvb, offset + 1); + record_length += byte; + byte = tvb_get_guint8(tvb, offset + 2); + padding_length = byte; + } + + /* + * Can we do reassembly? + */ + if (ssl_desegment && pinfo->can_desegment) { + /* + * Yes - is the record split across segment boundaries? + */ + if (available_bytes < (record_length_length + record_length)) { + /* + * Yes. Tell the TCP dissector where the data for this + * message starts in the data it handed us, and how many + * more bytes we need, and return. + */ + pinfo->desegment_offset = offset; + pinfo->desegment_len = (record_length_length + record_length) + - available_bytes; + *need_desegmentation = TRUE; + return offset; + } + } + offset += record_length_length; + + /* add the record layer subtree header */ + ti = proto_tree_add_item(tree, hf_ssl2_record, tvb, initial_offset, + record_length_length + record_length, 0); + dtls_record_tree = proto_item_add_subtree(ti, ett_dtls_record); + + /* pull the msg_type so we can bail if it's unknown */ + msg_type = tvb_get_guint8(tvb, initial_offset + record_length_length); + + /* if we get a server_hello or later handshake in v2, then set + * this to sslv2 + */ + if (*conv_version == SSL_VER_UNKNOWN) + { + if (ssl_looks_like_valid_pct_handshake(tvb, + (initial_offset + + record_length_length), + record_length)) { + *conv_version = SSL_VER_PCT; + /*ssl_set_conv_version(pinfo, ssl->version);*/ + } + else if (msg_type >= 2 && msg_type <= 8) + { + *conv_version = SSL_VER_SSLv2; + /*ssl_set_conv_version(pinfo, ssl->version);*/ + } + } + + /* if we get here, but don't have a version set for the + * conversation, then set a version for just this frame + * (e.g., on a client hello) + */ + if (check_col(pinfo->cinfo, COL_PROTOCOL)) + { + col_set_str(pinfo->cinfo, COL_PROTOCOL, + (*conv_version == SSL_VER_PCT) ? "PCT" : "SSLv2"); + } + + /* see if the msg_type is valid; if not the payload is + * probably encrypted, so note that fact and bail + */ + msg_type_str = match_strval(msg_type, + (*conv_version == SSL_VER_PCT) + ? pct_msg_types : ssl_20_msg_types); + if (!msg_type_str + || ((*conv_version != SSL_VER_PCT) && + !ssl_looks_like_valid_v2_handshake(tvb, initial_offset + + record_length_length, + record_length)) + || ((*conv_version == SSL_VER_PCT) && + !ssl_looks_like_valid_pct_handshake(tvb, initial_offset + + record_length_length, + record_length))) + { + if (dtls_record_tree) + { + proto_item_set_text(dtls_record_tree, "%s Record Layer: %s", + (*conv_version == SSL_VER_PCT) + ? "PCT" : "SSLv2", + "Encrypted Data"); + } + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_str(pinfo->cinfo, COL_INFO, "Encrypted Data"); + return initial_offset + record_length_length + record_length; + } + else + { + if (check_col(pinfo->cinfo, COL_INFO)) + col_append_str(pinfo->cinfo, COL_INFO, msg_type_str); + + if (dtls_record_tree) + { + proto_item_set_text(dtls_record_tree, "%s Record Layer: %s", + (*conv_version == SSL_VER_PCT) + ? "PCT" : "SSLv2", + msg_type_str); + } + } + + /* We have a valid message type, so move foward, filling in the + * tree by adding the length, is_escape boolean and padding_length, + * if present in the original packet + */ + if (dtls_record_tree) + { + /* add the record length */ + tvb_ensure_bytes_exist(tvb, offset, record_length_length); + ti = proto_tree_add_uint (dtls_record_tree, + hf_dtls_record_length, tvb, + initial_offset, record_length_length, + record_length); + } + if (dtls_record_tree && is_escape != -1) + { + proto_tree_add_boolean(dtls_record_tree, + hf_ssl2_record_is_escape, tvb, + initial_offset, 1, is_escape); + } + if (dtls_record_tree && padding_length != -1) + { + proto_tree_add_uint(dtls_record_tree, + hf_ssl2_record_padding_length, tvb, + initial_offset + 2, 1, padding_length); + } + + /* + * dissect the record data + */ + + /* jump forward to the start of the record data */ + offset = initial_offset + record_length_length; + + /* add the message type */ + if (dtls_record_tree) + { + proto_tree_add_item(dtls_record_tree, + (*conv_version == SSL_VER_PCT) + ? hf_pct_msg_type : hf_ssl2_msg_type, + tvb, offset, 1, 0); + } + offset++; /* move past msg_type byte */ + + if (*conv_version != SSL_VER_PCT) + { + /* dissect the message (only handle client hello right now) */ + switch (msg_type) { + case SSL2_HND_CLIENT_HELLO: + dissect_ssl2_hnd_client_hello(tvb, dtls_record_tree, offset, ssl); + break; + + case SSL2_HND_CLIENT_MASTER_KEY: + dissect_ssl2_hnd_client_master_key(tvb, dtls_record_tree, offset); + break; + + case SSL2_HND_SERVER_HELLO: + dissect_ssl2_hnd_server_hello(tvb, dtls_record_tree, offset, pinfo); + break; + + case SSL2_HND_ERROR: + case SSL2_HND_CLIENT_FINISHED: + case SSL2_HND_SERVER_VERIFY: + case SSL2_HND_SERVER_FINISHED: + case SSL2_HND_REQUEST_CERTIFICATE: + case SSL2_HND_CLIENT_CERTIFICATE: + /* unimplemented */ + break; + + default: /* unknown */ + break; + } + } + else + { + /* dissect the message */ + switch (msg_type) { + case PCT_MSG_CLIENT_HELLO: + dissect_pct_msg_client_hello(tvb, dtls_record_tree, offset); + break; + case PCT_MSG_SERVER_HELLO: + dissect_pct_msg_server_hello(tvb, dtls_record_tree, offset, pinfo); + break; + case PCT_MSG_CLIENT_MASTER_KEY: + dissect_pct_msg_client_master_key(tvb, dtls_record_tree, offset); + break; + case PCT_MSG_SERVER_VERIFY: + dissect_pct_msg_server_verify(tvb, dtls_record_tree, offset); + break; + case PCT_MSG_ERROR: + dissect_pct_msg_error(tvb, dtls_record_tree, offset); + break; + + default: /* unknown */ + break; + } + } + return (initial_offset + record_length_length + record_length); +} + +static void +dissect_ssl2_hnd_client_hello(tvbuff_t *tvb, + proto_tree *tree, guint32 offset, + SslDecryptSession* ssl) +{ + /* struct { + * uint8 msg_type; + * Version version; + * uint16 cipher_spec_length; + * uint16 session_id_length; + * uint16 challenge_length; + * V2CipherSpec cipher_specs[V2ClientHello.cipher_spec_length]; + * opaque session_id[V2ClientHello.session_id_length]; + * Random challenge; + * } V2ClientHello; + * + * Note: when we get here, offset's already pointing at Version + * + */ + guint16 version; + guint16 cipher_spec_length; + guint16 session_id_length; + guint16 challenge_length; + + proto_tree *ti; + proto_tree *cs_tree=0; + + version = tvb_get_ntohs(tvb, offset); + if (!ssl_is_valid_ssl_version(version)) + { + /* invalid version; probably encrypted data */ + return; + } + + if (tree || ssl) + { + /* show the version */ + if (tree) + proto_tree_add_item(tree, hf_dtls_record_version, tvb, + offset, 2, FALSE); + offset += 2; + + cipher_spec_length = tvb_get_ntohs(tvb, offset); + if (tree) + proto_tree_add_item(tree, hf_ssl2_handshake_cipher_spec_len, + tvb, offset, 2, FALSE); + offset += 2; + + session_id_length = tvb_get_ntohs(tvb, offset); + if (tree) + proto_tree_add_item(tree, hf_ssl2_handshake_session_id_len, + tvb, offset, 2, FALSE); + offset += 2; + + challenge_length = tvb_get_ntohs(tvb, offset); + if (tree) + proto_tree_add_item(tree, hf_ssl2_handshake_challenge_len, + tvb, offset, 2, FALSE); + offset += 2; + + if (tree) + { + /* tell the user how many cipher specs they've won */ + tvb_ensure_bytes_exist(tvb, offset, cipher_spec_length); + ti = proto_tree_add_none_format(tree, hf_dtls_handshake_cipher_suites, + tvb, offset, cipher_spec_length, + "Cipher Specs (%u specs)", + cipher_spec_length/3); + + /* make this a subtree and expand the actual specs below */ + cs_tree = proto_item_add_subtree(ti, ett_dtls_cipher_suites); + if (!cs_tree) + { + cs_tree = tree; /* failsafe */ + } + } + + /* iterate through the cipher specs, showing them */ + while (cipher_spec_length > 0) + { + if (cs_tree) + proto_tree_add_item(cs_tree, hf_ssl2_handshake_cipher_spec, + tvb, offset, 3, FALSE); + offset += 3; /* length of one cipher spec */ + cipher_spec_length -= 3; + } + + /* if there's a session id, show it */ + if (session_id_length > 0) + { + if (tree) + { + tvb_ensure_bytes_exist(tvb, offset, session_id_length); + proto_tree_add_bytes_format(tree, + hf_dtls_handshake_session_id, + tvb, offset, session_id_length, + tvb_get_ptr(tvb, offset, session_id_length), + "Session ID (%u byte%s)", + session_id_length, + plurality(session_id_length, "", "s")); + } + + /* PAOLO: get session id and reset session state for key [re]negotiation */ + if (ssl) + { + tvb_memcpy(tvb,ssl->session_id.data, offset, session_id_length); + ssl->session_id.data_len = session_id_length; + ssl->state &= ~(SSL_HAVE_SESSION_KEY|SSL_MASTER_SECRET| + SSL_CIPHER|SSL_SERVER_RANDOM); + } + offset += session_id_length; + } + + /* if there's a challenge, show it */ + if (challenge_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, challenge_length); + + if (tree) + proto_tree_add_item(tree, hf_ssl2_handshake_challenge, + tvb, offset, challenge_length, 0); + if (ssl) + { + /* PAOLO: get client random data; we get at most 32 bytes from + challenge */ + int max = challenge_length > 32? 32: challenge_length; + + ssl_debug_printf("client random len: %d padded to 32\n", + challenge_length); + + /* client random is padded with zero and 'right' aligned */ + memset(ssl->client_random.data, 0, 32 - max); + tvb_memcpy(tvb, &ssl->client_random.data[32 - max], offset, max); + ssl->client_random.data_len = 32; + ssl->state |= SSL_CLIENT_RANDOM; + + } + offset += challenge_length; + } + } +} + +static void +dissect_pct_msg_client_hello(tvbuff_t *tvb, + proto_tree *tree, guint32 offset) +{ + guint16 CH_CLIENT_VERSION, CH_OFFSET, CH_CIPHER_SPECS_LENGTH, CH_HASH_SPECS_LENGTH, CH_CERT_SPECS_LENGTH, CH_EXCH_SPECS_LENGTH, CH_KEY_ARG_LENGTH; + proto_item *CH_CIPHER_SPECS_ti, *CH_HASH_SPECS_ti, *CH_CERT_SPECS_ti, *CH_EXCH_SPECS_ti; + proto_tree *CH_CIPHER_SPECS_tree, *CH_HASH_SPECS_tree, *CH_CERT_SPECS_tree, *CH_EXCH_SPECS_tree; + gint i; + + CH_CLIENT_VERSION = tvb_get_ntohs(tvb, offset); + if(CH_CLIENT_VERSION != PCT_VERSION_1) + proto_tree_add_text(tree, tvb, offset, 2, "Client Version, should be %x in PCT version 1", PCT_VERSION_1); + else + proto_tree_add_text(tree, tvb, offset, 2, "Client Version (%x)", PCT_VERSION_1); + offset += 2; + + proto_tree_add_text(tree, tvb, offset, 1, "PAD"); + offset += 1; + + proto_tree_add_text(tree, tvb, offset, 32, "Client Session ID Data (32 bytes)"); + offset += 32; + + proto_tree_add_text(tree, tvb, offset, 32, "Challange Data(32 bytes)"); + offset += 32; + + CH_OFFSET = tvb_get_ntohs(tvb, offset); + if(CH_OFFSET != PCT_CH_OFFSET_V1) + proto_tree_add_text(tree, tvb, offset, 2, "CH_OFFSET: %d, should be %d in PCT version 1", CH_OFFSET, PCT_CH_OFFSET_V1); + else + proto_tree_add_text(tree, tvb, offset, 2, "CH_OFFSET: %d", CH_OFFSET); + offset += 2; + + CH_CIPHER_SPECS_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "CIPHER_SPECS Length: %d", CH_CIPHER_SPECS_LENGTH); + offset += 2; + + CH_HASH_SPECS_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "HASH_SPECS Length: %d", CH_HASH_SPECS_LENGTH); + offset += 2; + + CH_CERT_SPECS_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "CERT_SPECS Length: %d", CH_CERT_SPECS_LENGTH); + offset += 2; + + CH_EXCH_SPECS_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "EXCH_SPECS Length: %d", CH_EXCH_SPECS_LENGTH); + offset += 2; + + CH_KEY_ARG_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "IV Length: %d", CH_KEY_ARG_LENGTH); + offset += 2; + + if(CH_CIPHER_SPECS_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, CH_CIPHER_SPECS_LENGTH); + CH_CIPHER_SPECS_ti = proto_tree_add_item(tree, hf_pct_handshake_cipher_spec, tvb, offset, CH_CIPHER_SPECS_LENGTH, FALSE); + CH_CIPHER_SPECS_tree = proto_item_add_subtree(CH_CIPHER_SPECS_ti, ett_pct_cipher_suites); + + for(i=0; i<(CH_CIPHER_SPECS_LENGTH/4); i++) { + proto_tree_add_item(CH_CIPHER_SPECS_tree, hf_pct_handshake_cipher, tvb, offset, 2, FALSE); + offset += 2; + proto_tree_add_text(CH_CIPHER_SPECS_tree, tvb, offset, 1, "Encryption key length: %d", tvb_get_guint8(tvb, offset)); + offset += 1; + proto_tree_add_text(CH_CIPHER_SPECS_tree, tvb, offset, 1, "MAC key length in bits: %d", tvb_get_guint8(tvb, offset) + 64); + offset += 1; + } + } + + if(CH_HASH_SPECS_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, CH_HASH_SPECS_LENGTH); + CH_HASH_SPECS_ti = proto_tree_add_item(tree, hf_pct_handshake_hash_spec, tvb, offset, CH_HASH_SPECS_LENGTH, FALSE); + CH_HASH_SPECS_tree = proto_item_add_subtree(CH_HASH_SPECS_ti, ett_pct_hash_suites); + + for(i=0; i<(CH_HASH_SPECS_LENGTH/2); i++) { + proto_tree_add_item(CH_HASH_SPECS_tree, hf_pct_handshake_hash, tvb, offset, 2, FALSE); + offset += 2; + } + } + + if(CH_CERT_SPECS_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, CH_CERT_SPECS_LENGTH); + CH_CERT_SPECS_ti = proto_tree_add_item(tree, hf_pct_handshake_cert_spec, tvb, offset, CH_CERT_SPECS_LENGTH, FALSE); + CH_CERT_SPECS_tree = proto_item_add_subtree(CH_CERT_SPECS_ti, ett_pct_cert_suites); + + for(i=0; i< (CH_CERT_SPECS_LENGTH/2); i++) { + proto_tree_add_item(CH_CERT_SPECS_tree, hf_pct_handshake_cert, tvb, offset, 2, FALSE); + offset += 2; + } + } + + if(CH_EXCH_SPECS_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, CH_EXCH_SPECS_LENGTH); + CH_EXCH_SPECS_ti = proto_tree_add_item(tree, hf_pct_handshake_exch_spec, tvb, offset, CH_EXCH_SPECS_LENGTH, FALSE); + CH_EXCH_SPECS_tree = proto_item_add_subtree(CH_EXCH_SPECS_ti, ett_pct_exch_suites); + + for(i=0; i<(CH_EXCH_SPECS_LENGTH/2); i++) { + proto_tree_add_item(CH_EXCH_SPECS_tree, hf_pct_handshake_exch, tvb, offset, 2, FALSE); + offset += 2; + } + } + + if(CH_KEY_ARG_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, CH_KEY_ARG_LENGTH); + proto_tree_add_text(tree, tvb, offset, CH_KEY_ARG_LENGTH, "IV data (%d bytes)", CH_KEY_ARG_LENGTH); + offset += CH_KEY_ARG_LENGTH; + } +} + +static void +dissect_pct_msg_server_hello(tvbuff_t *tvb, proto_tree *tree, guint32 offset, packet_info *pinfo) +{ +/* structure: +char SH_MSG_SERVER_HELLO +char SH_PAD +char SH_SERVER_VERSION_MSB +char SH_SERVER_VERSION_LSB +char SH_RESTART_SESSION_OK +char SH_CLIENT_AUTH_REQ +char SH_CIPHER_SPECS_DATA[4] +char SH_HASH_SPECS_DATA[2] +char SH_CERT_SPECS_DATA[2] +char SH_EXCH_SPECS_DATA[2] +char SH_CONNECTION_ID_DATA[32] +char SH_CERTIFICATE_LENGTH_MSB +char SH_CERTIFICATE_LENGTH_LSB +char SH_CLIENT_CERT_SPECS_LENGTH_MSB +char SH_CLIENT_CERT_SPECS_LENGTH_LSB +char SH_CLIENT_SIG_SPECS_LENGTH_MSB +char SH_CLIENT_SIG_SPECS_LENGTH_LSB +char SH_RESPONSE_LENGTH_MSB +char SH_RESPONSE_LENGTH_LSB +char SH_CERTIFICATE_DATA[MSB<<8|LSB] +char SH_CLIENT_CERT_SPECS_DATA[MSB<<8|LSB] +char SH_CLIENT_SIG_SPECS_DATA[MSB<<8|LSB] +char SH_RESPONSE_DATA[MSB<<8|LSB] + +*/ + + guint16 SH_SERVER_VERSION, SH_CERT_LENGTH, SH_CERT_SPECS_LENGTH, SH_CLIENT_SIG_LENGTH, SH_RESPONSE_LENGTH; + + proto_tree_add_text(tree, tvb, offset, 1, "PAD"); + offset += 1; + + SH_SERVER_VERSION = tvb_get_ntohs(tvb, offset); + if(SH_SERVER_VERSION != PCT_VERSION_1) + proto_tree_add_text(tree, tvb, offset, 2, "Server Version, should be %x in PCT version 1", PCT_VERSION_1); + else + proto_tree_add_text(tree, tvb, offset, 2, "Server Version (%x)", PCT_VERSION_1); + offset += 2; + + proto_tree_add_text(tree, tvb, offset, 1, "SH_RESTART_SESSION_OK flag"); + offset += 1; + + proto_tree_add_text(tree, tvb, offset, 1, "SH_CLIENT_AUTH_REQ flag"); + offset += 1; + + proto_tree_add_item(tree, hf_pct_handshake_cipher, tvb, offset, 2, FALSE); + offset += 2; + proto_tree_add_text(tree, tvb, offset, 1, "Encryption key length: %d", tvb_get_guint8(tvb, offset)); + offset += 1; + proto_tree_add_text(tree, tvb, offset, 1, "MAC key length in bits: %d", tvb_get_guint8(tvb, offset) + 64); + offset += 1; + + proto_tree_add_item(tree, hf_pct_handshake_hash, tvb, offset, 2, FALSE); + offset += 2; + + proto_tree_add_item(tree, hf_pct_handshake_cert, tvb, offset, 2, FALSE); + offset += 2; + + proto_tree_add_item(tree, hf_pct_handshake_exch, tvb, offset, 2, FALSE); + offset += 2; + + proto_tree_add_text(tree, tvb, offset, 32, "Connection ID Data (32 bytes)"); + offset += 32; + + SH_CERT_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Server Certificate Length: %d", SH_CERT_LENGTH); + offset += 2; + + SH_CERT_SPECS_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Client CERT_SPECS Length: %d", SH_CERT_SPECS_LENGTH); + offset += 2; + + SH_CLIENT_SIG_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Client SIG_SPECS Length: %d", SH_CLIENT_SIG_LENGTH); + offset += 2; + + SH_RESPONSE_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Response Length: %d", SH_RESPONSE_LENGTH); + offset += 2; + + if(SH_CERT_LENGTH) { + dissect_x509af_Certificate(FALSE, tvb, offset, pinfo, tree, hf_pct_handshake_server_cert); + offset += SH_CERT_LENGTH; + } + + if(SH_CERT_SPECS_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, SH_CERT_SPECS_LENGTH); + proto_tree_add_text(tree, tvb, offset, SH_CERT_SPECS_LENGTH, "Client CERT_SPECS (%d bytes)", SH_CERT_SPECS_LENGTH); + offset += SH_CERT_SPECS_LENGTH; + } + + if(SH_CLIENT_SIG_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, SH_CLIENT_SIG_LENGTH); + proto_tree_add_text(tree, tvb, offset, SH_CLIENT_SIG_LENGTH, "Client Signature (%d bytes)", SH_CLIENT_SIG_LENGTH); + offset += SH_CLIENT_SIG_LENGTH; + } + + if(SH_RESPONSE_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, SH_RESPONSE_LENGTH); + proto_tree_add_text(tree, tvb, offset, SH_RESPONSE_LENGTH, "Server Response (%d bytes)", SH_RESPONSE_LENGTH); + offset += SH_RESPONSE_LENGTH; + } + +} + +static void +dissect_pct_msg_client_master_key(tvbuff_t *tvb, proto_tree *tree, guint32 offset) +{ + guint16 CMK_CLEAR_KEY_LENGTH, CMK_ENCRYPTED_KEY_LENGTH, CMK_KEY_ARG_LENGTH, CMK_VERIFY_PRELUDE, CMK_CLIENT_CERT_LENGTH, CMK_RESPONSE_LENGTH; + + proto_tree_add_text(tree, tvb, offset, 1, "PAD"); + offset += 1; + + proto_tree_add_item(tree, hf_pct_handshake_cert, tvb, offset, 2, FALSE); + offset += 2; + + proto_tree_add_item(tree, hf_pct_handshake_sig, tvb, offset, 2, FALSE); + offset += 2; + + CMK_CLEAR_KEY_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Clear Key Length: %d",CMK_CLEAR_KEY_LENGTH); + offset += 2; + + CMK_ENCRYPTED_KEY_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Encrypted Key Length: %d",CMK_ENCRYPTED_KEY_LENGTH); + offset += 2; + + CMK_KEY_ARG_LENGTH= tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "IV Length: %d",CMK_KEY_ARG_LENGTH); + offset += 2; + + CMK_VERIFY_PRELUDE = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Verify Prelude Length: %d",CMK_VERIFY_PRELUDE); + offset += 2; + + CMK_CLIENT_CERT_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Client Cert Length: %d",CMK_CLIENT_CERT_LENGTH); + offset += 2; + + CMK_RESPONSE_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Response Length: %d",CMK_RESPONSE_LENGTH); + offset += 2; + + if(CMK_CLEAR_KEY_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, CMK_CLEAR_KEY_LENGTH); + proto_tree_add_text(tree, tvb, offset, CMK_CLEAR_KEY_LENGTH, "Clear Key data (%d bytes)", CMK_CLEAR_KEY_LENGTH); + offset += CMK_CLEAR_KEY_LENGTH; + } + if(CMK_ENCRYPTED_KEY_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, CMK_ENCRYPTED_KEY_LENGTH); + proto_tree_add_text(tree, tvb, offset, CMK_ENCRYPTED_KEY_LENGTH, "Encrypted Key data (%d bytes)", CMK_ENCRYPTED_KEY_LENGTH); + offset += CMK_ENCRYPTED_KEY_LENGTH; + } + if(CMK_KEY_ARG_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, CMK_KEY_ARG_LENGTH); + proto_tree_add_text(tree, tvb, offset, CMK_KEY_ARG_LENGTH, "IV data (%d bytes)", CMK_KEY_ARG_LENGTH); + offset += CMK_KEY_ARG_LENGTH; + } + if(CMK_VERIFY_PRELUDE) { + tvb_ensure_bytes_exist(tvb, offset, CMK_VERIFY_PRELUDE); + proto_tree_add_text(tree, tvb, offset, CMK_VERIFY_PRELUDE, "Verify Prelude data (%d bytes)", CMK_VERIFY_PRELUDE); + offset += CMK_VERIFY_PRELUDE; + } + if(CMK_CLIENT_CERT_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, CMK_CLIENT_CERT_LENGTH); + proto_tree_add_text(tree, tvb, offset, CMK_CLIENT_CERT_LENGTH, "Client Certificate data (%d bytes)", CMK_CLIENT_CERT_LENGTH); + offset += CMK_CLIENT_CERT_LENGTH; + } + if(CMK_RESPONSE_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, CMK_RESPONSE_LENGTH); + proto_tree_add_text(tree, tvb, offset, CMK_RESPONSE_LENGTH, "Response data (%d bytes)", CMK_RESPONSE_LENGTH); + offset += CMK_RESPONSE_LENGTH; + } +} + +static void +dissect_pct_msg_server_verify(tvbuff_t *tvb, + proto_tree *tree, guint32 offset) +{ + guint16 SV_RESPONSE_LENGTH; + + proto_tree_add_text(tree, tvb, offset, 1, "PAD"); + offset += 1; + + proto_tree_add_text(tree, tvb, offset, 32, "Server Session ID data (32 bytes)"); + offset += 32; + + SV_RESPONSE_LENGTH = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Server Response Length: %d", SV_RESPONSE_LENGTH); + offset += 2; + + if(SV_RESPONSE_LENGTH) { + tvb_ensure_bytes_exist(tvb, offset, SV_RESPONSE_LENGTH); + proto_tree_add_text(tree, tvb, offset, SV_RESPONSE_LENGTH, "Server Response (%d bytes)", SV_RESPONSE_LENGTH); + offset += SV_RESPONSE_LENGTH; + } +} + +static void +dissect_pct_msg_error(tvbuff_t *tvb, + proto_tree *tree, guint32 offset) +{ + guint16 ERROR_CODE, INFO_LEN; + + ERROR_CODE = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_pct_msg_error_type, tvb, offset, 2, FALSE); + offset += 2; + + INFO_LEN = tvb_get_ntohs(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 2, "Eror Information Length: %d", INFO_LEN); + offset += 2; + if (ERROR_CODE == PCT_ERR_SPECS_MISMATCH && INFO_LEN == 6) + { + proto_tree_add_text(tree, tvb, offset, 1, "SPECS_MISMATCH_CIPHER"); + offset += 1; + proto_tree_add_text(tree, tvb, offset, 1, "SPECS_MISMATCH_HASH"); + offset += 1; + proto_tree_add_text(tree, tvb, offset, 1, "SPECS_MISMATCH_CERT"); + offset += 1; + proto_tree_add_text(tree, tvb, offset, 1, "SPECS_MISMATCH_EXCH"); + offset += 1; + proto_tree_add_text(tree, tvb, offset, 1, "SPECS_MISMATCH_CLIENT_CERT"); + offset += 1; + proto_tree_add_text(tree, tvb, offset, 1, "SPECS_MISMATCH_CLIENT_SIG"); + offset += 1; + } + else if(INFO_LEN) { + proto_tree_add_text(tree, tvb, offset, INFO_LEN, "Error Information dta (%d bytes)", INFO_LEN); + offset += INFO_LEN; + } +} + +static void +dissect_ssl2_hnd_client_master_key(tvbuff_t *tvb, + proto_tree *tree, guint32 offset) +{ + /* struct { + * uint8 msg_type; + * V2Cipherspec cipher; + * uint16 clear_key_length; + * uint16 encrypted_key_length; + * uint16 key_arg_length; + * opaque clear_key_data[V2ClientMasterKey.clear_key_length]; + * opaque encrypted_key_data[V2ClientMasterKey.encrypted_key_length]; + * opaque key_arg_data[V2ClientMasterKey.key_arg_length]; + * } V2ClientMasterKey; + * + * Note: when we get here, offset's already pointing at cipher + */ + guint16 clear_key_length; + guint16 encrypted_key_length; + guint16 key_arg_length; + + /* at this point, everything we do involves the tree, + * so quit now if we don't have one ;-) + */ + if (!tree) + { + return; + } + + /* show the selected cipher */ + proto_tree_add_item(tree, hf_ssl2_handshake_cipher_spec, + tvb, offset, 3, FALSE); + offset += 3; + + /* get the fixed fields */ + clear_key_length = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_ssl2_handshake_clear_key_len, + tvb, offset, 2, FALSE); + offset += 2; + + encrypted_key_length = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_ssl2_handshake_enc_key_len, + tvb, offset, 2, FALSE); + offset += 2; + + key_arg_length = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_ssl2_handshake_key_arg_len, + tvb, offset, 2, FALSE); + offset += 2; + + /* show the variable length fields */ + if (clear_key_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, clear_key_length); + proto_tree_add_item(tree, hf_ssl2_handshake_clear_key, + tvb, offset, clear_key_length, FALSE); + offset += clear_key_length; + } + + if (encrypted_key_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, encrypted_key_length); + proto_tree_add_item(tree, hf_ssl2_handshake_enc_key, + tvb, offset, encrypted_key_length, FALSE); + offset += encrypted_key_length; + } + + if (key_arg_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, key_arg_length); + proto_tree_add_item(tree, hf_ssl2_handshake_key_arg, + tvb, offset, key_arg_length, FALSE); + offset += key_arg_length; + } + +} + +static void +dissect_ssl2_hnd_server_hello(tvbuff_t *tvb, + proto_tree *tree, guint32 offset, packet_info *pinfo) +{ + /* struct { + * uint8 msg_type; + * uint8 session_id_hit; + * uint8 certificate_type; + * uint16 server_version; + * uint16 certificate_length; + * uint16 cipher_specs_length; + * uint16 connection_id_length; + * opaque certificate_data[V2ServerHello.certificate_length]; + * opaque cipher_specs_data[V2ServerHello.cipher_specs_length]; + * opaque connection_id_data[V2ServerHello.connection_id_length]; + * } V2ServerHello; + * + * Note: when we get here, offset's already pointing at session_id_hit + */ + guint16 certificate_length; + guint16 cipher_spec_length; + guint16 connection_id_length; + guint16 version; + proto_tree *ti; + proto_tree *subtree; + + /* everything we do only makes sense with a tree, so + * quit now if we don't have one + */ + if (!tree) + { + return; + } + + version = tvb_get_ntohs(tvb, offset + 2); + if (!ssl_is_valid_ssl_version(version)) + { + /* invalid version; probably encrypted data */ + return; + } + + + /* is there a hit? */ + proto_tree_add_item(tree, hf_ssl2_handshake_session_id_hit, + tvb, offset, 1, FALSE); + offset++; + + /* what type of certificate is this? */ + proto_tree_add_item(tree, hf_ssl2_handshake_cert_type, + tvb, offset, 1, FALSE); + offset++; + + /* now the server version */ + proto_tree_add_item(tree, hf_dtls_handshake_server_version, + tvb, offset, 2, FALSE); + offset += 2; + + /* get the fixed fields */ + certificate_length = tvb_get_ntohs(tvb, offset); + proto_tree_add_uint(tree, hf_dtls_handshake_certificate_len, + tvb, offset, 2, certificate_length); + offset += 2; + + cipher_spec_length = tvb_get_ntohs(tvb, offset); + proto_tree_add_uint(tree, hf_ssl2_handshake_cipher_spec_len, + tvb, offset, 2, cipher_spec_length); + offset += 2; + + connection_id_length = tvb_get_ntohs(tvb, offset); + proto_tree_add_uint(tree, hf_ssl2_handshake_connection_id_len, + tvb, offset, 2, connection_id_length); + offset += 2; + + /* now the variable length fields */ + if (certificate_length > 0) + { + dissect_x509af_Certificate(FALSE, tvb, offset, pinfo, tree, hf_dtls_handshake_certificate); + offset += certificate_length; + } + + if (cipher_spec_length > 0) + { + /* provide a collapsing node for the cipher specs */ + tvb_ensure_bytes_exist(tvb, offset, cipher_spec_length); + ti = proto_tree_add_none_format(tree, + hf_dtls_handshake_cipher_suites, + tvb, offset, cipher_spec_length, + "Cipher Specs (%u spec%s)", + cipher_spec_length/3, + plurality(cipher_spec_length/3, "", "s")); + subtree = proto_item_add_subtree(ti, ett_dtls_cipher_suites); + if (!subtree) + { + subtree = tree; + } + + /* iterate through the cipher specs */ + while (cipher_spec_length > 0) + { + proto_tree_add_item(subtree, hf_ssl2_handshake_cipher_spec, + tvb, offset, 3, FALSE); + offset += 3; + cipher_spec_length -= 3; + } + } + + if (connection_id_length > 0) + { + tvb_ensure_bytes_exist(tvb, offset, connection_id_length); + proto_tree_add_item(tree, hf_ssl2_handshake_connection_id, + tvb, offset, connection_id_length, FALSE); + offset += connection_id_length; + } + +} + + + + +/********************************************************************* + * + * Support Functions + * + *********************************************************************/ +#if 0 +static void +ssl_set_conv_version(packet_info *pinfo, guint version) +{ + conversation_t *conversation; + + if (pinfo->fd->flags.visited) + { + /* We've already processed this frame; no need to do any more + * work on it. + */ + return; + } + + conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst, pinfo->ptype, + pinfo->srcport, pinfo->destport, 0); + + if (conversation == NULL) + { + /* create a new conversation */ + conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst, pinfo->ptype, + pinfo->srcport, pinfo->destport, 0); + } + + if (conversation_get_proto_data(conversation, proto_dtls) != NULL) + { + /* get rid of the current data */ + conversation_delete_proto_data(conversation, proto_dtls); + } + conversation_add_proto_data(conversation, proto_dtls, GINT_TO_POINTER(version)); +} +#endif + +static int +ssl_is_valid_handshake_type(guint8 type) +{ + + switch (type) { + case SSL_HND_HELLO_REQUEST: + case SSL_HND_CLIENT_HELLO: + case SSL_HND_SERVER_HELLO: + case SSL_HND_HELLO_VERIFY_REQUEST: + case SSL_HND_CERTIFICATE: + case SSL_HND_SERVER_KEY_EXCHG: + case SSL_HND_CERT_REQUEST: + case SSL_HND_SVR_HELLO_DONE: + case SSL_HND_CERT_VERIFY: + case SSL_HND_CLIENT_KEY_EXCHG: + case SSL_HND_FINISHED: + return 1; + } + return 0; +} + +static int +ssl_is_valid_content_type(guint8 type) +{ + if (type >= 0x14 && type <= 0x17) + { + return 1; + } + + return 0; +} + +static int +ssl_is_valid_ssl_version(guint16 version) +{ + const gchar *version_str = match_strval(version, ssl_versions); + return version_str != NULL; +} + +static int +ssl_is_authoritative_version_message(guint8 content_type, + guint8 next_byte) +{ + if (content_type == SSL_ID_HANDSHAKE + && ssl_is_valid_handshake_type(next_byte)) + { + return (next_byte != SSL_HND_CLIENT_HELLO); + } + else if (ssl_is_valid_content_type(content_type) + && content_type != SSL_ID_HANDSHAKE) + { + return 1; + } + return 0; +} + +static int +ssl_is_v2_client_hello(tvbuff_t *tvb, guint32 offset) +{ + guint8 byte; + + byte = tvb_get_guint8(tvb, offset); + if (byte != 0x80) /* v2 client hello should start this way */ + { + return 0; + } + + byte = tvb_get_guint8(tvb, offset+2); + if (byte != 0x01) /* v2 client hello msg type */ + { + return 0; + } + + /* 1 in 2^16 of being right; improve later if necessary */ + return 1; +} + +/* this applies a heuristic to determine whether + * or not the data beginning at offset looks like a + * valid sslv2 record. this isn't really possible, + * but we'll try to do a reasonable job anyway. + */ +static int +ssl_looks_like_sslv2(tvbuff_t *tvb, guint32 offset) +{ + /* here's the current approach: + * + * we only try to catch unencrypted handshake messages, so we can + * assume that there is not padding. This means that the + * first byte must be >= 0x80 and there must be a valid sslv2 + * msg_type in the third byte + */ + + /* get the first byte; must have high bit set */ + guint8 byte = tvb_get_guint8(tvb, offset); + if (byte < 0x80) + { + return 0; + } + + /* get the supposed msg_type byte; since we only care about + * unencrypted handshake messages (we can't tell the type for + * encrypted messages), we just check against that list + */ + byte = tvb_get_guint8(tvb, offset + 2); + switch(byte) { + case SSL2_HND_ERROR: + case SSL2_HND_CLIENT_HELLO: + case SSL2_HND_CLIENT_MASTER_KEY: + case SSL2_HND_SERVER_HELLO: + case PCT_MSG_CLIENT_MASTER_KEY: + case PCT_MSG_ERROR: + return 1; + } + return 0; +} + +/* this applies a heuristic to determine whether + * or not the data beginning at offset looks like a + * valid sslv3 record. this is somewhat more reliable + * than sslv2 due to the structure of the v3 protocol + */ +static int +ssl_looks_like_sslv3(tvbuff_t *tvb, guint32 offset) +{ + /* have to have a valid content type followed by a valid + * protocol version + */ + guint8 byte; + guint16 version; + + /* see if the first byte is a valid content type */ + byte = tvb_get_guint8(tvb, offset); + if (!ssl_is_valid_content_type(byte)) + { + return 0; + } + + /* now check to see if the version byte appears valid */ + version = tvb_get_ntohs(tvb, offset + 1); + if (version != DTLSV1DOT0_VERSION) + { + return 0; + } + + return 1; +} + +/* applies a heuristic to determine whether + * or not the data beginning at offset looks + * like a valid, unencrypted v2 handshake message. + * since it isn't possible to completely tell random + * data apart from a valid message without state, + * we try to help the odds. + */ +static int +ssl_looks_like_valid_v2_handshake(tvbuff_t *tvb, guint32 offset, + guint32 record_length) +{ + /* first byte should be a msg_type. + * + * - we know we only see client_hello, client_master_key, + * and server_hello in the clear, so check to see if + * msg_type is one of those (this gives us a 3 in 2^8 + * chance of saying yes with random payload) + * + * - for those three types that we know about, do some + * further validation to reduce the chance of an error + */ + guint8 msg_type; + guint16 version; + guint32 sum; + + /* fetch the msg_type */ + msg_type = tvb_get_guint8(tvb, offset); + + switch (msg_type) { + case SSL2_HND_CLIENT_HELLO: + /* version follows msg byte, so verify that this is valid */ + version = tvb_get_ntohs(tvb, offset+1); + return ssl_is_valid_ssl_version(version); + break; + + case SSL2_HND_SERVER_HELLO: + /* version is three bytes after msg_type */ + version = tvb_get_ntohs(tvb, offset+3); + return ssl_is_valid_ssl_version(version); + break; + + case SSL2_HND_CLIENT_MASTER_KEY: + /* sum of clear_key_length, encrypted_key_length, and key_arg_length + * must be less than record length + */ + sum = tvb_get_ntohs(tvb, offset + 4); /* clear_key_length */ + sum += tvb_get_ntohs(tvb, offset + 6); /* encrypted_key_length */ + sum += tvb_get_ntohs(tvb, offset + 8); /* key_arg_length */ + if (sum > record_length) + { + return 0; + } + return 1; + break; + + default: + return 0; + } + return 0; +} + +/* applies a heuristic to determine whether + * or not the data beginning at offset looks + * like a valid, unencrypted v2 handshake message. + * since it isn't possible to completely tell random + * data apart from a valid message without state, + * we try to help the odds. + */ +static int +ssl_looks_like_valid_pct_handshake(tvbuff_t *tvb, guint32 offset, + guint32 record_length) +{ + /* first byte should be a msg_type. + * + * - we know we only see client_hello, client_master_key, + * and server_hello in the clear, so check to see if + * msg_type is one of those (this gives us a 3 in 2^8 + * chance of saying yes with random payload) + * + * - for those three types that we know about, do some + * further validation to reduce the chance of an error + */ + guint8 msg_type; + guint16 version; + guint32 sum; + + /* fetch the msg_type */ + msg_type = tvb_get_guint8(tvb, offset); + + switch (msg_type) { + case PCT_MSG_CLIENT_HELLO: + /* version follows msg byte, so verify that this is valid */ + version = tvb_get_ntohs(tvb, offset+1); + return version == PCT_VERSION_1; + break; + + case PCT_MSG_SERVER_HELLO: + /* version is one byte after msg_type */ + version = tvb_get_ntohs(tvb, offset+2); + return version == PCT_VERSION_1; + break; + + case PCT_MSG_CLIENT_MASTER_KEY: + /* sum of various length fields must be less than record length */ + sum = tvb_get_ntohs(tvb, offset + 6); /* clear_key_length */ + sum += tvb_get_ntohs(tvb, offset + 8); /* encrypted_key_length */ + sum += tvb_get_ntohs(tvb, offset + 10); /* key_arg_length */ + sum += tvb_get_ntohs(tvb, offset + 12); /* verify_prelude_length */ + sum += tvb_get_ntohs(tvb, offset + 14); /* client_cert_length */ + sum += tvb_get_ntohs(tvb, offset + 16); /* response_length */ + if (sum > record_length) + { + return 0; + } + return 1; + break; + + case PCT_MSG_SERVER_VERIFY: + /* record is 36 bytes longer than response_length */ + sum = tvb_get_ntohs(tvb, offset + 34); /* response_length */ + if ((sum + 36) == record_length) + return 1; + else + return 0; + break; + + default: + return 0; + } + return 0; +} + + +/********************************************************************* + * + * Standard Ethereal Protocol Registration and housekeeping + * + *********************************************************************/ +void +proto_register_dtls(void) +{ + + /* Setup list of header fields See Section 1.6.1 for details*/ + static hf_register_info hf[] = { + { &hf_dtls_record, + { "Record Layer", "dtls.record", + FT_NONE, BASE_NONE, NULL, 0x0, + "Record layer", HFILL } + }, + { &hf_dtls_record_content_type, + { "Content Type", "dtls.record.content_type", + FT_UINT8, BASE_DEC, VALS(ssl_31_content_type), 0x0, + "Content type", HFILL} + }, + { &hf_dtls_record_version, + { "Version", "dtls.record.version", + FT_UINT16, BASE_HEX, VALS(ssl_versions), 0x0, + "Record layer version.", HFILL } + }, + { &hf_dtls_record_epoch, + { "Epoch", "dtls.record.epoch", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Epoch", HFILL } + }, + { &hf_dtls_record_sequence_number, + { "Sequence Number", "dtls.record.sequence_number", + FT_DOUBLE, BASE_DEC, NULL, 0x0, + "Sequence Number", HFILL } + }, + { &hf_dtls_record_length, + { "Length", "dtls.record.length", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Length of DTLS record data", HFILL } + }, + { &hf_dtls_record_appdata, + { "Application Data", "dtls.app_data", + FT_NONE, BASE_NONE, NULL, 0x0, + "Payload is application data", HFILL } + }, + { &hf_dtls_record_appdata_decrypted, + { "Application Data decrypted", "dtls.app_data_decrypted", + FT_STRING, BASE_NONE, NULL, 0x0, + "Payload is decrypted application data", HFILL } + }, + { &hf_dtls_change_cipher_spec, + { "Change Cipher Spec Message", "dtls.change_cipher_spec", + FT_NONE, BASE_NONE, NULL, 0x0, + "Signals a change in cipher specifications", HFILL } + }, + { & hf_dtls_alert_message, + { "Alert Message", "dtls.alert_message", + FT_NONE, BASE_NONE, NULL, 0x0, + "Alert message", HFILL } + }, + { & hf_dtls_alert_message_level, + { "Level", "dtls.alert_message.level", + FT_UINT8, BASE_DEC, VALS(ssl_31_alert_level), 0x0, + "Alert message level", HFILL } + }, + { &hf_dtls_alert_message_description, + { "Description", "dtls.alert_message.desc", + FT_UINT8, BASE_DEC, VALS(ssl_31_alert_description), 0x0, + "Alert message description", HFILL } + }, + { &hf_dtls_handshake_protocol, + { "Handshake Protocol", "dtls.handshake", + FT_NONE, BASE_NONE, NULL, 0x0, + "Handshake protocol message", HFILL} + }, + { &hf_dtls_handshake_type, + { "Handshake Type", "dtls.handshake.type", + FT_UINT8, BASE_DEC, VALS(ssl_31_handshake_type), 0x0, + "Type of handshake message", HFILL} + }, + { &hf_dtls_handshake_length, + { "Length", "dtls.handshake.length", + FT_UINT24, BASE_DEC, NULL, 0x0, + "Length of handshake message", HFILL } + }, + { &hf_dtls_handshake_message_seq, + { "Message Sequence", "dtls.handshake.message_seq", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Message sequence of handshake message", HFILL } + }, + { &hf_dtls_handshake_fragment_offset, + { "Fragment Offset", "dtls.handshake.fragment_offset", + FT_UINT24, BASE_DEC, NULL, 0x0, + "Fragment offset of handshake message", HFILL } + }, + { &hf_dtls_handshake_fragment_length, + { "Fragment Length", "dtls.handshake.fragment_length", + FT_UINT24, BASE_DEC, NULL, 0x0, + "Fragment length of handshake message", HFILL } + }, + { &hf_dtls_handshake_client_version, + { "Version", "dtls.handshake.version", + FT_UINT16, BASE_HEX, VALS(ssl_versions), 0x0, + "Maximum version supported by client", HFILL } + }, + { &hf_dtls_handshake_server_version, + { "Version", "dtls.handshake.version", + FT_UINT16, BASE_HEX, VALS(ssl_versions), 0x0, + "Version selected by server", HFILL } + }, + { &hf_dtls_handshake_random_time, + { "Random.gmt_unix_time", "dtls.handshake.random_time", + FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0, + "Unix time field of random structure", HFILL } + }, + { &hf_dtls_handshake_random_bytes, + { "Random.bytes", "dtls.handshake.random", + FT_NONE, BASE_NONE, NULL, 0x0, + "Random challenge used to authenticate server", HFILL } + }, + { &hf_dtls_handshake_cipher_suites_len, + { "Cipher Suites Length", "dtls.handshake.cipher_suites_length", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Length of cipher suites field", HFILL } + }, + { &hf_dtls_handshake_cipher_suites, + { "Cipher Suites", "dtls.handshake.ciphersuites", + FT_NONE, BASE_NONE, NULL, 0x0, + "List of cipher suites supported by client", HFILL } + }, + { &hf_dtls_handshake_cipher_suite, + { "Cipher Suite", "dtls.handshake.ciphersuite", + FT_UINT16, BASE_HEX, VALS(ssl_31_ciphersuite), 0x0, + "Cipher suite", HFILL } + }, + { &hf_dtls_handshake_cookie_len, + { "Cookie Length", "dtls.handshake.cookie_length", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Length of the cookie field", HFILL } + }, + { &hf_dtls_handshake_cookie, + { "Cookie", "dtls.handshake.cookie", + FT_NONE, BASE_NONE, NULL, 0x0, + "Cookie", HFILL } + }, + { &hf_dtls_handshake_session_id, + { "Session ID", "dtls.handshake.session_id", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Identifies the DTLS session, allowing later resumption", HFILL } + }, + { &hf_dtls_handshake_comp_methods_len, + { "Compression Methods Length", "dtls.handshake.comp_methods_length", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Length of compression methods field", HFILL } + }, + { &hf_dtls_handshake_comp_methods, + { "Compression Methods", "dtls.handshake.comp_methods", + FT_NONE, BASE_NONE, NULL, 0x0, + "List of compression methods supported by client", HFILL } + }, + { &hf_dtls_handshake_comp_method, + { "Compression Method", "dtls.handshake.comp_method", + FT_UINT8, BASE_DEC, VALS(ssl_31_compression_method), 0x0, + "Compression Method", HFILL } + }, + { &hf_dtls_handshake_extensions_len, + { "Extensions Length", "dtls.handshake.extensions_length", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Length of hello extensions", HFILL } + }, + { &hf_dtls_handshake_extension_type, + { "Type", "dtls.handshake.extension.type", + FT_UINT16, BASE_HEX, VALS(tls_hello_extension_types), 0x0, + "Hello extension type", HFILL } + }, + { &hf_dtls_handshake_extension_len, + { "Length", "dtls.handshake.extension.len", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Length of a hello extension", HFILL } + }, + { &hf_dtls_handshake_extension_data, + { "Data", "dtls.handshake.extension.data", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Hello Extension data", HFILL } + }, + { &hf_dtls_handshake_certificates_len, + { "Certificates Length", "dtls.handshake.certificates_length", + FT_UINT24, BASE_DEC, NULL, 0x0, + "Length of certificates field", HFILL } + }, + { &hf_dtls_handshake_certificates, + { "Certificates", "dtls.handshake.certificates", + FT_NONE, BASE_NONE, NULL, 0x0, + "List of certificates", HFILL } + }, + { &hf_dtls_handshake_certificate, + { "Certificate", "dtls.handshake.certificate", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Certificate", HFILL } + }, + { &hf_dtls_handshake_certificate_len, + { "Certificate Length", "dtls.handshake.certificate_length", + FT_UINT24, BASE_DEC, NULL, 0x0, + "Length of certificate", HFILL } + }, + { &hf_dtls_handshake_cert_types_count, + { "Certificate types count", "dtls.handshake.cert_types_count", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Count of certificate types", HFILL } + }, + { &hf_dtls_handshake_cert_types, + { "Certificate types", "dtls.handshake.cert_types", + FT_NONE, BASE_NONE, NULL, 0x0, + "List of certificate types", HFILL } + }, + { &hf_dtls_handshake_cert_type, + { "Certificate type", "dtls.handshake.cert_type", + FT_UINT8, BASE_DEC, VALS(ssl_31_client_certificate_type), 0x0, + "Certificate type", HFILL } + }, + { &hf_dtls_handshake_finished, + { "Verify Data", "dtls.handshake.verify_data", + FT_NONE, BASE_NONE, NULL, 0x0, + "Opaque verification data", HFILL } + }, + { &hf_dtls_handshake_md5_hash, + { "MD5 Hash", "dtls.handshake.md5_hash", + FT_NONE, BASE_NONE, NULL, 0x0, + "Hash of messages, master_secret, etc.", HFILL } + }, + { &hf_dtls_handshake_sha_hash, + { "SHA-1 Hash", "dtls.handshake.sha_hash", + FT_NONE, BASE_NONE, NULL, 0x0, + "Hash of messages, master_secret, etc.", HFILL } + }, + { &hf_dtls_handshake_session_id_len, + { "Session ID Length", "dtls.handshake.session_id_length", + FT_UINT8, BASE_DEC, NULL, 0x0, + "Length of session ID field", HFILL } + }, + { &hf_dtls_handshake_dnames_len, + { "Distinguished Names Length", "dtls.handshake.dnames_len", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Length of list of CAs that server trusts", HFILL } + }, + { &hf_dtls_handshake_dnames, + { "Distinguished Names", "dtls.handshake.dnames", + FT_NONE, BASE_NONE, NULL, 0x0, + "List of CAs that server trusts", HFILL } + }, + { &hf_dtls_handshake_dname_len, + { "Distinguished Name Length", "dtls.handshake.dname_len", + FT_UINT16, BASE_DEC, NULL, 0x0, + "Length of distinguished name", HFILL } + }, + { &hf_dtls_handshake_dname, + { "Distinguished Name", "dtls.handshake.dname", + FT_BYTES, BASE_NONE, NULL, 0x0, + "Distinguished name of a CA that server trusts", HFILL } + }, + }; + + /* Setup protocol subtree array */ + static gint *ett[] = { + &ett_dtls, + &ett_dtls_record, + &ett_dtls_alert, + &ett_dtls_handshake, + &ett_dtls_cipher_suites, + &ett_dtls_comp_methods, + &ett_dtls_extension, + &ett_dtls_certs, + &ett_dtls_cert_types, + &ett_dtls_dnames, + }; + + /* Register the protocol name and description */ + proto_dtls = proto_register_protocol("Datagram Transport Layer Security", + "DTLS", "dtls"); + + /* Required function calls to register the header fields and + * subtrees used */ + proto_register_field_array(proto_dtls, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + + { + module_t *dtls_module = prefs_register_protocol(proto_dtls, ssl_parse); + prefs_register_string_preference(dtls_module, "keys_list", "RSA keys list", + "comma separated list of private RSA keys used for DTLS decryption; " + "each list entry must be in the form of <ip>:<port>:<key_file_name>" + "<key_file_name> is the local file name of the RSA private key used by the specified server\n", + (const char **)&dtls_keys_list); + prefs_register_string_preference(dtls_module, "ports_list", "DTLS ports list", + "comma separated list of tcp ports numbers to be dissectes as DTLS; " + "each list entry must be in the form of <port>:<clear-text-port>" + "<clear-text-port> is the port numbert associated with the protocol tunneled over DTLS for this port\n", + (const char **)&dtls_ports_list); + prefs_register_string_preference(dtls_module, "debug_file", "DTLS debug file", + "redirect dtls debug to file name; leave empty to disable debug, " + "use \"" SSL_DEBUG_USE_STDERR "\" to redirect output to stderr\n", + (const char **)&dtls_debug_file_name); + } + + register_dissector("dtls", dissect_dtls, proto_dtls); + + register_init_routine(ssl_init); + ssl_lib_init(); + dtls_tap = register_tap("dtls"); + ssl_debug_printf("proto_register_dtls: registered tap %s:%d\n", + "dtls", dtls_tap); +} + +/* If this dissector uses sub-dissector registration add a registration + * routine. This format is required because a script is used to find + * these routines and create the code that calls these routines. + */ +void +proto_reg_handoff_dtls(void) +{ + dtls_handle = find_dissector("dtls"); + + /* add now dissector to default ports.*/ + ssl_parse(); +} |