~ubuntu-branches/ubuntu/gutsy/wireshark/gutsy-security

/* Do not modify this file.                                                   */

/* It is created automatically by the ASN.1 to Wireshark dissector compiler   */

/* ../../tools/asn2wrs.py -b -e -p spnego -c spnego.cnf -s packet-spnego-template spnego.asn */

 

/* Input file: packet-spnego-template.c */

 * Copyright 2005, Ronnie Sahlberg (krb decryption)

 * Copyright 2005, Anders Broman (converted to asn2wrs generated dissector)

 *

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

#include "packet-dcerpc.h"

#include "packet-gssapi.h"

#include "packet-kerberos.h"

#include <epan/conversation.h>

#include <epan/emem.h>

 

dissect_spnego_MechTypeList(gboolean implicit_tag _U_, tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, int hf_index _U_) {

#line 91 "spnego.cnf"

 

  saw_mechanism = FALSE;

 

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

                                      MechTypeList_sequence_of, hf_index, ett_spnego_MechTypeList);

 

  return offset;

}

static int dissect_mechTypes(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int offset) {

 

static int

dissect_spnego_T_mechToken(gboolean implicit_tag _U_, tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, int hf_index _U_) {

 

  tvbuff_t *mechToken_tvb = NULL;

 

 

static int

dissect_spnego_T_NegTokenInit_mechListMIC(gboolean implicit_tag _U_, tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, int hf_index _U_) {

 

  gint8 class;

  gboolean pc;

 

static int

dissect_spnego_T_supportedMech(gboolean implicit_tag _U_, tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, int hf_index _U_) {

 

  conversation_t *conversation;

 

 

 

  /*

   */

    conversation_add_proto_data(conversation, proto_spnego, next_level_value);

  }

 

 

static int

dissect_spnego_T_responseToken(gboolean implicit_tag _U_, tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, int hf_index _U_) {

 

  tvbuff_t *responseToken_tvb;

 

   * However, we should make sure that there is something in the 

   * response token ...

   */

  }

 

 

 

static int

dissect_spnego_T_mechListMIC(gboolean implicit_tag _U_, tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, int hf_index _U_) {

 

  tvbuff_t *mechListMIC_tvb;

 

   * Now, we should be able to dispatch, if we've gotten a tvbuff for

   * the MIC and we have information on how to dissect its contents.

   */

 

 

 

#line 100 "packet-spnego-template.c"

/*

 * This is the SPNEGO KRB5 dissector. It is not true KRB5, but some ASN.1

 * ASN.1 wrapped by the looks of it. It conforms to RFC1964.

 

#define KRB_TOKEN_AP_REQ                0x0001

#define KRB_TOKEN_AP_REP                0x0002

        gint32 tag;

        guint32 len;

 

                                   -1, FALSE);

 

        subtree = proto_item_add_subtree(item, ett_spnego_krb5);

         * [APPLICATION 0] {

         *   OID,

         *   USHORT (0x0001 == AP-REQ, 0x0002 == AP-REP, 0x0003 == ERROR),

         *

         * However, for some protocols, the KRB5 blob starts at the SHORT

         * and has no DER encoded header etc.

        case KRB_TOKEN_AP_REQ:

        case KRB_TOKEN_AP_REP:

        case KRB_TOKEN_AP_ERR:

          offset = dissect_kerberos_main(krb5_tvb, pinfo, subtree, FALSE, NULL);

          break;

 

        case KRB_TOKEN_GETMIC:

          break;

 

        case KRB_TOKEN_WRAP:

}

 

#ifdef HAVE_KERBEROS

 

#ifndef KEYTYPE_ARCFOUR_56

# define KEYTYPE_ARCFOUR_56 24

 

        memcpy(L40 + 10, T, sizeof(T));

        md5_hmac(

                key_data,

                k5_data);

        memset(&k5_data[7], 0xAB, 9);

    } else {

        md5_hmac(

                key_data,

                key_size,

                k5_data);

    }

 

    md5_hmac(

        k5_data,

        key6_data);

 

    return 0;

    unsigned char digest[16];

    int rc4_usage;

    guint8 cksum[16];

    rc4_usage=usage2arcfour(usage);

                ksign_c);

    md5_init(&ms);

    t[0] = (rc4_usage >>  0) & 0xFF;

 * Verify padding of a gss wrapped message and return its length.

 */

static int

                   size_t datalen,

                   size_t *padlen)

{

 

    {

        rc4_state_struct rc4_state;

        crypt_rc4_init(&rc4_state, k6_data, sizeof(k6_data));

        memcpy(SND_SEQ, (unsigned char *)tvb_get_ptr(pinfo->gssapi_wrap_tvb, 8, 8), 8);

        crypt_rc4(&rc4_state, SND_SEQ, 8);

        memcpy(output_message_buffer, input_message_buffer, datalen);

        crypt_rc4(&rc4_state, output_message_buffer, datalen);

    } else {

                8); /* Confounder */

                datalen);

    }

    memset(k6_data, 0, sizeof(k6_data));

    if(pinfo->decrypt_gssapi_tvb==DECRYPT_GSSAPI_NORMAL){

        ret = arcfour_mic_cksum(key_value, key_size,

                            KRB5_KU_USAGE_SEAL,

                            tvb_get_ptr(pinfo->gssapi_wrap_tvb, 0, 8), 8,

                            Confounder, sizeof(Confounder),

                            datalen + padlen);

        if (ret) {

            return -10;

        }

 

            tvb_get_ptr(pinfo->gssapi_wrap_tvb, 16, 8),

            8); /* SGN_CKSUM */

        if (cmp) {

        /*

         * The KRB5 blob conforms to RFC1964:

         *   USHORT (0x0102 == GSS_Wrap)

         */

 

        /* Now, the sign and seal algorithms ... */

                        int len;

                        len=tvb_reported_length_remaining(tvb,offset);

                        if(len>tvb_length_remaining(tvb, offset)){

                                   we dont have the full pdu.

                                */

                                return offset;

                        pinfo->gssapi_encrypted_tvb = tvb_new_subset(

                                        tvb, offset, len, len);

                }

                /* if this is KRB5 wrapped rc4-hmac */

                if((token_id==KRB_TOKEN_WRAP)

                 &&(sgn_alg==KRB_SGN_ALG_HMAC)

                                23 /* rc4-hmac */);

#endif /* HAVE_HEIMDAL_KERBEROS || HAVE_MIT_KERBEROS */

                }

#endif

        /*

         * Return the offset past the checksum, so that we know where

         * the data we're wrapped around starts.  Also, set the length

         * of our top-level item to that offset, so it doesn't cover

         * the data we're wrapped around.

         * Note that for DCERPC the GSSAPI blobs comes after the data it wraps,

         * not before.

         */

        /*

         * The KRB5 blob conforms to RFC1964:

         *   USHORT (0x0101 == GSS_GetMIC)

         */

 

        /* Now, the sign algorithm ... */

        /*

         * The KRB5 blob conforms to RFC1964:

         *   USHORT (0x0102 == GSS_Wrap)

         */

 

        /* First, the token ID ... */

         */

 

 

                                   -1, FALSE);

 

        subtree = proto_item_add_subtree(item, ett_spnego);

                                             pinfo->destport, 0);

 

            if (conversation) {

                                                               proto_spnego);

                if (next_level_value)

                    p_add_proto_data(pinfo->fd, proto_spnego, next_level_value);

            }

        }

 

                                   -1, FALSE);

 

        subtree = proto_item_add_subtree(item, ett_spnego);

                  { "krb5_blob", "spnego.krb5.blob", FT_BYTES,

                    BASE_NONE, NULL, 0, "krb5_blob", HFILL }},

                { &hf_spnego_krb5_oid,

                    BASE_NONE, NULL, 0, "KRB5 OID", HFILL }},

                { &hf_spnego_krb5_tok_id,

                  { "krb5_tok_id", "spnego.krb5.tok_id", FT_UINT16, BASE_HEX,