/* -*-c-*-
*
- * $Id: packet-tripe.c,v 1.3 2004/04/08 01:36:17 mdw Exp $
+ * $Id$
*
* TrIPE protocol dissector for Ethereal
*
#include <glib.h>
#include <gmodule.h>
-#include <epan/packet.h>
-
-#ifdef ETHEREAL_BUGGERED
-# define plugin_address_table_t void
-# define plugin_address_table_init(x)
-#else
-# include <plugins/plugin_api.h>
-#endif
+#include <ethereal/config.h>
+#include <ethereal/epan/packet.h>
+#include <ethereal/epan/prefs.h>
#include "tripe-protocol.h"
static int proto_tripe = -1;
+static guint hashsz = 20, tagsz = 10, ivsz = 8;
+
typedef struct hfmp {
int hf, hf_len, hf_val, tt;
} hfmp;
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;
/*----- 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)
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);
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:;
}
void proto_register_tripe(void)
{
+ module_t *mod;
+
static value_string vs_kxtype[] = {
{ KX_PRECHAL, "KX_PRECHAL (prechallenge)" },
{ KX_COOKIE, "KX_COOKIE (cookie)" },
};
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[] = {
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)
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();
}
~mdw / tripe / blobdiff