开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
snmpksm.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：57k
源码类别：

SNMP编程

开发平台：

Unix_Linux

snmpksm.c：源码内容
  1. /*
  2.  * snmpksm.c
  3.  *
  4.  * This code implements the Kerberos Security Model (KSM) for SNMP.
  5.  *
  6.  * Security number - 2066432
  7.  */
  9. #include <net-snmp/net-snmp-config.h>
  11. #include <sys/types.h>
  12. #if HAVE_WINSOCK_H
  13. #include <winsock.h>
  14. #endif
  15. #include <stdio.h>
  16. #ifdef HAVE_STDLIB_H
  17. #include <stdlib.h>
  18. #endif
  19. #if TIME_WITH_SYS_TIME
  20. # ifdef WIN32
  21. #  include <sys/timeb.h>
  22. # else
  23. #  include <sys/time.h>
  24. # endif
  25. # include <time.h>
  26. #else
  27. # if HAVE_SYS_TIME_H
  28. #  include <sys/time.h>
  29. # else
  30. #  include <time.h>
  31. # endif
  32. #endif
  33. #if HAVE_STRING_H
  34. #include <string.h>
  35. #else
  36. #include <strings.h>
  37. #endif
  38. #ifdef HAVE_NETINET_IN_H
  39. #include <netinet/in.h>
  40. #endif
  41. #include <errno.h>
  44. #if HAVE_DMALLOC_H
  45. #include <dmalloc.h>
  46. #endif
  48. #ifdef HEIMDAL
  49. #ifndef MIT_NEW_CRYPTO
  50. #define OLD_HEIMDAL
  51. #endif  /* ! MIT_NEW_CRYPTO */
  52. #endif  /* HEIMDAL */
  54. #ifdef HEIMDAL
  55. #define oid heimdal_oid_renamed
  56. #endif /* HEIMDAL */
  57. #include <krb5.h>
  58. #include <com_err.h>
  59. #ifdef HEIMDAL
  60. #undef oid
  61. #endif /* HEIMDAL */
  63. #ifdef HEIMDAL
  64. #define CHECKSUM_TYPE(x) (x)->cksumtype
  65. #define CHECKSUM_CONTENTS(x) ((char *)((x)->checksum.data))
  66. #define CHECKSUM_LENGTH(x) (x)->checksum.length
  67. #define TICKET_CLIENT(x) (x)->client
  68. #else /* HEIMDAL */
  69. #define CHECKSUM_TYPE(x) (x)->checksum_type
  70. #define CHECKSUM_CONTENTS(x) (x)->contents
  71. #define CHECKSUM_LENGTH(x) (x)->length
  72. #define TICKET_CLIENT(x) (x)->enc_part2->client
  73. #endif /* HEIMDAL */
  75. #include <net-snmp/output_api.h>
  76. #include <net-snmp/config_api.h>
  77. #include <net-snmp/utilities.h>
  79. #include <net-snmp/library/asn1.h>
  80. #include <net-snmp/library/snmp_api.h>
  81. #include <net-snmp/library/callback.h>
  82. #include <net-snmp/library/keytools.h>
  83. #include <net-snmp/library/snmpv3.h>
  84. #include <net-snmp/library/lcd_time.h>
  85. #include <net-snmp/library/scapi.h>
  86. #include <net-snmp/library/callback.h>
  87. #include <net-snmp/library/snmp_secmod.h>
  88. #include <net-snmp/library/snmpksm.h>
  90. static krb5_context kcontext = NULL;
  91. static krb5_rcache rcache = NULL;
  92. static krb5_keytab keytab = NULL;
  93. static int keytab_setup = 0;
  94. static const char *service_name = NULL;
  96. static int      ksm_session_init(netsnmp_session *);
  97. static void     ksm_free_state_ref(void *);
  98. static int      ksm_free_pdu(netsnmp_pdu *);
  99. static int      ksm_clone_pdu(netsnmp_pdu *, netsnmp_pdu *);
  101. static int      ksm_insert_cache(long, krb5_auth_context, u_char *,
  102.                                  size_t);
  103. static void     ksm_decrement_ref_count(long);
  104. static void     ksm_increment_ref_count(long);
  105. static struct ksm_cache_entry *ksm_get_cache(long);
  107. #define HASHSIZE 64
  109. /*
  110.  * Our information stored for the response PDU.
  111.  */
  113. struct ksm_secStateRef {
  114.     krb5_auth_context auth_context;
  115.     krb5_cksumtype  cksumtype;
  116. };
  118. /*
  119.  * A KSM outgoing pdu cache entry
  120.  */
  122. struct ksm_cache_entry {
  123.     long            msgid;
  124.     int             refcount;
  125.     krb5_auth_context auth_context;
  126.     u_char         *secName;
  127.     size_t          secNameLen;
  128.     struct ksm_cache_entry *next;
  129. };
  131. /*
  132.  * Poor man's hash table
  133.  */
  135. static struct ksm_cache_entry *ksm_hash_table[HASHSIZE];
  137. /*
  138.  * Stuff to deal with config values
  139.  * Note the conditionals that wrap these--i don't know if these are
  140.  * needed, since i don't know how library initialization and callbacks
  141.  * and stuff work
  142.  */
  144. static int
  145. init_snmpksm_post_config(int majorid, int minorid, void *serverarg,
  146.  void *clientarg)
  147. {
  149.     if (kcontext == NULL) {
  150. /* not reached, i'd imagine */
  151.         return SNMPERR_KRB5;
  152.     }
  154.     if (service_name == NULL) {
  155. /* always reached, i'd imagine */
  156. char *c = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,
  157. NETSNMP_DS_LIB_KSM_SERVICE_NAME);
  158. if (c != NULL) {
  159. service_name = c;
  160. }
  161. else {
  162. service_name = "host";
  163. }
  164.     }
  166.     if (keytab_setup == 0) {
  167. /* always reached, i'd imagine */
  168. char *c = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,
  169. NETSNMP_DS_LIB_KSM_KEYTAB);
  170. if (c) {
  171.     krb5_error_code retval;
  172.     DEBUGMSGTL(("ksm", "Using keytab %sn", c));
  173.     retval = krb5_kt_resolve(kcontext, c, &keytab);
  174.     if (retval) {
  175. DEBUGMSGTL(("ksm", "krb5_kt_resolve("%s") failed. KSM "
  176.     "config callback failingn", error_message(retval)));
  177. return SNMPERR_KRB5;
  178.     }
  179. }
  180. else {
  181.     DEBUGMSGTL(("ksm", "Using default keytabn", c));
  182. }
  183. keytab_setup = 1;
  184.     }
  186.     return SNMPERR_SUCCESS;
  187. }
  189. /*
  190.  * Initialize all of the state required for Kerberos (right now, just call
  191.  * krb5_init_context).
  192.  */
  194. void
  195. init_ksm(void)
  196. {
  197.     krb5_error_code retval;
  198.     struct snmp_secmod_def *def;
  199.     int             i;
  201.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defKSMKeytab",
  202.                                NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_KSM_KEYTAB);
  203.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defKSMServiceName",
  204.                                NETSNMP_DS_LIBRARY_ID,
  205.        NETSNMP_DS_LIB_KSM_SERVICE_NAME);
  206.     snmp_register_callback(SNMP_CALLBACK_LIBRARY,
  207.    SNMP_CALLBACK_POST_READ_CONFIG,
  208.    init_snmpksm_post_config, NULL);
  211.     if (kcontext == NULL) {
  212.         retval = krb5_init_context(&kcontext);
  214.         if (retval) {
  215.             DEBUGMSGTL(("ksm", "krb5_init_context failed (%s), not "
  216.                         "registering KSMn", error_message(retval)));
  217.             return;
  218.         }
  219.     }
  221.     for (i = 0; i < HASHSIZE; i++)
  222.         ksm_hash_table[i] = NULL;
  224.     def = SNMP_MALLOC_STRUCT(snmp_secmod_def);
  226.     if (!def) {
  227.         DEBUGMSGTL(("ksm", "Unable to malloc snmp_secmod struct, not "
  228.                     "registering KSMn"));
  229.         return;
  230.     }
  232.     def->encode_reverse = ksm_rgenerate_out_msg;
  233.     def->decode = ksm_process_in_msg;
  234.     def->session_open = ksm_session_init;
  235.     def->pdu_free_state_ref = ksm_free_state_ref;
  236.     def->pdu_free = ksm_free_pdu;
  237.     def->pdu_clone = ksm_clone_pdu;
  239.     register_sec_mod(2066432, "ksm", def);
  240. }
  242. /*
  243.  * These routines implement a simple cache for information we need to
  244.  * process responses.  When we send out a request, it contains an AP_REQ;
  245.  * we get back an AP_REP, and we need the authorization context from the
  246.  * AP_REQ to decrypt the AP_REP.  But because right now there's nothing
  247.  * that gets preserved across calls to rgenerate_out_msg to process_in_msg,
  248.  * we cache these internally based on the message ID (we also cache the
  249.  * passed-in security name, for reasons that are mostly stupid).
  250.  */
  252. static int
  253. ksm_insert_cache(long msgid, krb5_auth_context auth_context,
  254.                  u_char * secName, size_t secNameLen)
  255. {
  256.     struct ksm_cache_entry *entry;
  257.     int             bucket;
  258.     int             retval;
  260.     entry = SNMP_MALLOC_STRUCT(ksm_cache_entry);
  262.     if (!entry)
  263.         return SNMPERR_MALLOC;
  265.     entry->msgid = msgid;
  266.     entry->auth_context = auth_context;
  267.     entry->refcount = 1;
  269.     retval = memdup(&entry->secName, secName, secNameLen);
  271.     if (retval != SNMPERR_SUCCESS) {
  272.         free(entry);
  273.         return retval;
  274.     }
  276.     entry->secNameLen = secNameLen;
  278.     bucket = msgid % HASHSIZE;
  280.     entry->next = ksm_hash_table[bucket];
  281.     ksm_hash_table[bucket] = entry;
  283.     return SNMPERR_SUCCESS;
  284. }
  286. static struct ksm_cache_entry *
  287. ksm_get_cache(long msgid)
  288. {
  289.     struct ksm_cache_entry *entry;
  290.     int             bucket;
  292.     bucket = msgid % HASHSIZE;
  294.     for (entry = ksm_hash_table[bucket]; entry != NULL;
  295.          entry = entry->next)
  296.         if (entry->msgid == msgid)
  297.             return entry;
  299.     return NULL;
  300. }
  302. static void
  303. ksm_decrement_ref_count(long msgid)
  304. {
  305.     struct ksm_cache_entry *entry, *entry1;
  306.     int             bucket;
  308.     bucket = msgid % HASHSIZE;
  310.     if (ksm_hash_table[bucket] && ksm_hash_table[bucket]->msgid == msgid) {
  311.         entry = ksm_hash_table[bucket];
  313.         /*
  314.          * If the reference count is zero, then free it
  315.          */
  317.         if (--entry->refcount <= 0) {
  318.             DEBUGMSGTL(("ksm", "Freeing entry for msgid %ldn", msgid));
  319.             krb5_auth_con_free(kcontext, entry->auth_context);
  320.             free(entry->secName);
  321.             ksm_hash_table[bucket] = entry->next;
  322.             free(entry);
  323.         }
  325.         return;
  327.     } else if (ksm_hash_table[bucket])
  328.         for (entry1 = ksm_hash_table[bucket], entry = entry1->next;
  329.              entry != NULL; entry1 = entry, entry = entry->next)
  330.             if (entry->msgid == msgid) {
  332.                 if (--entry->refcount <= 0) {
  333.                     DEBUGMSGTL(("ksm", "Freeing entry for msgid %ldn",
  334.                                 msgid));
  335.                     krb5_auth_con_free(kcontext, entry->auth_context);
  336.                     free(entry->secName);
  337.                     entry1->next = entry->next;
  338.                     free(entry);
  339.                 }
  341.                 return;
  342.             }
  344.     DEBUGMSGTL(("ksm",
  345.                 "KSM: Unable to decrement cache entry for msgid %ld.n",
  346.                 msgid));
  347. }
  349. static void
  350. ksm_increment_ref_count(long msgid)
  351. {
  352.     struct ksm_cache_entry *entry = ksm_get_cache(msgid);
  354.     if (!entry) {
  355.         DEBUGMSGTL(("ksm", "Unable to find cache entry for msgid %ld "
  356.                     "for incrementn", msgid));
  357.         return;
  358.     }
  360.     entry->refcount++;
  361. }
  363. /*
  364.  * Initialize specific session information (right now, just set up things to
  365.  * not do an engineID probe)
  366.  */
  368. static int
  369. ksm_session_init(netsnmp_session * sess)
  370. {
  371.     DEBUGMSGTL(("ksm",
  372.                 "KSM: Reached our session initialization callbackn"));
  374.     sess->flags |= SNMP_FLAGS_DONT_PROBE;
  376.     return SNMPERR_SUCCESS;
  377. }
  379. /*
  380.  * Free our state information (this is only done on the agent side)
  381.  */
  383. static void
  384. ksm_free_state_ref(void *ptr)
  385. {
  386.     struct ksm_secStateRef *ref = (struct ksm_secStateRef *) ptr;
  388.     DEBUGMSGTL(("ksm", "KSM: Freeing state referencen"));
  390.     krb5_auth_con_free(kcontext, ref->auth_context);
  392.     free(ref);
  393. }
  395. /*
  396.  * This is called when the PDU is freed; this will decrement reference counts
  397.  * for entries in our state cache.
  398.  */
  400. static int
  401. ksm_free_pdu(netsnmp_pdu *pdu)
  402. {
  403.     ksm_decrement_ref_count(pdu->msgid);
  405.     DEBUGMSGTL(("ksm", "Decrementing cache entry for PDU msgid %ldn",
  406.                 pdu->msgid));
  408.     return SNMPERR_SUCCESS;
  409. }
  411. /*
  412.  * This is called when a PDU is cloned (to increase reference counts)
  413.  */
  415. static int
  416. ksm_clone_pdu(netsnmp_pdu *pdu, netsnmp_pdu *pdu2)
  417. {
  418.     ksm_increment_ref_count(pdu->msgid);
  420.     DEBUGMSGTL(("ksm", "Incrementing cache entry for PDU msgid %ldn",
  421.                 pdu->msgid));
  423.     return SNMPERR_SUCCESS;
  424. }
  426. /****************************************************************************
  427.  *
  428.  * ksm_generate_out_msg
  429.  *
  430.  * Parameters:
  431.  * (See list below...)
  432.  *
  433.  * Returns:
  434.  * SNMPERR_GENERIC                        On success.
  435.  * SNMPERR_KRB5
  436.  * ... and others
  437.  *
  438.  *
  439.  * Generate an outgoing message.
  440.  *
  441.  ****************************************************************************/
  443. int
  444. ksm_rgenerate_out_msg(struct snmp_secmod_outgoing_params *parms)
  445. {
  446.     krb5_auth_context auth_context = NULL;
  447.     krb5_error_code retcode;
  448.     krb5_ccache     cc = NULL;
  449.     int             retval = SNMPERR_SUCCESS;
  450.     krb5_data       outdata, ivector;
  451.     krb5_keyblock  *subkey = NULL;
  452. #ifdef MIT_NEW_CRYPTO
  453.     krb5_data       input;
  454.     krb5_enc_data   output;
  455.     unsigned int    numcksumtypes;
  456.     krb5_cksumtype  *cksumtype_array;
  457. #elif defined OLD_HEIMDAL /* MIT_NEW_CRYPTO */
  458.     krb5_crypto heim_crypto = NULL;
  459. #else                           /* MIT_NEW_CRYPTO */
  460.     krb5_encrypt_block eblock;
  461. #endif                          /* MIT_NEW_CRYPTO */
  462.     size_t          blocksize, encrypted_length;
  463.     unsigned char  *encrypted_data = NULL;
  464.     int             zero = 0, i;
  465.     u_char         *cksum_pointer, *endp = *parms->wholeMsg;
  466.     krb5_cksumtype  cksumtype;
  467.     krb5_checksum   pdu_checksum;
  468.     u_char         **wholeMsg = parms->wholeMsg;
  469.     size_t    *offset = parms->wholeMsgOffset, seq_offset;
  470.     struct ksm_secStateRef *ksm_state = (struct ksm_secStateRef *)
  471.         parms->secStateRef;
  472. #ifdef OLD_HEIMDAL
  473.     krb5_data encrypted_scoped_pdu;
  474. #endif /* OLD_HEIMDAL */
  475.     int rc;
  476.     char *colon = NULL;
  478.     DEBUGMSGTL(("ksm", "Starting KSM processingn"));
  480.     outdata.length = 0;
  481.     outdata.data = NULL;
  482.     ivector.length = 0;
  483.     ivector.data = NULL;
  484.     CHECKSUM_CONTENTS(&pdu_checksum) = NULL;
  486.     if (!ksm_state) {
  487.         /*
  488.          * If we've got a port number as part of the "peername", then
  489.          * suppress this (temporarily) while we build the credential info.
  490.          *   XXX - what about "udp:host" style addresses?
  491.          */
  492.         colon = strrchr(params->session->peername, ':');
  493.         if (colon != NULL) {
  494.             *colon='';
  495.         }
  497.         /*
  498.          * If we don't have a ksm_state, then we're a request.  Get a
  499.          * credential cache and build a ap_req.
  500.          */
  501.         retcode = krb5_cc_default(kcontext, &cc);
  503.         if (retcode) {
  504.             DEBUGMSGTL(("ksm", "KSM: krb5_cc_default failed: %sn",
  505.                         error_message(retcode)));
  506.             snmp_set_detail(error_message(retcode));
  507.             retval = SNMPERR_KRB5;
  508.             goto error;
  509.         }
  511.         DEBUGMSGTL(("ksm", "KSM: Set credential cache successfullyn"));
  513.         /*
  514.          * This seems odd, since we don't need this until later (or earlier,
  515.          * depending on how you look at it), but because the most likely
  516.          * errors are Kerberos at this point, I'll get this now to save
  517.          * time not encoding the rest of the packet.
  518.          *
  519.          * Also, we need the subkey to encrypt the PDU (if required).
  520.          */
  522.         retcode =
  523.             krb5_mk_req(kcontext, &auth_context,
  524.                         AP_OPTS_MUTUAL_REQUIRED | AP_OPTS_USE_SUBKEY,
  525.                         (char *) service_name, parms->session->peername, NULL,
  526.                         cc, &outdata);
  528.         if (colon != NULL)
  529.             *colon=':';
  531.         if (retcode) {
  532.             DEBUGMSGTL(("ksm", "KSM: krb5_mk_req failed: %sn",
  533.                         error_message(retcode)));
  534.             snmp_set_detail(error_message(retcode));
  535.             retval = SNMPERR_KRB5;
  536.             goto error;
  537.         }
  539. DEBUGMSGTL(("ksm", "KSM: ticket retrieved successfully for "%s/%s" "
  540.     "(may not be actual ticket sname)n", service_name,
  541.     parms->session->peername));
  543.     } else {
  545.         /*
  546.          * Grab the auth_context from our security state reference
  547.          */
  549.         auth_context = ksm_state->auth_context;
  551.         /*
  552.          * Bundle up an AP_REP.  Note that we do this only when we
  553.          * have a security state reference (which means we're in an agent
  554.          * and we're sending a response).
  555.          */
  557.         DEBUGMSGTL(("ksm", "KSM: Starting reply processing.n"));
  559.         retcode = krb5_mk_rep(kcontext, auth_context, &outdata);
  561.         if (retcode) {
  562.             DEBUGMSGTL(("ksm", "KSM: krb5_mk_rep failed: %sn",
  563.                         error_message(retcode)));
  564.             snmp_set_detail(error_message(retcode));
  565.             retval = SNMPERR_KRB5;
  566.             goto error;
  567.         }
  569.         DEBUGMSGTL(("ksm", "KSM: Finished with krb5_mk_rep()n"));
  570.     }
  572.     /*
  573.      * If we have to encrypt the PDU, do that now
  574.      */
  576.     if (parms->secLevel == SNMP_SEC_LEVEL_AUTHPRIV) {
  578.         DEBUGMSGTL(("ksm", "KSM: Starting PDU encryption.n"));
  580.         /*
  581.          * It's weird -
  582.          *
  583.          * If we're on the manager, it's a local subkey (because that's in
  584.          * our AP_REQ)
  585.          *
  586.          * If we're on the agent, it's a remote subkey (because that comes
  587.          * FROM the received AP_REQ).
  588.          */
  590.         if (ksm_state)
  591.             retcode = krb5_auth_con_getremotesubkey(kcontext, auth_context,
  592.                                                     &subkey);
  593.         else
  594.             retcode = krb5_auth_con_getlocalsubkey(kcontext, auth_context,
  595.                                                    &subkey);
  597.         if (retcode) {
  598.             DEBUGMSGTL(("ksm",
  599.                         "KSM: krb5_auth_con_getlocalsubkey failed: %sn",
  600.                         error_message(retcode)));
  601.             snmp_set_detail(error_message(retcode));
  602.             retval = SNMPERR_KRB5;
  603.             goto error;
  604.         }
  606.         /*
  607.          * Note that here we need to handle different things between the
  608.          * old and new crypto APIs.  First, we need to get the final encrypted
  609.          * length of the PDU.
  610.          */
  612. #ifdef MIT_NEW_CRYPTO
  613.         retcode = krb5_c_encrypt_length(kcontext, subkey->enctype,
  614.                                         parms->scopedPduLen,
  615.                                         &encrypted_length);
  617.         if (retcode) {
  618.             DEBUGMSGTL(("ksm",
  619.                         "Encryption length calculation failed: %sn",
  620.                         error_message(retcode)));
  621.             snmp_set_detail(error_message(retcode));
  622.             retval = SNMPERR_KRB5;
  623.             goto error;
  624.         }
  625. #elif defined OLD_HEIMDAL
  626. retcode = krb5_crypto_init(kcontext, subkey, 0, &heim_crypto);
  627.         if (retcode) {
  628.             DEBUGMSGTL(("ksm", "krb5_crypto_init failed: %sn",
  629.                         error_message(retcode)));
  630.             snmp_set_detail(error_message(retcode));
  631.             retval = SNMPERR_KRB5;
  632.             goto error;
  633.         }
  634. encrypted_length = krb5_get_wrapped_length(kcontext, heim_crypto,
  635.    parms->scopedPduLen);
  636. #else                           /* MIT_NEW_CRYPTO */
  638.         krb5_use_enctype(kcontext, &eblock, subkey->enctype);
  639.         retcode = krb5_process_key(kcontext, &eblock, subkey);
  641.         if (retcode) {
  642.             DEBUGMSGTL(("ksm", "krb5_process_key failed: %sn",
  643.                         error_message(retcode)));
  644.             snmp_set_detail(error_message(retcode));
  645.             retval = SNMPERR_KRB5;
  646.             goto error;
  647.         }
  649.         encrypted_length = krb5_encrypt_size(parms->scopedPduLen,
  650.                                              eblock.crypto_entry);
  651. #endif                          /* MIT_NEW_CRYPTO */
  653. #ifndef OLD_HEIMDAL /* since heimdal allocs the space for us */
  654.         encrypted_data = malloc(encrypted_length);
  656.         if (!encrypted_data) {
  657.             DEBUGMSGTL(("ksm",
  658.                         "KSM: Unable to malloc %d bytes for encrypt "
  659.                         "buffer: %sn", parms->scopedPduLen,
  660.                         strerror(errno)));
  661.             retval = SNMPERR_MALLOC;
  662. #ifndef MIT_NEW_CRYPTO
  663.             krb5_finish_key(kcontext, &eblock);
  664. #endif                          /* ! MIT_NEW_CRYPTO */
  666.             goto error;
  667.         }
  668. #endif /* ! OLD_HEIMDAL */
  670.         /*
  671.          * We need to set up a blank initialization vector for the encryption.
  672.          * Use a block of all zero's (which is dependent on the block size
  673.          * of the encryption method).
  674.          */
  676. #ifdef MIT_NEW_CRYPTO
  678.         retcode = krb5_c_block_size(kcontext, subkey->enctype, &blocksize);
  680.         if (retcode) {
  681.             DEBUGMSGTL(("ksm",
  682.                         "Unable to determine crypto block size: %sn",
  683.                         error_message(retcode)));
  684.             snmp_set_detail(error_message(retcode));
  685.             retval = SNMPERR_KRB5;
  686.             goto error;
  687.         }
  688. #elif defined (OLD_HEIMDAL) /* MIT_NEW_CRYPTO */
  689. #else                           /* MIT_NEW_CRYPTO */
  691.         blocksize =
  692.             krb5_enctype_array[subkey->enctype]->system->block_length;
  694. #endif                          /* MIT_NEW_CRYPTO */
  696. #ifndef OLD_HEIMDAL /* since allocs the space for us */
  697.         ivector.data = malloc(blocksize);
  699.         if (!ivector.data) {
  700.             DEBUGMSGTL(("ksm", "Unable to allocate %d bytes for ivectorn",
  701.                         blocksize));
  702.             retval = SNMPERR_MALLOC;
  703.             goto error;
  704.         }
  706.         ivector.length = blocksize;
  707.         memset(ivector.data, 0, blocksize);
  708. #endif /* OLD_HEIMDAL */
  710.         /*
  711.          * Finally!  Do the encryption!
  712.          */
  714. #ifdef MIT_NEW_CRYPTO
  716.         input.data = (char *) parms->scopedPdu;
  717.         input.length = parms->scopedPduLen;
  718.         output.ciphertext.data = (char *) encrypted_data;
  719.         output.ciphertext.length = encrypted_length;
  721.         retcode =
  722.             krb5_c_encrypt(kcontext, subkey, KSM_KEY_USAGE_ENCRYPTION,
  723.                            &ivector, &input, &output);
  725. #elif defined OLD_HEIMDAL /* MIT_NEW_CRYPTO */
  727. krb5_data_zero(&encrypted_scoped_pdu);
  728. retcode = krb5_encrypt(kcontext, heim_crypto, KSM_KEY_USAGE_ENCRYPTION,
  729.        parms->scopedPdu, parms->scopedPduLen,
  730.        &encrypted_scoped_pdu);
  731. if (retcode == 0) {
  732. encrypted_length = encrypted_scoped_pdu.length;
  733. encrypted_data = encrypted_scoped_pdu.data;
  734. krb5_data_zero(&encrypted_scoped_pdu);
  735. }
  736. #else                           /* MIT_NEW_CRYPTO */
  738.         retcode = krb5_encrypt(kcontext, (krb5_pointer) parms->scopedPdu,
  739.                                (krb5_pointer) encrypted_data,
  740.                                parms->scopedPduLen, &eblock, ivector.data);
  742.         krb5_finish_key(kcontext, &eblock);
  744. #endif                          /* MIT_NEW_CRYPTO */
  746.         if (retcode) {
  747.             DEBUGMSGTL(("ksm", "KSM: krb5_encrypt failed: %sn",
  748.                         error_message(retcode)));
  749.             retval = SNMPERR_KRB5;
  750.             snmp_set_detail(error_message(retcode));
  751.             goto error;
  752.         }
  754. *offset = 0;
  756.         rc = asn_realloc_rbuild_string(wholeMsg, parms->wholeMsgLen,
  757.                                              offset, 1,
  758.                                              (u_char) (ASN_UNIVERSAL |
  759.                                                        ASN_PRIMITIVE |
  760.                                                        ASN_OCTET_STR),
  761.                                              encrypted_data,
  762.                                              encrypted_length);
  764.         if (rc == 0) {
  765.             DEBUGMSGTL(("ksm", "Building encrypted payload failed.n"));
  766.             retval = SNMPERR_TOO_LONG;
  767.             goto error;
  768.         }
  770.         DEBUGMSGTL(("ksm", "KSM: Encryption complete.n"));
  772.     } else {
  773.         /*
  774.          * Plaintext PDU (not encrypted)
  775.          */
  777.         if (*parms->wholeMsgLen < parms->scopedPduLen) {
  778.             DEBUGMSGTL(("ksm", "Not enough room for plaintext PDU.n"));
  779.             retval = SNMPERR_TOO_LONG;
  780.             goto error;
  781.         }
  782.     }
  784.     /*
  785.      * Start encoding the msgSecurityParameters
  786.      *
  787.      * For now, use 0 for the response hint
  788.      */
  790.     DEBUGMSGTL(("ksm", "KSM: scopedPdu added to payloadn"));
  792.     seq_offset = *offset;
  794.     rc = asn_realloc_rbuild_int(wholeMsg, parms->wholeMsgLen,
  795.                                       offset, 1,
  796.                                       (u_char) (ASN_UNIVERSAL |
  797.                                                 ASN_PRIMITIVE |
  798.                                                 ASN_INTEGER),
  799.                                       (long *) &zero, sizeof(zero));
  801.     if (rc == 0) {
  802.         DEBUGMSGTL(("ksm", "Building ksm security parameters failed.n"));
  803.         retval = SNMPERR_TOO_LONG;
  804.         goto error;
  805.     }
  807.     rc = asn_realloc_rbuild_string(wholeMsg, parms->wholeMsgLen,
  808.                                          offset, 1,
  809.                                          (u_char) (ASN_UNIVERSAL |
  810.                                                    ASN_PRIMITIVE |
  811.                                                    ASN_OCTET_STR),
  812.                                          (u_char *) outdata.data,
  813.                                          outdata.length);
  815.     if (rc == 0) {
  816.         DEBUGMSGTL(("ksm", "Building ksm AP_REQ failed.n"));
  817.         retval = SNMPERR_TOO_LONG;
  818.         goto error;
  819.     }
  821.     /*
  822.      * If we didn't encrypt the packet, we haven't yet got the subkey.
  823.      * Get that now.
  824.      */
  826.     if (!subkey) {
  827.         if (ksm_state)
  828.             retcode = krb5_auth_con_getremotesubkey(kcontext, auth_context,
  829.                                                     &subkey);
  830.         else
  831.             retcode = krb5_auth_con_getlocalsubkey(kcontext, auth_context,
  832.                                                    &subkey);
  833.         if (retcode) {
  834.             DEBUGMSGTL(("ksm", "krb5_auth_con_getlocalsubkey failed: %sn",
  835.                         error_message(retcode)));
  836.             snmp_set_detail(error_message(retcode));
  837.             retval = SNMPERR_KRB5;
  838.             goto error;
  839.         }
  840. #ifdef OLD_HEIMDAL
  841.  retcode = krb5_crypto_init(kcontext, subkey, 0, &heim_crypto);
  842.         if (retcode) {
  843.             DEBUGMSGTL(("ksm", "krb5_crypto_init failed: %sn",
  844.                         error_message(retcode)));
  845.             snmp_set_detail(error_message(retcode));
  846.             retval = SNMPERR_KRB5;
  847.             goto error;
  848.         }
  849. #endif /* OLD_HEIMDAL */
  850.     }
  852.     /*
  853.      * Now, we need to pick the "right" checksum algorithm.  For old
  854.      * crypto, just pick CKSUMTYPE_RSA_MD5_DES; for new crypto, pick
  855.      * one of the "approved" ones.
  856.      */
  858. #ifdef MIT_NEW_CRYPTO
  859.     retcode = krb5_c_keyed_checksum_types(kcontext, subkey->enctype,
  860.                                           &numcksumtypes, &cksumtype_array);
  862.     if (retcode) {
  863. DEBUGMSGTL(("ksm", "Unable to find appropriate keyed checksum: %sn",
  864.     error_message(retcode)));
  865. snmp_set_detail(error_message(retcode));
  866.         retval = SNMPERR_KRB5;
  867.         goto error;
  868.     }
  870.     if (numcksumtypes <= 0) {
  871. DEBUGMSGTL(("ksm", "We received a list of zero cksumtypes for this "
  872.     "enctype (%d)n", subkey->enctype));
  873. snmp_set_detail("No valid checksum type for this encryption type");
  874. retval = SNMPERR_KRB5;
  875. goto error;
  876.     }
  878.     /*
  879.      * It's not clear to me from the API which checksum you're supposed
  880.      * to support, so I'm taking a guess at the first one
  881.      */
  883.     cksumtype = cksumtype_array[0];
  885.     krb5_free_cksumtypes(kcontext, cksumtype_array);
  887.     DEBUGMSGTL(("ksm", "KSM: Choosing checksum type of %d (subkey type "
  888. "of %d)n", cksumtype, subkey->enctype));
  890.     retcode = krb5_c_checksum_length(kcontext, cksumtype, &blocksize);
  892.     if (retcode) {
  893.         DEBUGMSGTL(("ksm", "Unable to determine checksum length: %sn",
  894.                     error_message(retcode)));
  895.         snmp_set_detail(error_message(retcode));
  896.         retval = SNMPERR_KRB5;
  897.         goto error;
  898.     }
  900.     CHECKSUM_LENGTH(&pdu_checksum) = blocksize;
  902. #else /* MIT_NEW_CRYPTO */
  903.     if (ksm_state)
  904.         cksumtype = ksm_state->cksumtype;
  905.     else
  906. #ifdef OLD_HEIMDAL
  907.     {
  908.     /* no way to tell what kind of checksum to use without trying */
  909.     retval = krb5_create_checksum(kcontext, heim_crypto, 
  910.   KSM_KEY_USAGE_CHECKSUM, 0,
  911.   parms->scopedPdu, parms->scopedPduLen,
  912.   &pdu_checksum);
  913.     if (retval) {
  914.     DEBUGMSGTL(("ksm", "Unable to create a checksum: %sn",
  915. error_message(retval)));
  916.     snmp_set_detail(error_message(retcode));
  917.     retval = SNMPERR_KRB5;
  918.     goto error;
  919.     }
  920.     cksumtype = CHECKSUM_TYPE(&pdu_checksum);
  921.     }
  922. #else /* OLD_HEIMDAL */
  923. cksumtype = CKSUMTYPE_RSA_MD5_DES;
  924. #endif /* OLD_HEIMDAL */
  926. #ifdef OLD_HEIMDAL
  927. if (!krb5_checksum_is_keyed(kcontext, cksumtype)) {
  928. #else  /* OLD_HEIMDAL */
  929.     if (!is_keyed_cksum(cksumtype)) {
  930. #endif  /* OLD_HEIMDAL */
  931.         DEBUGMSGTL(("ksm", "Checksum type %d is not a keyed checksumn",
  932.                     cksumtype));
  933.         snmp_set_detail("Checksum is not a keyed checksum");
  934.         retval = SNMPERR_KRB5;
  935.         goto error;
  936.     }
  938. #ifdef OLD_HEIMDAL
  939.     if (!krb5_checksum_is_collision_proof(kcontext, cksumtype)) {
  940. #else  /* OLD_HEIMDAL */
  941.     if (!is_coll_proof_cksum(cksumtype)) {
  942. #endif  /* OLD_HEIMDAL */
  943.         DEBUGMSGTL(("ksm", "Checksum type %d is not a collision-proof "
  944.                     "checksumn", cksumtype));
  945.         snmp_set_detail("Checksum is not a collision-proof checksum");
  946.         retval = SNMPERR_KRB5;
  947.         goto error;
  948.     }
  950. #ifdef OLD_HEIMDAL
  951.     if (CHECKSUM_CONTENTS(&pdu_checksum) != NULL ) {
  952. /* we did the bogus checksum--don't need to ask for the size again
  953.  * or initialize cksumtype; just free the bits */
  954. free(CHECKSUM_CONTENTS(&pdu_checksum));
  955. CHECKSUM_CONTENTS(&pdu_checksum) = NULL;
  956.     }
  957.     else {
  958. retval = krb5_checksumsize(kcontext, cksumtype,
  959.    &CHECKSUM_LENGTH(&pdu_checksum));
  960. if (retval) {
  961.     DEBUGMSGTL(("ksm", "Unable to determine checksum length: %sn",
  962. error_message(retval)));
  963.     snmp_set_detail(error_message(retcode));
  964.     retval = SNMPERR_KRB5;
  965.     goto error;
  966. }
  967. #else /* OLD_HEIMDAL */
  968.     CHECKSUM_LENGTH(&pdu_checksum) = krb5_checksum_size(kcontext, cksumtype);
  969. #endif /* OLD_HEIMDAL */
  970.     CHECKSUM_TYPE(&pdu_checksum) = cksumtype;
  971. #ifdef OLD_HEIMDAL
  972.     }
  973. #endif /* OLD_HEIMDAL */
  975. #endif /* MIT_NEW_CRYPTO */
  977.     /*
  978.      * Note that here, we're just leaving blank space for the checksum;
  979.      * we remember where that is, and we'll fill it in later.
  980.      */
  982.     *offset += CHECKSUM_LENGTH(&pdu_checksum);
  983.     memset(*wholeMsg + *parms->wholeMsgLen - *offset, 0, CHECKSUM_LENGTH(&pdu_checksum));
  985.     cksum_pointer = *wholeMsg + *parms->wholeMsgLen - *offset;
  987.     rc = asn_realloc_rbuild_header(wholeMsg, parms->wholeMsgLen,
  988.                                          parms->wholeMsgOffset, 1,
  989.                                          (u_char) (ASN_UNIVERSAL |
  990.                                                    ASN_PRIMITIVE |
  991.                                                    ASN_OCTET_STR),
  992.                                          CHECKSUM_LENGTH(&pdu_checksum));
  994.     if (rc == 0) {
  995.         DEBUGMSGTL(("ksm", "Building ksm security parameters failed.n"));
  996.         retval = SNMPERR_TOO_LONG;
  997.         goto error;
  998.     }
  1000.     rc = asn_realloc_rbuild_int(wholeMsg, parms->wholeMsgLen,
  1001.                                       parms->wholeMsgOffset, 1,
  1002.                                       (u_char) (ASN_UNIVERSAL |
  1003.                                                 ASN_PRIMITIVE |
  1004.                                                 ASN_OCTET_STR),
  1005.                                       (long *) &cksumtype,
  1006.                                       sizeof(cksumtype));
  1008.     if (rc == 0) {
  1009.         DEBUGMSGTL(("ksm", "Building ksm security parameters failed.n"));
  1010.         retval = SNMPERR_TOO_LONG;
  1011.         goto error;
  1012.     }
  1014.     rc = asn_realloc_rbuild_sequence(wholeMsg, parms->wholeMsgLen,
  1015.                                            parms->wholeMsgOffset, 1,
  1016.                                            (u_char) (ASN_SEQUENCE |
  1017.                                                      ASN_CONSTRUCTOR),
  1018.                                            *offset - seq_offset);
  1020.     if (rc == 0) {
  1021.         DEBUGMSGTL(("ksm", "Building ksm security parameters failed.n"));
  1022.         retval = SNMPERR_TOO_LONG;
  1023.         goto error;
  1024.     }
  1026.     rc = asn_realloc_rbuild_header(wholeMsg, parms->wholeMsgLen,
  1027.                                          parms->wholeMsgOffset, 1,
  1028.                                          (u_char) (ASN_UNIVERSAL |
  1029.                                                    ASN_PRIMITIVE |
  1030.                                                    ASN_OCTET_STR),
  1031.                                          *offset - seq_offset);
  1033.     if (rc == 0) {
  1034.         DEBUGMSGTL(("ksm", "Building ksm security parameters failed.n"));
  1035.         retval = SNMPERR_TOO_LONG;
  1036.         goto error;
  1037.     }
  1039.     DEBUGMSGTL(("ksm", "KSM: Security parameter encoding completedn"));
  1041.     /*
  1042.      * We're done with the KSM security parameters - now we do the global
  1043.      * header and wrap up the whole PDU.
  1044.      */
  1046.     if (*parms->wholeMsgLen < parms->globalDataLen) {
  1047.         DEBUGMSGTL(("ksm", "Building global data failed.n"));
  1048.         retval = SNMPERR_TOO_LONG;
  1049.         goto error;
  1050.     }
  1052.     *offset += parms->globalDataLen;
  1053.     memcpy(*wholeMsg + *parms->wholeMsgLen - *offset,
  1054.    parms->globalData, parms->globalDataLen);
  1056.     rc = asn_realloc_rbuild_sequence(wholeMsg, parms->wholeMsgLen,
  1057.                                            offset, 1,
  1058.                                            (u_char) (ASN_SEQUENCE |
  1059.                                                      ASN_CONSTRUCTOR),
  1060.                                            *offset);
  1062.     if (rc == 0) {
  1063.         DEBUGMSGTL(("ksm", "Building master packet sequence.n"));
  1064.         retval = SNMPERR_TOO_LONG;
  1065.         goto error;
  1066.     }
  1068.     DEBUGMSGTL(("ksm", "KSM: PDU master packet encoding complete.n"));
  1070.     /*
  1071.      * Now we need to checksum the entire PDU (since it's built).
  1072.      */
  1074. #ifndef OLD_HEIMDAL /* since heimdal allocs the mem for us */
  1075.     CHECKSUM_CONTENTS(&pdu_checksum) = malloc(CHECKSUM_LENGTH(&pdu_checksum));
  1077.     if (!CHECKSUM_CONTENTS(&pdu_checksum)) {
  1078.         DEBUGMSGTL(("ksm", "Unable to malloc %d bytes for checksumn",
  1079.                     CHECKSUM_LENGTH(&pdu_checksum)));
  1080.         retval = SNMPERR_MALLOC;
  1081.         goto error;
  1082.     }
  1083. #endif /* ! OLD_HEIMDAL */
  1084. #ifdef MIT_NEW_CRYPTO
  1086.     input.data = (char *) (*wholeMsg + *parms->wholeMsgLen - *offset);
  1087.     input.length = *offset;
  1088.         retcode = krb5_c_make_checksum(kcontext, cksumtype, subkey,
  1089.                                        KSM_KEY_USAGE_CHECKSUM, &input,
  1090.                                        &pdu_checksum);
  1092. #elif defined(OLD_HEIMDAL) /* MIT_NEW_CRYPTO */
  1094. retcode = krb5_create_checksum(kcontext, heim_crypto,
  1095.        KSM_KEY_USAGE_CHECKSUM, cksumtype,
  1096.        *wholeMsg + *parms->wholeMsgLen
  1097.        - *offset, *offset, &pdu_checksum);
  1098. #else                           /* MIT_NEW_CRYPTO */
  1100.     retcode = krb5_calculate_checksum(kcontext, cksumtype, *wholeMsg +
  1101.       *parms->wholeMsgLen - *offset,
  1102.                                       *offset,
  1103.                                       (krb5_pointer) subkey->contents,
  1104.                                       subkey->length, &pdu_checksum);
  1106. #endif                          /* MIT_NEW_CRYPTO */
  1108.     if (retcode) {
  1109.         DEBUGMSGTL(("ksm", "Calculate checksum failed: %sn",
  1110.                     error_message(retcode)));
  1111.         retval = SNMPERR_KRB5;
  1112.         snmp_set_detail(error_message(retcode));
  1113.         goto error;
  1114.     }
  1116.     DEBUGMSGTL(("ksm", "KSM: Checksum calculation complete.n"));
  1118.     memcpy(cksum_pointer, CHECKSUM_CONTENTS(&pdu_checksum), CHECKSUM_LENGTH(&pdu_checksum));
  1120.     DEBUGMSGTL(("ksm", "KSM: Writing checksum of %d bytes at offset %dn",
  1121.                 CHECKSUM_LENGTH(&pdu_checksum), cksum_pointer - (*wholeMsg + 1)));
  1123.     DEBUGMSGTL(("ksm", "KSM: Checksum:"));
  1125.     for (i = 0; i < CHECKSUM_LENGTH(&pdu_checksum); i++)
  1126.         DEBUGMSG(("ksm", " %02x",
  1127.                   (unsigned int) CHECKSUM_CONTENTS(&pdu_checksum)[i]));
  1129.     DEBUGMSG(("ksm", "n"));
  1131.     /*
  1132.      * If we're _not_ called as part of a response (null ksm_state),
  1133.      * then save the auth_context for later using our cache routines.
  1134.      */
  1136.     if (!ksm_state) {
  1137.         if ((retval = ksm_insert_cache(parms->pdu->msgid, auth_context,
  1138.                                        (u_char *) parms->secName,
  1139.                                        parms->secNameLen)) !=
  1140.             SNMPERR_SUCCESS)
  1141.             goto error;
  1142.         auth_context = NULL;
  1143.     }
  1145.     DEBUGMSGTL(("ksm", "KSM processing complete!n"));
  1147.   error:
  1149.     if (CHECKSUM_CONTENTS(&pdu_checksum))
  1150. #ifdef MIT_NEW_CRYPTO
  1151.         krb5_free_checksum_contents(kcontext, &pdu_checksum);
  1152. #else                           /* MIT_NEW_CRYPTO */
  1153.         free(CHECKSUM_CONTENTS(&pdu_checksum));
  1154. #endif                          /* MIT_NEW_CRYPTO */
  1156.     if (ivector.data)
  1157.         free(ivector.data);
  1159.     if (subkey)
  1160.         krb5_free_keyblock(kcontext, subkey);
  1162. #ifdef OLD_HEIMDAL /* OLD_HEIMDAL */
  1163.     if (heim_crypto)
  1164.     krb5_crypto_destroy(kcontext, heim_crypto);
  1165. #endif /* OLD_HEIMDAL */
  1167.     if (encrypted_data)
  1168.         free(encrypted_data);
  1170.     if (cc)
  1171.         krb5_cc_close(kcontext, cc);
  1173.     if (auth_context && !ksm_state)
  1174.         krb5_auth_con_free(kcontext, auth_context);
  1176.     return retval;
  1177. }
  1179. /****************************************************************************
  1180.  *
  1181.  * ksm_process_in_msg
  1182.  *
  1183.  * Parameters:
  1184.  * (See list below...)
  1185.  *
  1186.  * Returns:
  1187.  * KSM_ERR_NO_ERROR                        On success.
  1188.  * SNMPERR_KRB5
  1189.  * KSM_ERR_GENERIC_ERROR
  1190.  * KSM_ERR_UNSUPPORTED_SECURITY_LEVEL
  1191.  *
  1192.  *
  1193.  * Processes an incoming message.
  1194.  *
  1195.  ****************************************************************************/
  1197. int
  1198. ksm_process_in_msg(struct snmp_secmod_incoming_params *parms)
  1199. {
  1200.     long            temp;
  1201.     krb5_cksumtype  cksumtype;
  1202.     krb5_auth_context auth_context = NULL;
  1203.     krb5_error_code retcode;
  1204.     krb5_checksum   checksum;
  1205.     krb5_data       ap_req, ivector;
  1206.     krb5_flags      flags;
  1207.     krb5_keyblock  *subkey = NULL;
  1208. #ifdef MIT_NEW_CRYPTO
  1209.     krb5_data       input, output;
  1210.     krb5_boolean    valid;
  1211.     krb5_enc_data   in_crypt;
  1212. #elif defined OLD_HEIMDAL /* MIT_NEW_CRYPTO */
  1213.     krb5_data output;
  1214.     krb5_crypto heim_crypto = NULL;
  1215. #else                           /* MIT_NEW_CRYPTO */
  1216.     krb5_encrypt_block eblock;
  1217. #endif                          /* MIT_NEW_CRYPTO */
  1218.     krb5_ticket    *ticket = NULL;
  1219.     int             retval = SNMPERR_SUCCESS, response = 0;
  1220.     size_t          length =
  1221.         parms->wholeMsgLen - (u_int) (parms->secParams - parms->wholeMsg);
  1222.     u_char         *current = parms->secParams, type;
  1223.     size_t          cksumlength, blocksize;
  1224.     long            hint;
  1225.     char           *cname;
  1226.     struct ksm_secStateRef *ksm_state;
  1227.     struct ksm_cache_entry *entry;
  1229.     DEBUGMSGTL(("ksm", "Processing has begunn"));
  1231.     CHECKSUM_CONTENTS(&checksum) = NULL;
  1232.     ap_req.data = NULL;
  1233.     ivector.length = 0;
  1234.     ivector.data = NULL;
  1236.     /*
  1237.      * First, parse the security parameters (because we need the subkey inside
  1238.      * of the ticket to do anything
  1239.      */
  1241.     if ((current = asn_parse_sequence(current, &length, &type,
  1242.                                       (ASN_UNIVERSAL | ASN_PRIMITIVE |
  1243.                                        ASN_OCTET_STR),
  1244.                                       "ksm first octet")) == NULL) {
  1245.         DEBUGMSGTL(("ksm", "Initial security paramter parsing failedn"));
  1247.         retval = SNMPERR_ASN_PARSE_ERR;
  1248.         goto error;
  1249.     }
  1251.     if ((current = asn_parse_sequence(current, &length, &type,
  1252.                                       (ASN_SEQUENCE | ASN_CONSTRUCTOR),
  1253.                                       "ksm sequence")) == NULL) {
  1254.         DEBUGMSGTL(("ksm",
  1255.                     "Security parameter sequence parsing failedn"));
  1257.         retval = SNMPERR_ASN_PARSE_ERR;
  1258.         goto error;
  1259.     }
  1261.     if ((current = asn_parse_int(current, &length, &type, &temp,
  1262.                                  sizeof(temp))) == NULL) {
  1263.         DEBUGMSGTL(("ksm", "Security parameter checksum type parsing"
  1264.                     "failedn"));
  1266.         retval = SNMPERR_ASN_PARSE_ERR;
  1267.         goto error;
  1268.     }
  1270.     cksumtype = temp;
  1272. #ifdef MIT_NEW_CRYPTO
  1273.     if (!krb5_c_valid_cksumtype(cksumtype)) {
  1274.         DEBUGMSGTL(("ksm", "Invalid checksum type (%d)n", cksumtype));
  1276.         retval = SNMPERR_KRB5;
  1277.         snmp_set_detail("Invalid checksum type");
  1278.         goto error;
  1279.     }
  1281.     if (!krb5_c_is_keyed_cksum(cksumtype)) {
  1282.         DEBUGMSGTL(("ksm", "Checksum type %d is not a keyed checksumn",
  1283.                     cksumtype));
  1284.         snmp_set_detail("Checksum is not a keyed checksum");
  1285.         retval = SNMPERR_KRB5;
  1286.         goto error;
  1287.     }
  1289.     if (!krb5_c_is_coll_proof_cksum(cksumtype)) {
  1290.         DEBUGMSGTL(("ksm", "Checksum type %d is not a collision-proof "
  1291.                     "checksumn", cksumtype));
  1292.         snmp_set_detail("Checksum is not a collision-proof checksum");
  1293.         retval = SNMPERR_KRB5;
  1294.         goto error;
  1295.     }
  1296. #else /* ! MIT_NEW_CRYPTO */
  1297. #ifdef OLD_HEIMDAL
  1298.     /* kludge */
  1299.     if (krb5_checksumsize(kcontext, cksumtype, &cksumlength)) {
  1300. #else /* OLD_HEIMDAL */
  1301.     if (!valid_cksumtype(cksumtype)) {
  1302. #endif /* OLD_HEIMDAL */
  1303.         DEBUGMSGTL(("ksm", "Invalid checksum type (%d)n", cksumtype));
  1305.         retval = SNMPERR_KRB5;
  1306.         snmp_set_detail("Invalid checksum type");
  1307.         goto error;
  1308.     }
  1310. #ifdef OLD_HEIMDAL
  1311.     if (!krb5_checksum_is_keyed(kcontext, cksumtype)) {
  1312. #else /* OLD_HEIMDAL */
  1313.     if (!is_keyed_cksum(cksumtype)) {
  1314. #endif /* OLD_HEIMDAL */
  1315.         DEBUGMSGTL(("ksm", "Checksum type %d is not a keyed checksumn",
  1316.                     cksumtype));
  1317.         snmp_set_detail("Checksum is not a keyed checksum");
  1318.         retval = SNMPERR_KRB5;
  1319.         goto error;
  1320.     }
  1322. #ifdef OLD_HEIMDAL
  1323.     if (!krb5_checksum_is_collision_proof(kcontext, cksumtype)) {
  1324. #else /* OLD_HEIMDAL */
  1325.     if (!is_coll_proof_cksum(cksumtype)) {
  1326. #endif /* OLD_HEIMDAL */
  1327.         DEBUGMSGTL(("ksm", "Checksum type %d is not a collision-proof "
  1328.                     "checksumn", cksumtype));
  1329.         snmp_set_detail("Checksum is not a collision-proof checksum");
  1330.         retval = SNMPERR_KRB5;
  1331.         goto error;
  1332.     }
  1333. #endif /* MIT_NEW_CRYPTO */
  1335.     CHECKSUM_TYPE(&checksum) = cksumtype;
  1337.     cksumlength = length;
  1339.     if ((current = asn_parse_sequence(current, &cksumlength, &type,
  1340.                                       (ASN_UNIVERSAL | ASN_PRIMITIVE |
  1341.                                        ASN_OCTET_STR), "ksm checksum")) ==
  1342.         NULL) {
  1343.         DEBUGMSGTL(("ksm",
  1344.                     "Security parameter checksum parsing failedn"));
  1346.         retval = SNMPERR_ASN_PARSE_ERR;
  1347.         goto error;
  1348.     }
  1350.     CHECKSUM_CONTENTS(&checksum) = malloc(cksumlength);
  1351.     if (!CHECKSUM_CONTENTS(&checksum)) {
  1352.         DEBUGMSGTL(("ksm", "Unable to malloc %d bytes for checksum.n",
  1353.                     cksumlength));
  1354.         retval = SNMPERR_MALLOC;
  1355.         goto error;
  1356.     }
  1358.     memcpy(CHECKSUM_CONTENTS(&checksum), current, cksumlength);
  1360.     CHECKSUM_LENGTH(&checksum) = cksumlength;
  1361.     CHECKSUM_TYPE(&checksum) = cksumtype;
  1363.     /*
  1364.      * Zero out the checksum so the validation works correctly
  1365.      */
  1367.     memset(current, 0, cksumlength);
  1369.     current += cksumlength;
  1370.     length = parms->wholeMsgLen - (u_int) (current - parms->wholeMsg);
  1372.     if ((current = asn_parse_sequence(current, &length, &type,
  1373.                                       (ASN_UNIVERSAL | ASN_PRIMITIVE |
  1374.                                        ASN_OCTET_STR), "ksm ap_req")) ==
  1375.         NULL) {
  1376.         DEBUGMSGTL(("ksm", "KSM security parameter AP_REQ/REP parsing "
  1377.                     "failedn"));
  1379.         retval = SNMPERR_ASN_PARSE_ERR;
  1380.         goto error;
  1381.     }
  1383.     ap_req.length = length;
  1384.     ap_req.data = malloc(length);
  1385.     if (!ap_req.data) {
  1386.         DEBUGMSGTL(("ksm",
  1387.                     "KSM unable to malloc %d bytes for AP_REQ/REP.n",
  1388.                     length));
  1389.         retval = SNMPERR_MALLOC;
  1390.         goto error;
  1391.     }
  1393.     memcpy(ap_req.data, current, length);
  1395.     current += length;
  1396.     length = parms->wholeMsgLen - (u_int) (current - parms->wholeMsg);
  1398.     if ((current = asn_parse_int(current, &length, &type, &hint,
  1399.                                  sizeof(hint))) == NULL) {
  1400.         DEBUGMSGTL(("ksm",
  1401.                     "KSM security parameter hint parsing failedn"));
  1403.         retval = SNMPERR_ASN_PARSE_ERR;
  1404.         goto error;
  1405.     }
  1407.     /*
  1408.      * Okay!  We've got it all!  Now try decoding the damn ticket.
  1409.      *
  1410.      * But of course there's a WRINKLE!  We need to figure out if we're
  1411.      * processing a AP_REQ or an AP_REP.  How do we do that?  We're going
  1412.      * to cheat, and look at the first couple of bytes (which is what
  1413.      * the Kerberos library routines do anyway).
  1414.      *
  1415.      * If there are ever new Kerberos message formats, we'll need to fix
  1416.      * this here.
  1417.      *
  1418.      * If it's a _response_, then we need to get the auth_context
  1419.      * from our cache.
  1420.      */
  1422.     if (ap_req.length
  1423. #ifndef HEIMDAL
  1424.         && (ap_req.data[0] == 0x6e || ap_req.data[0] == 0x4e)) {
  1425. #else /* HEIMDAL */
  1426.         && (((char *)ap_req.data)[0] == 0x6e || ((char *)ap_req.data)[0] == 0x4e)) {
  1427. #endif
  1429.         /*
  1430.          * We need to initalize the authorization context, and set the
  1431.          * replay cache in it (and initialize the replay cache if we
  1432.          * haven't already
  1433.          */
  1435.         retcode = krb5_auth_con_init(kcontext, &auth_context);
  1437.         if (retcode) {
  1438.             DEBUGMSGTL(("ksm", "krb5_auth_con_init failed: %sn",
  1439.                         error_message(retcode)));
  1440.             retval = SNMPERR_KRB5;
  1441.             snmp_set_detail(error_message(retcode));
  1442.             goto error;
  1443.         }
  1445.         if (!rcache) {
  1446.             krb5_data       server;
  1447.             server.data = "host";
  1448.             server.length = strlen(server.data);
  1450.             retcode = krb5_get_server_rcache(kcontext, &server, &rcache);
  1452.             if (retcode) {
  1453.                 DEBUGMSGTL(("ksm", "krb5_get_server_rcache failed: %sn",
  1454.                             error_message(retcode)));
  1455.                 retval = SNMPERR_KRB5;
  1456.                 snmp_set_detail(error_message(retcode));
  1457.                 goto error;
  1458.             }
  1459.         }
  1461.         retcode = krb5_auth_con_setrcache(kcontext, auth_context, rcache);
  1463.         if (retcode) {
  1464.             DEBUGMSGTL(("ksm", "krb5_auth_con_setrcache failed: %sn",
  1465.                         error_message(retcode)));
  1466.             retval = SNMPERR_KRB5;
  1467.             snmp_set_detail(error_message(retcode));
  1468.             goto error;
  1469.         }
  1471.         retcode = krb5_rd_req(kcontext, &auth_context, &ap_req, NULL,
  1472.                               keytab, &flags, &ticket);
  1474.         krb5_auth_con_setrcache(kcontext, auth_context, NULL);
  1476.         if (retcode) {
  1477.             DEBUGMSGTL(("ksm", "krb5_rd_req() failed: %sn",
  1478.                         error_message(retcode)));
  1479.             retval = SNMPERR_KRB5;
  1480.             snmp_set_detail(error_message(retcode));
  1481.             goto error;
  1482.         }
  1484.         retcode =
  1485.             krb5_unparse_name(kcontext, TICKET_CLIENT(ticket), &cname);
  1487.         if (retcode == 0) {
  1488.             DEBUGMSGTL(("ksm", "KSM authenticated principal name: %sn",
  1489.                         cname));
  1490.             free(cname);
  1491.         }
  1493.         /*
  1494.          * Check to make sure AP_OPTS_MUTUAL_REQUIRED was set
  1495.          */
  1497.         if (!(flags & AP_OPTS_MUTUAL_REQUIRED)) {
  1498.             DEBUGMSGTL(("ksm",
  1499.                         "KSM MUTUAL_REQUIRED not set in request!n"));
  1500.             retval = SNMPERR_KRB5;
  1501.             snmp_set_detail("MUTUAL_REQUIRED not set in message");
  1502.             goto error;
  1503.         }
  1505.         retcode =
  1506.             krb5_auth_con_getremotesubkey(kcontext, auth_context, &subkey);
  1508.         if (retcode) {
  1509.             DEBUGMSGTL(("ksm", "KSM remote subkey retrieval failed: %sn",
  1510.                         error_message(retcode)));
  1511.             retval = SNMPERR_KRB5;
  1512.             snmp_set_detail(error_message(retcode));
  1513.             goto error;
  1514.         }
  1516. #ifndef HEIMDAL
  1517.     } else if (ap_req.length && (ap_req.data[0] == 0x6f ||
  1518.                                  ap_req.data[0] == 0x4f)) {
  1519. #else /* HEIMDAL */
  1520.     } else if (ap_req.length && (((char *)ap_req.data)[0] == 0x6f ||
  1521.                                  ((char *)ap_req.data)[0] == 0x4f)) {
  1522. #endif /* HEIMDAL */
  1523.         /*
  1524.          * Looks like a response; let's see if we've got that auth_context
  1525.          * in our cache.
  1526.          */
  1528.         krb5_ap_rep_enc_part *repl = NULL;
  1530.         response = 1;
  1532.         entry = ksm_get_cache(parms->pdu->msgid);
  1534.         if (!entry) {
  1535.             DEBUGMSGTL(("ksm",
  1536.                         "KSM: Unable to find auth_context for PDU with "
  1537.                         "message ID of %ldn", parms->pdu->msgid));
  1538.             retval = SNMPERR_KRB5;
  1539.             goto error;
  1540.         }
  1542.         auth_context = entry->auth_context;
  1544.         /*
  1545.          * In that case, let's call the rd_rep function
  1546.          */
  1548.         retcode = krb5_rd_rep(kcontext, auth_context, &ap_req, &repl);
  1550.         if (repl)
  1551.             krb5_free_ap_rep_enc_part(kcontext, repl);
  1553.         if (retcode) {
  1554.             DEBUGMSGTL(("ksm", "KSM: krb5_rd_rep() failed: %sn",
  1555.                         error_message(retcode)));
  1556.             retval = SNMPERR_KRB5;
  1557.             goto error;
  1558.         }
  1560.         DEBUGMSGTL(("ksm", "KSM: krb5_rd_rep() decoded successfully.n"));
  1562.         retcode =
  1563.             krb5_auth_con_getlocalsubkey(kcontext, auth_context, &subkey);
  1565.         if (retcode) {
  1566.             DEBUGMSGTL(("ksm", "Unable to retrieve local subkey: %sn",
  1567.                         error_message(retcode)));
  1568.             retval = SNMPERR_KRB5;
  1569.             snmp_set_detail("Unable to retrieve local subkey");
  1570.             goto error;
  1571.         }
  1573.     } else {
  1574. #ifndef HEIMDAL
  1575.         DEBUGMSGTL(("ksm", "Unknown Kerberos message type (%02x)n",
  1576.                     ap_req.data[0]));
  1577. #else  /* HEIMDAL */
  1578.  DEBUGMSGTL(("ksm", "Unknown Kerberos message type (%02x)n",
  1579.                     ((char *)ap_req.data)[0]));
  1580. #endif
  1581.         retval = SNMPERR_KRB5;
  1582.         snmp_set_detail("Unknown Kerberos message type");
  1583.         goto error;
  1584.     }
  1586. #ifdef MIT_NEW_CRYPTO
  1587.     input.data = (char *) parms->wholeMsg;
  1588.     input.length = parms->wholeMsgLen;
  1590.     retcode =
  1591.         krb5_c_verify_checksum(kcontext, subkey, KSM_KEY_USAGE_CHECKSUM,
  1592.                                &input, &checksum, &valid);
  1593. #elif defined(OLD_HEIMDAL) /* MIT_NEW_CRYPTO */
  1594.     retcode = krb5_crypto_init(kcontext, subkey, 0, &heim_crypto);
  1595.     if (retcode) {
  1596.             DEBUGMSGTL(("ksm", "krb5_crypto_init failed: %sn",
  1597.                         error_message(retcode)));
  1598.             snmp_set_detail(error_message(retcode));
  1599.             retval = SNMPERR_KRB5;
  1600.             goto error;
  1601.     }
  1602.     retcode = krb5_verify_checksum(kcontext, heim_crypto,
  1603.    KSM_KEY_USAGE_CHECKSUM, parms->wholeMsg,
  1604.    parms->wholeMsgLen, &checksum);
  1605. #else                           /* MIT_NEW_CRYPTO */
  1606.     retcode = krb5_verify_checksum(kcontext, cksumtype, &checksum,
  1607.                                    parms->wholeMsg, parms->wholeMsgLen,
  1608.                                    (krb5_pointer) subkey->contents,
  1609.                                    subkey->length);
  1610. #endif                          /* MIT_NEW_CRYPTO */
  1612.     if (retcode) {
  1613.         DEBUGMSGTL(("ksm", "KSM checksum verification failed: %sn",
  1614.                     error_message(retcode)));
  1615.         retval = SNMPERR_KRB5;
  1616.         snmp_set_detail(error_message(retcode));
  1617.         goto error;
  1618.     }
  1620.     /*
  1621.      * Don't ask me why they didn't simply return an error, but we have
  1622.      * to check to see if "valid" is false.
  1623.      */
  1625. #ifdef MIT_NEW_CRYPTO
  1626.     if (!valid) {
  1627.         DEBUGMSGTL(("ksm", "Computed checksum did not match supplied "
  1628.                     "checksum!n"));
  1629.         retval = SNMPERR_KRB5;
  1630.         snmp_set_detail
  1631.             ("Computed checksum did not match supplied checksum");
  1632.         goto error;
  1633.     }
  1634. #endif                          /* MIT_NEW_CRYPTO */
  1636.     /*
  1637.      * Handle an encrypted PDU.  Note that it's an OCTET_STRING of the
  1638.      * output of whatever Kerberos cryptosystem you're using (defined by
  1639.      * the encryption type).  Note that this is NOT the EncryptedData
  1640.      * sequence - it's what goes in the "cipher" field of EncryptedData.
  1641.      */
  1643.     if (parms->secLevel == SNMP_SEC_LEVEL_AUTHPRIV) {
  1645.         if ((current = asn_parse_sequence(current, &length, &type,
  1646.                                           (ASN_UNIVERSAL | ASN_PRIMITIVE |
  1647.                                            ASN_OCTET_STR), "ksm pdu")) ==
  1648.             NULL) {
  1649.             DEBUGMSGTL(("ksm", "KSM sPDU octet decoding failedn"));
  1650.             retval = SNMPERR_ASN_PARSE_ERR;
  1651.             goto error;
  1652.         }
  1654.         /*
  1655.          * The PDU is now pointed at by "current", and the length is in
  1656.          * "length".
  1657.          */
  1659.         DEBUGMSGTL(("ksm", "KSM starting sPDU decoden"));
  1661.         /*
  1662.          * We need to set up a blank initialization vector for the decryption.
  1663.          * Use a block of all zero's (which is dependent on the block size
  1664.          * of the encryption method).
  1665.          */
  1667. #ifdef MIT_NEW_CRYPTO
  1669.         retcode = krb5_c_block_size(kcontext, subkey->enctype, &blocksize);
  1671.         if (retcode) {
  1672.             DEBUGMSGTL(("ksm",
  1673.                         "Unable to determine crypto block size: %sn",
  1674.                         error_message(retcode)));
  1675.             snmp_set_detail(error_message(retcode));
  1676.             retval = SNMPERR_KRB5;
  1677.             goto error;
  1678.         }
  1679. #elif defined(OLD_HEIMDAL) /* MIT_NEW_CRYPTO */
  1680. #else                           /* MIT_NEW_CRYPTO */
  1682.         blocksize =
  1683.             krb5_enctype_array[subkey->enctype]->system->block_length;
  1685. #endif                          /* MIT_NEW_CRYPTO */
  1687. #ifndef OLD_HEIMDAL
  1688.         ivector.data = malloc(blocksize);
  1690.         if (!ivector.data) {
  1691.             DEBUGMSGTL(("ksm", "Unable to allocate %d bytes for ivectorn",
  1692.                         blocksize));
  1693.             retval = SNMPERR_MALLOC;
  1694.             goto error;
  1695.         }
  1697.         ivector.length = blocksize;
  1698.         memset(ivector.data, 0, blocksize);
  1700. #ifndef MIT_NEW_CRYPTO
  1702.         krb5_use_enctype(kcontext, &eblock, subkey->enctype);
  1704.         retcode = krb5_process_key(kcontext, &eblock, subkey);
  1706.         if (retcode) {
  1707.             DEBUGMSGTL(("ksm", "KSM key post-processing failed: %sn",
  1708.                         error_message(retcode)));
  1709.             snmp_set_detail(error_message(retcode));
  1710.             retval = SNMPERR_KRB5;
  1711.             goto error;
  1712.         }
  1713. #endif                          /* !MIT_NEW_CRYPTO */
  1715. #endif /* ! OLD_HEIMDAL */
  1717.         if (length > *parms->scopedPduLen) {
  1718.             DEBUGMSGTL(("ksm", "KSM not enough room - have %d bytes to "
  1719.                         "decrypt but only %d bytes availablen", length,
  1720.                         *parms->scopedPduLen));
  1721.             retval = SNMPERR_TOO_LONG;
  1722. #ifndef MIT_NEW_CRYPTO
  1723. #ifndef OLD_HEIMDAL
  1724.             krb5_finish_key(kcontext, &eblock);
  1725. #endif                          /* ! OLD_HEIMDAL */
  1726. #endif                          /* ! MIT_NEW_CRYPTO */
  1727.             goto error;
  1728.         }
  1729. #ifdef MIT_NEW_CRYPTO
  1730.         in_crypt.ciphertext.data = (char *) current;
  1731.         in_crypt.ciphertext.length = length;
  1732.         in_crypt.enctype = subkey->enctype;
  1733.         output.data = (char *) *parms->scopedPdu;
  1734.         output.length = *parms->scopedPduLen;
  1736.         retcode =
  1737.             krb5_c_decrypt(kcontext, subkey, KSM_KEY_USAGE_ENCRYPTION,
  1738.                            &ivector, &in_crypt, &output);
  1739. #elif defined (OLD_HEIMDAL) /* MIT_NEW_CRYPTO */
  1740. retcode = krb5_decrypt(kcontext, heim_crypto, KSM_KEY_USAGE_ENCRYPTION,
  1741.        current, length, &output);
  1742. if (retcode == 0) {
  1743. *parms->scopedPdu = (char *) output.data;
  1744. *parms->scopedPduLen = output.length;
  1745. krb5_data_zero(&output);
  1746. }
  1747. #else                           /* MIT_NEW_CRYPTO */
  1749.         retcode = krb5_decrypt(kcontext, (krb5_pointer) current,
  1750.                                *parms->scopedPdu, length, &eblock,
  1751.                                ivector.data);
  1753.         krb5_finish_key(kcontext, &eblock);
  1755. #endif                          /* MIT_NEW_CRYPTO */
  1757.         if (retcode) {
  1758.             DEBUGMSGTL(("ksm", "Decryption failed: %sn",
  1759.                         error_message(retcode)));
  1760.             snmp_set_detail(error_message(retcode));
  1761.             retval = SNMPERR_KRB5;
  1762.             goto error;
  1763.         }
  1765.         *parms->scopedPduLen = length;
  1767.     } else {
  1768.         /*
  1769.          * Clear PDU
  1770.          */
  1772.         *parms->scopedPdu = current;
  1773.         *parms->scopedPduLen =
  1774.             parms->wholeMsgLen - (current - parms->wholeMsg);
  1775.     }
  1777.     /*
  1778.      * A HUGE GROSS HACK
  1779.      */
  1781.     *parms->maxSizeResponse = parms->maxMsgSize - 200;
  1783.     DEBUGMSGTL(("ksm", "KSM processing completen"));
  1785.     /*
  1786.      * Set the secName to the right value (a hack for now).  But that's
  1787.      * only used for when we're processing a request, not a response.
  1788.      */
  1790.     if (!response) {
  1792.         retcode = krb5_unparse_name(kcontext, TICKET_CLIENT(ticket),
  1793.                                     &cname);
  1795.         if (retcode) {
  1796.             DEBUGMSGTL(("ksm", "KSM krb5_unparse_name failed: %sn",
  1797.                         error_message(retcode)));
  1798.             snmp_set_detail(error_message(retcode));
  1799.             retval = SNMPERR_KRB5;
  1800.             goto error;
  1801.         }
  1803.         if (strlen(cname) > *parms->secNameLen + 1) {
  1804.             DEBUGMSGTL(("ksm",
  1805.                         "KSM: Principal length (%d) is too long (%d)n",
  1806.                         strlen(cname), parms->secNameLen));
  1807.             retval = SNMPERR_TOO_LONG;
  1808.             free(cname);
  1809.             goto error;
  1810.         }
  1812.         strcpy(parms->secName, cname);
  1813.         *parms->secNameLen = strlen(cname);
  1815.         free(cname);
  1817.         /*
  1818.          * Also, if we're not a response, keep around our auth_context so we
  1819.          * can encode the reply message correctly
  1820.          */
  1822.         ksm_state = SNMP_MALLOC_STRUCT(ksm_secStateRef);
  1824.         if (!ksm_state) {
  1825.             DEBUGMSGTL(("ksm", "KSM unable to malloc memory for "
  1826.                         "ksm_secStateRefn"));
  1827.             retval = SNMPERR_MALLOC;
  1828.             goto error;
  1829.         }
  1831.         ksm_state->auth_context = auth_context;
  1832.         auth_context = NULL;
  1833.         ksm_state->cksumtype = cksumtype;
  1835.         *parms->secStateRef = ksm_state;
  1836.     } else {
  1838.         /*
  1839.          * We _still_ have to set the secName in process_in_msg().  Do
  1840.          * that now with what we were passed in before (we cached it,
  1841.          * remember?)
  1842.          */
  1844.         memcpy(parms->secName, entry->secName, entry->secNameLen);
  1845.         *parms->secNameLen = entry->secNameLen;
  1846.     }
  1848.     /*
  1849.      * Just in case
  1850.      */
  1852.     parms->secEngineID = (u_char *) "";
  1853.     *parms->secEngineIDLen = 0;
  1855.     auth_context = NULL;        /* So we don't try to free it on success */
  1857.   error:
  1858.     if (retval == SNMPERR_ASN_PARSE_ERR &&
  1859.         snmp_increment_statistic(STAT_SNMPINASNPARSEERRS) == 0)
  1860.         DEBUGMSGTL(("ksm", "Failed to increment statistics.n"));
  1862.     if (subkey)
  1863.         krb5_free_keyblock(kcontext, subkey);
  1865. #ifdef OLD_HEIMDAL /* OLD_HEIMDAL */
  1866.     if (heim_crypto)
  1867.     krb5_crypto_destroy(kcontext, heim_crypto);
  1868. #endif /* OLD_HEIMDAL */
  1870.     if (CHECKSUM_CONTENTS(&checksum))
  1871.         free(CHECKSUM_CONTENTS(&checksum));
  1873.     if (ivector.data)
  1874.         free(ivector.data);
  1876.     if (ticket)
  1877.         krb5_free_ticket(kcontext, ticket);
  1879.     if (!response && auth_context)
  1880.         krb5_auth_con_free(kcontext, auth_context);
  1882.     if (ap_req.data)
  1883.         free(ap_req.data);
  1885.     return retval;
  1886. }