lib/gssapi/krb5/sequence.c

   1 /*
   2  * Copyright (c) 2003 - 2006 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 "gsskrb5_locl.h"
  35
  36 #define DEFAULT_JITTER_WINDOW 20
  37
  38 struct gss_msg_order {
  39     OM_uint32 flags;
  40     OM_uint32 start;
  41     OM_uint32 length;
  42     OM_uint32 jitter_window;
  43     OM_uint32 first_seq;
  44     OM_uint32 elem[1];
  45 };
  46
  47
  48 /*
  49  *
  50  */
  51
  52 static OM_uint32
  53 msg_order_alloc(OM_uint32 *minor_status,
  54                 struct gss_msg_order **o,
  55                 OM_uint32 jitter_window)
  56 {
  57     size_t len;
  58
  59     len = jitter_window * sizeof((*o)->elem[0]);
  60     len += sizeof(**o);
  61     len -= sizeof((*o)->elem[0]);
  62
  63     *o = calloc(1, len);
  64     if (*o == NULL) {
  65         *minor_status = ENOMEM;
  66         return GSS_S_FAILURE;
  67     }
  68
  69     *minor_status = 0;
  70     return GSS_S_COMPLETE;
  71 }
  72
  73 /*
  74  *
  75  */
  76
  77 OM_uint32
  78 _gssapi_msg_order_create(OM_uint32 *minor_status,
  79                          struct gss_msg_order **o,
  80                          OM_uint32 flags,
  81                          OM_uint32 seq_num,
  82                          OM_uint32 jitter_window,
  83                          int use_64)
  84 {
  85     OM_uint32 ret;
  86
  87     if (jitter_window == 0)
  88         jitter_window = DEFAULT_JITTER_WINDOW;
  89
  90     ret = msg_order_alloc(minor_status, o, jitter_window);
  91     if(ret != GSS_S_COMPLETE)
  92         return ret;
  93
  94     (*o)->flags = flags;
  95     (*o)->length = 0;
  96     (*o)->first_seq = seq_num;
  97     (*o)->jitter_window = jitter_window;
  98     (*o)->elem[0] = seq_num - 1;
  99
 100     *minor_status = 0;
 101     return GSS_S_COMPLETE;
 102 }
 103
 104 OM_uint32
 105 _gssapi_msg_order_destroy(struct gss_msg_order **m)
 106 {
 107     free(*m);
 108     *m = NULL;
 109     return GSS_S_COMPLETE;
 110 }
 111
 112 static void
 113 elem_set(struct gss_msg_order *o, unsigned int slot, OM_uint32 val)
 114 {
 115     o->elem[slot % o->jitter_window] = val;
 116 }
 117
 118 static void
 119 elem_insert(struct gss_msg_order *o,
 120             unsigned int after_slot,
 121             OM_uint32 seq_num)
 122 {
 123     assert(o->jitter_window > after_slot);
 124
 125     if (o->length > after_slot)
 126         memmove(&o->elem[after_slot + 1], &o->elem[after_slot],
 127                 (o->length - after_slot - 1) * sizeof(o->elem[0]));
 128
 129     elem_set(o, after_slot, seq_num);
 130
 131     if (o->length < o->jitter_window)
 132         o->length++;
 133 }
 134
 135 /* rule 1: expected sequence number */
 136 /* rule 2: > expected sequence number */
 137 /* rule 3: seqnum < seqnum(first) */
 138 /* rule 4+5: seqnum in [seqnum(first),seqnum(last)]  */
 139
 140 OM_uint32
 141 _gssapi_msg_order_check(struct gss_msg_order *o, OM_uint32 seq_num)
 142 {
 143     OM_uint32 r;
 144     int i;
 145
 146     if (o == NULL)
 147         return GSS_S_COMPLETE;
 148
 149     if ((o->flags & (GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG)) == 0)
 150         return GSS_S_COMPLETE;
 151
 152     /* check if the packet is the next in order */
 153     if (o->elem[0] == seq_num - 1) {
 154         elem_insert(o, 0, seq_num);
 155         return GSS_S_COMPLETE;
 156     }
 157
 158     r = (o->flags & (GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG))==GSS_C_REPLAY_FLAG;
 159
 160     /* sequence number larger then largest sequence number
 161      * or smaller then the first sequence number */
 162     if (seq_num > o->elem[0]
 163         || seq_num < o->first_seq
 164         || o->length == 0)
 165     {
 166         elem_insert(o, 0, seq_num);
 167         if (r) {
 168             return GSS_S_COMPLETE;
 169         } else {
 170             return GSS_S_GAP_TOKEN;
 171         }
 172     }
 173
 174     assert(o->length > 0);
 175
 176     /* sequence number smaller the first sequence number */
 177     if (seq_num < o->elem[o->length - 1]) {
 178         if (r)
 179             return(GSS_S_OLD_TOKEN);
 180         else
 181             return(GSS_S_UNSEQ_TOKEN);
 182     }
 183
 184     if (seq_num == o->elem[o->length - 1]) {
 185         return GSS_S_DUPLICATE_TOKEN;
 186     }
 187
 188     for (i = 0; i < o->length - 1; i++) {
 189         if (o->elem[i] == seq_num)
 190             return GSS_S_DUPLICATE_TOKEN;
 191         if (o->elem[i + 1] < seq_num && o->elem[i] < seq_num) {
 192             elem_insert(o, i, seq_num);
 193             if (r)
 194                 return GSS_S_COMPLETE;
 195             else
 196                 return GSS_S_UNSEQ_TOKEN;
 197         }
 198     }
 199
 200     return GSS_S_FAILURE;
 201 }
 202
 203 OM_uint32
 204 _gssapi_msg_order_f(OM_uint32 flags)
 205 {
 206     return flags & (GSS_C_SEQUENCE_FLAG|GSS_C_REPLAY_FLAG);
 207 }
 208
 209 /*
 210  * Translate `o` into inter-process format and export in to `sp'.
 211  */
 212
 213 krb5_error_code
 214 _gssapi_msg_order_export(krb5_storage *sp, struct gss_msg_order *o)
 215 {
 216     krb5_error_code kret;
 217     OM_uint32 i;
 218
 219     kret = krb5_store_int32(sp, o->flags);
 220     if (kret)
 221         return kret;
 222     kret = krb5_store_int32(sp, o->start);
 223     if (kret)
 224         return kret;
 225     kret = krb5_store_int32(sp, o->length);
 226     if (kret)
 227         return kret;
 228     kret = krb5_store_int32(sp, o->jitter_window);
 229     if (kret)
 230         return kret;
 231     kret = krb5_store_int32(sp, o->first_seq);
 232     if (kret)
 233         return kret;
 234
 235     for (i = 0; i < o->jitter_window; i++) {
 236         kret = krb5_store_int32(sp, o->elem[i]);
 237         if (kret)
 238             return kret;
 239     }
 240
 241     return 0;
 242 }
 243
 244 OM_uint32
 245 _gssapi_msg_order_import(OM_uint32 *minor_status,
 246                          krb5_storage *sp,
 247                          struct gss_msg_order **o)
 248 {
 249     OM_uint32 ret;
 250     krb5_error_code kret;
 251     int32_t i, flags, start, length, jitter_window, first_seq;
 252
 253     kret = krb5_ret_int32(sp, &flags);
 254     if (kret)
 255         goto failed;
 256     kret = krb5_ret_int32(sp, &start);
 257     if (kret)
 258         goto failed;
 259     kret = krb5_ret_int32(sp, &length);
 260     if (kret)
 261         goto failed;
 262     kret = krb5_ret_int32(sp, &jitter_window);
 263     if (kret)
 264         goto failed;
 265     kret = krb5_ret_int32(sp, &first_seq);
 266     if (kret)
 267         goto failed;
 268
 269     ret = msg_order_alloc(minor_status, o, jitter_window);
 270     if (ret != GSS_S_COMPLETE)
 271         return ret;
 272
 273     (*o)->flags = flags;
 274     (*o)->start = start;
 275     (*o)->length = length;
 276     (*o)->jitter_window = jitter_window;
 277     (*o)->first_seq = first_seq;
 278
 279     for( i = 0; i < jitter_window; i++ ) {
 280         kret = krb5_ret_int32(sp, (int32_t*)&((*o)->elem[i]));
 281         if (kret)
 282             goto failed;
 283     }
 284
 285     *minor_status = 0;
 286     return GSS_S_COMPLETE;
 287
 288 failed:
 289     _gssapi_msg_order_destroy(o);
 290     *minor_status = kret;
 291     return GSS_S_FAILURE;
 292 }