path: root/epan/dissectors/packet-teap.c

/* packet-teap.c
 * Routines for TEAP (Tunnel Extensible Authentication Protocol)
 * RFC 7170
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "config.h"

#include <epan/packet.h>
#include <epan/expert.h>
#include <epan/proto_data.h>

void proto_register_teap(void);
void proto_reg_handoff_teap(void);

static int proto_teap;

static int ett_teap;
static int ett_teap_tlv;
static int ett_pac_attr_tlv;

static expert_field ei_teap_bad_length;

static dissector_handle_t teap_handle;

static dissector_handle_t eap_handle;

/*
  From RFC7170, pg 27

    0                   1                   2                   3
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |M|R|            TLV Type       |            Length             |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                              Value...
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/

#define TEAP_TLV_MANDATORY 0x8000
#define TEAP_TLV_RESERVED  0x4000
#define TEAP_TLV_TYPE      0x3FFF

#define TEAP_CRYPTO_FLAGS    0xF0
#define TEAP_CRYPTO_SUBTYPE  0x0F

#define TEAP_UNASSIGNED              0
#define TEAP_AUTHORITY_ID            1
#define TEAP_IDENTITY                2
#define TEAP_RESULT                  3
#define TEAP_NAK                     4
#define TEAP_ERROR                   5
#define TEAP_CHANNEL_BINDING         6
#define TEAP_VENDOR_SPECIFIC         7
#define TEAP_REQUEST_ACTION          8
#define TEAP_EAP_PAYLOAD             9
#define TEAP_INTERMEDIATE_RESULT     10
#define TEAP_PAC                     11
#define TEAP_CRYPTO_BINDING          12
#define TEAP_BASIC_PWD_AUTH_REQUEST  13
#define TEAP_BASIC_PWD_AUTH_RESPONSE 14
#define TEAP_PKCS7                   15
#define TEAP_PKCS10                  16
#define TEAP_TRUSTED_SERVER_ROOT     17

static const value_string teap_tlv_type_vals[] = {
   { TEAP_UNASSIGNED,              "Unassigned" },
   { TEAP_AUTHORITY_ID,            "Authority-ID" },
   { TEAP_IDENTITY,                "Identity-Type" },
   { TEAP_RESULT,                  "Result" },
   { TEAP_NAK,                     "NAK" },
   { TEAP_ERROR,                   "Error" },
   { TEAP_CHANNEL_BINDING,         "Channel-Binding" },
   { TEAP_VENDOR_SPECIFIC,         "Vendor-Specific" },
   { TEAP_REQUEST_ACTION,          "Request-Action" },
   { TEAP_EAP_PAYLOAD,             "EAP-Payload" },
   { TEAP_INTERMEDIATE_RESULT,     "Intermediate-Result" },
   { TEAP_PAC,                     "PAC" },
   { TEAP_CRYPTO_BINDING,          "Crypto-Binding" },
   { TEAP_BASIC_PWD_AUTH_REQUEST,  "Basic-Password-Auth-Req" },
   { TEAP_BASIC_PWD_AUTH_RESPONSE, "Basic-Password-Auth-Resp" },
   { TEAP_PKCS7,                   "PKCS#7" },
   { TEAP_PKCS10,                  "PKCS#10" },
   { TEAP_TRUSTED_SERVER_ROOT,     "Trusted-Server-Root" },
   { 0,                            NULL }
 };

static const value_string teap_identity_vals[] = {
   { 1, "User" },
   { 2, "Machine" },
   { 0, NULL }
 };

static const value_string teap_status_vals[] = {
   { 1, "Success" },
   { 2, "Failure" },
   { 0, NULL }
 };

static const value_string teap_request_action_status_vals[] = {
   { 1, "Success" },
   { 2, "Failure" },
   { 0, NULL }
 };

static const value_string teap_request_action_action_vals[] = {
   { 1, "Process-TLV" },
   { 2, "Negotiate-EAP" },
   { 0, NULL }
 };

 #define FLAG_EMSK_PRESENT 1
 #define FLAG_MSK_PRESENT  2
 #define FLAG_BOTH_PRESENT 3

static const value_string teap_crypto_flags_vals[] = {
   { FLAG_EMSK_PRESENT, "EMSK Compound MAC is present" },
   { FLAG_MSK_PRESENT,  "MSK Compound MAC is present" },
   { FLAG_BOTH_PRESENT, "Both EMSK and MSK Compound MAC are present" },
   { 0, NULL }
};

static const value_string teap_crypto_subtype_vals[] = {
   { 0, "Binding Request" },
   { 1, "Binding Response" },
   { 0, NULL }
};

static const value_string teap_error_code_vals[] = {
   { 1,    "User account expires soon" },
   { 2,    "User account credential expires soon" },
   { 3,    "User account authorizations change soon" },
   { 4,    "Clock skew detected" },
   { 5,    "Contact administrator" },
   { 6,    "User account credentials change required" },
   { 1001, "Inner Method Error" },
   { 1002, "Unspecified authentication infrastructure problem" },
   { 1003, "Unspecified authentication failure" },
   { 1004, "Unspecified authorization failure" },
   { 1005, "User account credentials unavailable" },
   { 1006, "User account expired" },
   { 1007, "User account locked: try again later" },
   { 1008, "User account locked: admin intervention required" },
   { 1009, "Authentication infrastructure unavailable" },
   { 1010, "Authentication infrastructure not trusted" },
   { 1011, "Clock skew too great" },
   { 1012, "Invalid inner realm" },
   { 1013, "Token out of sync: administrator intervention required" },
   { 1014, "Token out of sync: PIN change required" },
   { 1015, "Token revoked" },
   { 1016, "Tokens exhausted" },
   { 1017, "Challenge expired" },
   { 1018, "Challenge algorithm mismatch" },
   { 1019, "Client certificate not supplied" },
   { 1020, "Client certificate rejected" },
   { 1021, "Realm mismatch between inner and outer identity" },
   { 1022, "Unsupported Algorithm In Certificate Signing Request" },
   { 1023, "Unsupported Extension In Certificate Signing Request" },
   { 1024, "Bad Identity In Certificate Signing Request" },
   { 1025, "Bad Certificate Signing Request" },
   { 1026, "Internal CA Error" },
   { 1027, "General PKI Error" },
   { 1028, "Inner method's channel-binding data required but not supplied" },
   { 1029, "Inner method's channel-binding data did not include required information" },
   { 1030, "Inner method's channel binding failed" },
   { 1031, "User account credentials incorrect [USAGE NOT RECOMMENDED]" },
   { 2001, "Tunnel Compromise Error" },
   { 2002, "Unexpected TLVs Exchanged" },
   { 0, NULL }
};

#define PAC_KEY       1
#define PAC_OPAQUE    2
#define PAC_LIFETIME  3
#define PAC_A_ID      4
#define PAC_I_ID      5
#define PAC_RESERVED  6
#define PAC_A_ID_INFO 7
#define PAC_ACK       8
#define PAC_INFO      9
#define PAC_TYPE      10

static const value_string pac_attr_type_vals[] = {
   { PAC_KEY,       "PAC-Key" },
   { PAC_OPAQUE,    "PAC-Opaque" },
   { PAC_LIFETIME,  "PAC-Lifetime" },
   { PAC_A_ID,      "A-ID" },
   { PAC_I_ID,      "I-ID" },
   { PAC_RESERVED,  "Reserved" },
   { PAC_A_ID_INFO, "A-ID-Info" },
   { PAC_ACK,       "PAC-Acknowledgement" },
   { PAC_INFO,      "PAC-Info" },
   { PAC_TYPE,      "PAC-Type" },
   { 0,             NULL }
};

static const value_string pac_result_vals[] = {
   { 1, "Success" },
   { 2, "Failure" },
   { 0, NULL }
 };

static const value_string pac_type_vals[] = {
   { 1, "Tunnel PAC" },
   { 0, NULL }
 };

static int hf_teap_tlv_mandatory;
static int hf_teap_tlv_reserved;
static int hf_teap_tlv_type;
static int hf_teap_tlv_len;
static int hf_teap_tlv_val;
static int hf_teap_auth_id;
static int hf_teap_identity;
static int hf_teap_status;
static int hf_teap_vendor_id;
static int hf_teap_request_action_status;
static int hf_teap_request_action_action;
static int hf_teap_crypto_reserved;
static int hf_teap_crypto_version;
static int hf_teap_crypto_rcv_version;
static int hf_teap_crypto_flags;
static int hf_teap_crypto_subtype;
static int hf_teap_crypto_nonce;
static int hf_teap_crypto_emsk;
static int hf_teap_crypto_msk;
static int hf_teap_nak_type;
static int hf_teap_error_code;
static int hf_teap_prompt;
static int hf_teap_user_len;
static int hf_teap_username;
static int hf_teap_pass_len;
static int hf_teap_password;

static int hf_pac_attr_type;
static int hf_pac_attr_pac_key;
static int hf_pac_attr_pac_opaque;
static int hf_pac_attr_pac_lifetime;
static int hf_pac_attr_pac_a_id;
static int hf_pac_attr_pac_i_id;
static int hf_pac_attr_pac_reserved;
static int hf_pac_attr_pac_a_id_info;
static int hf_pac_attr_pac_result;
static int hf_pac_attr_pac_type;
static int hf_pac_attr_val;

static int
dissect_teap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_);

static int
dissect_teap_tlv_pac(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, uint16_t len);

static int
// NOLINTNEXTLINE(misc-no-recursion)
dissect_pac_attr(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
{
  uint16_t type;
  uint16_t len;
  int start_offset = offset;

  type = tvb_get_uint16(tvb, offset, ENC_BIG_ENDIAN);
  len = tvb_get_uint16(tvb, offset + 2, ENC_BIG_ENDIAN);

  proto_tree_add_item(tree, hf_pac_attr_type, tvb, offset, 2, ENC_BIG_ENDIAN);
  offset += 2;

  proto_tree_add_item(tree, hf_teap_tlv_len, tvb, offset, 2, ENC_BIG_ENDIAN);
  offset += 2;

  switch (type) {
    case PAC_KEY:
      proto_tree_add_item(tree, hf_pac_attr_pac_key, tvb, offset, len, ENC_NA);
      offset += len;
      break;

    case PAC_OPAQUE:
      proto_tree_add_item(tree, hf_pac_attr_pac_opaque, tvb, offset, len, ENC_NA);
      offset += len;
      break;

    case PAC_LIFETIME:
      proto_tree_add_item(tree, hf_pac_attr_pac_lifetime, tvb, offset, 4, ENC_NA);
      offset += 4;
      break;

    case PAC_A_ID:
      proto_tree_add_item(tree, hf_pac_attr_pac_a_id, tvb, offset, len, ENC_ASCII | ENC_NA);
      offset += len;
      break;

    case PAC_I_ID:
      proto_tree_add_item(tree, hf_pac_attr_pac_i_id, tvb, offset, len, ENC_ASCII | ENC_NA);
      offset += len;
      break;

    case PAC_RESERVED:
      proto_tree_add_item(tree, hf_pac_attr_pac_reserved, tvb, offset, len, ENC_NA);
      offset += len;
      break;

    case PAC_A_ID_INFO:
      proto_tree_add_item(tree, hf_pac_attr_pac_a_id_info, tvb, offset, len, ENC_ASCII | ENC_NA);
      offset += len;
      break;

    case PAC_ACK:
      proto_tree_add_item(tree, hf_pac_attr_pac_result, tvb, offset, len, ENC_NA);
      offset += len;
      break;

    case PAC_INFO:
      offset += dissect_teap_tlv_pac(tvb, pinfo, tree, offset, len);
      break;

    case PAC_TYPE:
      proto_tree_add_item(tree, hf_pac_attr_pac_type, tvb, offset, len, ENC_NA);
      offset += len;
      break;

    default:
      proto_tree_add_item(tree, hf_pac_attr_val, tvb, offset, len, ENC_NA);
      offset += len;
      break;
  }
  return offset - start_offset;
}

static int
// NOLINTNEXTLINE(misc-no-recursion)
dissect_teap_tlv_pac(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, uint16_t len)
{
  int start_offset = offset;

  increment_dissection_depth(pinfo);
  while (offset - start_offset < len) {
    offset += dissect_pac_attr(tvb, pinfo, tree, offset);
  }
  decrement_dissection_depth(pinfo);
  return offset - start_offset;
}

static int
// NOLINTNEXTLINE(misc-no-recursion)
dissect_teap_tlv(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, bool top)
{
  int start_offset = offset;
  uint16_t type;
  uint16_t len;
  proto_tree *tlv_tree;
  proto_tree *ti_len;
  tvbuff_t *next_tvb;

  type = tvb_get_uint16(tvb, offset, ENC_BIG_ENDIAN) & TEAP_TLV_TYPE;
  len = tvb_get_uint16(tvb, offset + 2, ENC_BIG_ENDIAN);

  tlv_tree = proto_tree_add_subtree_format(tree, tvb, offset, 4 + len,
      ett_teap_tlv, NULL, "TLV %s (%u): ",
      val_to_str_const(type, teap_tlv_type_vals, "Unknown"), type);

  proto_tree_add_item(tlv_tree, hf_teap_tlv_mandatory, tvb, offset, 2, ENC_BIG_ENDIAN);
  proto_tree_add_item(tlv_tree, hf_teap_tlv_reserved, tvb, offset, 2, ENC_BIG_ENDIAN);
  proto_tree_add_item(tlv_tree, hf_teap_tlv_type, tvb, offset, 2, ENC_BIG_ENDIAN);
  offset += 2;

  proto_tree_add_item(tlv_tree, hf_teap_tlv_len, tvb, offset, 2, ENC_BIG_ENDIAN);
  offset += 2;

  if (top) {
    col_add_str(pinfo->cinfo, COL_INFO,
        val_to_str(type, teap_tlv_type_vals, "Unknown TLV (0x%02X)"));
  }
  switch (type) {
    case TEAP_AUTHORITY_ID:
      proto_tree_add_item(tlv_tree, hf_teap_auth_id, tvb, offset, len, ENC_NA);
      offset += len;
      break;

    case TEAP_IDENTITY:
      proto_tree_add_item(tlv_tree, hf_teap_identity, tvb, offset, 2, ENC_BIG_ENDIAN);
      offset += len;
      break;

    case TEAP_RESULT:
      proto_tree_add_item(tlv_tree, hf_teap_status, tvb, offset, 2, ENC_BIG_ENDIAN);
      offset += len;
      break;

    case TEAP_NAK:
      proto_tree_add_item(tlv_tree, hf_teap_vendor_id, tvb, offset, 4, ENC_BIG_ENDIAN);
      offset += 4;
      proto_tree_add_item(tlv_tree, hf_teap_nak_type, tvb, offset, 2, ENC_BIG_ENDIAN);
      offset += 2;

      if (len > 6) {
        next_tvb = tvb_new_subset_length(tvb, offset, len - 6);
        increment_dissection_depth(pinfo);
        offset += dissect_teap(next_tvb, pinfo, tlv_tree, NULL);
        decrement_dissection_depth(pinfo);
      }

      break;

    case TEAP_ERROR:
      proto_tree_add_item(tlv_tree, hf_teap_error_code, tvb, offset, 4, ENC_BIG_ENDIAN);
      offset += len;
      break;

    case TEAP_VENDOR_SPECIFIC:
      proto_tree_add_item(tlv_tree, hf_teap_vendor_id, tvb, offset, 4, ENC_BIG_ENDIAN);
      offset += len;
      break;

    case TEAP_REQUEST_ACTION:
      proto_tree_add_item(tlv_tree, hf_teap_request_action_status, tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      proto_tree_add_item(tlv_tree, hf_teap_request_action_action, tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;

      if (len > 2) {
        next_tvb = tvb_new_subset_length(tvb, offset, len - 2);
        offset += dissect_teap(next_tvb, pinfo, tlv_tree, NULL);
      }

      break;

    case TEAP_EAP_PAYLOAD:
    {
      uint16_t eaplen = tvb_get_uint16(tvb, offset + 2, ENC_BIG_ENDIAN);

      next_tvb = tvb_new_subset_length(tvb, offset, eaplen);
      call_dissector(eap_handle, next_tvb, pinfo, tlv_tree);
      offset += eaplen;

      if (len > eaplen) {
        next_tvb = tvb_new_subset_length(tvb, offset, len - eaplen);
        offset += dissect_teap(next_tvb, pinfo, tlv_tree, NULL);
      }
    }
    break;

    case TEAP_INTERMEDIATE_RESULT:
      proto_tree_add_item(tlv_tree, hf_teap_status, tvb, offset, 2, ENC_BIG_ENDIAN);
      offset += 2;

      if (len > 2) {
        next_tvb = tvb_new_subset_length(tvb, offset, len - 2);
        offset += dissect_teap(next_tvb, pinfo, tlv_tree, NULL);
      }

      break;

    case TEAP_PAC:
      offset += dissect_teap_tlv_pac(tvb, pinfo, tlv_tree, offset, len);
      break;

    case TEAP_CRYPTO_BINDING:
    {
      uint8_t flags;
      proto_tree_add_item(tlv_tree, hf_teap_crypto_reserved, tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      proto_tree_add_item(tlv_tree, hf_teap_crypto_version, tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      proto_tree_add_item(tlv_tree, hf_teap_crypto_rcv_version, tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      flags = (tvb_get_uint8(tvb, offset) & TEAP_CRYPTO_FLAGS) >> 4;
      proto_tree_add_item(tlv_tree, hf_teap_crypto_flags, tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(tlv_tree, hf_teap_crypto_subtype, tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      proto_tree_add_item(tlv_tree, hf_teap_crypto_nonce, tvb, offset, 32, ENC_NA);
      offset += 32;
      if (flags == FLAG_EMSK_PRESENT || flags == FLAG_BOTH_PRESENT) {
        proto_tree_add_item(tlv_tree, hf_teap_crypto_emsk, tvb, offset, 20, ENC_NA);
      }
      offset += 20;
      if (flags == FLAG_MSK_PRESENT || flags == FLAG_BOTH_PRESENT) {
        proto_tree_add_item(tlv_tree, hf_teap_crypto_msk, tvb, offset, 20, ENC_NA);
      }
      offset += 20;
    }
    break;

    case TEAP_BASIC_PWD_AUTH_REQUEST:
      if (len > 0) {
        proto_tree_add_item(tlv_tree, hf_teap_prompt, tvb, offset, len, ENC_ASCII | ENC_NA);
        offset += len;
      }
      break;

    case TEAP_BASIC_PWD_AUTH_RESPONSE:
    {
      uint8_t auth_len;
      auth_len = tvb_get_uint8(tvb, offset);
      proto_tree_add_item(tlv_tree, hf_teap_user_len, tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      proto_tree_add_item(tlv_tree, hf_teap_username, tvb, offset, auth_len, ENC_ASCII | ENC_NA);
      offset += auth_len;

      auth_len = tvb_get_uint8(tvb, offset);
      proto_tree_add_item(tlv_tree, hf_teap_pass_len, tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      proto_tree_add_item(tlv_tree, hf_teap_password, tvb, offset, auth_len, ENC_ASCII | ENC_NA);
      offset += auth_len;
    }
    break;

    case TEAP_CHANNEL_BINDING:
    case TEAP_TRUSTED_SERVER_ROOT:
    case TEAP_PKCS7:
    case TEAP_PKCS10:
    default:
      ti_len = proto_tree_add_item(tlv_tree, hf_teap_tlv_val, tvb, offset, len, ENC_NA);
      if ((unsigned)len + 4 > tvb_reported_length(tvb)) {
        expert_add_info(pinfo, ti_len, &ei_teap_bad_length);
      }
      offset += len;
      break;
  }

  return offset - start_offset;
}

static int
// NOLINTNEXTLINE(misc-no-recursion)
dissect_teap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
{
  proto_tree *ti;
  proto_tree *teap_tree;
  int offset = 0;

  col_set_str(pinfo->cinfo, COL_PROTOCOL, "TEAP");
  col_clear(pinfo->cinfo, COL_INFO);

  ti = proto_tree_add_item(tree, proto_teap, tvb, 0, tvb_captured_length(tvb), ENC_NA);
  teap_tree = proto_item_add_subtree(ti, ett_teap);

  while (offset < (int)tvb_captured_length(tvb)) {
    offset += dissect_teap_tlv(tvb, pinfo, teap_tree, offset, offset == 0);
  }

  return tvb_captured_length(tvb);
}

void
proto_register_teap(void)
{
  static hf_register_info hf[] = {
    { &hf_teap_tlv_mandatory, {
      "Mandatory", "teap.tlv.mandatory",
      FT_BOOLEAN, 16, NULL, TEAP_TLV_MANDATORY,
      NULL, HFILL }},

    { &hf_teap_tlv_reserved, {
      "Reserved", "teap.tlv.reserved",
      FT_UINT16, BASE_DEC, NULL, TEAP_TLV_RESERVED,
      NULL, HFILL }},

     { &hf_teap_tlv_type, {
      "Type", "teap.tlv.type",
      FT_UINT16, BASE_DEC, VALS(teap_tlv_type_vals), TEAP_TLV_TYPE,
      NULL, HFILL }},

     { &hf_teap_tlv_len, {
      "Length", "teap.tlv.len",
      FT_UINT16, BASE_DEC, NULL, 0x00,
      NULL, HFILL }},

     { &hf_teap_auth_id, {
      "ID", "teap.authority-id",
      FT_BYTES, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_identity, {
      "Identity", "teap.identity",
      FT_UINT16, BASE_DEC, VALS(teap_identity_vals), 0x0,
      NULL, HFILL }},

     { &hf_teap_status, {
      "Status", "teap.status",
      FT_UINT16, BASE_DEC, VALS(teap_status_vals), 0x0,
      NULL, HFILL }},

     { &hf_teap_vendor_id, {
      "Vendor-Id", "teap.vendor-id",
      FT_UINT32, BASE_HEX, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_crypto_reserved, {
      "Reserved", "teap.crypto.reserved",
      FT_UINT8, BASE_DEC, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_crypto_version, {
      "Version", "teap.crypto.version",
      FT_UINT8, BASE_DEC, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_crypto_rcv_version, {
      "Received Version", "teap.crypto.received-version",
      FT_UINT8, BASE_DEC, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_crypto_flags, {
      "Flags", "teap.crypto.flags",
      FT_UINT8, BASE_DEC, VALS(teap_crypto_flags_vals), TEAP_CRYPTO_FLAGS,
      NULL, HFILL }},

     { &hf_teap_crypto_subtype, {
      "Subtype", "teap.crypto.subtype",
      FT_UINT8, BASE_DEC, VALS(teap_crypto_subtype_vals), TEAP_CRYPTO_SUBTYPE,
      NULL, HFILL }},

     { &hf_teap_crypto_nonce, {
      "Nonce", "teap.crypto.nonce",
      FT_BYTES, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_crypto_emsk, {
      "EMSK Compound MAC", "teap.crypto.emsk",
      FT_BYTES, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_crypto_msk, {
      "MSK Compound MAC", "teap.crypto.msk",
      FT_BYTES, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_nak_type, {
      "NAK-Type", "teap.nak-type",
      FT_UINT16, BASE_HEX, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_error_code, {
      "Error-Code", "teap.error-code",
      FT_UINT32, BASE_DEC, VALS(teap_error_code_vals), 0x0,
      NULL, HFILL }},

     { &hf_teap_request_action_action, {
      "Action", "teap.request-action.action",
      FT_UINT8, BASE_DEC, VALS(teap_request_action_action_vals), 0x0,
      NULL, HFILL }},

     { &hf_teap_request_action_status, {
      "Status", "teap.request-action.status",
      FT_UINT8, BASE_DEC, VALS(teap_request_action_status_vals), 0x0,
      NULL, HFILL }},

     { &hf_teap_prompt, {
      "Prompt", "teap.prompt",
      FT_STRING, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_user_len, {
      "Userlen", "teap.user_len",
      FT_UINT8, BASE_DEC, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_username, {
      "Username", "teap.username",
      FT_STRING, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_pass_len, {
      "Passlen", "teap.pass_len",
      FT_UINT8, BASE_DEC, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_password, {
      "Password", "teap.password",
      FT_STRING, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_teap_tlv_val, {
      "Value", "teap.tlv.val",
      FT_BYTES, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_type, {
      "Type", "teap.pac.type",
      FT_UINT16, BASE_DEC, VALS(pac_attr_type_vals), 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_pac_key, {
      "Key", "teap.pac.key",
      FT_BYTES, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_pac_opaque, {
      "Opaque", "teap.pac.opaque",
      FT_BYTES, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_pac_lifetime, {
      "Lifetime", "teap.pac.lifetime",
      FT_UINT32, BASE_DEC, NULL, 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_pac_a_id, {
      "A-ID", "teap.pac.a-id",
      FT_STRING, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_pac_i_id, {
      "I-ID", "teap.pac.i-id",
      FT_STRING, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_pac_reserved, {
      "Reserved", "teap.pac.reserved",
      FT_BYTES, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_pac_a_id_info, {
      "A-ID-Info", "teap.pac.a-id-info",
      FT_STRING, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_pac_result, {
      "Type", "teap.pac.result",
      FT_UINT16, BASE_DEC, VALS(pac_result_vals), 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_pac_type, {
      "Type", "teap.pac.pac-type",
      FT_UINT16, BASE_DEC, VALS(pac_type_vals), 0x0,
      NULL, HFILL }},

     { &hf_pac_attr_val, {
      "Value", "teap.pac.val",
      FT_BYTES, BASE_NONE, NULL, 0x0,
      NULL, HFILL }},
  };

  static int *ett[] = {
    &ett_teap,
    &ett_teap_tlv,
    &ett_pac_attr_tlv,
  };
  static ei_register_info ei[] = {
     { &ei_teap_bad_length, { "teap.bad_length", PI_PROTOCOL, PI_WARN, "Bad length (too large)", EXPFILL }},
  };

  expert_module_t* expert_teap;

  proto_teap = proto_register_protocol("Tunnel Extensible Authentication Protocol",
                                       "TEAP", "teap");
  proto_register_field_array(proto_teap, hf, array_length(hf));
  proto_register_subtree_array(ett, array_length(ett));
  expert_teap = expert_register_protocol(proto_teap);
  expert_register_field_array(expert_teap, ei, array_length(ei));

  teap_handle = register_dissector("teap", dissect_teap, proto_teap);
}

void
proto_reg_handoff_teap(void)
{
  eap_handle = find_dissector_add_dependency("eap", proto_teap);
}
/*
 * Editor modelines
 *
 * Local Variables:
 * c-basic-offset: 2
 * tab-width: 8
 * indent-tabs-mode: nil
 * End:
 *
 * ex: set shiftwidth=2 tabstop=8 expandtab:
 * :indentSize=2:tabSize=8:noTabs=true:
 */