epan/dissectors/packet-hdcp2.c

   1 /* packet-hdcp2.c
   2  * Routines for HDCP2 dissection
   3  * Copyright 2011-2012, Martin Kaiser <martin@kaiser.cx>
   4  *
   5  * $Id$
   6  *
   7  * Wireshark - Network traffic analyzer
   8  * By Gerald Combs <gerald@wireshark.org>
   9  * Copyright 1998 Gerald Combs
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License along
  22  * with this program; if not, write to the Free Software Foundation, Inc.,
  23  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25
  26 /*
  27  * This dissector supports HDCP 2.x over TCP. For now, only the
  28  * authentication protocol messages are supported.
  29  *
  30  * The specification of version 2 of the protocol can be found at
  31  * http://www.digital-cp.com/files/static_page_files/DABB540C-1A4B-B294-D0008CB2D348FA19/HDCP Interface Independent Adaptation Specification Rev2_1.pdf
  32  */
  33
  34 #include "config.h"
  35
  36 #include <glib.h>
  37 #include <epan/packet.h>
  38 #include <epan/prefs.h>
  39 #include <epan/ptvcursor.h>
  40 #include <epan/expert.h>
  41
  42
  43 static int proto_hdcp2 = -1;
  44
  45 static gboolean  hdcp2_enable_dissector = FALSE;
  46
  47 void proto_reg_handoff_hdcp2(void);
  48
  49 static gint ett_hdcp2 = -1;
  50 static gint ett_hdcp2_cert = -1;
  51
  52 static int hf_hdcp2_msg_id = -1;
  53 static int hf_hdcp2_r_tx = -1;
  54 static int hf_hdcp2_repeater = -1;
  55 static int hf_hdcp2_cert_rcv_id = -1;
  56 static int hf_hdcp2_cert_n = -1;
  57 static int hf_hdcp2_cert_e = -1;
  58 static int hf_hdcp2_cert_rcv_sig = -1;
  59 static int hf_hdcp2_e_kpub_km = -1;
  60 static int hf_hdcp2_e_kh_km = -1;
  61 static int hf_hdcp2_m = -1;
  62 static int hf_hdcp2_r_rx = -1;
  63 static int hf_hdcp2_h_prime = -1;
  64 static int hf_hdcp2_r_n = -1;
  65 static int hf_hdcp2_l_prime = -1;
  66 static int hf_hdcp2_e_dkey_ks = -1;
  67 static int hf_hdcp2_r_iv = -1;
  68
  69 static expert_field ei_hdcp2_reserved_0 = EI_INIT;
  70
  71
  72 #define ID_AKE_INIT              2
  73 #define ID_AKE_SEND_CERT         3
  74 #define ID_AKE_NO_STORED_KM      4
  75 #define ID_AKE_STORED_KM         5
  76 #define ID_AKE_SEND_RRX          6
  77 #define ID_AKE_SEND_H_PRIME      7
  78 #define ID_AKE_SEND_PAIRING_INFO 8
  79 #define ID_LC_INIT               9
  80 #define ID_LC_SEND_L_PRIME      10
  81 #define ID_SKE_SEND_EKS         11
  82 #define ID_MAX                  31
  83
  84 #define RCV_ID_LEN    5  /* all lengths are in bytes */
  85 #define N_LEN       128
  86 #define E_LEN         3
  87 #define RCV_SIG_LEN 384
  88
  89 #define CERT_RX_LEN   (RCV_ID_LEN + N_LEN + E_LEN + 2 + RCV_SIG_LEN)
  90
  91 static const value_string hdcp2_msg_id[] = {
  92     { ID_AKE_INIT,              "AKE_Init" },
  93     { ID_AKE_SEND_CERT,         "AKE_Send_Cert" },
  94     { ID_AKE_NO_STORED_KM,      "AKE_No_Stored_km" },
  95     { ID_AKE_STORED_KM,         "AKE_Stored_km" },
  96     { ID_AKE_SEND_RRX,          "AKE_Send_rrx" },
  97     { ID_AKE_SEND_H_PRIME,      "AKE_Send_H_prime" },
  98     { ID_AKE_SEND_PAIRING_INFO, "AKE_Send_Pairing_Info" },
  99     { ID_LC_INIT,               "LC_Init" },
 100     { ID_LC_SEND_L_PRIME,       "LC_Send_L_prime" },
 101     { ID_SKE_SEND_EKS,          "SKE_Send_Eks" },
 102     { 0, NULL }
 103 };
 104
 105 typedef struct _msg_info_t {
 106     guint8  id;
 107     guint16 len;  /* number of bytes following initial msg_id field */
 108 } msg_info_t;
 109
 110 static GHashTable *msg_table = NULL;
 111
 112 static const msg_info_t msg_info[] = {
 113     { ID_AKE_INIT,               8 },
 114     { ID_AKE_SEND_CERT,        1+CERT_RX_LEN },
 115     { ID_AKE_NO_STORED_KM,     128 },
 116     { ID_AKE_STORED_KM,         32 },
 117     { ID_AKE_SEND_RRX,           8 },
 118     { ID_AKE_SEND_H_PRIME,      32 },
 119     { ID_AKE_SEND_PAIRING_INFO, 16 },
 120     { ID_LC_INIT,                8 },
 121     { ID_LC_SEND_L_PRIME,       32 },
 122     { ID_SKE_SEND_EKS,          24 }
 123 };
 124
 125
 126 static int
 127 dissect_hdcp2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
 128 {
 129     msg_info_t *mi;
 130     proto_item *pi;
 131     proto_tree *hdcp_tree, *cert_tree;
 132     guint8 msg_id;
 133     gboolean repeater;
 134     guint16 reserved;
 135     ptvcursor_t *cursor;
 136
 137     /* do the plausibility checks before setting up anything */
 138     msg_id = tvb_get_guint8(tvb, 0);
 139     if (msg_id > ID_MAX)
 140         return 0;
 141
 142     mi = (msg_info_t *)g_hash_table_lookup(msg_table,
 143             GUINT_TO_POINTER((guint)msg_id));
 144     /* 1 -> start after msg_id byte */
 145     if (!mi || mi->len!=tvb_reported_length_remaining(tvb, 1))
 146         return 0;
 147
 148     col_set_str(pinfo->cinfo, COL_PROTOCOL, "HDCP2");
 149     col_clear(pinfo->cinfo, COL_INFO);
 150
 151     pi = proto_tree_add_protocol_format(tree, proto_hdcp2,
 152             tvb, 0, tvb_reported_length(tvb), "HDCP2");
 153     hdcp_tree = proto_item_add_subtree(pi, ett_hdcp2);
 154     cursor = ptvcursor_new(hdcp_tree, tvb, 0);
 155
 156     col_append_fstr(pinfo->cinfo, COL_INFO, "%s",
 157                     val_to_str(msg_id, hdcp2_msg_id, "unknown (0x%x)"));
 158     ptvcursor_add(cursor, hf_hdcp2_msg_id, 1, ENC_BIG_ENDIAN);
 159
 160     switch (msg_id) {
 161         case ID_AKE_INIT:
 162             ptvcursor_add(cursor, hf_hdcp2_r_tx, 8, ENC_BIG_ENDIAN);
 163             break;
 164         case ID_AKE_SEND_CERT:
 165             repeater = ((tvb_get_guint8(tvb, ptvcursor_current_offset(cursor))
 166                         & 0x01) == 0x01);
 167             col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL, "%s",
 168                     repeater ? "repeater" : "no repeater");
 169             ptvcursor_add(cursor, hf_hdcp2_repeater, 1, ENC_BIG_ENDIAN);
 170             cert_tree = ptvcursor_add_text_with_subtree(cursor, CERT_RX_LEN,
 171                     ett_hdcp2_cert, "%s", "HDCP2 Certificate");
 172             ptvcursor_add(cursor, hf_hdcp2_cert_rcv_id, RCV_ID_LEN, ENC_NA);
 173             ptvcursor_add(cursor, hf_hdcp2_cert_n, N_LEN, ENC_NA);
 174             ptvcursor_add(cursor, hf_hdcp2_cert_e, E_LEN, ENC_BIG_ENDIAN);
 175             reserved = tvb_get_ntohs(tvb, ptvcursor_current_offset(cursor));
 176             pi = proto_tree_add_text(cert_tree, tvb,
 177                         ptvcursor_current_offset(cursor), 2, "reserved bytes");
 178             if (reserved != 0) {
 179                 expert_add_info(pinfo, pi, &ei_hdcp2_reserved_0);
 180             }
 181             ptvcursor_advance(cursor, 2);
 182             ptvcursor_add(cursor, hf_hdcp2_cert_rcv_sig, RCV_SIG_LEN, ENC_NA);
 183             ptvcursor_pop_subtree(cursor);
 184             break;
 185         case ID_AKE_NO_STORED_KM:
 186             ptvcursor_add(cursor, hf_hdcp2_e_kpub_km, 128, ENC_NA);
 187             break;
 188         case ID_AKE_STORED_KM:
 189             ptvcursor_add(cursor, hf_hdcp2_e_kh_km, 16, ENC_NA);
 190             ptvcursor_add(cursor, hf_hdcp2_m, 16, ENC_NA);
 191             break;
 192         case ID_AKE_SEND_RRX:
 193             ptvcursor_add(cursor, hf_hdcp2_r_rx, 8, ENC_BIG_ENDIAN);
 194             break;
 195         case ID_AKE_SEND_H_PRIME:
 196             ptvcursor_add(cursor, hf_hdcp2_h_prime, 32, ENC_NA);
 197             break;
 198         case ID_AKE_SEND_PAIRING_INFO:
 199             ptvcursor_add(cursor, hf_hdcp2_e_kh_km, 16, ENC_NA);
 200             break;
 201         case ID_LC_INIT:
 202             ptvcursor_add(cursor, hf_hdcp2_r_n, 8, ENC_BIG_ENDIAN);
 203             break;
 204         case ID_LC_SEND_L_PRIME:
 205             ptvcursor_add(cursor, hf_hdcp2_l_prime, 32, ENC_NA);
 206             break;
 207         case ID_SKE_SEND_EKS:
 208             ptvcursor_add(cursor, hf_hdcp2_e_dkey_ks, 16, ENC_NA);
 209             ptvcursor_add(cursor, hf_hdcp2_r_iv, 8, ENC_BIG_ENDIAN);
 210             break;
 211         default:
 212             break;
 213     }
 214
 215     ptvcursor_free(cursor);
 216     return tvb_reported_length(tvb);
 217 }
 218
 219
 220
 221 void
 222 proto_register_hdcp2(void)
 223 {
 224     guint i;
 225
 226     static hf_register_info hf[] = {
 227         { &hf_hdcp2_msg_id,
 228             { "Message ID", "hdcp2.msg_id", FT_UINT8, BASE_HEX,
 229                 VALS(hdcp2_msg_id), 0, NULL, HFILL } },
 230         { &hf_hdcp2_r_tx,
 231             { "r_tx", "hdcp2.r_tx", FT_UINT64, BASE_HEX,
 232                 NULL, 0, NULL, HFILL } },
 233         { &hf_hdcp2_repeater,
 234             { "Repeater", "hdcp2.repeater", FT_BOOLEAN, 8,
 235                 NULL, 0x1, NULL, HFILL } },
 236         { &hf_hdcp2_cert_rcv_id,
 237             { "Receiver ID", "hdcp2.cert.rcv_id", FT_BYTES, BASE_NONE,
 238                 NULL, 0, NULL, HFILL } },
 239         { &hf_hdcp2_cert_n,
 240             { "Receiver RSA key n", "hdcp2.cert.n", FT_BYTES, BASE_NONE,
 241                 NULL, 0, NULL, HFILL } },
 242         { &hf_hdcp2_cert_e,
 243             { "Receiver RSA key e", "hdcp2.cert.e", FT_UINT24, BASE_HEX,
 244                 NULL, 0, NULL, HFILL } },
 245         { &hf_hdcp2_cert_rcv_sig,
 246             { "Receiver signature", "hdcp2.cert.rcv_sig", FT_BYTES,
 247                 BASE_NONE, NULL, 0, NULL, HFILL } },
 248         { &hf_hdcp2_e_kpub_km,
 249             { "E_kpub_km", "hdcp2.e_kpub_km", FT_BYTES, BASE_NONE,
 250                 NULL, 0, NULL, HFILL } },
 251         { &hf_hdcp2_e_kh_km,
 252             { "E_kh_km", "hdcp2.e_kh_km", FT_BYTES, BASE_NONE,
 253                 NULL, 0, NULL, HFILL } },
 254         { &hf_hdcp2_m,
 255             { "m", "hdcp2.m", FT_BYTES, BASE_NONE,
 256                 NULL, 0, NULL, HFILL } },
 257         { &hf_hdcp2_r_rx,
 258             { "r_rx", "hdcp2.r_rx", FT_UINT64, BASE_HEX,
 259                 NULL, 0, NULL, HFILL } },
 260         { &hf_hdcp2_h_prime,
 261             { "H'", "hdcp2.h_prime", FT_BYTES, BASE_NONE,
 262                 NULL, 0, NULL, HFILL } },
 263         { &hf_hdcp2_r_n,
 264             { "r_n", "hdcp2.r_n", FT_UINT64, BASE_HEX,
 265                 NULL, 0, NULL, HFILL } },
 266         { &hf_hdcp2_l_prime,
 267             { "L'", "hdcp2.l_prime", FT_BYTES, BASE_NONE,
 268                 NULL, 0, NULL, HFILL } },
 269         { &hf_hdcp2_e_dkey_ks,
 270             { "E_dkey_ks", "hdcp2.e_dkey_ks", FT_BYTES, BASE_NONE,
 271                 NULL, 0, NULL, HFILL } },
 272         { &hf_hdcp2_r_iv,
 273             { "r_iv", "hdcp2.r_iv", FT_UINT64, BASE_HEX,
 274                 NULL, 0, NULL, HFILL } }
 275 };
 276
 277     static gint *ett[] = {
 278         &ett_hdcp2,
 279         &ett_hdcp2_cert
 280     };
 281
 282     static ei_register_info ei[] = {
 283         { &ei_hdcp2_reserved_0, { "hdcp2.reserved.not0", PI_PROTOCOL, PI_WARN, "reserved bytes must be set to 0x0", EXPFILL }},
 284     };
 285
 286     module_t *hdcp2_module;
 287     expert_module_t* expert_hdcp2;
 288
 289     msg_table = g_hash_table_new(g_direct_hash, g_direct_equal);
 290     for(i=0; i<array_length(msg_info); i++) {
 291         g_hash_table_insert(msg_table,
 292                 GUINT_TO_POINTER((guint)msg_info[i].id),
 293                 (const gpointer)(&msg_info[i]));
 294     }
 295
 296     proto_hdcp2 = proto_register_protocol(
 297             "High bandwidth Digital Content Protection version 2",
 298             "HDCP2", "hdcp2");
 299
 300     hdcp2_module = prefs_register_protocol(proto_hdcp2, proto_reg_handoff_hdcp2);
 301     prefs_register_bool_preference(hdcp2_module, "enable", "Enable dissector",
 302                         "Enable heuristic HDCP2 dissector (default is false)",
 303                         &hdcp2_enable_dissector);
 304
 305     proto_register_field_array(proto_hdcp2, hf, array_length(hf));
 306     proto_register_subtree_array(ett, array_length(ett));
 307     expert_hdcp2 = expert_register_protocol(proto_hdcp2);
 308     expert_register_field_array(expert_hdcp2, ei, array_length(ei));
 309
 310     new_register_dissector("hdcp2", dissect_hdcp2, proto_hdcp2);
 311 }
 312
 313 void
 314 proto_reg_handoff_hdcp2(void)
 315 {
 316     static gboolean prefs_initialized = FALSE;
 317
 318     if (!prefs_initialized) {
 319         heur_dissector_add ("tcp", dissect_hdcp2, proto_hdcp2);
 320
 321         prefs_initialized = TRUE;
 322     }
 323
 324     proto_set_decoding(proto_hdcp2, hdcp2_enable_dissector);
 325 }
 326
 327 /*
 328  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
 329  *
 330  * Local variables:
 331  * c-basic-offset: 4
 332  * tab-width: 8
 333  * indent-tabs-mode: nil
 334  * End:
 335  *
 336  * vi: set shiftwidth=4 tabstop=8 expandtab:
 337  * :indentSize=4:tabSize=8:noTabs=true:
 338  */