X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~mdw/git/tripe/blobdiff_plain/b4e566689f469cc1cffe99e50e16a346d0f9832d..3cdc3f3a27e8c4f4fe692009d868c773d298a68c:/ethereal/packet-tripe.c diff --git a/ethereal/packet-tripe.c b/ethereal/packet-tripe.c index 4b4e0ace..aaad0ec9 100644 --- a/ethereal/packet-tripe.c +++ b/ethereal/packet-tripe.c @@ -1,6 +1,6 @@ /* -*-c-*- * - * $Id: packet-tripe.c,v 1.3 2004/04/08 01:36:17 mdw Exp $ + * $Id$ * * TrIPE protocol dissector for Ethereal * @@ -38,14 +38,9 @@ #include #include -#include - -#ifdef ETHEREAL_BUGGERED -# define plugin_address_table_t void -# define plugin_address_table_init(x) -#else -# include -#endif +#include +#include +#include #include "tripe-protocol.h" @@ -53,6 +48,8 @@ static int proto_tripe = -1; +static guint hashsz = 20, tagsz = 10, ivsz = 8; + typedef struct hfmp { int hf, hf_len, hf_val, tt; } hfmp; @@ -65,8 +62,8 @@ static int hf_tripe_packet_type = -1; static int hf_tripe_ct = -1; static int hf_tripe_ct_seq = -1; static int hf_tripe_ct_iv = -1; -static int hf_tripe_ct_cbc = -1; -static int hf_tripe_ct_mac = -1; +static int hf_tripe_ct_ct = -1; +static int hf_tripe_ct_tag = -1; static int hf_tripe_kx_type = -1; static hfge hf_tripe_kx_mychal = { -1, -1, -1, -1, -1, -1, -1, -1 }; static int hf_tripe_kx_mycookie = -1; @@ -81,10 +78,12 @@ G_MODULE_EXPORT const gchar version[] = VERSION; /*----- Main code ---------------------------------------------------------*/ +static void prefcb(void) { } + static gint gethash(proto_tree *tt, int hf, tvbuff_t *b, gint off) { - proto_tree_add_item(tt, hf, b, off, 20, FALSE); - return (off + 20); + proto_tree_add_item(tt, hf, b, off, hashsz, FALSE); + return (off + hashsz); } static gint getmp(proto_tree *tt, const hfmp *hf, tvbuff_t *b, gint off) @@ -127,13 +126,15 @@ static void dissect_tripe(tvbuff_t *b, packet_info *p, proto_tree *t) proto_item *ti; proto_tree *tt; guint8 ty; - gint off = tvb_raw_offset(b); + gint off = 0; guint32 seq; /* --- Initialize the summary cells --- */ if (check_col(p->cinfo, COL_PROTOCOL)) col_set_str(p->cinfo, COL_PROTOCOL, "TrIPE"); + if (check_col(p->cinfo, COL_INFO)) + col_clear(p->cinfo, COL_INFO); ty = tvb_get_guint8(b, 0); if (check_col(p->cinfo, COL_INFO)) { col_clear(p->cinfo, COL_INFO); @@ -246,17 +247,21 @@ static void dissect_tripe(tvbuff_t *b, packet_info *p, proto_tree *t) goto done; ct: ti = proto_tree_add_item(tt, hf_tripe_ct, b, off, -1, FALSE); - seq = tvb_get_ntohl(b, off + 10); + seq = tvb_get_ntohl(b, off + tagsz); proto_item_set_text(ti, "Encrypted ciphertext (sequence number %lu)", (unsigned long)seq); tt = proto_item_add_subtree(ti, tt_tripe_ct); - proto_tree_add_item(tt, hf_tripe_ct_mac, b, off, 10, FALSE); - off += 10; + if (tagsz) { + proto_tree_add_item(tt, hf_tripe_ct_tag, b, off, tagsz, FALSE); + off += tagsz; + } proto_tree_add_item(tt, hf_tripe_ct_seq, b, off, 4, FALSE); off += 4; - proto_tree_add_item(tt, hf_tripe_ct_iv, b, off, 8, FALSE); - off += 8; - proto_tree_add_item(ti, hf_tripe_ct_cbc, b, off, -1, FALSE); + if (ivsz) { + proto_tree_add_item(tt, hf_tripe_ct_iv, b, off, ivsz, FALSE); + off += ivsz; + } + proto_tree_add_item(ti, hf_tripe_ct_ct, b, off, -1, FALSE); goto done; done:; } @@ -264,6 +269,8 @@ static void dissect_tripe(tvbuff_t *b, packet_info *p, proto_tree *t) void proto_register_tripe(void) { + module_t *mod; + static value_string vs_kxtype[] = { { KX_PRECHAL, "KX_PRECHAL (prechallenge)" }, { KX_COOKIE, "KX_COOKIE (cookie)" }, @@ -275,111 +282,111 @@ void proto_register_tripe(void) }; static hf_register_info hfs[] = { - &hf_tripe_cat, { + { &hf_tripe_cat, { "Message category", "tripe.cat", FT_UINT8, BASE_HEX, 0, MSG_CATMASK - }, - &hf_tripe_packet_type, { + } }, + { &hf_tripe_packet_type, { "Packet message type", "tripe.packet.type", FT_UINT8, BASE_HEX, 0, MSG_TYPEMASK, "This is the TrIPE packet type subcode." - }, - &hf_tripe_ct, { + } }, + { &hf_tripe_ct, { "Encrypted ciphertext", "tripe.ct", FT_BYTES, BASE_NONE, 0, 0, "This is an encrypted message." - }, - &hf_tripe_ct_seq, { + } }, + { &hf_tripe_ct_seq, { "Ciphertext sequence number", "tripe.ct.seq", FT_UINT32, BASE_DEC, 0, 0, "This is the unique sequence number for the ciphertext." - }, - &hf_tripe_ct_iv, { + } }, + { &hf_tripe_ct_iv, { "Ciphertext initialization vector", "tripe.ct.iv", FT_BYTES, BASE_NONE, 0, 0, "This is the initialization vector used for the actual encryption." - }, - &hf_tripe_ct_cbc, { - "CBC-encrypted data", "tripe.ct.cbc", + } }, + { &hf_tripe_ct_ct, { + "Actual encrypted data", "tripe.ct.ct", FT_BYTES, BASE_NONE, 0, 0, - "This is the CBC-encrypted message. Reading it ought to be hard." - }, - &hf_tripe_ct_mac, { - "Message authentication code", "tripe.ct.mac", + "This is the encrypted message. Reading it ought to be hard." + } }, + { &hf_tripe_ct_tag, { + "Message authentication code", "tripe.ct.tag", FT_BYTES, BASE_NONE, 0, 0, - "This is the message authentication code for the ciphertext." - }, - &hf_tripe_kx_type, { + "This is the message authentication code tag for the ciphertext." + } }, + { &hf_tripe_kx_type, { "Key-exchange message type", "tripe.kx.type", FT_UINT8, BASE_HEX, vs_kxtype, MSG_TYPEMASK, "This is the TrIPE key-exchange type subcode." - }, - &hf_tripe_kx_mychal.hf, { + } }, + { &hf_tripe_kx_mychal.hf, { "Sender's challenge data", "tripe.kx.mychal", FT_BYTES, BASE_NONE, 0, 0, "This is the sender's challenge." - }, - &hf_tripe_kx_mychal.hf_len, { + } }, + { &hf_tripe_kx_mychal.hf_len, { "Challenge length", "tripe.kx.mychal.len", FT_UINT16, BASE_DEC, 0, 0, "This is the length of the sender's challenge." - }, - &hf_tripe_kx_mychal.hf_val, { + } }, + { &hf_tripe_kx_mychal.hf_val, { "Challenge", "tripe.kx.mychal.val", FT_BYTES, BASE_NONE, 0, 0, "This is the value of the sender's challenge." - }, - &hf_tripe_kx_mychal.hfx_len, { + } }, + { &hf_tripe_kx_mychal.hfx_len, { "Challenge x length", "tripe.kx.mychal.x.len", FT_UINT16, BASE_DEC, 0, 0, "This is the length of the sender's challenge x-coordinate." - }, - &hf_tripe_kx_mychal.hfy_val, { + } }, + { &hf_tripe_kx_mychal.hfy_val, { "Challenge x value", "tripe.kx.mychal.x.val", FT_BYTES, BASE_NONE, 0, 0, "This is the value of the sender's challenge x-coordinate." - }, - &hf_tripe_kx_mychal.hfy_len, { + } }, + { &hf_tripe_kx_mychal.hfy_len, { "Challenge y length", "tripe.kx.mychal.y.len", FT_UINT16, BASE_DEC, 0, 0, "This is the length of the sender's challenge x-coordinate." - }, - &hf_tripe_kx_mychal.hfx_val, { + } }, + { &hf_tripe_kx_mychal.hfx_val, { "Challenge y value", "tripe.kx.mychal.y.val", FT_BYTES, BASE_NONE, 0, 0, "This is the value of the sender's challenge x-coordinate." - }, - &hf_tripe_kx_mycookie, { + } }, + { &hf_tripe_kx_mycookie, { "Sender's hashed cookie", "tripe.kx.mycookie", FT_BYTES, BASE_NONE, 0, 0, "This is the hash of the sender's challenge." - }, - &hf_tripe_kx_yourcookie, { + } }, + { &hf_tripe_kx_yourcookie, { "Recipient's hashed cookie", "tripe.kx.yourcookie", FT_BYTES, BASE_NONE, 0, 0, "This is the hash of the recipient's challenge." - }, - &hf_tripe_kx_check.hf, { + } }, + { &hf_tripe_kx_check.hf, { "Challenge check-value", "tripe.kx.check", FT_BYTES, BASE_NONE, 0, 0, "This is an encrypted check-value which proves that the sender " "knows the answer to the challenge, and that it is therefore honest." - }, - &hf_tripe_kx_check.hf_len, { + } }, + { &hf_tripe_kx_check.hf_len, { "Check-value length", "tripe.kx.check.len", FT_UINT16, BASE_DEC, 0, 0, "This is the length of the encrypted check-value." - }, - &hf_tripe_kx_check.hf_val, { + } }, + { &hf_tripe_kx_check.hf_val, { "Check-value data", "tripe.kx.check.val", FT_BYTES, BASE_NONE, 0, 0, "This is the actual encrypted check-value." - }, - &hf_tripe_huh, { + } }, + { &hf_tripe_huh, { "Unknown data", "tripe.huh", FT_BYTES, BASE_NONE, 0, 0, "I don't know what's meant to appear here." - }, + } }, }; static gint *tts[] = { @@ -392,6 +399,17 @@ void proto_register_tripe(void) proto_tripe = proto_register_protocol("TrIPE", "TrIPE", "tripe"); proto_register_field_array(proto_tripe, hfs, array_length(hfs)); proto_register_subtree_array(tts, array_length(tts)); + + mod = prefs_register_protocol(proto_tripe, prefcb); + prefs_register_uint_preference(mod, "hashsz", "Hash length", + "hash function output length (in octets)", + 10, &hashsz); + prefs_register_uint_preference(mod, "tagsz", "MAC tag length", + "MAC tag length (in octets)", 10, &tagsz); + prefs_register_uint_preference(mod, "ivsz", "IV length", + "block cipher initialization vector length" + " (in octets)", + 10, &ivsz); } void proto_reg_handoff_tripe(void) @@ -407,9 +425,8 @@ G_MODULE_EXPORT void plugin_reg_handoff(void) proto_reg_handoff_tripe(); } -G_MODULE_EXPORT void plugin_init(plugin_address_table_t *pat) +G_MODULE_EXPORT void plugin_register(void) { - plugin_address_table_init(pat); if (proto_tripe == -1) proto_register_tripe(); }