lib/gssapi/get_mic.c

   1 /*
   2  * Copyright (c) 1997 - 2003 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "gssapi_locl.h"
  35
  36 RCSID("$Id$");
  37
  38 static OM_uint32
  39 mic_des
  40            (OM_uint32 * minor_status,
  41             const gss_ctx_id_t context_handle,
  42             gss_qop_t qop_req,
  43             const gss_buffer_t message_buffer,
  44             gss_buffer_t message_token,
  45             krb5_keyblock *key
  46            )
  47 {
  48   u_char *p;
  49   MD5_CTX md5;
  50   u_char hash[16];
  51   des_key_schedule schedule;
  52   des_cblock deskey;
  53   des_cblock zero;
  54   int32_t seq_number;
  55   size_t len, total_len;
  56
  57   gssapi_krb5_encap_length (22, &len, &total_len);
  58
  59   message_token->length = total_len;
  60   message_token->value  = malloc (total_len);
  61   if (message_token->value == NULL) {
  62     *minor_status = ENOMEM;
  63     return GSS_S_FAILURE;
  64   }
  65
  66   p = gssapi_krb5_make_header(message_token->value,
  67                               len,
  68                               "\x01\x01"); /* TOK_ID */
  69
  70   memcpy (p, "\x00\x00", 2);    /* SGN_ALG = DES MAC MD5 */
  71   p += 2;
  72
  73   memcpy (p, "\xff\xff\xff\xff", 4); /* Filler */
  74   p += 4;
  75
  76   /* Fill in later (SND-SEQ) */
  77   memset (p, 0, 16);
  78   p += 16;
  79
  80   /* checksum */
  81   MD5_Init (&md5);
  82   MD5_Update (&md5, p - 24, 8);
  83   MD5_Update (&md5, message_buffer->value, message_buffer->length);
  84   MD5_Final (hash, &md5);
  85
  86   memset (&zero, 0, sizeof(zero));
  87   memcpy (&deskey, key->keyvalue.data, sizeof(deskey));
  88   des_set_key (&deskey, schedule);
  89   des_cbc_cksum ((void *)hash, (void *)hash, sizeof(hash),
  90                  schedule, &zero);
  91   memcpy (p - 8, hash, 8);      /* SGN_CKSUM */
  92
  93   /* sequence number */
  94   krb5_auth_con_getlocalseqnumber (gssapi_krb5_context,
  95                                context_handle->auth_context,
  96                                &seq_number);
  97
  98   p -= 16;                      /* SND_SEQ */
  99   p[0] = (seq_number >> 0)  & 0xFF;
 100   p[1] = (seq_number >> 8)  & 0xFF;
 101   p[2] = (seq_number >> 16) & 0xFF;
 102   p[3] = (seq_number >> 24) & 0xFF;
 103   memset (p + 4,
 104           (context_handle->more_flags & LOCAL) ? 0 : 0xFF,
 105           4);
 106
 107   des_set_key (&deskey, schedule);
 108   des_cbc_encrypt ((void *)p, (void *)p, 8,
 109                    schedule, (des_cblock *)(p + 8), DES_ENCRYPT);
 110
 111   krb5_auth_con_setlocalseqnumber (gssapi_krb5_context,
 112                                context_handle->auth_context,
 113                                ++seq_number);
 114
 115   memset (deskey, 0, sizeof(deskey));
 116   memset (schedule, 0, sizeof(schedule));
 117
 118   *minor_status = 0;
 119   return GSS_S_COMPLETE;
 120 }
 121
 122 static OM_uint32
 123 mic_des3
 124            (OM_uint32 * minor_status,
 125             const gss_ctx_id_t context_handle,
 126             gss_qop_t qop_req,
 127             const gss_buffer_t message_buffer,
 128             gss_buffer_t message_token,
 129             krb5_keyblock *key
 130            )
 131 {
 132   u_char *p;
 133   Checksum cksum;
 134   u_char seq[8];
 135
 136   int32_t seq_number;
 137   size_t len, total_len;
 138
 139   krb5_crypto crypto;
 140   krb5_error_code kret;
 141   krb5_data encdata;
 142   char *tmp;
 143   char ivec[8];
 144
 145   gssapi_krb5_encap_length (36, &len, &total_len);
 146
 147   message_token->length = total_len;
 148   message_token->value  = malloc (total_len);
 149   if (message_token->value == NULL) {
 150       *minor_status = ENOMEM;
 151       return GSS_S_FAILURE;
 152   }
 153
 154   p = gssapi_krb5_make_header(message_token->value,
 155                               len,
 156                               "\x01\x01"); /* TOK-ID */
 157
 158   memcpy (p, "\x04\x00", 2);    /* SGN_ALG = HMAC SHA1 DES3-KD */
 159   p += 2;
 160
 161   memcpy (p, "\xff\xff\xff\xff", 4); /* filler */
 162   p += 4;
 163
 164   /* this should be done in parts */
 165
 166   tmp = malloc (message_buffer->length + 8);
 167   if (tmp == NULL) {
 168       free (message_token->value);
 169       *minor_status = ENOMEM;
 170       return GSS_S_FAILURE;
 171   }
 172   memcpy (tmp, p - 8, 8);
 173   memcpy (tmp + 8, message_buffer->value, message_buffer->length);
 174
 175   kret = krb5_crypto_init(gssapi_krb5_context, key, 0, &crypto);
 176   if (kret) {
 177       free (message_token->value);
 178       free (tmp);
 179       gssapi_krb5_set_error_string ();
 180       *minor_status = kret;
 181       return GSS_S_FAILURE;
 182   }
 183
 184   kret = krb5_create_checksum (gssapi_krb5_context,
 185                                crypto,
 186                                KRB5_KU_USAGE_SIGN,
 187                                0,
 188                                tmp,
 189                                message_buffer->length + 8,
 190                                &cksum);
 191   free (tmp);
 192   krb5_crypto_destroy (gssapi_krb5_context, crypto);
 193   if (kret) {
 194       free (message_token->value);
 195       gssapi_krb5_set_error_string ();
 196       *minor_status = kret;
 197       return GSS_S_FAILURE;
 198   }
 199
 200   memcpy (p + 8, cksum.checksum.data, cksum.checksum.length);
 201
 202   /* sequence number */
 203   krb5_auth_con_getlocalseqnumber (gssapi_krb5_context,
 204                                context_handle->auth_context,
 205                                &seq_number);
 206
 207   seq[0] = (seq_number >> 0)  & 0xFF;
 208   seq[1] = (seq_number >> 8)  & 0xFF;
 209   seq[2] = (seq_number >> 16) & 0xFF;
 210   seq[3] = (seq_number >> 24) & 0xFF;
 211   memset (seq + 4,
 212           (context_handle->more_flags & LOCAL) ? 0 : 0xFF,
 213           4);
 214
 215   kret = krb5_crypto_init(gssapi_krb5_context, key,
 216                           ETYPE_DES3_CBC_NONE, &crypto);
 217   if (kret) {
 218       free (message_token->value);
 219       gssapi_krb5_set_error_string ();
 220       *minor_status = kret;
 221       return GSS_S_FAILURE;
 222   }
 223
 224   if (context_handle->more_flags & COMPAT_OLD_DES3)
 225       memset(ivec, 0, 8);
 226   else
 227       memcpy(ivec, p + 8, 8);
 228
 229   kret = krb5_encrypt_ivec (gssapi_krb5_context,
 230                             crypto,
 231                             KRB5_KU_USAGE_SEQ,
 232                             seq, 8, &encdata, ivec);
 233   krb5_crypto_destroy (gssapi_krb5_context, crypto);
 234   if (kret) {
 235       free (message_token->value);
 236       gssapi_krb5_set_error_string ();
 237       *minor_status = kret;
 238       return GSS_S_FAILURE;
 239   }
 240
 241   assert (encdata.length == 8);
 242
 243   memcpy (p, encdata.data, encdata.length);
 244   krb5_data_free (&encdata);
 245
 246   krb5_auth_con_setlocalseqnumber (gssapi_krb5_context,
 247                                context_handle->auth_context,
 248                                ++seq_number);
 249
 250   free_Checksum (&cksum);
 251   *minor_status = 0;
 252   return GSS_S_COMPLETE;
 253 }
 254
 255 OM_uint32 gss_get_mic
 256            (OM_uint32 * minor_status,
 257             const gss_ctx_id_t context_handle,
 258             gss_qop_t qop_req,
 259             const gss_buffer_t message_buffer,
 260             gss_buffer_t message_token
 261            )
 262 {
 263   krb5_keyblock *key;
 264   OM_uint32 ret;
 265   krb5_keytype keytype;
 266
 267   ret = gss_krb5_get_localkey(context_handle, &key);
 268   if (ret) {
 269       gssapi_krb5_set_error_string ();
 270       *minor_status = ret;
 271       return GSS_S_FAILURE;
 272   }
 273   krb5_enctype_to_keytype (gssapi_krb5_context, key->keytype, &keytype);
 274
 275   switch (keytype) {
 276   case KEYTYPE_DES :
 277       ret = mic_des (minor_status, context_handle, qop_req,
 278                      message_buffer, message_token, key);
 279       break;
 280   case KEYTYPE_DES3 :
 281       ret = mic_des3 (minor_status, context_handle, qop_req,
 282                       message_buffer, message_token, key);
 283       break;
 284   case KEYTYPE_ARCFOUR:
 285       ret = _gssapi_get_mic_arcfour (minor_status, context_handle, qop_req,
 286                                      message_buffer, message_token, key);
 287       break;
 288   default :
 289       *minor_status = KRB5_PROG_ETYPE_NOSUPP;
 290       ret = GSS_S_FAILURE;
 291       break;
 292   }
 293   krb5_free_keyblock (gssapi_krb5_context, key);
 294   return ret;
 295 }