/*

 * snmpksm.c

 *

 * This code implements the Kerberos Security Model (KSM) for SNMP.

 *

 * Security number - 2066432

 */

#include <net-snmp/net-snmp-config.h>

#include <sys/types.h>

#include <stdio.h>

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#if TIME_WITH_SYS_TIME

# include <sys/time.h>

# include <time.h>

#else

# if HAVE_SYS_TIME_H

#  include <sys/time.h>

# else

#  include <time.h>

# endif

#endif

#if HAVE_STRING_H

#include <string.h>

#else

#include <strings.h>

#endif

#ifdef HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#include <errno.h>

#if HAVE_DMALLOC_H

#include <dmalloc.h>

#endif

#ifdef NETSNMP_USE_KERBEROS_HEIMDAL

#ifndef NETSNMP_USE_KERBEROS_MIT

#define OLD_HEIMDAL

#endif 				/* ! NETSNMP_USE_KERBEROS_MIT */

#else

#define KRB5_DEPRECATED 1

#endif 				/* NETSNMP_USE_KERBEROS_HEIMDAL */

#ifdef NETSNMP_USE_KERBEROS_HEIMDAL

#define oid heimdal_oid_renamed

#endif				/* NETSNMP_USE_KERBEROS_HEIMDAL */

#include <krb5.h>

#ifdef NETSNMP_USE_KERBEROS_HEIMDAL

#undef oid

#endif				/* NETSNMP_USE_KERBEROS_HEIMDAL */

#ifdef NETSNMP_USE_KERBEROS_HEIMDAL

#define CHECKSUM_TYPE(x)	(x)->cksumtype

#define CHECKSUM_CONTENTS(x)	(x)->checksum.data

#define CHECKSUM_LENGTH(x)	(x)->checksum.length

#define TICKET_CLIENT(x)	(x)->client

#else				/* NETSNMP_USE_KERBEROS_HEIMDAL */

#define CHECKSUM_TYPE(x)	(x)->checksum_type

#define CHECKSUM_CONTENTS(x)	(x)->contents

#define CHECKSUM_LENGTH(x)	(x)->length

#define TICKET_CLIENT(x)	(x)->enc_part2->client

#endif				/* NETSNMP_USE_KERBEROS_HEIMDAL */

#if HAVE_ET_COM_ERR_H

#include <et/com_err.h>

#elif HAVE_COM_ERR_H

#include <com_err.h>

#endif

#include <net-snmp/output_api.h>

#include <net-snmp/config_api.h>

#include <net-snmp/utilities.h>

#include <net-snmp/library/asn1.h>

#include <net-snmp/library/snmp_api.h>

#include <net-snmp/library/callback.h>

#include <net-snmp/library/keytools.h>

#include <net-snmp/library/snmpv3.h>

#include <net-snmp/library/lcd_time.h>

#include <net-snmp/library/scapi.h>

#include <net-snmp/library/callback.h>

#include <net-snmp/library/snmp_secmod.h>

#include <net-snmp/library/snmpksm.h>

static krb5_context kcontext = NULL;

static krb5_rcache rcache = NULL;

static krb5_keytab keytab = NULL;

static int keytab_setup = 0;

static char *service_name = NULL;

static char service_host[] = "host";

static u_char null_id[] = {0};

static int      ksm_session_init(netsnmp_session *);

static void     ksm_free_state_ref(void *);

static int      ksm_free_pdu(netsnmp_pdu *);

static int      ksm_clone_pdu(netsnmp_pdu *, netsnmp_pdu *);

static int      ksm_insert_cache(long, krb5_auth_context, u_char *,

                                 size_t);

static void     ksm_decrement_ref_count(long);

static void     ksm_increment_ref_count(long);

static struct ksm_cache_entry *ksm_get_cache(long);

#if !defined(HAVE_KRB5_AUTH_CON_GETSENDSUBKEY) /* Heimdal */

krb5_error_code krb5_auth_con_getsendsubkey(krb5_context context,

				krb5_auth_context auth_context, 

				krb5_keyblock **keyblock)

{

    return krb5_auth_con_getlocalsubkey(context, auth_context, keyblock);

}

#endif

#if !defined(HAVE_KRB5_AUTH_CON_GETRECVSUBKEY) /* Heimdal */

krb5_error_code krb5_auth_con_getrecvsubkey(krb5_context context,

				krb5_auth_context auth_context, 

				krb5_keyblock **keyblock)

{

    return krb5_auth_con_getremotesubkey(context, auth_context, keyblock);

}

#endif

#define HASHSIZE	64

/*

 * Our information stored for the response PDU.

 */

struct ksm_secStateRef {

    krb5_auth_context auth_context;

    krb5_cksumtype  cksumtype;

};

/*

 * A KSM outgoing pdu cache entry

 */

struct ksm_cache_entry {

    long            msgid;

    int             refcount;

    krb5_auth_context auth_context;

    u_char         *secName;

    size_t          secNameLen;

    struct ksm_cache_entry *next;

};

/*

 * Poor man's hash table

 */

static struct ksm_cache_entry *ksm_hash_table[HASHSIZE];

/*

 * Stuff to deal with config values

 * Note the conditionals that wrap these--i don't know if these are

 * needed, since i don't know how library initialization and callbacks

 * and stuff work

 */

static int

init_snmpksm_post_config(int majorid, int minorid, void *serverarg,

			 void *clientarg)

{

    if (kcontext == NULL) {

	/* not reached, i'd imagine */

        return SNMPERR_KRB5;

    }

    if (service_name == NULL) {

	/* always reached, i'd imagine */

	char *c = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,

					NETSNMP_DS_LIB_KSM_SERVICE_NAME);

	if (c != NULL) {

		service_name = c;

	}

	else {

		service_name = service_host;

	}

    }

    if (keytab_setup == 0) {

	/* always reached, i'd imagine */

	char *c = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,

					NETSNMP_DS_LIB_KSM_KEYTAB);

	if (c) {

	    krb5_error_code retval;

	    DEBUGMSGTL(("ksm", "Using keytab %s\n", c));

	    retval = krb5_kt_resolve(kcontext, c, &keytab);

	    if (retval) {

		DEBUGMSGTL(("ksm", "krb5_kt_resolve(\"%s\") failed. KSM "

			    "config callback failing\n", error_message(retval)));

		return SNMPERR_KRB5;

	    }

	}

	else {

	    DEBUGMSGTL(("ksm", "Using default keytab\n"));

	}

	keytab_setup = 1;

    }

    return SNMPERR_SUCCESS;

}

/*

 * Initialize all of the state required for Kerberos (right now, just call

 * krb5_init_context).

 */

void

init_ksm(void)

{

    krb5_error_code retval;

    struct snmp_secmod_def *def;

    int             i;

    netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defKSMKeytab",

                               NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_KSM_KEYTAB);

    netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defKSMServiceName",

                               NETSNMP_DS_LIBRARY_ID,

			       NETSNMP_DS_LIB_KSM_SERVICE_NAME);

    snmp_register_callback(SNMP_CALLBACK_LIBRARY,

			   SNMP_CALLBACK_POST_READ_CONFIG,

			   init_snmpksm_post_config, NULL);

    if (kcontext == NULL) {

        retval = krb5_init_context(&kcontext);

        if (retval) {

            DEBUGMSGTL(("ksm", "krb5_init_context failed (%s), not "

                        "registering KSM\n", error_message(retval)));

            return;

        }

    }

    for (i = 0; i < HASHSIZE; i++)

        ksm_hash_table[i] = NULL;

    def = SNMP_MALLOC_STRUCT(snmp_secmod_def);

    if (!def) {

        DEBUGMSGTL(("ksm", "Unable to malloc snmp_secmod struct, not "

                    "registering KSM\n"));

        return;

    }

    def->encode_reverse = ksm_rgenerate_out_msg;

    def->decode = ksm_process_in_msg;

    def->session_open = ksm_session_init;

    def->pdu_free_state_ref = ksm_free_state_ref;

    def->pdu_free = ksm_free_pdu;

    def->pdu_clone = ksm_clone_pdu;

    register_sec_mod(NETSNMP_SEC_MODEL_KSM, "ksm", def);

}

void shutdown_ksm(void)

{

}

/*

 * These routines implement a simple cache for information we need to

 * process responses.  When we send out a request, it contains an AP_REQ;

 * we get back an AP_REP, and we need the authorization context from the

 * AP_REQ to decrypt the AP_REP.  But because right now there's nothing

 * that gets preserved across calls to rgenerate_out_msg to process_in_msg,

 * we cache these internally based on the message ID (we also cache the

 * passed-in security name, for reasons that are mostly stupid).

 */

static int

ksm_insert_cache(long msgid, krb5_auth_context auth_context,

                 u_char * secName, size_t secNameLen)

{

    struct ksm_cache_entry *entry;

    int             bucket;

    entry = SNMP_MALLOC_STRUCT(ksm_cache_entry);

    if (!entry)

        return SNMPERR_MALLOC;

    entry->msgid = msgid;

    entry->auth_context = auth_context;

    entry->refcount = 1;

    entry->secName = netsnmp_memdup(secName, secNameLen);

    if (secName && !entry->secName) {

        free(entry);

        return SNMPERR_GENERR;

    }

    entry->secNameLen = secNameLen;

    bucket = msgid % HASHSIZE;

    entry->next = ksm_hash_table[bucket];

    ksm_hash_table[bucket] = entry;

    return SNMPERR_SUCCESS;

}

static struct ksm_cache_entry *

ksm_get_cache(long msgid)

{

    struct ksm_cache_entry *entry;

    int             bucket;

    bucket = msgid % HASHSIZE;

    for (entry = ksm_hash_table[bucket]; entry != NULL;

         entry = entry->next)

        if (entry->msgid == msgid)

            return entry;

    return NULL;

}

static void

ksm_decrement_ref_count(long msgid)

{

    struct ksm_cache_entry *entry, *entry1;

    int             bucket;

    bucket = msgid % HASHSIZE;

    if (ksm_hash_table[bucket] && ksm_hash_table[bucket]->msgid == msgid) {

        entry = ksm_hash_table[bucket];

        /*

         * If the reference count is zero, then free it

         */

        if (--entry->refcount <= 0) {

            DEBUGMSGTL(("ksm", "Freeing entry for msgid %ld\n", msgid));

            krb5_auth_con_free(kcontext, entry->auth_context);

            free(entry->secName);

            ksm_hash_table[bucket] = entry->next;

            free(entry);

        }

        return;

    } else if (ksm_hash_table[bucket])

        for (entry1 = ksm_hash_table[bucket], entry = entry1->next;

             entry != NULL; entry1 = entry, entry = entry->next)

            if (entry->msgid == msgid) {

                if (--entry->refcount <= 0) {

                    DEBUGMSGTL(("ksm", "Freeing entry for msgid %ld\n",

                                msgid));

                    krb5_auth_con_free(kcontext, entry->auth_context);

                    free(entry->secName);

                    entry1->next = entry->next;

                    free(entry);

                }

                return;

            }

    DEBUGMSGTL(("ksm",

                "KSM: Unable to decrement cache entry for msgid %ld.\n",

                msgid));

}

static void

ksm_increment_ref_count(long msgid)

{

    struct ksm_cache_entry *entry = ksm_get_cache(msgid);

    if (!entry) {

        DEBUGMSGTL(("ksm", "Unable to find cache entry for msgid %ld "

                    "for increment\n", msgid));

        return;

    }

    entry->refcount++;

}

/*

 * Initialize specific session information (right now, just set up things to

 * not do an engineID probe)

 */

static int

ksm_session_init(netsnmp_session * sess)

{

    DEBUGMSGTL(("ksm",

                "KSM: Reached our session initialization callback\n"));

    sess->flags |= SNMP_FLAGS_DONT_PROBE;

    return SNMPERR_SUCCESS;

}

/*

 * Free our state information (this is only done on the agent side)

 */

static void

ksm_free_state_ref(void *ptr)

{

    struct ksm_secStateRef *ref = (struct ksm_secStateRef *) ptr;

    DEBUGMSGTL(("ksm", "KSM: Freeing state reference\n"));

    krb5_auth_con_free(kcontext, ref->auth_context);

    free(ref);

}

/*

 * This is called when the PDU is freed; this will decrement reference counts

 * for entries in our state cache.

 */

static int

ksm_free_pdu(netsnmp_pdu *pdu)

{

    ksm_decrement_ref_count(pdu->msgid);

    DEBUGMSGTL(("ksm", "Decrementing cache entry for PDU msgid %ld\n",

                pdu->msgid));

    return SNMPERR_SUCCESS;

}

/*

 * This is called when a PDU is cloned (to increase reference counts)

 */

static int

ksm_clone_pdu(netsnmp_pdu *pdu, netsnmp_pdu *pdu2)

{

    ksm_increment_ref_count(pdu->msgid);

    DEBUGMSGTL(("ksm", "Incrementing cache entry for PDU msgid %ld\n",

                pdu->msgid));

    return SNMPERR_SUCCESS;

}

/****************************************************************************

 *

 * ksm_generate_out_msg

 *

 * Parameters:

 *	(See list below...)

 *

 * Returns:

 *	SNMPERR_GENERIC                        On success.

 *	SNMPERR_KRB5

 *	... and others

 *

 *

 * Generate an outgoing message.

 *

 ****************************************************************************/

int

ksm_rgenerate_out_msg(struct snmp_secmod_outgoing_params *parms)

{

    krb5_auth_context auth_context = NULL;

    krb5_error_code retcode;

    krb5_ccache     cc = NULL;

    int             retval = SNMPERR_SUCCESS;

    krb5_data       outdata, ivector;

    krb5_keyblock  *subkey = NULL;

#ifdef NETSNMP_USE_KERBEROS_MIT

    krb5_data       input;

    krb5_enc_data   output;

    unsigned int    numcksumtypes;

    krb5_cksumtype  *cksumtype_array;

#elif defined OLD_HEIMDAL	/* NETSNMP_USE_KERBEROS_MIT */

    krb5_crypto heim_crypto = NULL;

#else                           /* NETSNMP_USE_KERBEROS_MIT */

    krb5_encrypt_block eblock;

#endif                          /* NETSNMP_USE_KERBEROS_MIT */

    size_t          blocksize, encrypted_length;

    unsigned char  *encrypted_data = NULL;

    long            zero = 0, tmp;

    int             i;

    u_char         *cksum_pointer;

    krb5_cksumtype  cksumtype;

    krb5_checksum   pdu_checksum;

    u_char         **wholeMsg = parms->wholeMsg;

    size_t	   *offset = parms->wholeMsgOffset, seq_offset;

    struct ksm_secStateRef *ksm_state = (struct ksm_secStateRef *)

        parms->secStateRef;

#ifdef OLD_HEIMDAL

    krb5_data encrypted_scoped_pdu;

#endif				/* OLD_HEIMDAL */

    int rc;

    char *colon = NULL;

    DEBUGMSGTL(("ksm", "Starting KSM processing\n"));

    outdata.length = 0;

    outdata.data = NULL;

    ivector.length = 0;

    ivector.data = NULL;

    CHECKSUM_CONTENTS(&pdu_checksum) = NULL;

    if (!ksm_state) {

        /*

         * If we've got a port number as part of the "peername", then

         * suppress this (temporarily) while we build the credential info.

         *   XXX - what about "udp:host" style addresses?

         */

        colon = strrchr(parms->session->peername, ':');

        if (colon != NULL) {

            *colon='\0';

        }

        /*

         * If we don't have a ksm_state, then we're a request.  Get a

         * credential cache and build a ap_req.

         */

        retcode = krb5_cc_default(kcontext, &cc);

        if (retcode) {

            DEBUGMSGTL(("ksm", "KSM: krb5_cc_default failed: %s\n",

                        error_message(retcode)));

            snmp_set_detail(error_message(retcode));

            retval = SNMPERR_KRB5;

            goto error;

        }

        DEBUGMSGTL(("ksm", "KSM: Set credential cache successfully\n"));

        /*

         * This seems odd, since we don't need this until later (or earlier,

         * depending on how you look at it), but because the most likely

         * errors are Kerberos at this point, I'll get this now to save

         * time not encoding the rest of the packet.

         *

         * Also, we need the subkey to encrypt the PDU (if required).

         */

        retcode =

            krb5_mk_req(kcontext, &auth_context,

                        AP_OPTS_MUTUAL_REQUIRED | AP_OPTS_USE_SUBKEY,

                        service_name, parms->session->peername, NULL,

                        cc, &outdata);

        if (colon != NULL)

            *colon=':';

        if (retcode) {

            DEBUGMSGTL(("ksm", "KSM: krb5_mk_req failed: %s\n",

                        error_message(retcode)));

            snmp_set_detail(error_message(retcode));

            retval = SNMPERR_KRB5;

            goto error;

        }

	DEBUGMSGTL(("ksm", "KSM: ticket retrieved successfully for \"%s/%s\" "

		    "(may not be actual ticket sname)\n", service_name,

		    parms->session->peername));

    } else {

        /*

         * Grab the auth_context from our security state reference

         */

        auth_context = ksm_state->auth_context;

        /*

         * Bundle up an AP_REP.  Note that we do this only when we

         * have a security state reference (which means we're in an agent

         * and we're sending a response).

         */

        DEBUGMSGTL(("ksm", "KSM: Starting reply processing.\n"));

        retcode = krb5_mk_rep(kcontext, auth_context, &outdata);

        if (retcode) {

            DEBUGMSGTL(("ksm", "KSM: krb5_mk_rep failed: %s\n",

                        error_message(retcode)));

            snmp_set_detail(error_message(retcode));

            retval = SNMPERR_KRB5;

            goto error;

        }

        DEBUGMSGTL(("ksm", "KSM: Finished with krb5_mk_rep()\n"));

    }

    /*

     * If we have to encrypt the PDU, do that now

     */

    if (parms->secLevel == SNMP_SEC_LEVEL_AUTHPRIV) {

        DEBUGMSGTL(("ksm", "KSM: Starting PDU encryption.\n"));

        /*

         * It's weird -

         *

         * If we're on the manager, it's a local subkey (because that's in

         * our AP_REQ)

         *

         * If we're on the agent, it's a remote subkey (because that comes

         * FROM the received AP_REQ).

         */

        if (ksm_state)

            retcode = krb5_auth_con_getrecvsubkey(kcontext, auth_context,

                                                    &subkey);

        else

            retcode = krb5_auth_con_getsendsubkey(kcontext, auth_context,

                                                   &subkey);

        if (retcode) {

            DEBUGMSGTL(("ksm",

                        "KSM: krb5_auth_con_getsendsubkey failed: %s\n",

                        error_message(retcode)));

            snmp_set_detail(error_message(retcode));

            retval = SNMPERR_KRB5;

            goto error;

        }

        /*

         * Note that here we need to handle different things between the

         * old and new crypto APIs.  First, we need to get the final encrypted

         * length of the PDU.

         */

#ifdef NETSNMP_USE_KERBEROS_MIT

        retcode = krb5_c_encrypt_length(kcontext, subkey->enctype,

                                        parms->scopedPduLen,

                                        &encrypted_length);

        if (retcode) {

            DEBUGMSGTL(("ksm",

                        "Encryption length calculation failed: %s\n",

                        error_message(retcode)));

            snmp_set_detail(error_message(retcode));

            retval = SNMPERR_KRB5;

            goto error;

        }

#elif defined OLD_HEIMDAL

	retcode = krb5_crypto_init(kcontext, subkey, 0, &heim_crypto);

        if (retcode) {

            DEBUGMSGTL(("ksm", "krb5_crypto_init failed: %s\n",

                        error_message(retcode)));

            snmp_set_detail(error_message(retcode));

            retval = SNMPERR_KRB5;

            goto error;

        }

	encrypted_length = krb5_get_wrapped_length(kcontext, heim_crypto,

						   parms->scopedPduLen);

#else                           /* NETSNMP_USE_KERBEROS_MIT */

        krb5_use_enctype(kcontext, &eblock, subkey->enctype);

        retcode = krb5_process_key(kcontext, &eblock, subkey);

        if (retcode) {

            DEBUGMSGTL(("ksm", "krb5_process_key failed: %s\n",

                        error_message(retcode)));

            snmp_set_detail(error_message(retcode));

            retval = SNMPERR_KRB5;

            goto error;

        }

        encrypted_length = krb5_encrypt_size(parms->scopedPduLen,

                                             eblock.crypto_entry);

#endif                          /* NETSNMP_USE_KERBEROS_MIT */

#ifndef OLD_HEIMDAL /* since heimdal allocs the space for us */

        encrypted_data = malloc(encrypted_length);

        if (!encrypted_data) {

            DEBUGMSGTL(("ksm",

                        "KSM: Unable to malloc %d bytes for encrypt "

                        "buffer: %s\n", (int)parms->scopedPduLen,

                        strerror(errno)));

            retval = SNMPERR_MALLOC;

#ifndef NETSNMP_USE_KERBEROS_MIT

            krb5_finish_key(kcontext, &eblock);

#endif                          /* ! NETSNMP_USE_KERBEROS_MIT */

            goto error;

        }

#endif /* ! OLD_HEIMDAL */

        /*

         * We need to set up a blank initialization vector for the encryption.

         * Use a block of all zero's (which is dependent on the block size

         * of the encryption method).

         */

#ifdef NETSNMP_USE_KERBEROS_MIT

        retcode = krb5_c_block_size(kcontext, subkey->enctype, &blocksize);

        if (retcode) {

            DEBUGMSGTL(("ksm",

                        "Unable to determine crypto block size: %s\n",

                        error_message(retcode)));

            snmp_set_detail(error_message(retcode));

            retval = SNMPERR_KRB5;

            goto error;

        }

#elif defined (OLD_HEIMDAL)	/* NETSNMP_USE_KERBEROS_MIT */

#else                           /* NETSNMP_USE_KERBEROS_MIT */

        blocksize =

            krb5_enctype_array[subkey->enctype]->system->block_length;

#endif                          /* NETSNMP_USE_KERBEROS_MIT */

#ifndef OLD_HEIMDAL	/* since allocs the space for us */

        ivector.data = malloc(blocksize);

        if (!ivector.data) {

            DEBUGMSGTL(("ksm", "Unable to allocate %d bytes for ivector\n",

                        (int)blocksize));

            retval = SNMPERR_MALLOC;

            goto error;

        }

        ivector.length = blocksize;

        memset(ivector.data, 0, blocksize);

#endif /* OLD_HEIMDAL */

        /*

         * Finally!  Do the encryption!

         */

#ifdef NETSNMP_USE_KERBEROS_MIT

        input.data = (char *) parms->scopedPdu;

        input.length = parms->scopedPduLen;

        output.ciphertext.data = (char *) encrypted_data;

        output.ciphertext.length = encrypted_length;

        retcode =

            krb5_c_encrypt(kcontext, subkey, KSM_KEY_USAGE_ENCRYPTION,

                           &ivector, &input, &output);

#elif defined OLD_HEIMDAL /* NETSNMP_USE_KERBEROS_MIT */

	krb5_data_zero(&encrypted_scoped_pdu);

	retcode = krb5_encrypt(kcontext, heim_crypto, KSM_KEY_USAGE_ENCRYPTION,

			       parms->scopedPdu, parms->scopedPduLen,

			       &encrypted_scoped_pdu);

	if (retcode == 0) {

		encrypted_length = encrypted_scoped_pdu.length;

		encrypted_data = encrypted_scoped_pdu.data;

		krb5_data_zero(&encrypted_scoped_pdu);

	}

#else                           /* NETSNMP_USE_KERBEROS_MIT */

        retcode = krb5_encrypt(kcontext, (krb5_pointer) parms->scopedPdu,

                               (krb5_pointer) encrypted_data,

                               parms->scopedPduLen, &eblock, ivector.data);

        krb5_finish_key(kcontext, &eblock);

#endif                          /* NETSNMP_USE_KERBEROS_MIT */

        if (retcode) {

            DEBUGMSGTL(("ksm", "KSM: krb5_encrypt failed: %s\n",

                        error_message(retcode)));

            retval = SNMPERR_KRB5;

            snmp_set_detail(error_message(retcode));

            goto error;

        }

	*offset = 0;

        rc = asn_realloc_rbuild_string(wholeMsg, parms->wholeMsgLen,

                                             offset, 1,

                                             (u_char) (ASN_UNIVERSAL |

                                                       ASN_PRIMITIVE |

                                                       ASN_OCTET_STR),

                                             encrypted_data,

                                             encrypted_length);

        if (rc == 0) {

            DEBUGMSGTL(("ksm", "Building encrypted payload failed.\n"));

            retval = SNMPERR_TOO_LONG;

            goto error;

        }

        DEBUGMSGTL(("ksm", "KSM: Encryption complete.\n"));

    } else {

        /*

         * Plaintext PDU (not encrypted)

         */

        if (*parms->wholeMsgLen < parms->scopedPduLen) {

            DEBUGMSGTL(("ksm", "Not enough room for plaintext PDU.\n"));

            retval = SNMPERR_TOO_LONG;

            goto error;

        }

    }

    /*

     * Start encoding the msgSecurityParameters

     *

     * For now, use 0 for the response hint

     */

    DEBUGMSGTL(("ksm", "KSM: scopedPdu added to payload\n"));

    seq_offset = *offset;

    rc = asn_realloc_rbuild_int(wholeMsg, parms->wholeMsgLen,

                                      offset, 1,

                                      (u_char) (ASN_UNIVERSAL |

                                                ASN_PRIMITIVE |

                                                ASN_INTEGER),

                                      (long *) &zero, sizeof(zero));

    if (rc == 0) {

        DEBUGMSGTL(("ksm", "Building ksm security parameters failed.\n"));

        retval = SNMPERR_TOO_LONG;

        goto error;

    }

    rc = asn_realloc_rbuild_string(wholeMsg, parms->wholeMsgLen,

                                         offset, 1,

                                         (u_char) (ASN_UNIVERSAL |

                                                   ASN_PRIMITIVE |

                                                   ASN_OCTET_STR),

                                         (u_char *) outdata.data,

                                         outdata.length);

    if (rc == 0) {

        DEBUGMSGTL(("ksm", "Building ksm AP_REQ failed.\n"));

        retval = SNMPERR_TOO_LONG;

        goto error;

    }

    /*

     * If we didn't encrypt the packet, we haven't yet got the subkey.

     * Get that now.

     */

    if (!subkey) {

        if (ksm_state)

            retcode = krb5_auth_con_getrecvsubkey(kcontext, auth_context,

                                                    &subkey);

        else

            retcode = krb5_auth_con_getsendsubkey(kcontext, auth_context,

                                                   &subkey);

        if (retcode) {

            DEBUGMSGTL(("ksm", "krb5_auth_con_getsendsubkey failed: %s\n",

                        error_message(retcode)));

            snmp_set_detail(error_message(retcode));

            retval = SNMPERR_KRB5;

            goto error;

        }

#ifdef OLD_HEIMDAL

	 retcode = krb5_crypto_init(kcontext, subkey, 0, &heim_crypto);

        if (retcode) {

            DEBUGMSGTL(("ksm", "krb5_crypto_init failed: %s\n",

                        error_message(retcode)));

            snmp_set_detail(error_message(retcode));

            retval = SNMPERR_KRB5;

            goto error;

        }

#endif					/* OLD_HEIMDAL */

    }

    /*

     * Now, we need to pick the "right" checksum algorithm.  For old

     * crypto, just pick CKSUMTYPE_RSA_MD5_DES; for new crypto, pick

     * one of the "approved" ones.