source4/heimdal/lib/gssapi/wrap.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: wrap.c,v 1.31 2005/01/05 02:52:12 lukeh Exp $");
  37
  38 OM_uint32
  39 gsskrb5_get_initiator_subkey(OM_uint32 *minor_status,
  40                              gss_ctx_id_t context_handle,
  41                              gss_buffer_t key)
  42 {
  43     krb5_error_code ret;
  44     krb5_keyblock *skey = NULL;
  45
  46     HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
  47     if (context_handle->more_flags & LOCAL) {
  48         ret = krb5_auth_con_getlocalsubkey(gssapi_krb5_context,
  49                                            context_handle->auth_context,
  50                                            &skey);
  51         if (ret) {
  52                 *minor_status = ret;
  53                 return GSS_KRB5_S_KG_NO_SUBKEY; /* XXX */
  54         }
  55
  56     } else {
  57         ret = krb5_auth_con_getremotesubkey(gssapi_krb5_context,
  58                                             context_handle->auth_context,
  59                                             &skey);
  60         if (ret) {
  61                 *minor_status = ret;
  62                 return GSS_KRB5_S_KG_NO_SUBKEY; /* XXX */
  63         }
  64
  65     }
  66     HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
  67     key->length = skey->keyvalue.length;
  68     key->value  = malloc (key->length);
  69     if (!key->value) {
  70             krb5_free_keyblock(gssapi_krb5_context, skey);
  71             *minor_status = ENOMEM;
  72             return GSS_S_FAILURE;
  73     }
  74     memcpy(key->value, skey->keyvalue.data, key->length);
  75     krb5_free_keyblock(gssapi_krb5_context, skey);
  76     return 0;
  77 }
  78
  79 OM_uint32
  80 gss_krb5_get_subkey(const gss_ctx_id_t context_handle,
  81                     krb5_keyblock **key)
  82 {
  83     krb5_keyblock *skey = NULL;
  84
  85     HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
  86     if (context_handle->more_flags & LOCAL) {
  87         krb5_auth_con_getremotesubkey(gssapi_krb5_context,
  88                                       context_handle->auth_context,
  89                                       &skey);
  90     } else {
  91         krb5_auth_con_getlocalsubkey(gssapi_krb5_context,
  92                                      context_handle->auth_context,
  93                                      &skey);
  94     }
  95     /*
  96      * Only use the initiator subkey or ticket session key if
  97      * an acceptor subkey was not required.
  98      */
  99     if (skey == NULL &&
 100         (context_handle->more_flags & ACCEPTOR_SUBKEY) == 0) {
 101         if (context_handle->more_flags & LOCAL) {
 102             krb5_auth_con_getlocalsubkey(gssapi_krb5_context,
 103                                          context_handle->auth_context,
 104                                          &skey);
 105         } else {
 106             krb5_auth_con_getremotesubkey(gssapi_krb5_context,
 107                                           context_handle->auth_context,
 108                                           &skey);
 109         }
 110         if(skey == NULL)
 111             krb5_auth_con_getkey(gssapi_krb5_context,
 112                                  context_handle->auth_context,
 113                                  &skey);
 114     }
 115     HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
 116     if(skey == NULL)
 117         return GSS_KRB5_S_KG_NO_SUBKEY; /* XXX */
 118     *key = skey;
 119     return 0;
 120 }
 121
 122 static OM_uint32
 123 sub_wrap_size (
 124             OM_uint32 req_output_size,
 125             OM_uint32 * max_input_size,
 126             int blocksize,
 127             int extrasize
 128            )
 129 {
 130     size_t len, total_len;
 131
 132     len = 8 + req_output_size + blocksize + extrasize;
 133
 134     gssapi_krb5_encap_length(len, &len, &total_len, GSS_KRB5_MECHANISM);
 135
 136     total_len -= req_output_size; /* token length */
 137     if (total_len < req_output_size) {
 138         *max_input_size = (req_output_size - total_len);
 139         (*max_input_size) &= (~(OM_uint32)(blocksize - 1));
 140     } else {
 141         *max_input_size = 0;
 142     }
 143     return GSS_S_COMPLETE;
 144 }
 145
 146 OM_uint32
 147 gss_wrap_size_limit (
 148             OM_uint32 * minor_status,
 149             const gss_ctx_id_t context_handle,
 150             int conf_req_flag,
 151             gss_qop_t qop_req,
 152             OM_uint32 req_output_size,
 153             OM_uint32 * max_input_size
 154            )
 155 {
 156   krb5_keyblock *key;
 157   OM_uint32 ret;
 158   krb5_keytype keytype;
 159
 160   ret = gss_krb5_get_subkey(context_handle, &key);
 161   if (ret) {
 162       gssapi_krb5_set_error_string ();
 163       *minor_status = ret;
 164       return GSS_S_FAILURE;
 165   }
 166   krb5_enctype_to_keytype (gssapi_krb5_context, key->keytype, &keytype);
 167
 168   switch (keytype) {
 169   case KEYTYPE_DES :
 170   case KEYTYPE_ARCFOUR:
 171   case KEYTYPE_ARCFOUR_56:
 172       ret = sub_wrap_size(req_output_size, max_input_size, 8, 22);
 173       break;
 174   case KEYTYPE_DES3 :
 175       ret = sub_wrap_size(req_output_size, max_input_size, 8, 34);
 176       break;
 177   default :
 178       ret = _gssapi_wrap_size_cfx(minor_status, context_handle,
 179                                   conf_req_flag, qop_req,
 180                                   req_output_size, max_input_size, key);
 181       break;
 182   }
 183   krb5_free_keyblock (gssapi_krb5_context, key);
 184   *minor_status = 0;
 185   return ret;
 186 }
 187
 188 static OM_uint32
 189 wrap_des
 190            (OM_uint32 * minor_status,
 191             const gss_ctx_id_t context_handle,
 192             int conf_req_flag,
 193             gss_qop_t qop_req,
 194             const gss_buffer_t input_message_buffer,
 195             int * conf_state,
 196             gss_buffer_t output_message_buffer,
 197             krb5_keyblock *key
 198            )
 199 {
 200   u_char *p;
 201   MD5_CTX md5;
 202   u_char hash[16];
 203   DES_key_schedule schedule;
 204   DES_cblock deskey;
 205   DES_cblock zero;
 206   int i;
 207   int32_t seq_number;
 208   size_t len, total_len, padlength, datalen;
 209
 210   padlength = 8 - (input_message_buffer->length % 8);
 211   datalen = input_message_buffer->length + padlength + 8;
 212   len = datalen + 22;
 213   gssapi_krb5_encap_length (len, &len, &total_len, GSS_KRB5_MECHANISM);
 214
 215   output_message_buffer->length = total_len;
 216   output_message_buffer->value  = malloc (total_len);
 217   if (output_message_buffer->value == NULL) {
 218     *minor_status = ENOMEM;
 219     return GSS_S_FAILURE;
 220   }
 221
 222   p = gssapi_krb5_make_header(output_message_buffer->value,
 223                               len,
 224                               "\x02\x01", /* TOK_ID */
 225                               GSS_KRB5_MECHANISM);
 226
 227   /* SGN_ALG */
 228   memcpy (p, "\x00\x00", 2);
 229   p += 2;
 230   /* SEAL_ALG */
 231   if(conf_req_flag)
 232       memcpy (p, "\x00\x00", 2);
 233   else
 234       memcpy (p, "\xff\xff", 2);
 235   p += 2;
 236   /* Filler */
 237   memcpy (p, "\xff\xff", 2);
 238   p += 2;
 239
 240   /* fill in later */
 241   memset (p, 0, 16);
 242   p += 16;
 243
 244   /* confounder + data + pad */
 245   krb5_generate_random_block(p, 8);
 246   memcpy (p + 8, input_message_buffer->value,
 247           input_message_buffer->length);
 248   memset (p + 8 + input_message_buffer->length, padlength, padlength);
 249
 250   /* checksum */
 251   MD5_Init (&md5);
 252   MD5_Update (&md5, p - 24, 8);
 253   MD5_Update (&md5, p, datalen);
 254   MD5_Final (hash, &md5);
 255
 256   memset (&zero, 0, sizeof(zero));
 257   memcpy (&deskey, key->keyvalue.data, sizeof(deskey));
 258   DES_set_key (&deskey, &schedule);
 259   DES_cbc_cksum ((void *)hash, (void *)hash, sizeof(hash),
 260                  &schedule, &zero);
 261   memcpy (p - 8, hash, 8);
 262
 263   /* sequence number */
 264   HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
 265   krb5_auth_con_getlocalseqnumber (gssapi_krb5_context,
 266                                context_handle->auth_context,
 267                                &seq_number);
 268
 269   p -= 16;
 270   p[0] = (seq_number >> 0)  & 0xFF;
 271   p[1] = (seq_number >> 8)  & 0xFF;
 272   p[2] = (seq_number >> 16) & 0xFF;
 273   p[3] = (seq_number >> 24) & 0xFF;
 274   memset (p + 4,
 275           (context_handle->more_flags & LOCAL) ? 0 : 0xFF,
 276           4);
 277
 278   DES_set_key (&deskey, &schedule);
 279   DES_cbc_encrypt ((void *)p, (void *)p, 8,
 280                    &schedule, (DES_cblock *)(p + 8), DES_ENCRYPT);
 281
 282   krb5_auth_con_setlocalseqnumber (gssapi_krb5_context,
 283                                context_handle->auth_context,
 284                                ++seq_number);
 285   HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
 286
 287   /* encrypt the data */
 288   p += 16;
 289
 290   if(conf_req_flag) {
 291       memcpy (&deskey, key->keyvalue.data, sizeof(deskey));
 292
 293       for (i = 0; i < sizeof(deskey); ++i)
 294           deskey[i] ^= 0xf0;
 295       DES_set_key (&deskey, &schedule);
 296       memset (&zero, 0, sizeof(zero));
 297       DES_cbc_encrypt ((void *)p,
 298                        (void *)p,
 299                        datalen,
 300                        &schedule,
 301                        &zero,
 302                        DES_ENCRYPT);
 303   }
 304   memset (deskey, 0, sizeof(deskey));
 305   memset (&schedule, 0, sizeof(schedule));
 306
 307   if(conf_state != NULL)
 308       *conf_state = conf_req_flag;
 309   *minor_status = 0;
 310   return GSS_S_COMPLETE;
 311 }
 312
 313 static OM_uint32
 314 wrap_des3
 315            (OM_uint32 * minor_status,
 316             const gss_ctx_id_t context_handle,
 317             int conf_req_flag,
 318             gss_qop_t qop_req,
 319             const gss_buffer_t input_message_buffer,
 320             int * conf_state,
 321             gss_buffer_t output_message_buffer,
 322             krb5_keyblock *key
 323            )
 324 {
 325   u_char *p;
 326   u_char seq[8];
 327   int32_t seq_number;
 328   size_t len, total_len, padlength, datalen;
 329   u_int32_t ret;
 330   krb5_crypto crypto;
 331   Checksum cksum;
 332   krb5_data encdata;
 333
 334   padlength = 8 - (input_message_buffer->length % 8);
 335   datalen = input_message_buffer->length + padlength + 8;
 336   len = datalen + 34;
 337   gssapi_krb5_encap_length (len, &len, &total_len, GSS_KRB5_MECHANISM);
 338
 339   output_message_buffer->length = total_len;
 340   output_message_buffer->value  = malloc (total_len);
 341   if (output_message_buffer->value == NULL) {
 342     *minor_status = ENOMEM;
 343     return GSS_S_FAILURE;
 344   }
 345
 346   p = gssapi_krb5_make_header(output_message_buffer->value,
 347                               len,
 348                               "\x02\x01", /* TOK_ID */
 349                               GSS_KRB5_MECHANISM);
 350
 351   /* SGN_ALG */
 352   memcpy (p, "\x04\x00", 2);    /* HMAC SHA1 DES3-KD */
 353   p += 2;
 354   /* SEAL_ALG */
 355   if(conf_req_flag)
 356       memcpy (p, "\x02\x00", 2); /* DES3-KD */
 357   else
 358       memcpy (p, "\xff\xff", 2);
 359   p += 2;
 360   /* Filler */
 361   memcpy (p, "\xff\xff", 2);
 362   p += 2;
 363
 364   /* calculate checksum (the above + confounder + data + pad) */
 365
 366   memcpy (p + 20, p - 8, 8);
 367   krb5_generate_random_block(p + 28, 8);
 368   memcpy (p + 28 + 8, input_message_buffer->value,
 369           input_message_buffer->length);
 370   memset (p + 28 + 8 + input_message_buffer->length, padlength, padlength);
 371
 372   ret = krb5_crypto_init(gssapi_krb5_context, key, 0, &crypto);
 373   if (ret) {
 374       gssapi_krb5_set_error_string ();
 375       free (output_message_buffer->value);
 376       *minor_status = ret;
 377       return GSS_S_FAILURE;
 378   }
 379
 380   ret = krb5_create_checksum (gssapi_krb5_context,
 381                               crypto,
 382                               KRB5_KU_USAGE_SIGN,
 383                               0,
 384                               p + 20,
 385                               datalen + 8,
 386                               &cksum);
 387   krb5_crypto_destroy (gssapi_krb5_context, crypto);
 388   if (ret) {
 389       gssapi_krb5_set_error_string ();
 390       free (output_message_buffer->value);
 391       *minor_status = ret;
 392       return GSS_S_FAILURE;
 393   }
 394
 395   /* zero out SND_SEQ + SGN_CKSUM in case */
 396   memset (p, 0, 28);
 397
 398   memcpy (p + 8, cksum.checksum.data, cksum.checksum.length);
 399   free_Checksum (&cksum);
 400
 401   HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
 402   /* sequence number */
 403   krb5_auth_con_getlocalseqnumber (gssapi_krb5_context,
 404                                context_handle->auth_context,
 405                                &seq_number);
 406
 407   seq[0] = (seq_number >> 0)  & 0xFF;
 408   seq[1] = (seq_number >> 8)  & 0xFF;
 409   seq[2] = (seq_number >> 16) & 0xFF;
 410   seq[3] = (seq_number >> 24) & 0xFF;
 411   memset (seq + 4,
 412           (context_handle->more_flags & LOCAL) ? 0 : 0xFF,
 413           4);
 414
 415
 416   ret = krb5_crypto_init(gssapi_krb5_context, key, ETYPE_DES3_CBC_NONE,
 417                          &crypto);
 418   if (ret) {
 419       free (output_message_buffer->value);
 420       *minor_status = ret;
 421       return GSS_S_FAILURE;
 422   }
 423
 424   {
 425       DES_cblock ivec;
 426
 427       memcpy (&ivec, p + 8, 8);
 428       ret = krb5_encrypt_ivec (gssapi_krb5_context,
 429                                crypto,
 430                                KRB5_KU_USAGE_SEQ,
 431                                seq, 8, &encdata,
 432                                &ivec);
 433   }
 434   krb5_crypto_destroy (gssapi_krb5_context, crypto);
 435   if (ret) {
 436       gssapi_krb5_set_error_string ();
 437       free (output_message_buffer->value);
 438       *minor_status = ret;
 439       return GSS_S_FAILURE;
 440   }
 441
 442   assert (encdata.length == 8);
 443
 444   memcpy (p, encdata.data, encdata.length);
 445   krb5_data_free (&encdata);
 446
 447   krb5_auth_con_setlocalseqnumber (gssapi_krb5_context,
 448                                context_handle->auth_context,
 449                                ++seq_number);
 450   HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
 451
 452   /* encrypt the data */
 453   p += 28;
 454
 455   if(conf_req_flag) {
 456       krb5_data tmp;
 457
 458       ret = krb5_crypto_init(gssapi_krb5_context, key,
 459                              ETYPE_DES3_CBC_NONE, &crypto);
 460       if (ret) {
 461           gssapi_krb5_set_error_string ();
 462           free (output_message_buffer->value);
 463           *minor_status = ret;
 464           return GSS_S_FAILURE;
 465       }
 466       ret = krb5_encrypt(gssapi_krb5_context, crypto, KRB5_KU_USAGE_SEAL,
 467                          p, datalen, &tmp);
 468       krb5_crypto_destroy(gssapi_krb5_context, crypto);
 469       if (ret) {
 470           gssapi_krb5_set_error_string ();
 471           free (output_message_buffer->value);
 472           *minor_status = ret;
 473           return GSS_S_FAILURE;
 474       }
 475       assert (tmp.length == datalen);
 476
 477       memcpy (p, tmp.data, datalen);
 478       krb5_data_free(&tmp);
 479   }
 480   if(conf_state != NULL)
 481       *conf_state = conf_req_flag;
 482   *minor_status = 0;
 483   return GSS_S_COMPLETE;
 484 }
 485
 486 OM_uint32 gss_wrap
 487            (OM_uint32 * minor_status,
 488             const gss_ctx_id_t context_handle,
 489             int conf_req_flag,
 490             gss_qop_t qop_req,
 491             const gss_buffer_t input_message_buffer,
 492             int * conf_state,
 493             gss_buffer_t output_message_buffer
 494            )
 495 {
 496   krb5_keyblock *key;
 497   OM_uint32 ret;
 498   krb5_keytype keytype;
 499
 500   ret = gss_krb5_get_subkey(context_handle, &key);
 501   if (ret) {
 502       gssapi_krb5_set_error_string ();
 503       *minor_status = ret;
 504       return GSS_S_FAILURE;
 505   }
 506   krb5_enctype_to_keytype (gssapi_krb5_context, key->keytype, &keytype);
 507
 508   switch (keytype) {
 509   case KEYTYPE_DES :
 510       ret = wrap_des (minor_status, context_handle, conf_req_flag,
 511                       qop_req, input_message_buffer, conf_state,
 512                       output_message_buffer, key);
 513       break;
 514   case KEYTYPE_DES3 :
 515       ret = wrap_des3 (minor_status, context_handle, conf_req_flag,
 516                        qop_req, input_message_buffer, conf_state,
 517                        output_message_buffer, key);
 518       break;
 519   case KEYTYPE_ARCFOUR:
 520   case KEYTYPE_ARCFOUR_56:
 521       ret = _gssapi_wrap_arcfour (minor_status, context_handle, conf_req_flag,
 522                                   qop_req, input_message_buffer, conf_state,
 523                                   output_message_buffer, key);
 524       break;
 525   default :
 526       ret = _gssapi_wrap_cfx (minor_status, context_handle, conf_req_flag,
 527                               qop_req, input_message_buffer, conf_state,
 528                               output_message_buffer, key);
 529       break;
 530   }
 531   krb5_free_keyblock (gssapi_krb5_context, key);
 532   return ret;
 533 }