source4/heimdal/lib/krb5/rd_priv.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("$Id: rd_priv.c 17056 2006-04-12 16:18:10Z lha $");
  37
  38 krb5_error_code KRB5_LIB_FUNCTION
  39 krb5_rd_priv(krb5_context context,
  40              krb5_auth_context auth_context,
  41              const krb5_data *inbuf,
  42              krb5_data *outbuf,
  43              krb5_replay_data *outdata)
  44 {
  45     krb5_error_code ret;
  46     KRB_PRIV priv;
  47     EncKrbPrivPart part;
  48     size_t len;
  49     krb5_data plain;
  50     krb5_keyblock *key;
  51     krb5_crypto crypto;
  52
  53     if (outbuf)
  54         krb5_data_zero(outbuf);
  55
  56     if ((auth_context->flags &
  57          (KRB5_AUTH_CONTEXT_RET_TIME | KRB5_AUTH_CONTEXT_RET_SEQUENCE)) &&
  58         outdata == NULL)
  59         return KRB5_RC_REQUIRED; /* XXX better error, MIT returns this */
  60
  61     memset(&priv, 0, sizeof(priv));
  62     ret = decode_KRB_PRIV (inbuf->data, inbuf->length, &priv, &len);
  63     if (ret)
  64         goto failure;
  65     if (priv.pvno != 5) {
  66         krb5_clear_error_string (context);
  67         ret = KRB5KRB_AP_ERR_BADVERSION;
  68         goto failure;
  69     }
  70     if (priv.msg_type != krb_priv) {
  71         krb5_clear_error_string (context);
  72         ret = KRB5KRB_AP_ERR_MSG_TYPE;
  73         goto failure;
  74     }
  75
  76     if (auth_context->remote_subkey)
  77         key = auth_context->remote_subkey;
  78     else if (auth_context->local_subkey)
  79         key = auth_context->local_subkey;
  80     else
  81         key = auth_context->keyblock;
  82
  83     ret = krb5_crypto_init(context, key, 0, &crypto);
  84     if (ret)
  85         goto failure;
  86     ret = krb5_decrypt_EncryptedData(context,
  87                                      crypto,
  88                                      KRB5_KU_KRB_PRIV,
  89                                      &priv.enc_part,
  90                                      &plain);
  91     krb5_crypto_destroy(context, crypto);
  92     if (ret)
  93         goto failure;
  94
  95     ret = decode_EncKrbPrivPart (plain.data, plain.length, &part, &len);
  96     krb5_data_free (&plain);
  97     if (ret)
  98         goto failure;
  99
 100     /* check sender address */
 101
 102     if (part.s_address
 103         && auth_context->remote_address
 104         && !krb5_address_compare (context,
 105                                   auth_context->remote_address,
 106                                   part.s_address)) {
 107         krb5_clear_error_string (context);
 108         ret = KRB5KRB_AP_ERR_BADADDR;
 109         goto failure_part;
 110     }
 111
 112     /* check receiver address */
 113
 114     if (part.r_address
 115         && auth_context->local_address
 116         && !krb5_address_compare (context,
 117                                   auth_context->local_address,
 118                                   part.r_address)) {
 119         krb5_clear_error_string (context);
 120         ret = KRB5KRB_AP_ERR_BADADDR;
 121         goto failure_part;
 122     }
 123
 124     /* check timestamp */
 125     if (auth_context->flags & KRB5_AUTH_CONTEXT_DO_TIME) {
 126         krb5_timestamp sec;
 127
 128         krb5_timeofday (context, &sec);
 129         if (part.timestamp == NULL ||
 130             part.usec      == NULL ||
 131             abs(*part.timestamp - sec) > context->max_skew) {
 132             krb5_clear_error_string (context);
 133             ret = KRB5KRB_AP_ERR_SKEW;
 134             goto failure_part;
 135         }
 136     }
 137
 138     /* XXX - check replay cache */
 139
 140     /* check sequence number. since MIT krb5 cannot generate a sequence
 141        number of zero but instead generates no sequence number, we accept that
 142     */
 143
 144     if (auth_context->flags & KRB5_AUTH_CONTEXT_DO_SEQUENCE) {
 145         if ((part.seq_number == NULL
 146              && auth_context->remote_seqnumber != 0)
 147             || (part.seq_number != NULL
 148                 && *part.seq_number != auth_context->remote_seqnumber)) {
 149             krb5_clear_error_string (context);
 150             ret = KRB5KRB_AP_ERR_BADORDER;
 151             goto failure_part;
 152         }
 153         auth_context->remote_seqnumber++;
 154     }
 155
 156     ret = krb5_data_copy (outbuf, part.user_data.data, part.user_data.length);
 157     if (ret)
 158         goto failure_part;
 159
 160     if ((auth_context->flags &
 161          (KRB5_AUTH_CONTEXT_RET_TIME | KRB5_AUTH_CONTEXT_RET_SEQUENCE))) {
 162         /* if these fields are not present in the priv-part, silently
 163            return zero */
 164         memset(outdata, 0, sizeof(*outdata));
 165         if(part.timestamp)
 166             outdata->timestamp = *part.timestamp;
 167         if(part.usec)
 168             outdata->usec = *part.usec;
 169         if(part.seq_number)
 170             outdata->seq = *part.seq_number;
 171     }
 172
 173   failure_part:
 174     free_EncKrbPrivPart (&part);
 175
 176   failure:
 177     free_KRB_PRIV (&priv);
 178     return ret;
 179 }