[tripe] / ethereal / packet-tripe.c

/* -*-c-*-
 *
 * $Id: packet-tripe.c,v 1.3 2004/04/08 01:36:17 mdw Exp $
 *
 * TrIPE protocol dissector for Ethereal
 *
 * (c) 2003 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Trivial IP Encryption (TrIPE).
 *
 * TrIPE 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.
 * 
 * TrIPE 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 TrIPE; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <netinet/in.h>

#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 "tripe-protocol.h"

/*----- Static variables --------------------------------------------------*/

static int proto_tripe = -1;

typedef struct hfmp {
  int hf, hf_len, hf_val, tt;
} hfmp;
typedef struct hfge {
  int hf, hf_len, hf_val, hfx_len, hfx_val, hfy_len, hfy_val, tt;
} hfge;

static int hf_tripe_cat = -1;
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_kx_type = -1;
static hfge hf_tripe_kx_mychal = { -1, -1, -1, -1, -1, -1, -1, -1 };
static int hf_tripe_kx_mycookie = -1;
static int hf_tripe_kx_yourcookie = -1;
static hfmp hf_tripe_kx_check = { -1, -1, -1, -1 };
static int hf_tripe_huh = -1;

static int tt_tripe = -1;
static int tt_tripe_ct = -1;

G_MODULE_EXPORT const gchar version[] = VERSION;

/*----- Main code ---------------------------------------------------------*/

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); 
}

static gint getmp(proto_tree *tt, const hfmp *hf, tvbuff_t *b, gint off)
{
  guint16 len = tvb_get_ntohs(b, off);
  proto_item *ti = proto_tree_add_item(tt, hf->hf, b, off, len + 2, FALSE);
  tt = proto_item_add_subtree(ti, hf->tt);
  proto_tree_add_item(tt, hf->hf_len, b, off, 2, FALSE);
  proto_tree_add_item(tt, hf->hf_val, b, off + 2, len, FALSE);
  return (off + 2 + len);
}

static gint getge(proto_tree *tt, const hfge *hf, tvbuff_t *b, gint off)
{
  guint16 len = tvb_get_ntohs(b, off), len2;
  guint r;
  proto_item *ti;
  r = tvb_length_remaining(b, off);
  if (r < 4 + len ||
      (len2 = tvb_get_ntohs(b, off + 2 + len), r < 4 + len + len2)) {
    ti = proto_tree_add_item(tt, hf->hf, b, off, len + 2, FALSE);
    tt = proto_item_add_subtree(ti, hf->tt);
    proto_tree_add_item(tt, hf->hf_len, b, off, 2, FALSE);
    proto_tree_add_item(tt, hf->hf_val, b, off + 2, len, FALSE);
    r = off + len + 2;
  } else {
    ti = proto_tree_add_item(tt, hf->hf, b, off, len + len2 + 4, FALSE);
    tt = proto_item_add_subtree(ti, hf->tt);
    proto_tree_add_item(tt, hf->hfx_len, b, off, 2, FALSE);
    proto_tree_add_item(tt, hf->hfx_val, b, off + 2, len, FALSE);
    proto_tree_add_item(tt, hf->hfy_len, b, off + 2 + len, 2, FALSE);
    proto_tree_add_item(tt, hf->hfy_val, b, off + 4 + len, len2, FALSE);
    r = off + len + len2 + 4;
  }    
  return (r);
}

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);
  guint32 seq;

  /* --- Initialize the summary cells --- */

  if (check_col(p->cinfo, COL_PROTOCOL))
    col_set_str(p->cinfo, COL_PROTOCOL, "TrIPE");
  ty = tvb_get_guint8(b, 0);
  if (check_col(p->cinfo, COL_INFO)) {
    col_clear(p->cinfo, COL_INFO);
    switch (ty & MSG_CATMASK) {
      case MSG_PACKET:
	switch (ty & MSG_TYPEMASK) {
	  case 0:
	    col_set_str(p->cinfo, COL_INFO, "Packet data");
	    break;
	  default:
	    col_add_fstr(p->cinfo, COL_INFO,
			 "Packet data, unknown type code %u",
			 ty & MSG_TYPEMASK);
	    break;
	}
	break;
      case MSG_KEYEXCH:
	switch (ty & MSG_TYPEMASK) {
	  case KX_PRECHAL:
	    col_set_str(p->cinfo, COL_INFO, "Key exchange, prechallenge");
	    break;
	  case KX_COOKIE:
	    col_set_str(p->cinfo, COL_INFO, "Key exchange, cookie");
	    break;
	  case KX_CHAL:
	    col_set_str(p->cinfo, COL_INFO, "Key exchange, challenge");
	    break;
	  case KX_REPLY:
	    col_set_str(p->cinfo, COL_INFO, "Key exchange, reply");
	    break;
	  case KX_SWITCH:
	    col_set_str(p->cinfo, COL_INFO, "Key exchange, switch request");
	    break;
	  case KX_SWITCHOK:
	    col_set_str(p->cinfo, COL_INFO, "Key exchange, switch response");
	    break;
	  default:
	    col_add_fstr(p->cinfo, COL_INFO,
			 "Key exchange, unknown type code %u",
			 ty & MSG_TYPEMASK);
	    break;
	}
	break;
      default:
	col_add_fstr(p->cinfo, COL_INFO,
		     "Unknown category code %u, unknown type code %u",
		     ty & MSG_CATMASK, ty & MSG_TYPEMASK);
	break;
    }
  }

  /* --- Fill in the tree --- */

  if (t) {
    ti = proto_tree_add_item(t, proto_tripe, b, 0, -1, FALSE);
    tt = proto_item_add_subtree(ti, tt_tripe);

    proto_tree_add_item(tt, hf_tripe_cat, b, 0, 1, FALSE);

    off = 1;
    switch (ty & MSG_CATMASK) {
      case MSG_PACKET:
	proto_tree_add_item(tt, hf_tripe_packet_type, b, 0, 1, FALSE);
	switch (ty & MSG_TYPEMASK) {
	  case 0:
	    goto ct;
	  default:
	    goto huh;
	}
	break;
      case MSG_KEYEXCH:
	proto_tree_add_item(tt, hf_tripe_kx_type, b, 0, 1, FALSE);
	switch (ty & MSG_TYPEMASK) {
	  case KX_PRECHAL:
	    off = getge(tt, &hf_tripe_kx_mychal, b, off);
	    goto tail;
	  case KX_COOKIE:
	    off = getge(tt, &hf_tripe_kx_mychal, b, off);
	    off = gethash(tt, hf_tripe_kx_yourcookie, b, off);
	    goto tail;
	  case KX_CHAL:
	    off = getge(tt, &hf_tripe_kx_mychal, b, off);
	    off = gethash(tt, hf_tripe_kx_yourcookie, b, off);
	    off = getmp(tt, &hf_tripe_kx_check, b, off);
	    goto tail;
	  case KX_REPLY:
	    off = gethash(tt, hf_tripe_kx_mycookie, b, off);
	    off = gethash(tt, hf_tripe_kx_yourcookie, b, off);
	    off = getmp(tt, &hf_tripe_kx_check, b, off);
	    goto ct;
	  case KX_SWITCH:
	    off = gethash(tt, hf_tripe_kx_mycookie, b, off);
	    off = gethash(tt, hf_tripe_kx_yourcookie, b, off);
	    goto ct;
	  case KX_SWITCHOK:
	    goto ct;
	  default:
	    goto huh;
	}
	break;
      default:
	goto huh;
    }
  tail:
    if (tvb_offset_exists(b, off))
      goto huh;
    goto done;
  huh:
    proto_tree_add_item(tt, hf_tripe_huh, b, off, -1, FALSE);
    goto done;
  ct:
    ti = proto_tree_add_item(tt, hf_tripe_ct, b, off, -1, FALSE);
    seq = tvb_get_ntohl(b, off + 10);
    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;
    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);
    goto done;
  done:;
  }  
}

void proto_register_tripe(void)
{
  static value_string vs_kxtype[] = {
    { KX_PRECHAL,	"KX_PRECHAL (prechallenge)" },
    { KX_COOKIE,	"KX_COOKIE (cookie)" },
    { KX_CHAL,		"KX_CHAL (challenge)" },
    { KX_REPLY,		"KX_REPLY (reply)" },
    { KX_SWITCH,	"KX_SWITCH (switch request)" },
    { KX_SWITCHOK,	"KX_SWITCHOK (switch response)" },
    { 0,		0 }
  };

  static hf_register_info hfs[] = {
    &hf_tripe_cat, {
      "Message category", "tripe.cat",
      FT_UINT8, BASE_HEX, 0, MSG_CATMASK
    },
    &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, {
      "Encrypted ciphertext", "tripe.ct",
      FT_BYTES, BASE_NONE, 0, 0,
      "This is an encrypted message."
    },
    &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, {
      "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",
      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",
      FT_BYTES, BASE_NONE, 0, 0,
      "This is the message authentication code 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, {
      "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, {
      "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, {
      "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, {
      "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, {
      "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, {
      "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, {
      "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, {
      "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, {
      "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, {
      "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, {
      "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, {
      "Check-value data", "tripe.kx.check.val",
      FT_BYTES, BASE_NONE, 0, 0,
      "This is the actual encrypted check-value."
    },
    &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[] = {
    &tt_tripe,
    &tt_tripe_ct,
    &hf_tripe_kx_mychal.tt,
    &hf_tripe_kx_check.tt,
  };

  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));
}

void proto_reg_handoff_tripe(void)
{
  dissector_handle_t dh;

  dh = create_dissector_handle(dissect_tripe, proto_tripe);
  dissector_add("udp.port", 22003, dh);
}

G_MODULE_EXPORT void plugin_reg_handoff(void)
{
  proto_reg_handoff_tripe();
}

G_MODULE_EXPORT void plugin_init(plugin_address_table_t *pat)
{
  plugin_address_table_init(pat);
  if (proto_tripe == -1)
    proto_register_tripe();
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
165db1a8	1	/* --c--
165db1a8	2	*
b4e56668	3	* $Id: packet-tripe.c,v 1.3 2004/04/08 01:36:17 mdw Exp $
165db1a8	4	*
	5	* TrIPE protocol dissector for Ethereal
	6	*
	7	* (c) 2003 Straylight/Edgeware
	8	*/
	9
	10	/----- Licensing notice --------------------------------------------------
	11	*
	12	* This file is part of Trivial IP Encryption (TrIPE).
	13	*
	14	* TrIPE is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU General Public License as published by
	16	* the Free Software Foundation; either version 2 of the License, or
	17	* (at your option) any later version.
	18	*
	19	* TrIPE is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU General Public License
	25	* along with TrIPE; if not, write to the Free Software Foundation,
	26	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	27	*/
	28
165db1a8	29	/----- Header files ------------------------------------------------------/
	30
	31	#include "config.h"
	32
	33	#include <stdio.h>
	34	#include <stdlib.h>
	35	#include <string.h>
	36
	37	#include <netinet/in.h>
	38
	39	#include <glib.h>
	40	#include <gmodule.h>
	41	#include <epan/packet.h>
	42
	43	#ifdef ETHEREAL_BUGGERED
	44	# define plugin_address_table_t void
	45	# define plugin_address_table_init(x)
	46	#else
	47	# include <plugins/plugin_api.h>
	48	#endif
	49
	50	#include "tripe-protocol.h"
	51
	52	/----- Static variables --------------------------------------------------/
	53
	54	static int proto_tripe = -1;
	55
52c03a2a	56	typedef struct hfmp {
	57	int hf, hf_len, hf_val, tt;
	58	} hfmp;
	59	typedef struct hfge {
	60	int hf, hf_len, hf_val, hfx_len, hfx_val, hfy_len, hfy_val, tt;
	61	} hfge;
165db1a8	62
	63	static int hf_tripe_cat = -1;
	64	static int hf_tripe_packet_type = -1;
	65	static int hf_tripe_ct = -1;
	66	static int hf_tripe_ct_seq = -1;
	67	static int hf_tripe_ct_iv = -1;
	68	static int hf_tripe_ct_cbc = -1;
	69	static int hf_tripe_ct_mac = -1;
	70	static int hf_tripe_kx_type = -1;
52c03a2a	71	static hfge hf_tripe_kx_mychal = { -1, -1, -1, -1, -1, -1, -1, -1 };
165db1a8	72	static int hf_tripe_kx_mycookie = -1;
	73	static int hf_tripe_kx_yourcookie = -1;
	74	static hfmp hf_tripe_kx_check = { -1, -1, -1, -1 };
	75	static int hf_tripe_huh = -1;
	76
	77	static int tt_tripe = -1;
	78	static int tt_tripe_ct = -1;
	79
	80	G_MODULE_EXPORT const gchar version[] = VERSION;
	81
	82	/----- Main code ---------------------------------------------------------/
	83
	84	static gint gethash(proto_tree tt, int hf, tvbuff_t b, gint off)
	85	{
	86	proto_tree_add_item(tt, hf, b, off, 20, FALSE);
	87	return (off + 20);
	88	}
	89
	90	static gint getmp(proto_tree tt, const hfmp hf, tvbuff_t *b, gint off)
	91	{
	92	guint16 len = tvb_get_ntohs(b, off);
	93	proto_item *ti = proto_tree_add_item(tt, hf->hf, b, off, len + 2, FALSE);
	94	tt = proto_item_add_subtree(ti, hf->tt);
	95	proto_tree_add_item(tt, hf->hf_len, b, off, 2, FALSE);
	96	proto_tree_add_item(tt, hf->hf_val, b, off + 2, len, FALSE);
	97	return (off + 2 + len);
	98	}
	99
52c03a2a	100	static gint getge(proto_tree tt, const hfge hf, tvbuff_t *b, gint off)
	101	{
	102	guint16 len = tvb_get_ntohs(b, off), len2;
	103	guint r;
	104	proto_item *ti;
	105	r = tvb_length_remaining(b, off);
	106	if (r < 4 + len \|\|
	107	(len2 = tvb_get_ntohs(b, off + 2 + len), r < 4 + len + len2)) {
	108	ti = proto_tree_add_item(tt, hf->hf, b, off, len + 2, FALSE);
	109	tt = proto_item_add_subtree(ti, hf->tt);
	110	proto_tree_add_item(tt, hf->hf_len, b, off, 2, FALSE);
	111	proto_tree_add_item(tt, hf->hf_val, b, off + 2, len, FALSE);
	112	r = off + len + 2;
	113	} else {
	114	ti = proto_tree_add_item(tt, hf->hf, b, off, len + len2 + 4, FALSE);
	115	tt = proto_item_add_subtree(ti, hf->tt);
	116	proto_tree_add_item(tt, hf->hfx_len, b, off, 2, FALSE);
	117	proto_tree_add_item(tt, hf->hfx_val, b, off + 2, len, FALSE);
	118	proto_tree_add_item(tt, hf->hfy_len, b, off + 2 + len, 2, FALSE);
	119	proto_tree_add_item(tt, hf->hfy_val, b, off + 4 + len, len2, FALSE);
	120	r = off + len + len2 + 4;
	121	}
	122	return (r);
	123	}
	124
165db1a8	125	static void dissect_tripe(tvbuff_t b, packet_info p, proto_tree *t)
	126	{
	127	proto_item *ti;
	128	proto_tree *tt;
	129	guint8 ty;
	130	gint off = tvb_raw_offset(b);
	131	guint32 seq;
	132
	133	/* --- Initialize the summary cells --- */
	134
	135	if (check_col(p->cinfo, COL_PROTOCOL))
	136	col_set_str(p->cinfo, COL_PROTOCOL, "TrIPE");
	137	ty = tvb_get_guint8(b, 0);
	138	if (check_col(p->cinfo, COL_INFO)) {
	139	col_clear(p->cinfo, COL_INFO);
	140	switch (ty & MSG_CATMASK) {
	141	case MSG_PACKET:
	142	switch (ty & MSG_TYPEMASK) {
	143	case 0:
	144	col_set_str(p->cinfo, COL_INFO, "Packet data");
	145	break;
	146	default:
	147	col_add_fstr(p->cinfo, COL_INFO,
	148	"Packet data, unknown type code %u",
	149	ty & MSG_TYPEMASK);
	150	break;
	151	}
	152	break;
	153	case MSG_KEYEXCH:
	154	switch (ty & MSG_TYPEMASK) {
	155	case KX_PRECHAL:
	156	col_set_str(p->cinfo, COL_INFO, "Key exchange, prechallenge");
	157	break;
	158	case KX_COOKIE:
	159	col_set_str(p->cinfo, COL_INFO, "Key exchange, cookie");
	160	break;
	161	case KX_CHAL:
	162	col_set_str(p->cinfo, COL_INFO, "Key exchange, challenge");
	163	break;
	164	case KX_REPLY:
	165	col_set_str(p->cinfo, COL_INFO, "Key exchange, reply");
	166	break;
	167	case KX_SWITCH:
	168	col_set_str(p->cinfo, COL_INFO, "Key exchange, switch request");
	169	break;
	170	case KX_SWITCHOK:
	171	col_set_str(p->cinfo, COL_INFO, "Key exchange, switch response");
	172	break;
	173	default:
	174	col_add_fstr(p->cinfo, COL_INFO,
	175	"Key exchange, unknown type code %u",
	176	ty & MSG_TYPEMASK);
	177	break;
	178	}
	179	break;
	180	default:
	181	col_add_fstr(p->cinfo, COL_INFO,
	182	"Unknown category code %u, unknown type code %u",
	183	ty & MSG_CATMASK, ty & MSG_TYPEMASK);
	184	break;
	185	}
	186	}
	187
	188	/* --- Fill in the tree --- */
189
190	if (t) {
191	ti = proto_tree_add_item(t, proto_tripe, b, 0, -1, FALSE);
192	tt = proto_item_add_subtree(ti, tt_tripe);
193
194	proto_tree_add_item(tt, hf_tripe_cat, b, 0, 1, FALSE);
195
196	off = 1;
197	switch (ty & MSG_CATMASK) {
198	case MSG_PACKET:
199	proto_tree_add_item(tt, hf_tripe_packet_type, b, 0, 1, FALSE);
200	switch (ty & MSG_TYPEMASK) {
201	case 0:
202	goto ct;
203	default:
204	goto huh;
205	}
206	break;
207	case MSG_KEYEXCH:
208	proto_tree_add_item(tt, hf_tripe_kx_type, b, 0, 1, FALSE);
209	switch (ty & MSG_TYPEMASK) {
210	case KX_PRECHAL:
52c03a2a	211	off = getge(tt, &hf_tripe_kx_mychal, b, off);
165db1a8	212	goto tail;
165db1a8	213	case KX_COOKIE:
52c03a2a	214	off = getge(tt, &hf_tripe_kx_mychal, b, off);
165db1a8	215	off = gethash(tt, hf_tripe_kx_yourcookie, b, off);
	216	goto tail;
	217	case KX_CHAL:
52c03a2a	218	off = getge(tt, &hf_tripe_kx_mychal, b, off);
165db1a8	219	off = gethash(tt, hf_tripe_kx_yourcookie, b, off);
	220	off = getmp(tt, &hf_tripe_kx_check, b, off);
	221	goto tail;
	222	case KX_REPLY:
	223	off = gethash(tt, hf_tripe_kx_mycookie, b, off);
	224	off = gethash(tt, hf_tripe_kx_yourcookie, b, off);
	225	off = getmp(tt, &hf_tripe_kx_check, b, off);
	226	goto ct;
	227	case KX_SWITCH:
	228	off = gethash(tt, hf_tripe_kx_mycookie, b, off);
	229	off = gethash(tt, hf_tripe_kx_yourcookie, b, off);
	230	goto ct;
	231	case KX_SWITCHOK:
	232	goto ct;
	233	default:
	234	goto huh;
	235	}
	236	break;
	237	default:
	238	goto huh;
	239	}
	240	tail:
	241	if (tvb_offset_exists(b, off))
	242	goto huh;
	243	goto done;
	244	huh:
	245	proto_tree_add_item(tt, hf_tripe_huh, b, off, -1, FALSE);
	246	goto done;
	247	ct:
	248	ti = proto_tree_add_item(tt, hf_tripe_ct, b, off, -1, FALSE);
	249	seq = tvb_get_ntohl(b, off + 10);
	250	proto_item_set_text(ti, "Encrypted ciphertext (sequence number %lu)",
	251	(unsigned long)seq);
	252	tt = proto_item_add_subtree(ti, tt_tripe_ct);
	253	proto_tree_add_item(tt, hf_tripe_ct_mac, b, off, 10, FALSE);
	254	off += 10;
	255	proto_tree_add_item(tt, hf_tripe_ct_seq, b, off, 4, FALSE);
	256	off += 4;
	257	proto_tree_add_item(tt, hf_tripe_ct_iv, b, off, 8, FALSE);
	258	off += 8;
	259	proto_tree_add_item(ti, hf_tripe_ct_cbc, b, off, -1, FALSE);
	260	goto done;
	261	done:;
	262	}
	263	}
	264
	265	void proto_register_tripe(void)
	266	{
	267	static value_string vs_kxtype[] = {
	268	{ KX_PRECHAL, "KX_PRECHAL (prechallenge)" },
	269	{ KX_COOKIE, "KX_COOKIE (cookie)" },
	270	{ KX_CHAL, "KX_CHAL (challenge)" },
	271	{ KX_REPLY, "KX_REPLY (reply)" },
	272	{ KX_SWITCH, "KX_SWITCH (switch request)" },
	273	{ KX_SWITCHOK, "KX_SWITCHOK (switch response)" },
	274	{ 0, 0 }
	275	};
	276
	277	static hf_register_info hfs[] = {
	278	&hf_tripe_cat, {
	279	"Message category", "tripe.cat",
	280	FT_UINT8, BASE_HEX, 0, MSG_CATMASK
	281	},
	282	&hf_tripe_packet_type, {
283	"Packet message type", "tripe.packet.type",
284	FT_UINT8, BASE_HEX, 0, MSG_TYPEMASK,
285	"This is the TrIPE packet type subcode."
286	},
287	&hf_tripe_ct, {
288	"Encrypted ciphertext", "tripe.ct",
289	FT_BYTES, BASE_NONE, 0, 0,
290	"This is an encrypted message."
291	},
292	&hf_tripe_ct_seq, {
293	"Ciphertext sequence number", "tripe.ct.seq",
294	FT_UINT32, BASE_DEC, 0, 0,
295	"This is the unique sequence number for the ciphertext."
296	},
297	&hf_tripe_ct_iv, {
298	"Ciphertext initialization vector", "tripe.ct.iv",
299	FT_BYTES, BASE_NONE, 0, 0,
300	"This is the initialization vector used for the actual encryption."
301	},
302	&hf_tripe_ct_cbc, {
303	"CBC-encrypted data", "tripe.ct.cbc",
304	FT_BYTES, BASE_NONE, 0, 0,
305	"This is the CBC-encrypted message. Reading it ought to be hard."
306	},
307	&hf_tripe_ct_mac, {
308	"Message authentication code", "tripe.ct.mac",
309	FT_BYTES, BASE_NONE, 0, 0,
310	"This is the message authentication code for the ciphertext."
311	},
312	&hf_tripe_kx_type, {
313	"Key-exchange message type", "tripe.kx.type",
314	FT_UINT8, BASE_HEX, vs_kxtype, MSG_TYPEMASK,
315	"This is the TrIPE key-exchange type subcode."
316	},
317	&hf_tripe_kx_mychal.hf, {
318	"Sender's challenge data", "tripe.kx.mychal",
319	FT_BYTES, BASE_NONE, 0, 0,
52c03a2a	320	"This is the sender's challenge."
165db1a8	321	},
	322	&hf_tripe_kx_mychal.hf_len, {
	323	"Challenge length", "tripe.kx.mychal.len",
	324	FT_UINT16, BASE_DEC, 0, 0,
52c03a2a	325	"This is the length of the sender's challenge."
165db1a8	326	},
165db1a8	327	&hf_tripe_kx_mychal.hf_val, {
52c03a2a	328	"Challenge", "tripe.kx.mychal.val",
	329	FT_BYTES, BASE_NONE, 0, 0,
	330	"This is the value of the sender's challenge."
	331	},
	332	&hf_tripe_kx_mychal.hfx_len, {
	333	"Challenge x length", "tripe.kx.mychal.x.len",
	334	FT_UINT16, BASE_DEC, 0, 0,
	335	"This is the length of the sender's challenge x-coordinate."
	336	},
	337	&hf_tripe_kx_mychal.hfy_val, {
	338	"Challenge x value", "tripe.kx.mychal.x.val",
	339	FT_BYTES, BASE_NONE, 0, 0,
	340	"This is the value of the sender's challenge x-coordinate."
	341	},
	342	&hf_tripe_kx_mychal.hfy_len, {
	343	"Challenge y length", "tripe.kx.mychal.y.len",
	344	FT_UINT16, BASE_DEC, 0, 0,
	345	"This is the length of the sender's challenge x-coordinate."
	346	},
	347	&hf_tripe_kx_mychal.hfx_val, {
	348	"Challenge y value", "tripe.kx.mychal.y.val",
165db1a8	349	FT_BYTES, BASE_NONE, 0, 0,
52c03a2a	350	"This is the value of the sender's challenge x-coordinate."
165db1a8	351	},
	352	&hf_tripe_kx_mycookie, {
	353	"Sender's hashed cookie", "tripe.kx.mycookie",
	354	FT_BYTES, BASE_NONE, 0, 0,
	355	"This is the hash of the sender's challenge."
	356	},
	357	&hf_tripe_kx_yourcookie, {
	358	"Recipient's hashed cookie", "tripe.kx.yourcookie",
	359	FT_BYTES, BASE_NONE, 0, 0,
	360	"This is the hash of the recipient's challenge."
	361	},
	362	&hf_tripe_kx_check.hf, {
	363	"Challenge check-value", "tripe.kx.check",
	364	FT_BYTES, BASE_NONE, 0, 0,
	365	"This is an encrypted check-value which proves that the sender "
	366	"knows the answer to the challenge, and that it is therefore honest."
	367	},
	368	&hf_tripe_kx_check.hf_len, {
	369	"Check-value length", "tripe.kx.check.len",
	370	FT_UINT16, BASE_DEC, 0, 0,
	371	"This is the length of the encrypted check-value."
	372	},
	373	&hf_tripe_kx_check.hf_val, {
	374	"Check-value data", "tripe.kx.check.val",
	375	FT_BYTES, BASE_NONE, 0, 0,
	376	"This is the actual encrypted check-value."
	377	},
	378	&hf_tripe_huh, {
	379	"Unknown data", "tripe.huh",
	380	FT_BYTES, BASE_NONE, 0, 0,
	381	"I don't know what's meant to appear here."
	382	},
	383	};
	384
	385	static gint *tts[] = {
	386	&tt_tripe,
	387	&tt_tripe_ct,
	388	&hf_tripe_kx_mychal.tt,
	389	&hf_tripe_kx_check.tt,
	390	};
	391
	392	proto_tripe = proto_register_protocol("TrIPE", "TrIPE", "tripe");
	393	proto_register_field_array(proto_tripe, hfs, array_length(hfs));
	394	proto_register_subtree_array(tts, array_length(tts));
	395	}
	396
	397	void proto_reg_handoff_tripe(void)
	398	{
	399	dissector_handle_t dh;
	400
	401	dh = create_dissector_handle(dissect_tripe, proto_tripe);
	402	dissector_add("udp.port", 22003, dh);
	403	}
	404
	405	G_MODULE_EXPORT void plugin_reg_handoff(void)
	406	{
	407	proto_reg_handoff_tripe();
	408	}
	409
	410	G_MODULE_EXPORT void plugin_init(plugin_address_table_t *pat)
	411	{
	412	plugin_address_table_init(pat);
	413	if (proto_tripe == -1)
	414	proto_register_tripe();
415	}
416
417	/----- That's all, folks -------------------------------------------------/