lib/gssapi/wrap.c

   1 /*
   2  * Copyright (c) 1997 - 2000 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 OM_uint32 gss_wrap_size_limit (
  39             OM_uint32 * minor_status,
  40             const gss_ctx_id_t context_handle,
  41             int conf_req_flag,
  42             gss_qop_t qop_req,
  43             OM_uint32 req_output_size,
  44             OM_uint32 * max_input_size
  45            )
  46 {
  47   size_t len, total_len, padlength;
  48   padlength = 8 - (req_output_size % 8);
  49   len = req_output_size + 8 + padlength + 22;
  50   gssapi_krb5_encap_length(len, &len, &total_len);
  51   *max_input_size = (OM_uint32)total_len;
  52   return GSS_S_COMPLETE;
  53 }
  54
  55 OM_uint32 gss_wrap
  56            (OM_uint32 * minor_status,
  57             const gss_ctx_id_t context_handle,
  58             int conf_req_flag,
  59             gss_qop_t qop_req,
  60             const gss_buffer_t input_message_buffer,
  61             int * conf_state,
  62             gss_buffer_t output_message_buffer
  63            )
  64 {
  65   u_char *p;
  66   MD5_CTX md5;
  67   u_char hash[16];
  68   des_key_schedule schedule;
  69   des_cblock key;
  70   des_cblock zero;
  71   int i;
  72   int32_t seq_number;
  73   size_t len, total_len, padlength;
  74
  75   padlength = 8 - (input_message_buffer->length % 8);
  76   len = input_message_buffer->length + 8 + padlength + 22;
  77   gssapi_krb5_encap_length (len, &len, &total_len);
  78
  79   output_message_buffer->length = total_len;
  80   output_message_buffer->value  = malloc (total_len);
  81   if (output_message_buffer->value == NULL)
  82     return GSS_S_FAILURE;
  83
  84   p = gssapi_krb5_make_header(output_message_buffer->value,
  85                               len,
  86                               "\x02\x01");
  87
  88
  89   /* SGN_ALG */
  90   memcpy (p, "\x00\x00", 2);
  91   p += 2;
  92   /* SEAL_ALG */
  93   if(conf_req_flag)
  94       memcpy (p, "\x00\x00", 2);
  95   else
  96       memcpy (p, "\xff\xff", 2);
  97   p += 2;
  98   /* Filler */
  99   memcpy (p, "\xff\xff", 2);
 100   p += 2;
 101
 102   /* fill in later */
 103   memset (p, 0, 16);
 104   p += 16;
 105
 106   /* confounder + data + pad */
 107   des_new_random_key((des_cblock*)p);
 108   memcpy (p + 8, input_message_buffer->value,
 109           input_message_buffer->length);
 110   memset (p + 8 + input_message_buffer->length, padlength, padlength);
 111
 112   /* checksum */
 113   MD5Init (&md5);
 114   MD5Update (&md5, p - 24, 8);
 115   MD5Update (&md5, p, input_message_buffer->length + padlength + 8);
 116   MD5Final (hash, &md5);
 117
 118   memset (&zero, 0, sizeof(zero));
 119   gss_krb5_getsomekey(context_handle, &key);
 120   des_set_key (&key, schedule);
 121   des_cbc_cksum ((const void *)hash, (void *)hash, sizeof(hash),
 122                  schedule, &zero);
 123   memcpy (p - 8, hash, 8);
 124
 125   /* sequence number */
 126   krb5_auth_getlocalseqnumber (gssapi_krb5_context,
 127                                context_handle->auth_context,
 128                                &seq_number);
 129
 130   p -= 16;
 131   p[0] = (seq_number >> 0)  & 0xFF;
 132   p[1] = (seq_number >> 8)  & 0xFF;
 133   p[2] = (seq_number >> 16) & 0xFF;
 134   p[3] = (seq_number >> 24) & 0xFF;
 135   memset (p + 4,
 136           (context_handle->more_flags & LOCAL) ? 0 : 0xFF,
 137           4);
 138
 139   des_set_key (&key, schedule);
 140   des_cbc_encrypt ((const void *)p, (void *)p, 8,
 141                    schedule, (des_cblock *)(p + 8), DES_ENCRYPT);
 142
 143   krb5_auth_setlocalseqnumber (gssapi_krb5_context,
 144                                context_handle->auth_context,
 145                                ++seq_number);
 146
 147   /* encrypt the data */
 148   p += 16;
 149
 150   if(conf_req_flag) {
 151       gss_krb5_getsomekey(context_handle, &key);
 152       for (i = 0; i < sizeof(key); ++i)
 153           key[i] ^= 0xf0;
 154       des_set_key (&key, schedule);
 155       memset (&zero, 0, sizeof(zero));
 156       des_cbc_encrypt ((const void *)p,
 157                        (void *)p,
 158                        8 + input_message_buffer->length + padlength,
 159                        schedule,
 160                        &zero,
 161                        DES_ENCRYPT);
 162
 163       memset (key, 0, sizeof(key));
 164       memset (schedule, 0, sizeof(schedule));
 165   }
 166   if(conf_state != NULL)
 167       *conf_state = conf_req_flag;
 168   return GSS_S_COMPLETE;
 169 }