RADIUS: Add support for extended attributes (RFC 6929)

Bug: 13176
Change-Id: I22cdce01d8e7d5b69c2013684a98a9a48acc0d13
Reviewed-on: https://code.wireshark.org/review/21727
Petri-Dish: Alexis La Goutte <alexis.lagoutte@gmail.com>
Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org>
Reviewed-by: Michael Mann <mmann78@netscape.net>

diff --git a/epan/dissectors/packet-radius.c b/epan/dissectors/packet-radius.c
index 43f1149f947eb6d36da098ce268b24fa0ca9e777..9ea178e4a6058557f90ff032c013134e744f576d 100644 (file)
--- a/epan/dissectors/packet-radius.c
+++ b/epan/dissectors/packet-radius.c
@@ -34,6 +34,7 @@
  * RFC 2869 - RADIUS Extensions
  * RFC 3162 - RADIUS and IPv6
  * RFC 3576 - Dynamic Authorization Extensions to RADIUS
+ * RFC 6929 - Remote Authentication Dial-In User Service (RADIUS) Protocol Extensions
  *
  * See also
  *
@@ -186,6 +187,8 @@ static int hf_radius_eap_fragment = -1;
 static int hf_radius_avp = -1;
 static int hf_radius_avp_length = -1;
 static int hf_radius_avp_type = -1;
+static int hf_radius_avp_extended_type = -1;
+static int hf_radius_avp_extended_more = -1;
 static int hf_radius_3gpp_ms_tmime_zone = -1;
 
 static int hf_radius_egress_vlanid_tag = -1;
@@ -214,7 +217,7 @@ static int radius_tap = -1;
 
 static radius_vendor_info_t no_vendor = {"Unknown Vendor", 0, NULL, -1, 1, 1, FALSE};
 
-static radius_attr_info_t no_dictionary_entry = {"Unknown-Attribute", 0, FALSE, FALSE, radius_octets, NULL, NULL, -1, -1, -1, -1, -1, NULL };
+static radius_attr_info_t no_dictionary_entry = {"Unknown-Attribute", { { 0, 0 } }, FALSE, FALSE, radius_octets, NULL, NULL, -1, -1, -1, -1, -1, NULL };
 
 static dissector_handle_t eap_handle;
 static dissector_handle_t radius_handle;
@@ -1395,9 +1398,12 @@ dissect_attribute_value_pairs(proto_tree *tree, packet_info *pinfo, tvbuff_t *tv
 
        while (length > 0) {
                radius_attr_info_t *dictionary_entry = NULL;
-               guint32 avp_type;
+               guint32 avp_type0 = 0, avp_type1 = 0;
+               radius_attr_type_t avp_type;
                guint32 avp_length;
                guint32 vendor_id;
+               gboolean avp_is_extended = FALSE;
+               int avp_offset_start = offset;
 
                proto_item *avp_item;
                proto_item *avp_len_item;
@@ -1408,8 +1414,16 @@ dissect_attribute_value_pairs(proto_tree *tree, packet_info *pinfo, tvbuff_t *tv
                                                   "Not enough room in packet for AVP header");
                        break;  /* exit outer loop, then cleanup & return */
                }
-               avp_type = tvb_get_guint8(tvb, offset);
+
+               avp_type0 = tvb_get_guint8(tvb, offset);
                avp_length = tvb_get_guint8(tvb, offset+1);
+               avp_is_extended = RADIUS_ATTR_TYPE_IS_EXTENDED(avp_type0);
+               if (avp_is_extended) {
+                       avp_type1 = tvb_get_guint8(tvb, offset+2);
+               }
+               memset(&avp_type, 0, sizeof(avp_type));
+               avp_type.u8_code[0] = avp_type0;
+               avp_type.u8_code[1] = avp_type1;
 
                if (avp_length < 2) {
                        proto_tree_add_expert_format(tree, pinfo, &ei_radius_invalid_length, tvb, offset, 0,
@@ -1417,6 +1431,12 @@ dissect_attribute_value_pairs(proto_tree *tree, packet_info *pinfo, tvbuff_t *tv
                        break;  /* exit outer loop, then cleanup & return */
                }
 
+               if (avp_is_extended && avp_length < 3) {
+                       proto_tree_add_expert_format(tree, pinfo, &ei_radius_invalid_length, tvb, offset, 0,
+                                                  "Extended AVP too short: length %u < 3", avp_length);
+                       break;  /* exit outer loop, then cleanup & return */
+               }
+
                if (length < avp_length) {
                        proto_tree_add_expert_format(tree, pinfo, &ei_radius_invalid_length, tvb, offset, 0,
                                                   "Not enough room in packet for AVP");
@@ -1425,20 +1445,32 @@ dissect_attribute_value_pairs(proto_tree *tree, packet_info *pinfo, tvbuff_t *tv
 
                length -= avp_length;
 
-               dictionary_entry = (radius_attr_info_t *)g_hash_table_lookup(dict->attrs_by_id, GUINT_TO_POINTER(avp_type));
+               dictionary_entry = (radius_attr_info_t *)g_hash_table_lookup(dict->attrs_by_id, GUINT_TO_POINTER(avp_type.value));
 
                if (!dictionary_entry) {
                        dictionary_entry = &no_dictionary_entry;
                }
 
                avp_item = proto_tree_add_bytes_format_value(tree, hf_radius_avp, tvb, offset, avp_length,
-                                              NULL, "l=%u t=%s(%u)", avp_length,
-                                              dictionary_entry->name, avp_type);
+                                              NULL, "l=%u t=%s", avp_length,
+                                              dictionary_entry->name);
+               if (avp_is_extended)
+                       proto_item_append_text(avp_item, "(%u.%u)", avp_type0, avp_type1);
+               else
+                       proto_item_append_text(avp_item, "(%u)", avp_type0);
 
                avp_length -= 2;
                offset += 2;
+               if (avp_is_extended) {
+                       avp_length -= 1;
+                       offset += 1;
+               }
+               if (RADIUS_ATTR_TYPE_IS_EXTENDED_LONG(avp_type0)) {
+                       avp_length -= 1;
+                       offset += 1;
+               }
 
-               if (avp_type == RADIUS_ATTR_TYPE_VENDOR_SPECIFIC) {
+               if (avp_type0 == RADIUS_ATTR_TYPE_VENDOR_SPECIFIC || (avp_is_extended && avp_type1 == RADIUS_ATTR_TYPE_VENDOR_SPECIFIC)) {
                        radius_vendor_info_t *vendor;
                        proto_tree *vendor_tree;
                        gint max_offset = offset + avp_length;
@@ -1466,14 +1498,20 @@ dissect_attribute_value_pairs(proto_tree *tree, packet_info *pinfo, tvbuff_t *tv
 
                        vendor_tree = proto_item_add_subtree(avp_item, vendor->ett);
 
-                       proto_tree_add_item(vendor_tree, hf_radius_avp_type, tvb, offset-6, 1, ENC_BIG_ENDIAN);
-                       proto_tree_add_item(vendor_tree, hf_radius_avp_length, tvb, offset-5, 1, ENC_BIG_ENDIAN);
+                       proto_tree_add_item(vendor_tree, hf_radius_avp_type, tvb, avp_offset_start, 1, ENC_BIG_ENDIAN);
+                       proto_tree_add_item(vendor_tree, hf_radius_avp_length, tvb, avp_offset_start+1, 1, ENC_BIG_ENDIAN);
+                       if (avp_is_extended) {
+                               proto_tree_add_item(vendor_tree, hf_radius_avp_extended_type, tvb, avp_offset_start+2, 1, ENC_BIG_ENDIAN);
+                       }
+                       if (RADIUS_ATTR_TYPE_IS_EXTENDED_LONG(avp_type0)) {
+                               proto_tree_add_item(vendor_tree, hf_radius_avp_extended_more, tvb, avp_offset_start+3, 1, ENC_BIG_ENDIAN);
+                       }
 
                        while (offset < max_offset) {
                                guint32 avp_vsa_type;
                                guint32 avp_vsa_len;
                                guint8 avp_vsa_flags = 0;
-                               guint32 avp_vsa_header_len = vendor->type_octets + vendor->length_octets + (vendor->has_flags ? 1 : 0);
+                               guint32 avp_vsa_header_len;
 
                                switch (vendor->type_octets) {
                                        case 1:
@@ -1491,19 +1529,25 @@ dissect_attribute_value_pairs(proto_tree *tree, packet_info *pinfo, tvbuff_t *tv
                                                avp_vsa_type = tvb_get_guint8(tvb, offset++);
                                }
 
-                               switch (vendor->length_octets) {
-                                       case 1:
-                                               avp_vsa_len = tvb_get_guint8(tvb, offset++);
-                                               break;
-                                       case 0:
-                                               avp_vsa_len = avp_length;
-                                               break;
-                                       case 2:
-                                               avp_vsa_len = tvb_get_ntohs(tvb, offset);
-                                               offset += 2;
-                                               break;
-                                       default:
-                                               avp_vsa_len = tvb_get_guint8(tvb, offset++);
+                               if (!avp_is_extended) {
+                                       switch (vendor->length_octets) {
+                                               case 1:
+                                                       avp_vsa_len = tvb_get_guint8(tvb, offset++);
+                                                       break;
+                                               case 0:
+                                                       avp_vsa_len = avp_length;
+                                                       break;
+                                               case 2:
+                                                       avp_vsa_len = tvb_get_ntohs(tvb, offset);
+                                                       offset += 2;
+                                                       break;
+                                               default:
+                                                       avp_vsa_len = tvb_get_guint8(tvb, offset++);
+                                       }
+                                       avp_vsa_header_len = vendor->type_octets + vendor->length_octets + (vendor->has_flags ? 1 : 0);
+                               } else {
+                                       avp_vsa_len = avp_length;
+                                       avp_vsa_header_len = vendor->type_octets + (vendor->has_flags ? 1 : 0);
                                }
 
                                if (vendor->has_flags) {
@@ -1603,8 +1647,8 @@ dissect_attribute_value_pairs(proto_tree *tree, packet_info *pinfo, tvbuff_t *tv
 
                avp_tree = proto_item_add_subtree(avp_item, dictionary_entry->ett);
 
-               proto_tree_add_item(avp_tree, hf_radius_avp_type, tvb, offset-2, 1, ENC_BIG_ENDIAN);
-               proto_tree_add_item(avp_tree, hf_radius_avp_length, tvb, offset-1, 1, ENC_BIG_ENDIAN);
+               proto_tree_add_item(avp_tree, hf_radius_avp_type, tvb, avp_offset_start, 1, ENC_BIG_ENDIAN);
+               proto_tree_add_item(avp_tree, hf_radius_avp_length, tvb, avp_offset_start+1, 1, ENC_BIG_ENDIAN);
 
                if (show_length) {
                        avp_len_item = proto_tree_add_uint(avp_tree,
@@ -1613,7 +1657,14 @@ dissect_attribute_value_pairs(proto_tree *tree, packet_info *pinfo, tvbuff_t *tv
                        PROTO_ITEM_SET_GENERATED(avp_len_item);
                }
 
-               if (avp_type == RADIUS_ATTR_TYPE_EAP_MESSAGE) {
+               if (avp_is_extended) {
+                       proto_tree_add_item(avp_tree, hf_radius_avp_extended_type, tvb, avp_offset_start+2, 1, ENC_BIG_ENDIAN);
+               }
+               if (RADIUS_ATTR_TYPE_IS_EXTENDED_LONG(avp_type0)) {
+                       proto_tree_add_item(avp_tree, hf_radius_avp_extended_more, tvb, avp_offset_start+3, 1, ENC_BIG_ENDIAN);
+               }
+
+               if (avp_type0 == RADIUS_ATTR_TYPE_EAP_MESSAGE) {
                        gint tvb_len;
 
                        eap_seg_num++;
@@ -1732,12 +1783,13 @@ dissect_attribute_value_pairs(proto_tree *tree, packet_info *pinfo, tvbuff_t *tv
                        }
 
                        offset += avp_length;
-               } else {
-                       add_avp_to_tree(avp_tree, avp_item, pinfo, tvb, dictionary_entry,
-                                       avp_length, offset);
-                       offset += avp_length;
+                       continue;
                }
 
+               add_avp_to_tree(avp_tree, avp_item, pinfo, tvb, dictionary_entry,
+                               avp_length, offset);
+               offset += avp_length;
+
        }  /* while (length > 0) */
 
        CLEANUP_CALL_AND_POP_PFX(lb); /* vsa_buffer_table_destroy(vsa_buffer_table) */
@@ -2349,13 +2401,16 @@ register_vendors(gpointer k _U_, gpointer v, gpointer p)
 }
 
 extern void
-radius_register_avp_dissector(guint32 vendor_id, guint32 attribute_id, radius_avp_dissector_t radius_avp_dissector)
+radius_register_avp_dissector(guint32 vendor_id, guint32 _attribute_id, radius_avp_dissector_t radius_avp_dissector)
 {
        radius_vendor_info_t *vendor;
        radius_attr_info_t *dictionary_entry;
        GHashTable *by_id;
+       radius_attr_type_t attribute_id;
 
        DISSECTOR_ASSERT(radius_avp_dissector != NULL);
+       memset(&attribute_id, 0, sizeof(attribute_id));
+       attribute_id.u8_code[0] = _attribute_id;
 
        if (vendor_id) {
                vendor = (radius_vendor_info_t *)g_hash_table_lookup(dict->vendors_by_id, GUINT_TO_POINTER(vendor_id));
@@ -2379,17 +2434,17 @@ radius_register_avp_dissector(guint32 vendor_id, guint32 attribute_id, radius_av
                        g_hash_table_insert(dict->vendors_by_name, (gpointer)(vendor->name), vendor);
                }
 
-               dictionary_entry = (radius_attr_info_t *)g_hash_table_lookup(vendor->attrs_by_id, GUINT_TO_POINTER(attribute_id));
+               dictionary_entry = (radius_attr_info_t *)g_hash_table_lookup(vendor->attrs_by_id, GUINT_TO_POINTER(attribute_id.value));
                by_id = vendor->attrs_by_id;
        } else {
-               dictionary_entry = (radius_attr_info_t *)g_hash_table_lookup(dict->attrs_by_id, GUINT_TO_POINTER(attribute_id));
+               dictionary_entry = (radius_attr_info_t *)g_hash_table_lookup(dict->attrs_by_id, GUINT_TO_POINTER(attribute_id.value));
                by_id = dict->attrs_by_id;
        }
 
        if (!dictionary_entry) {
                dictionary_entry = (radius_attr_info_t *)g_malloc(sizeof(radius_attr_info_t));
 
-               dictionary_entry->name = g_strdup_printf("Unknown-Attribute-%u", attribute_id);
+               dictionary_entry->name = g_strdup_printf("Unknown-Attribute-%u", attribute_id.value);
                dictionary_entry->code = attribute_id;
                dictionary_entry->encrypt = 0;
                dictionary_entry->type = NULL;
@@ -2401,7 +2456,7 @@ radius_register_avp_dissector(guint32 vendor_id, guint32 attribute_id, radius_av
                dictionary_entry->ett = no_dictionary_entry.ett;
                dictionary_entry->tlvs_by_id = NULL;
 
-               g_hash_table_insert(by_id, GUINT_TO_POINTER(dictionary_entry->code), dictionary_entry);
+               g_hash_table_insert(by_id, GUINT_TO_POINTER(dictionary_entry->code.value), dictionary_entry);
        }
 
        dictionary_entry->dissector = radius_avp_dissector;
@@ -2581,6 +2636,12 @@ register_radius_fields(const char *unused _U_)
                { &hf_radius_avp_type,
                { "AVP Type", "radius.avp.type", FT_UINT8, BASE_DEC, NULL, 0x0,
                        NULL, HFILL }},
+               { &hf_radius_avp_extended_type,
+               { "AVP Extended Type", "radius.avp.extended_type", FT_UINT8, BASE_DEC, NULL, 0x0,
+                       NULL, HFILL }},
+               { &hf_radius_avp_extended_more,
+               { "AVP Extended More", "radius.avp.extended_more", FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x80,
+                       NULL, HFILL }},
                { &hf_radius_egress_vlanid_tag,
                { "Tag", "radius.egress_vlanid_tag", FT_UINT32, BASE_HEX, VALS(egress_vlan_tag_vals), 0xFF000000,
                        NULL, HFILL }},

diff --git a/epan/dissectors/packet-radius.h b/epan/dissectors/packet-radius.h
index 9ddf1054e5a94a867d0f04f947542030cabc6789..93fed5b94c183544d061c9242ff4997ad5fd12a1 100644 (file)
--- a/epan/dissectors/packet-radius.h
+++ b/epan/dissectors/packet-radius.h
@@ -78,6 +78,24 @@
  */
 #define RADIUS_ATTR_TYPE_VENDOR_SPECIFIC                       26
 #define RADIUS_ATTR_TYPE_EAP_MESSAGE                           79
+#define RADIUS_ATTR_TYPE_EXTENDED_1                            241
+#define RADIUS_ATTR_TYPE_EXTENDED_2                            242
+#define RADIUS_ATTR_TYPE_EXTENDED_3                            243
+#define RADIUS_ATTR_TYPE_EXTENDED_4                            244
+#define RADIUS_ATTR_TYPE_EXTENDED_5                            245
+#define RADIUS_ATTR_TYPE_EXTENDED_6                            246
+
+#define RADIUS_ATTR_TYPE_IS_EXTENDED(avp_type)                 \
+       ((avp_type) == RADIUS_ATTR_TYPE_EXTENDED_1 ||           \
+               (avp_type) == RADIUS_ATTR_TYPE_EXTENDED_2 ||    \
+               (avp_type) == RADIUS_ATTR_TYPE_EXTENDED_3 ||    \
+               (avp_type) == RADIUS_ATTR_TYPE_EXTENDED_4 ||    \
+               (avp_type) == RADIUS_ATTR_TYPE_EXTENDED_5 ||    \
+               (avp_type) == RADIUS_ATTR_TYPE_EXTENDED_6)
+
+#define RADIUS_ATTR_TYPE_IS_EXTENDED_LONG(avp_type)            \
+       ((avp_type) == RADIUS_ATTR_TYPE_EXTENDED_5 ||           \
+               (avp_type) == RADIUS_ATTR_TYPE_EXTENDED_6)
 
 
 typedef struct _radius_vendor_info_t {
@@ -95,9 +113,14 @@ typedef void (radius_attr_dissector_t)(radius_attr_info_t*, proto_tree*, packet_
 
 typedef const gchar* (radius_avp_dissector_t)(proto_tree*,tvbuff_t*, packet_info*);
 
+typedef union _radius_attr_type_t {
+       guint8 u8_code[2];
+       guint  value;
+} radius_attr_type_t;
+
 struct _radius_attr_info_t {
        gchar *name;
-       guint code;
+       radius_attr_type_t code;
        guint encrypt;  /* 0 or value for "encrypt=" option */
        gboolean tagged;
        radius_attr_dissector_t* type;

diff --git a/epan/radius_dict.l b/epan/radius_dict.l
index 3dac0f70077877198c6e348b9c10f012ebc85821..75553dff6d7644207b1c71deff4d28324767fcca 100644 (file)
--- a/epan/radius_dict.l
+++ b/epan/radius_dict.l
@@ -271,7 +271,7 @@ static void add_value(Radius_scanner_state_t* state, const gchar* attrib_name, c
 }
 
 <ATTR>[0-9a-z_/.-]+                    { yyextra->attr_name = g_strdup(yytext); yyextra->encrypted = 0; yyextra->has_tag = FALSE; BEGIN ATTR_W_NAME; }
-<ATTR_W_NAME>[0-9]+                    { yyextra->attr_id = g_strdup(yytext);  BEGIN ATTR_W_ID;}
+<ATTR_W_NAME>[0-9.]+                   { yyextra->attr_id = g_strdup(yytext);  BEGIN ATTR_W_ID;}
 <ATTR_W_NAME>0x[0-9a-f]+               { yyextra->attr_id = g_strdup_printf("%u",(int)strtoul(yytext,NULL,16)); BEGIN ATTR_W_ID;}
 <ATTR_W_ID>integer                     { yyextra->attr_type = radius_integer;  BEGIN ATTR_W_TYPE; }
 <ATTR_W_ID>string                      { yyextra->attr_type = radius_string;  BEGIN ATTR_W_TYPE; }
@@ -449,7 +449,8 @@ static void add_vendor(Radius_scanner_state_t* state, const gchar* name, guint32
 static gboolean add_attribute(Radius_scanner_state_t* state, const gchar* name, const  gchar* codestr, radius_attr_dissector_t type, const  gchar* vendor, guint encrypted_flag, gboolean tagged, const gchar* attr) {
        radius_attr_info_t* a;
        GHashTable* by_id;
-       guint32 code;
+       radius_attr_type_t code;
+       gchar *dot, *extcodestr = NULL;
 
        if (attr){
                return add_tlv(state, name, codestr, type, attr);
@@ -470,9 +471,18 @@ static gboolean add_attribute(Radius_scanner_state_t* state, const gchar* name,
                by_id = state->dict->attrs_by_id;
        }
 
-       code= (guint32) strtoul(codestr, NULL, 10);
+       memset(&code, 0, sizeof(code));
+       dot = strchr(codestr, '.');
+       if (dot) {
+               *dot = '\0';
+               extcodestr = dot + 1;
+       }
+       code.u8_code[0] = (guint8) strtoul(codestr, NULL, 10);
+       if (extcodestr) {
+               code.u8_code[1] = (guint8) strtoul(extcodestr, NULL, 10);
+       }
 
-       a=(radius_attr_info_t*)g_hash_table_lookup(by_id, GUINT_TO_POINTER(code));
+       a=(radius_attr_info_t*)g_hash_table_lookup(by_id, GUINT_TO_POINTER(code.value));
 
        if (!a) {
                /*
@@ -494,7 +504,7 @@ static gboolean add_attribute(Radius_scanner_state_t* state, const gchar* name,
                a->hf_len = -1;
                a->ett = -1;
                a->tlvs_by_id = NULL;
-               g_hash_table_insert(by_id, GUINT_TO_POINTER(code),a);
+               g_hash_table_insert(by_id, GUINT_TO_POINTER(code.value),a);
                g_hash_table_insert(state->dict->attrs_by_name,(gpointer) (a->name),a);
        } else {
                /*
@@ -537,7 +547,7 @@ static gboolean add_attribute(Radius_scanner_state_t* state, const gchar* name,
 static gboolean add_tlv(Radius_scanner_state_t* state, const gchar* name, const  gchar* codestr, radius_attr_dissector_t type, const gchar* attr) {
        radius_attr_info_t* a;
        radius_attr_info_t* s;
-       guint32 code;
+       radius_attr_type_t code;
 
        a = (radius_attr_info_t*)g_hash_table_lookup(state->dict->attrs_by_name, attr);
 
@@ -556,9 +566,10 @@ static gboolean add_tlv(Radius_scanner_state_t* state, const gchar* name, const
                a->tlvs_by_id = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, free_radius_attr_info);
        }
 
-       code = (guint32) strtoul(codestr, NULL, 10);
+       memset(&code, 0, sizeof(code));
+       code.u8_code[0] = (guint8) strtoul(codestr, NULL, 10);
 
-       s = (radius_attr_info_t*)g_hash_table_lookup(a->tlvs_by_id, GUINT_TO_POINTER(code));
+       s = (radius_attr_info_t*)g_hash_table_lookup(a->tlvs_by_id, GUINT_TO_POINTER(code.value));
 
        if (!s) {
                /*
@@ -581,7 +592,7 @@ static gboolean add_tlv(Radius_scanner_state_t* state, const gchar* name, const
                s->ett = -1;
                s->tlvs_by_id = NULL;
 
-               g_hash_table_insert(a->tlvs_by_id,GUINT_TO_POINTER(s->code),s);
+               g_hash_table_insert(a->tlvs_by_id,GUINT_TO_POINTER(s->code.value),s);
                g_hash_table_insert(state->dict->tlvs_by_name,(gpointer) (s->name),s);
        }
 

diff --git a/radius/dictionary b/radius/dictionary
index c642bf7179aa5085d96ddd29231593709025bb0f..b92b76fca343c828e33cb1a130e6f169d77f6e48 100644 (file)
--- a/radius/dictionary
+++ b/radius/dictionary
@@ -115,30 +115,13 @@ $INCLUDE dictionary.rfc6519
 $INCLUDE dictionary.rfc6572
 $INCLUDE dictionary.rfc6677
 $INCLUDE dictionary.rfc6911
-#
-# We do not support RFC 6929, so we comment this out.
-# See bug 13176.
-#
-#$INCLUDE dictionary.rfc6929
-#
-# We do not support RFC 6929, so we comment this out.
-# See bug 13176.
-#
-#$INCLUDE dictionary.rfc6930
+$INCLUDE dictionary.rfc6929
+$INCLUDE dictionary.rfc6930
 $INCLUDE dictionary.rfc7055
 #$INCLUDE dictionary.rfc7155
 #$INCLUDE dictionary.rfc7268
-#
-# We do not support RFC 6929, so we comment these out.  They cause
-#
-#  radius: Vendor: 'integer', does not exist in {dictionary file}
-#
-# errors.
-#
-# See bug 13176.
-#
-#$INCLUDE dictionary.rfc7499
-#$INCLUDE dictionary.rfc7930
+$INCLUDE dictionary.rfc7499
+$INCLUDE dictionary.rfc7930
 
 
 #