/* Do not modify this file. Changes will be overwritten.                      */

/* Generated automatically by the ASN.1 to Wireshark dissector compiler       */

/* packet-x509af.c                                                            */

/* asn2wrs.py -b -q -L -p x509af -c ./x509af.cnf -s ./packet-x509af-template -D . -O ../.. AuthenticationFramework.asn */

/* packet-x509af.c

 * Routines for X.509 Authentication Framework packet dissection

 *  Ronnie Sahlberg 2004

 *

 * 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/oids.h>

#include <epan/asn1.h>

#include <epan/expert.h>

#include <epan/strutil.h>

#include <epan/export_object.h>

#include <epan/proto_data.h>

#include <wsutil/array.h>

#include <wsutil/wsgcrypt.h>

#include "packet-ber.h"

#include "packet-x509af.h"

#include "packet-x509ce.h"

#include "packet-x509if.h"

#include "packet-x509sat.h"

#include "packet-ldap.h"

#include "packet-pkixalgs.h"

#if defined(HAVE_LIBGNUTLS)

#include <gnutls/gnutls.h>

#endif

void proto_register_x509af(void);

void proto_reg_handoff_x509af(void);

static dissector_handle_t pkix_crl_handle;

static int x509af_eo_tap;

/* Initialize the protocol and registered fields */

static int proto_x509af;

static int hf_x509af_algorithm_id;

static int hf_x509af_extension_id;

static int hf_x509af_subjectPublicKey_dh;

static int hf_x509af_subjectPublicKey_dsa;

static int hf_x509af_subjectPublicKey_rsa;

static int hf_x509af_x509af_Certificate_PDU;      /* Certificate */

static int hf_x509af_SubjectPublicKeyInfo_PDU;    /* SubjectPublicKeyInfo */

static int hf_x509af_CertificatePair_PDU;         /* CertificatePair */

static int hf_x509af_CertificateList_PDU;         /* CertificateList */

static int hf_x509af_AttributeCertificate_PDU;    /* AttributeCertificate */

static int hf_x509af_DSS_Params_PDU;              /* DSS_Params */

static int hf_x509af_Userid_PDU;                  /* Userid */

static int hf_x509af_signedCertificate;           /* T_signedCertificate */

static int hf_x509af_version;                     /* Version */

static int hf_x509af_serialNumber;                /* CertificateSerialNumber */

static int hf_x509af_signature;                   /* AlgorithmIdentifier */

static int hf_x509af_issuer;                      /* Name */

static int hf_x509af_validity;                    /* Validity */

static int hf_x509af_subject;                     /* SubjectName */

static int hf_x509af_subjectPublicKeyInfo;        /* SubjectPublicKeyInfo */

static int hf_x509af_issuerUniqueIdentifier;      /* UniqueIdentifier */

static int hf_x509af_subjectUniqueIdentifier;     /* UniqueIdentifier */

static int hf_x509af_extensions;                  /* Extensions */

static int hf_x509af_algorithmIdentifier;         /* AlgorithmIdentifier */

static int hf_x509af_encrypted;                   /* BIT_STRING */

static int hf_x509af_rdnSequence;                 /* RDNSequence */

static int hf_x509af_algorithmId;                 /* T_algorithmId */

static int hf_x509af_parameters;                  /* T_parameters */

static int hf_x509af_notBefore;                   /* T_notBefore */

static int hf_x509af_notAfter;                    /* T_notAfter */

static int hf_x509af_algorithm;                   /* AlgorithmIdentifier */

static int hf_x509af_subjectPublicKey;            /* T_subjectPublicKey */

static int hf_x509af_utcTime;                     /* T_utcTime */

static int hf_x509af_generalizedTime;             /* GeneralizedTime */

static int hf_x509af_Extensions_item;             /* Extension */

static int hf_x509af_extnId;                      /* T_extnId */

static int hf_x509af_critical;                    /* BOOLEAN */

static int hf_x509af_extnValue;                   /* T_extnValue */

static int hf_x509af_userCertificate;             /* Certificate */

static int hf_x509af_certificationPath;           /* ForwardCertificationPath */

static int hf_x509af_ForwardCertificationPath_item;  /* CrossCertificates */

static int hf_x509af_CrossCertificates_item;      /* Certificate */

static int hf_x509af_theCACertificates;           /* SEQUENCE_OF_CertificatePair */

static int hf_x509af_theCACertificates_item;      /* CertificatePair */

static int hf_x509af_issuedByThisCA;              /* Certificate */

static int hf_x509af_issuedToThisCA;              /* Certificate */

static int hf_x509af_signedCertificateList;       /* T_signedCertificateList */

static int hf_x509af_thisUpdate;                  /* Time */

static int hf_x509af_nextUpdate;                  /* Time */

static int hf_x509af_revokedCertificates;         /* T_revokedCertificates */

static int hf_x509af_revokedCertificates_item;    /* T_revokedCertificates_item */

static int hf_x509af_revokedUserCertificate;      /* CertificateSerialNumber */

static int hf_x509af_revocationDate;              /* Time */

static int hf_x509af_crlEntryExtensions;          /* Extensions */

static int hf_x509af_crlExtensions;               /* Extensions */

static int hf_x509af_attributeCertificate;        /* AttributeCertificate */

static int hf_x509af_acPath;                      /* SEQUENCE_OF_ACPathData */

static int hf_x509af_acPath_item;                 /* ACPathData */

static int hf_x509af_certificate;                 /* Certificate */

static int hf_x509af_signedAttributeCertificateInfo;  /* AttributeCertificateInfo */

static int hf_x509af_info_subject;                /* InfoSubject */

static int hf_x509af_baseCertificateID;           /* IssuerSerial */

static int hf_x509af_infoSubjectName;             /* GeneralNames */

static int hf_x509af_issuerName;                  /* GeneralNames */

static int hf_x509af_attCertValidityPeriod;       /* AttCertValidityPeriod */

static int hf_x509af_attributes;                  /* SEQUENCE_OF_Attribute */

static int hf_x509af_attributes_item;             /* Attribute */

static int hf_x509af_issuerUniqueID;              /* UniqueIdentifier */

static int hf_x509af_serial;                      /* CertificateSerialNumber */

static int hf_x509af_issuerUID;                   /* UniqueIdentifier */

static int hf_x509af_notBeforeTime;               /* GeneralizedTime */

static int hf_x509af_notAfterTime;                /* GeneralizedTime */

static int hf_x509af_assertion_subject;           /* AssertionSubject */

static int hf_x509af_assertionSubjectName;        /* SubjectName */

static int hf_x509af_assertionIssuer;             /* Name */

static int hf_x509af_attCertValidity;             /* GeneralizedTime */

static int hf_x509af_attType;                     /* SET_OF_AttributeType */

static int hf_x509af_attType_item;                /* AttributeType */

static int hf_x509af_p;                           /* INTEGER */

static int hf_x509af_q;                           /* INTEGER */

static int hf_x509af_g;                           /* INTEGER */

/* Initialize the subtree pointers */

static int ett_pkix_crl;

static int ett_x509af_SubjectPublicKey;

static int ett_x509af_Certificate;

static int ett_x509af_T_signedCertificate;

static int ett_x509af_SubjectName;

static int ett_x509af_AlgorithmIdentifier;

static int ett_x509af_Validity;

static int ett_x509af_SubjectPublicKeyInfo;

static int ett_x509af_Time;

static int ett_x509af_Extensions;

static int ett_x509af_Extension;

static int ett_x509af_Certificates;

static int ett_x509af_ForwardCertificationPath;

static int ett_x509af_CrossCertificates;

static int ett_x509af_CertificationPath;

static int ett_x509af_SEQUENCE_OF_CertificatePair;

static int ett_x509af_CertificatePair;

static int ett_x509af_CertificateList;

static int ett_x509af_T_signedCertificateList;

static int ett_x509af_T_revokedCertificates;

static int ett_x509af_T_revokedCertificates_item;

static int ett_x509af_AttributeCertificationPath;

static int ett_x509af_SEQUENCE_OF_ACPathData;

static int ett_x509af_ACPathData;

static int ett_x509af_AttributeCertificate;

static int ett_x509af_AttributeCertificateInfo;

static int ett_x509af_InfoSubject;

static int ett_x509af_SEQUENCE_OF_Attribute;

static int ett_x509af_IssuerSerial;

static int ett_x509af_AttCertValidityPeriod;

static int ett_x509af_AttributeCertificateAssertion;

static int ett_x509af_AssertionSubject;

static int ett_x509af_SET_OF_AttributeType;

static int ett_x509af_DSS_Params;

static expert_field ei_x509af_certificate_invalid;

static const char *algorithm_id;

static void

x509af_export_publickey(tvbuff_t *tvb, asn1_ctx_t *actx, int offset, int len);

/* proto_data keys */

#define X509AF_EO_INFO_KEY      0

#define X509AF_PRIVATE_DATA_KEY 1

typedef struct _x509af_eo_t {

  const char *subjectname;

  tvbuff_t *payload;

} x509af_eo_t;

typedef struct _x509af_private_data_t {

  nstime_t last_time;

  nstime_t not_before;

  nstime_t not_after;

#if 0

  // TODO: Move static global algorithm_id here.

  // (Why is the algorithm_id string wmem_file_scope()? That makes

  // no sense as a global common to all conversations.)

  const char *algorithm_id;

#endif

} x509af_private_data_t;

static x509af_private_data_t *

x509af_get_private_data(packet_info *pinfo)

{

  x509af_private_data_t *x509af_data = (x509af_private_data_t*)p_get_proto_data(pinfo->pool, pinfo, proto_x509af, X509AF_PRIVATE_DATA_KEY);

  if (!x509af_data) {

    x509af_data = wmem_new0(pinfo->pool, x509af_private_data_t);

    nstime_set_unset(&x509af_data->not_before);

    nstime_set_unset(&x509af_data->not_after);

    p_add_proto_data(pinfo->pool, pinfo, proto_x509af, X509AF_PRIVATE_DATA_KEY, x509af_data);

  }

  return x509af_data;

}

const value_string x509af_Version_vals[] = {

  {   0, "v1" },

  {   1, "v2" },

  {   2, "v3" },

  { 0, NULL }

};

unsigned

dissect_x509af_Version(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,

                                                NULL);

  return offset;

}

unsigned

dissect_x509af_CertificateSerialNumber(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_integer64(implicit_tag, actx, tree, tvb, offset, hf_index,

                                                NULL);

  return offset;

}

static unsigned

dissect_x509af_T_algorithmId(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  const char *name;

    offset = dissect_ber_object_identifier_str(implicit_tag, actx, tree, tvb, offset, hf_x509af_algorithm_id, &actx->external.direct_reference);

  if(actx->external.direct_reference) {

    algorithm_id = (const char *)wmem_strdup(wmem_file_scope(), actx->external.direct_reference);

    name = oid_resolved_from_string(actx->pinfo->pool, actx->external.direct_reference);

    proto_item_append_text(tree, " (%s)", name ? name : actx->external.direct_reference);

  }

  return offset;

}

static unsigned

dissect_x509af_T_parameters(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset=call_ber_oid_callback(actx->external.direct_reference, tvb, offset, actx->pinfo, tree, NULL);

  return offset;

}

static const ber_sequence_t AlgorithmIdentifier_sequence[] = {

  { &hf_x509af_algorithmId  , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_x509af_T_algorithmId },

  { &hf_x509af_parameters   , BER_CLASS_ANY, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509af_T_parameters },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_AlgorithmIdentifier(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  if (algorithm_id) {

    wmem_free(wmem_file_scope(), (void*)algorithm_id);

    algorithm_id = NULL;

  }

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   AlgorithmIdentifier_sequence, hf_index, ett_x509af_AlgorithmIdentifier);

  return offset;

}

static unsigned

dissect_x509af_T_utcTime(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  char *outstr, *newstr;

  int old_offset = offset;

  x509af_private_data_t *x509af_data = x509af_get_private_data(actx->pinfo);

  /* the 2-digit year can only be in the range 1950..2049 https://tools.ietf.org/html/rfc5280#section-4.1.2.5.1 */

  offset = dissect_ber_UTCTime(implicit_tag, actx, tree, tvb, offset, -1, &outstr, NULL);

  if (hf_index > 0 && outstr) {

    nstime_t time_val;

    newstr = wmem_strconcat(actx->pinfo->pool, outstr[0] < '5' ? "20": "19", outstr, NULL);

    iso8601_to_nstime(&time_val, newstr, ISO8601_DATETIME_AUTO);

    /* move past TLV */

    old_offset = get_ber_identifier(tvb, old_offset, NULL, NULL, NULL);

    old_offset = get_ber_length(tvb, old_offset, NULL, NULL);

    proto_tree_add_time(tree, hf_index, tvb, old_offset, offset - old_offset, &time_val);

    nstime_copy(&x509af_data->last_time, &time_val);

  }

  return offset;

}

static unsigned

dissect_x509af_GeneralizedTime(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_GeneralizedTime(implicit_tag, actx, tree, tvb, offset, hf_index);

  return offset;

}

const value_string x509af_Time_vals[] = {

  {   0, "utcTime" },

  {   1, "generalizedTime" },

  { 0, NULL }

};

static const ber_choice_t Time_choice[] = {

  {   0, &hf_x509af_utcTime      , BER_CLASS_UNI, BER_UNI_TAG_UTCTime, BER_FLAGS_NOOWNTAG, dissect_x509af_T_utcTime },

  {   1, &hf_x509af_generalizedTime, BER_CLASS_UNI, BER_UNI_TAG_GeneralizedTime, BER_FLAGS_NOOWNTAG, dissect_x509af_GeneralizedTime },

  { 0, NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_Time(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  x509af_private_data_t *x509af_data = x509af_get_private_data(actx->pinfo);

  nstime_set_unset(&x509af_data->last_time);

  offset = dissect_ber_choice(actx, tree, tvb, offset,

                                 Time_choice, hf_index, ett_x509af_Time,

                                 NULL);

  return offset;

}

static unsigned

dissect_x509af_T_notBefore(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_x509af_Time(implicit_tag, tvb, offset, actx, tree, hf_index);

  x509af_private_data_t *x509af_data = x509af_get_private_data(actx->pinfo);

  nstime_copy(&x509af_data->not_before, &x509af_data->last_time);

  return offset;

}

static unsigned

dissect_x509af_T_notAfter(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_x509af_Time(implicit_tag, tvb, offset, actx, tree, hf_index);

  x509af_private_data_t *x509af_data = x509af_get_private_data(actx->pinfo);

  nstime_copy(&x509af_data->not_after, &x509af_data->last_time);

  if (actx->pinfo->presence_flags & PINFO_HAS_TS &&

      !nstime_is_unset(&x509af_data->not_before) &&

      !nstime_is_unset(&x509af_data->not_after)) {

    if (nstime_cmp(&x509af_data->not_before, &x509af_data->not_after) > 0) {

      expert_add_info_format(actx->pinfo, proto_tree_get_parent(tree), &ei_x509af_certificate_invalid, "Invalid certificate (notBefore time is after notAfter time)");

    } else if ((nstime_cmp(&x509af_data->not_before, &actx->pinfo->abs_ts) > 0) || (nstime_cmp(&actx->pinfo->abs_ts, &x509af_data->not_after) > 0)) {

      expert_add_info_format(actx->pinfo, proto_tree_get_parent(tree), &ei_x509af_certificate_invalid, "Invalid certificate (frame arrival time %s not in valid interval)", abs_time_to_str(actx->pinfo->pool, &actx->pinfo->abs_ts, ABSOLUTE_TIME_UTC, true));

    }

  }

  return offset;

}

static const ber_sequence_t Validity_sequence[] = {

  { &hf_x509af_notBefore    , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_x509af_T_notBefore },

  { &hf_x509af_notAfter     , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_x509af_T_notAfter },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_Validity(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   Validity_sequence, hf_index, ett_x509af_Validity);

  return offset;

}

static const value_string x509af_SubjectName_vals[] = {

  {   0, "rdnSequence" },

  { 0, NULL }

};

static const ber_choice_t SubjectName_choice[] = {

  {   0, &hf_x509af_rdnSequence  , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509if_RDNSequence },

  { 0, NULL, 0, 0, 0, NULL }

};

static unsigned

dissect_x509af_SubjectName(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  const char* str;

    offset = dissect_ber_choice(actx, tree, tvb, offset,

                                 SubjectName_choice, hf_index, ett_x509af_SubjectName,

                                 NULL);

  str = x509if_get_last_dn();

  proto_item_append_text(proto_item_get_parent(tree), " (%s)", str?str:"");

  x509af_eo_t *eo_info = p_get_proto_data(actx->pinfo->pool, actx->pinfo, proto_x509af, X509AF_EO_INFO_KEY);

  if (eo_info) {

    eo_info->subjectname = str;

  }

  return offset;

}

static unsigned

dissect_x509af_T_subjectPublicKey(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  tvbuff_t *bs_tvb = NULL;

  offset = dissect_ber_bitstring(false, actx, tree, tvb, offset,

                                 NULL, 0, hf_index, -1, &bs_tvb);

  /* See RFC 3279 for possible subjectPublicKey values given an Algorithm ID.

   * The contents of subjectPublicKey are always explicitly tagged. */

  if (bs_tvb && !g_strcmp0(algorithm_id, "1.2.840.113549.1.1.1")) { /* id-rsa */

    proto_tree *subtree = proto_item_add_subtree(actx->created_item, ett_x509af_SubjectPublicKey);

    dissect_pkixalgs_RSAPublicKey(false, bs_tvb, 0, actx, subtree, hf_x509af_subjectPublicKey_rsa);

  } else if (bs_tvb && !g_strcmp0(algorithm_id, "1.2.840.10040.4.1")) { /* id-dsa */

    proto_tree *subtree = proto_item_add_subtree(actx->created_item, ett_x509af_SubjectPublicKey);

    dissect_pkixalgs_DSAPublicKey(false, bs_tvb, 0, actx, subtree, hf_x509af_subjectPublicKey_dsa);

  } else if (bs_tvb && !g_strcmp0(algorithm_id, "1.2.840.10046.2.1")) { /* dhpublicnumber */

    proto_tree *subtree = proto_item_add_subtree(actx->created_item, ett_x509af_SubjectPublicKey);

    dissect_pkixalgs_DHPublicKey(false, bs_tvb, 0, actx, subtree, hf_x509af_subjectPublicKey_dh);

  }

  return offset;

}

static const ber_sequence_t SubjectPublicKeyInfo_sequence[] = {

  { &hf_x509af_algorithm    , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_AlgorithmIdentifier },

  { &hf_x509af_subjectPublicKey, BER_CLASS_UNI, BER_UNI_TAG_BITSTRING, BER_FLAGS_NOOWNTAG, dissect_x509af_T_subjectPublicKey },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_SubjectPublicKeyInfo(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  int orig_offset = offset;

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   SubjectPublicKeyInfo_sequence, hf_index, ett_x509af_SubjectPublicKeyInfo);

  x509af_export_publickey(tvb, actx, orig_offset, offset - orig_offset);

  return offset;

}

static unsigned

dissect_x509af_T_extnId(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  const char *name;

    offset = dissect_ber_object_identifier_str(implicit_tag, actx, tree, tvb, offset, hf_x509af_extension_id, &actx->external.direct_reference);

  if(actx->external.direct_reference) {

    name = oid_resolved_from_string(actx->pinfo->pool, actx->external.direct_reference);

    proto_item_append_text(tree, " (%s)", name ? name : actx->external.direct_reference);

  }

  return offset;

}

static unsigned

dissect_x509af_BOOLEAN(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_boolean(implicit_tag, actx, tree, tvb, offset, hf_index, NULL);

  return offset;

}

static unsigned

dissect_x509af_T_extnValue(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  int8_t ber_class;

  bool pc, ind;

  int32_t tag;

  uint32_t len;

  /* skip past the T and L  */

  offset = dissect_ber_identifier(actx->pinfo, tree, tvb, offset, &ber_class, &pc, &tag);

  offset = dissect_ber_length(actx->pinfo, tree, tvb, offset, &len, &ind);

  offset=call_ber_oid_callback(actx->external.direct_reference, tvb, offset, actx->pinfo, tree, NULL);

  return offset;

}

static const ber_sequence_t Extension_sequence[] = {

  { &hf_x509af_extnId       , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_x509af_T_extnId },

  { &hf_x509af_critical     , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509af_BOOLEAN },

  { &hf_x509af_extnValue    , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_x509af_T_extnValue },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_Extension(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   Extension_sequence, hf_index, ett_x509af_Extension);

  return offset;

}

static const ber_sequence_t Extensions_sequence_of[1] = {

  { &hf_x509af_Extensions_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_Extension },

};

unsigned

dissect_x509af_Extensions(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,

                                      Extensions_sequence_of, hf_index, ett_x509af_Extensions);

  return offset;

}

static const ber_sequence_t T_signedCertificate_sequence[] = {

  { &hf_x509af_version      , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL, dissect_x509af_Version },

  { &hf_x509af_serialNumber , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_x509af_CertificateSerialNumber },

  { &hf_x509af_signature    , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_AlgorithmIdentifier },

  { &hf_x509af_issuer       , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG, dissect_x509if_Name },

  { &hf_x509af_validity     , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_Validity },

  { &hf_x509af_subject      , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_x509af_SubjectName },

  { &hf_x509af_subjectPublicKeyInfo, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_SubjectPublicKeyInfo },

  { &hf_x509af_issuerUniqueIdentifier, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_x509sat_UniqueIdentifier },

  { &hf_x509af_subjectUniqueIdentifier, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_x509sat_UniqueIdentifier },

  { &hf_x509af_extensions   , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL, dissect_x509af_Extensions },

  { NULL, 0, 0, 0, NULL }

};

static unsigned

dissect_x509af_T_signedCertificate(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   T_signedCertificate_sequence, hf_index, ett_x509af_T_signedCertificate);

  return offset;

}

static unsigned

dissect_x509af_BIT_STRING(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_bitstring(implicit_tag, actx, tree, tvb, offset,

                                    NULL, 0, hf_index, -1,

                                    NULL);

  return offset;

}

static const ber_sequence_t Certificate_sequence[] = {

  { &hf_x509af_signedCertificate, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_T_signedCertificate },

  { &hf_x509af_algorithmIdentifier, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_AlgorithmIdentifier },

  { &hf_x509af_encrypted    , BER_CLASS_UNI, BER_UNI_TAG_BITSTRING, BER_FLAGS_NOOWNTAG, dissect_x509af_BIT_STRING },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_Certificate(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  int start_offset = offset;

  x509af_eo_t *eo_info = NULL;

  if (have_tap_listener(x509af_eo_tap)) {

    eo_info = wmem_new0(actx->pinfo->pool, x509af_eo_t);

    p_add_proto_data(actx->pinfo->pool, actx->pinfo, proto_x509af, X509AF_EO_INFO_KEY, eo_info);

  }

    offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   Certificate_sequence, hf_index, ett_x509af_Certificate);

  if (eo_info) {

    eo_info->payload = tvb_new_subset_length(tvb, start_offset, offset - start_offset);

    tap_queue_packet(x509af_eo_tap, actx->pinfo, eo_info);

  }

  return offset;

}

static const ber_sequence_t CrossCertificates_set_of[1] = {

  { &hf_x509af_CrossCertificates_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_Certificate },

};

unsigned

dissect_x509af_CrossCertificates(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_set_of(implicit_tag, actx, tree, tvb, offset,

                                 CrossCertificates_set_of, hf_index, ett_x509af_CrossCertificates);

  return offset;

}

static const ber_sequence_t ForwardCertificationPath_sequence_of[1] = {

  { &hf_x509af_ForwardCertificationPath_item, BER_CLASS_UNI, BER_UNI_TAG_SET, BER_FLAGS_NOOWNTAG, dissect_x509af_CrossCertificates },

};

unsigned

dissect_x509af_ForwardCertificationPath(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,

                                      ForwardCertificationPath_sequence_of, hf_index, ett_x509af_ForwardCertificationPath);

  return offset;

}

static const ber_sequence_t Certificates_sequence[] = {

  { &hf_x509af_userCertificate, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_Certificate },

  { &hf_x509af_certificationPath, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509af_ForwardCertificationPath },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_Certificates(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   Certificates_sequence, hf_index, ett_x509af_Certificates);

  return offset;

}

static const ber_sequence_t CertificatePair_sequence[] = {

  { &hf_x509af_issuedByThisCA, BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL, dissect_x509af_Certificate },

  { &hf_x509af_issuedToThisCA, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL, dissect_x509af_Certificate },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_CertificatePair(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   CertificatePair_sequence, hf_index, ett_x509af_CertificatePair);

  return offset;

}

static const ber_sequence_t SEQUENCE_OF_CertificatePair_sequence_of[1] = {

  { &hf_x509af_theCACertificates_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_CertificatePair },

};

static unsigned

dissect_x509af_SEQUENCE_OF_CertificatePair(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,

                                      SEQUENCE_OF_CertificatePair_sequence_of, hf_index, ett_x509af_SEQUENCE_OF_CertificatePair);

  return offset;

}

static const ber_sequence_t CertificationPath_sequence[] = {

  { &hf_x509af_userCertificate, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_Certificate },

  { &hf_x509af_theCACertificates, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509af_SEQUENCE_OF_CertificatePair },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_CertificationPath(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   CertificationPath_sequence, hf_index, ett_x509af_CertificationPath);

  return offset;

}

static const ber_sequence_t T_revokedCertificates_item_sequence[] = {

  { &hf_x509af_revokedUserCertificate, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_x509af_CertificateSerialNumber },

  { &hf_x509af_revocationDate, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_x509af_Time },

  { &hf_x509af_crlEntryExtensions, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509af_Extensions },

  { NULL, 0, 0, 0, NULL }

};

static unsigned

dissect_x509af_T_revokedCertificates_item(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   T_revokedCertificates_item_sequence, hf_index, ett_x509af_T_revokedCertificates_item);

  return offset;

}

static const ber_sequence_t T_revokedCertificates_sequence_of[1] = {

  { &hf_x509af_revokedCertificates_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_T_revokedCertificates_item },

};

static unsigned

dissect_x509af_T_revokedCertificates(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,

                                      T_revokedCertificates_sequence_of, hf_index, ett_x509af_T_revokedCertificates);

  return offset;

}

static const ber_sequence_t T_signedCertificateList_sequence[] = {

  { &hf_x509af_version      , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509af_Version },

  { &hf_x509af_signature    , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_AlgorithmIdentifier },

  { &hf_x509af_issuer       , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG, dissect_x509if_Name },

  { &hf_x509af_thisUpdate   , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_x509af_Time },

  { &hf_x509af_nextUpdate   , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_x509af_Time },

  { &hf_x509af_revokedCertificates, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509af_T_revokedCertificates },

  { &hf_x509af_crlExtensions, BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL, dissect_x509af_Extensions },

  { NULL, 0, 0, 0, NULL }

};

static unsigned

dissect_x509af_T_signedCertificateList(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   T_signedCertificateList_sequence, hf_index, ett_x509af_T_signedCertificateList);

  return offset;

}

static const ber_sequence_t CertificateList_sequence[] = {

  { &hf_x509af_signedCertificateList, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_T_signedCertificateList },

  { &hf_x509af_algorithmIdentifier, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_AlgorithmIdentifier },

  { &hf_x509af_encrypted    , BER_CLASS_UNI, BER_UNI_TAG_BITSTRING, BER_FLAGS_NOOWNTAG, dissect_x509af_BIT_STRING },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_CertificateList(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   CertificateList_sequence, hf_index, ett_x509af_CertificateList);

  return offset;

}

static const ber_sequence_t IssuerSerial_sequence[] = {

  { &hf_x509af_issuerName   , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509ce_GeneralNames },

  { &hf_x509af_serial       , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_x509af_CertificateSerialNumber },

  { &hf_x509af_issuerUID    , BER_CLASS_UNI, BER_UNI_TAG_BITSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509sat_UniqueIdentifier },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_IssuerSerial(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   IssuerSerial_sequence, hf_index, ett_x509af_IssuerSerial);

  return offset;

}

static const value_string x509af_InfoSubject_vals[] = {

  {   0, "baseCertificateID" },

  {   1, "subjectName" },

  { 0, NULL }

};

static const ber_choice_t InfoSubject_choice[] = {

  {   0, &hf_x509af_baseCertificateID, BER_CLASS_CON, 0, 0, dissect_x509af_IssuerSerial },

  {   1, &hf_x509af_infoSubjectName, BER_CLASS_CON, 1, 0, dissect_x509ce_GeneralNames },

  { 0, NULL, 0, 0, 0, NULL }

};

static unsigned

dissect_x509af_InfoSubject(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_choice(actx, tree, tvb, offset,

                                 InfoSubject_choice, hf_index, ett_x509af_InfoSubject,

                                 NULL);

  return offset;

}

static const ber_sequence_t AttCertValidityPeriod_sequence[] = {

  { &hf_x509af_notBeforeTime, BER_CLASS_UNI, BER_UNI_TAG_GeneralizedTime, BER_FLAGS_NOOWNTAG, dissect_x509af_GeneralizedTime },

  { &hf_x509af_notAfterTime , BER_CLASS_UNI, BER_UNI_TAG_GeneralizedTime, BER_FLAGS_NOOWNTAG, dissect_x509af_GeneralizedTime },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_AttCertValidityPeriod(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   AttCertValidityPeriod_sequence, hf_index, ett_x509af_AttCertValidityPeriod);

  return offset;

}

static const ber_sequence_t SEQUENCE_OF_Attribute_sequence_of[1] = {

  { &hf_x509af_attributes_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509if_Attribute },

};

static unsigned

dissect_x509af_SEQUENCE_OF_Attribute(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,

                                      SEQUENCE_OF_Attribute_sequence_of, hf_index, ett_x509af_SEQUENCE_OF_Attribute);

  return offset;

}

static const ber_sequence_t AttributeCertificateInfo_sequence[] = {

  { &hf_x509af_version      , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509af_Version },

  { &hf_x509af_info_subject , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_x509af_InfoSubject },

  { &hf_x509af_issuerName   , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509ce_GeneralNames },

  { &hf_x509af_signature    , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_AlgorithmIdentifier },

  { &hf_x509af_serialNumber , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_x509af_CertificateSerialNumber },

  { &hf_x509af_attCertValidityPeriod, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_AttCertValidityPeriod },

  { &hf_x509af_attributes   , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_SEQUENCE_OF_Attribute },

  { &hf_x509af_issuerUniqueID, BER_CLASS_UNI, BER_UNI_TAG_BITSTRING, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509sat_UniqueIdentifier },

  { &hf_x509af_extensions   , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509af_Extensions },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_AttributeCertificateInfo(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   AttributeCertificateInfo_sequence, hf_index, ett_x509af_AttributeCertificateInfo);

  return offset;

}

static const ber_sequence_t AttributeCertificate_sequence[] = {

  { &hf_x509af_signedAttributeCertificateInfo, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_AttributeCertificateInfo },

  { &hf_x509af_algorithmIdentifier, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_AlgorithmIdentifier },

  { &hf_x509af_encrypted    , BER_CLASS_UNI, BER_UNI_TAG_BITSTRING, BER_FLAGS_NOOWNTAG, dissect_x509af_BIT_STRING },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_AttributeCertificate(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   AttributeCertificate_sequence, hf_index, ett_x509af_AttributeCertificate);

  return offset;

}

static const ber_sequence_t ACPathData_sequence[] = {

  { &hf_x509af_certificate  , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL, dissect_x509af_Certificate },

  { &hf_x509af_attributeCertificate, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL, dissect_x509af_AttributeCertificate },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_ACPathData(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   ACPathData_sequence, hf_index, ett_x509af_ACPathData);

  return offset;

}

static const ber_sequence_t SEQUENCE_OF_ACPathData_sequence_of[1] = {

  { &hf_x509af_acPath_item  , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_ACPathData },

};

static unsigned

dissect_x509af_SEQUENCE_OF_ACPathData(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,

                                      SEQUENCE_OF_ACPathData_sequence_of, hf_index, ett_x509af_SEQUENCE_OF_ACPathData);

  return offset;

}

static const ber_sequence_t AttributeCertificationPath_sequence[] = {

  { &hf_x509af_attributeCertificate, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_x509af_AttributeCertificate },

  { &hf_x509af_acPath       , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_x509af_SEQUENCE_OF_ACPathData },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_AttributeCertificationPath(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   AttributeCertificationPath_sequence, hf_index, ett_x509af_AttributeCertificationPath);

  return offset;

}

static const value_string x509af_AssertionSubject_vals[] = {

  {   0, "baseCertificateID" },

  {   1, "subjectName" },

  { 0, NULL }

};

static const ber_choice_t AssertionSubject_choice[] = {

  {   0, &hf_x509af_baseCertificateID, BER_CLASS_CON, 0, 0, dissect_x509af_IssuerSerial },

  {   1, &hf_x509af_assertionSubjectName, BER_CLASS_CON, 1, 0, dissect_x509af_SubjectName },

  { 0, NULL, 0, 0, 0, NULL }

};

static unsigned

dissect_x509af_AssertionSubject(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_choice(actx, tree, tvb, offset,

                                 AssertionSubject_choice, hf_index, ett_x509af_AssertionSubject,

                                 NULL);

  return offset;

}

static const ber_sequence_t SET_OF_AttributeType_set_of[1] = {

  { &hf_x509af_attType_item , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_x509if_AttributeType },

};

static unsigned

dissect_x509af_SET_OF_AttributeType(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_set_of(implicit_tag, actx, tree, tvb, offset,

                                 SET_OF_AttributeType_set_of, hf_index, ett_x509af_SET_OF_AttributeType);

  return offset;

}

static const ber_sequence_t AttributeCertificateAssertion_sequence[] = {

  { &hf_x509af_assertion_subject, BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL, dissect_x509af_AssertionSubject },

  { &hf_x509af_assertionIssuer, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL, dissect_x509if_Name },

  { &hf_x509af_attCertValidity, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL, dissect_x509af_GeneralizedTime },

  { &hf_x509af_attType      , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL, dissect_x509af_SET_OF_AttributeType },

  { NULL, 0, 0, 0, NULL }

};

unsigned

dissect_x509af_AttributeCertificateAssertion(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   AttributeCertificateAssertion_sequence, hf_index, ett_x509af_AttributeCertificateAssertion);

  return offset;

}

static unsigned

dissect_x509af_INTEGER(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,

                                                NULL);

  return offset;

}

static const ber_sequence_t DSS_Params_sequence[] = {

  { &hf_x509af_p            , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_x509af_INTEGER },

  { &hf_x509af_q            , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_x509af_INTEGER },

  { &hf_x509af_g            , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_x509af_INTEGER },

  { NULL, 0, 0, 0, NULL }

};

static unsigned

dissect_x509af_DSS_Params(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,

                                   DSS_Params_sequence, hf_index, ett_x509af_DSS_Params);

  return offset;

}

static unsigned

dissect_x509af_Userid(bool implicit_tag _U_, tvbuff_t *tvb _U_, unsigned offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {

  offset = dissect_ber_constrained_restricted_string(implicit_tag, BER_UNI_TAG_UTF8String,

                                                        actx, tree, tvb, offset,

                                                        1, ub_user_identifier, hf_index, NULL);

  return offset;

}

/*--- PDUs ---*/

int dissect_x509af_Certificate_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) {

  unsigned offset = 0;

  asn1_ctx_t asn1_ctx;

  asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, true, pinfo);

  offset = dissect_x509af_Certificate(false, tvb, offset, &asn1_ctx, tree, hf_x509af_x509af_Certificate_PDU);

  return offset;

}

static int dissect_SubjectPublicKeyInfo_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) {

  unsigned offset = 0;

  asn1_ctx_t asn1_ctx;

  asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, true, pinfo);

  offset = dissect_x509af_SubjectPublicKeyInfo(false, tvb, offset, &asn1_ctx, tree, hf_x509af_SubjectPublicKeyInfo_PDU);

  return offset;

}

static int dissect_CertificatePair_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) {

  unsigned offset = 0;

  asn1_ctx_t asn1_ctx;

  asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, true, pinfo);

  offset = dissect_x509af_CertificatePair(false, tvb, offset, &asn1_ctx, tree, hf_x509af_CertificatePair_PDU);

  return offset;

}

static int dissect_CertificateList_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) {

  unsigned offset = 0;

  asn1_ctx_t asn1_ctx;

  asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, true, pinfo);

  offset = dissect_x509af_CertificateList(false, tvb, offset, &asn1_ctx, tree, hf_x509af_CertificateList_PDU);

  return offset;

}

static int dissect_AttributeCertificate_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) {

  unsigned offset = 0;

  asn1_ctx_t asn1_ctx;

  asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, true, pinfo);

  offset = dissect_x509af_AttributeCertificate(false, tvb, offset, &asn1_ctx, tree, hf_x509af_AttributeCertificate_PDU);

  return offset;

}

static int dissect_DSS_Params_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) {

  unsigned offset = 0;

  asn1_ctx_t asn1_ctx;

  asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, true, pinfo);

  offset = dissect_x509af_DSS_Params(false, tvb, offset, &asn1_ctx, tree, hf_x509af_DSS_Params_PDU);

  return offset;

}

static int dissect_Userid_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) {

  unsigned offset = 0;

  asn1_ctx_t asn1_ctx;

  asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, true, pinfo);

  offset = dissect_x509af_Userid(false, tvb, offset, &asn1_ctx, tree, hf_x509af_Userid_PDU);

  return offset;