crypto/dist/heimdal/lib/krb5/rd_safe.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 <krb5_locl.h>
  35
  36 __RCSID("$Heimdal: rd_safe.c 19827 2007-01-11 02:54:59Z lha $"
  37         "$NetBSD$");
  38
  39 static krb5_error_code
  40 verify_checksum(krb5_context context,
  41                 krb5_auth_context auth_context,
  42                 KRB_SAFE *safe)
  43 {
  44     krb5_error_code ret;
  45     u_char *buf;
  46     size_t buf_size;
  47     size_t len;
  48     Checksum c;
  49     krb5_crypto crypto;
  50     krb5_keyblock *key;
  51
  52     c = safe->cksum;
  53     safe->cksum.cksumtype       = 0;
  54     safe->cksum.checksum.data   = NULL;
  55     safe->cksum.checksum.length = 0;
  56
  57     ASN1_MALLOC_ENCODE(KRB_SAFE, buf, buf_size, safe, &len, ret);
  58     if(ret)
  59         return ret;
  60     if(buf_size != len)
  61         krb5_abortx(context, "internal error in ASN.1 encoder");
  62
  63     if (auth_context->remote_subkey)
  64         key = auth_context->remote_subkey;
  65     else if (auth_context->local_subkey)
  66         key = auth_context->local_subkey;
  67     else
  68         key = auth_context->keyblock;
  69
  70     ret = krb5_crypto_init(context, key, 0, &crypto);
  71     if (ret)
  72         goto out;
  73     ret = krb5_verify_checksum (context,
  74                                 crypto,
  75                                 KRB5_KU_KRB_SAFE_CKSUM,
  76                                 buf + buf_size - len,
  77                                 len,
  78                                 &c);
  79     krb5_crypto_destroy(context, crypto);
  80 out:
  81     safe->cksum = c;
  82     free (buf);
  83     return ret;
  84 }
  85
  86 krb5_error_code KRB5_LIB_FUNCTION
  87 krb5_rd_safe(krb5_context context,
  88              krb5_auth_context auth_context,
  89              const krb5_data *inbuf,
  90              krb5_data *outbuf,
  91              krb5_replay_data *outdata)
  92 {
  93     krb5_error_code ret;
  94     KRB_SAFE safe;
  95     size_t len;
  96
  97     if (outbuf)
  98         krb5_data_zero(outbuf);
  99
 100     if ((auth_context->flags &
 101          (KRB5_AUTH_CONTEXT_RET_TIME | KRB5_AUTH_CONTEXT_RET_SEQUENCE)) &&
 102         outdata == NULL) {
 103         krb5_set_error_string(context, "rd_safe: need outdata to return data");
 104         return KRB5_RC_REQUIRED; /* XXX better error, MIT returns this */
 105     }
 106
 107     ret = decode_KRB_SAFE (inbuf->data, inbuf->length, &safe, &len);
 108     if (ret)
 109         return ret;
 110     if (safe.pvno != 5) {
 111         ret = KRB5KRB_AP_ERR_BADVERSION;
 112         krb5_clear_error_string (context);
 113         goto failure;
 114     }
 115     if (safe.msg_type != krb_safe) {
 116         ret = KRB5KRB_AP_ERR_MSG_TYPE;
 117         krb5_clear_error_string (context);
 118         goto failure;
 119     }
 120     if (!krb5_checksum_is_keyed(context, safe.cksum.cksumtype)
 121         || !krb5_checksum_is_collision_proof(context, safe.cksum.cksumtype)) {
 122         ret = KRB5KRB_AP_ERR_INAPP_CKSUM;
 123         krb5_clear_error_string (context);
 124         goto failure;
 125     }
 126
 127     /* check sender address */
 128
 129     if (safe.safe_body.s_address
 130         && auth_context->remote_address
 131         && !krb5_address_compare (context,
 132                                   auth_context->remote_address,
 133                                   safe.safe_body.s_address)) {
 134         ret = KRB5KRB_AP_ERR_BADADDR;
 135         krb5_clear_error_string (context);
 136         goto failure;
 137     }
 138
 139     /* check receiver address */
 140
 141     if (safe.safe_body.r_address
 142         && auth_context->local_address
 143         && !krb5_address_compare (context,
 144                                   auth_context->local_address,
 145                                   safe.safe_body.r_address)) {
 146         ret = KRB5KRB_AP_ERR_BADADDR;
 147         krb5_clear_error_string (context);
 148         goto failure;
 149     }
 150
 151     /* check timestamp */
 152     if (auth_context->flags & KRB5_AUTH_CONTEXT_DO_TIME) {
 153         krb5_timestamp sec;
 154
 155         krb5_timeofday (context, &sec);
 156
 157         if (safe.safe_body.timestamp == NULL ||
 158             safe.safe_body.usec      == NULL ||
 159             abs(*safe.safe_body.timestamp - sec) > context->max_skew) {
 160             ret = KRB5KRB_AP_ERR_SKEW;
 161             krb5_clear_error_string (context);
 162             goto failure;
 163         }
 164     }
 165     /* XXX - check replay cache */
 166
 167     /* check sequence number. since MIT krb5 cannot generate a sequence
 168        number of zero but instead generates no sequence number, we accept that
 169     */
 170
 171     if (auth_context->flags & KRB5_AUTH_CONTEXT_DO_SEQUENCE) {
 172         if ((safe.safe_body.seq_number == NULL
 173              && auth_context->remote_seqnumber != 0)
 174             || (safe.safe_body.seq_number != NULL
 175                 && *safe.safe_body.seq_number !=
 176                 auth_context->remote_seqnumber)) {
 177             ret = KRB5KRB_AP_ERR_BADORDER;
 178             krb5_clear_error_string (context);
 179             goto failure;
 180         }
 181         auth_context->remote_seqnumber++;
 182     }
 183
 184     ret = verify_checksum (context, auth_context, &safe);
 185     if (ret)
 186         goto failure;
 187
 188     outbuf->length = safe.safe_body.user_data.length;
 189     outbuf->data   = malloc(outbuf->length);
 190     if (outbuf->data == NULL && outbuf->length != 0) {
 191         ret = ENOMEM;
 192         krb5_set_error_string (context, "malloc: out of memory");
 193         krb5_data_zero(outbuf);
 194         goto failure;
 195     }
 196     memcpy (outbuf->data, safe.safe_body.user_data.data, outbuf->length);
 197
 198     if ((auth_context->flags &
 199          (KRB5_AUTH_CONTEXT_RET_TIME | KRB5_AUTH_CONTEXT_RET_SEQUENCE))) {
 200         /* if these fields are not present in the safe-part, silently
 201            return zero */
 202         memset(outdata, 0, sizeof(*outdata));
 203         if(safe.safe_body.timestamp)
 204             outdata->timestamp = *safe.safe_body.timestamp;
 205         if(safe.safe_body.usec)
 206             outdata->usec = *safe.safe_body.usec;
 207         if(safe.safe_body.seq_number)
 208             outdata->seq = *safe.safe_body.seq_number;
 209     }
 210
 211   failure:
 212     free_KRB_SAFE (&safe);
 213     return ret;
 214 }