chiark - git - mdw - tripe/blob - wireshark/packet-tripe.c

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