lib/gssapi/krb5/test_sequence.c

   1 /*
   2  * Copyright (c) 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/gsskrb5_locl.h"
  35
  36 RCSID("$Id$");
  37
  38 /* correct ordering */
  39 OM_uint32 pattern1[] = {
  40     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
  41 };
  42
  43 /* gap 10 */
  44 OM_uint32 pattern2[] = {
  45     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13
  46 };
  47
  48 /* dup 9 */
  49 OM_uint32 pattern3[] = {
  50     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 11, 12, 13
  51 };
  52
  53 /* gaps */
  54 OM_uint32 pattern4[] = {
  55     0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 13, 14, 15, 16, 18, 100
  56 };
  57
  58 /* 11 before 10 */
  59 OM_uint32 pattern5[] = {
  60     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21
  61 };
  62
  63 /* long */
  64 OM_uint32 pattern6[] = {
  65     0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
  66     10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
  67     20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
  68     30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
  69     40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
  70     50, 51, 52, 53, 54, 55, 56, 57, 58, 59
  71 };
  72
  73 /* dont start at 0 */
  74 OM_uint32 pattern7[] = {
  75     11, 12, 13
  76 };
  77
  78 /* wrap around */
  79 OM_uint32 pattern8[] = {
  80     4294967293U, 4294967294U, 4294967295U, 0, 1, 2
  81 };
  82
  83 static int
  84 test_seq(int t, OM_uint32 flags, OM_uint32 start_seq,
  85          OM_uint32 *pattern, int pattern_len, OM_uint32 expected_error)
  86 {
  87     struct gss_msg_order *o;
  88     OM_uint32 maj_stat, min_stat;
  89     krb5_storage *sp;
  90     int i;
  91
  92     maj_stat = _gssapi_msg_order_create(&min_stat, &o, flags,
  93                                         start_seq, 20, 0);
  94     if (maj_stat)
  95         errx(1, "create: %d %d", maj_stat, min_stat);
  96
  97     sp = krb5_storage_emem();
  98     if (sp == NULL)
  99         errx(1, "krb5_storage_from_emem");
 100
 101     _gssapi_msg_order_export(sp, o);
 102
 103     for (i = 0; i < pattern_len; i++) {
 104         maj_stat = _gssapi_msg_order_check(o, pattern[i]);
 105         if (maj_stat)
 106             break;
 107     }
 108     if (maj_stat != expected_error) {
 109         printf("test pattern %d failed with %d (should have been %d)\n",
 110                t, maj_stat, expected_error);
 111         krb5_storage_free(sp);
 112         _gssapi_msg_order_destroy(&o);
 113         return 1;
 114     }
 115
 116
 117     _gssapi_msg_order_destroy(&o);
 118
 119     /* try again, now with export/imported blob */
 120     krb5_storage_seek(sp, 0, SEEK_SET);
 121
 122     maj_stat = _gssapi_msg_order_import(&min_stat, sp, &o);
 123     if (maj_stat)
 124         errx(1, "import: %d %d", maj_stat, min_stat);
 125
 126     for (i = 0; i < pattern_len; i++) {
 127         maj_stat = _gssapi_msg_order_check(o, pattern[i]);
 128         if (maj_stat)
 129             break;
 130     }
 131     if (maj_stat != expected_error) {
 132         printf("import/export test pattern %d failed "
 133                "with %d (should have been %d)\n",
 134                t, maj_stat, expected_error);
 135         _gssapi_msg_order_destroy(&o);
 136         krb5_storage_free(sp);
 137         return 1;
 138     }
 139
 140     _gssapi_msg_order_destroy(&o);
 141     krb5_storage_free(sp);
 142
 143     return 0;
 144 }
 145
 146 struct {
 147     OM_uint32 flags;
 148     OM_uint32 *pattern;
 149     int pattern_len;
 150     OM_uint32 error_code;
 151     OM_uint32 start_seq;
 152 } pl[] = {
 153     {
 154         GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG,
 155         pattern1,
 156         sizeof(pattern1)/sizeof(pattern1[0]),
 157         0
 158     },
 159     {
 160         GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG,
 161         pattern2,
 162         sizeof(pattern2)/sizeof(pattern2[0]),
 163         GSS_S_GAP_TOKEN
 164     },
 165     {
 166         GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG,
 167         pattern3,
 168         sizeof(pattern3)/sizeof(pattern3[0]),
 169         GSS_S_DUPLICATE_TOKEN
 170     },
 171     {
 172         GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG,
 173         pattern4,
 174         sizeof(pattern4)/sizeof(pattern4[0]),
 175         GSS_S_GAP_TOKEN
 176     },
 177     {
 178         GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG,
 179         pattern5,
 180         sizeof(pattern5)/sizeof(pattern5[0]),
 181         GSS_S_GAP_TOKEN
 182     },
 183     {
 184         GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG,
 185         pattern6,
 186         sizeof(pattern6)/sizeof(pattern6[0]),
 187         GSS_S_COMPLETE
 188     },
 189     {
 190         GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG,
 191         pattern7,
 192         sizeof(pattern7)/sizeof(pattern7[0]),
 193         GSS_S_GAP_TOKEN
 194     },
 195     {
 196         GSS_C_REPLAY_FLAG|GSS_C_SEQUENCE_FLAG,
 197         pattern8,
 198         sizeof(pattern8)/sizeof(pattern8[0]),
 199         GSS_S_COMPLETE,
 200         4294967293U
 201     },
 202     {
 203         0,
 204         pattern1,
 205         sizeof(pattern1)/sizeof(pattern1[0]),
 206         GSS_S_COMPLETE
 207     },
 208     {
 209         0,
 210         pattern2,
 211         sizeof(pattern2)/sizeof(pattern2[0]),
 212         GSS_S_COMPLETE
 213     },
 214     {
 215         0,
 216         pattern3,
 217         sizeof(pattern3)/sizeof(pattern3[0]),
 218         GSS_S_COMPLETE
 219     },
 220     {
 221         0,
 222         pattern4,
 223         sizeof(pattern4)/sizeof(pattern4[0]),
 224         GSS_S_COMPLETE
 225     },
 226     {
 227         0,
 228         pattern5,
 229         sizeof(pattern5)/sizeof(pattern5[0]),
 230         GSS_S_COMPLETE
 231     },
 232     {
 233         0,
 234         pattern6,
 235         sizeof(pattern6)/sizeof(pattern6[0]),
 236         GSS_S_COMPLETE
 237     },
 238     {
 239         0,
 240         pattern7,
 241         sizeof(pattern7)/sizeof(pattern7[0]),
 242         GSS_S_COMPLETE
 243     },
 244     {
 245         0,
 246         pattern8,
 247         sizeof(pattern8)/sizeof(pattern8[0]),
 248         GSS_S_COMPLETE,
 249         4294967293U
 250
 251     },
 252     {
 253         GSS_C_REPLAY_FLAG,
 254         pattern1,
 255         sizeof(pattern1)/sizeof(pattern1[0]),
 256         GSS_S_COMPLETE
 257     },
 258     {
 259         GSS_C_REPLAY_FLAG,
 260         pattern2,
 261         sizeof(pattern2)/sizeof(pattern2[0]),
 262         GSS_S_COMPLETE
 263     },
 264     {
 265         GSS_C_REPLAY_FLAG,
 266         pattern3,
 267         sizeof(pattern3)/sizeof(pattern3[0]),
 268         GSS_S_DUPLICATE_TOKEN
 269     },
 270     {
 271         GSS_C_REPLAY_FLAG,
 272         pattern4,
 273         sizeof(pattern4)/sizeof(pattern4[0]),
 274         GSS_S_COMPLETE
 275     },
 276     {
 277         GSS_C_REPLAY_FLAG,
 278         pattern5,
 279         sizeof(pattern5)/sizeof(pattern5[0]),
 280         0
 281     },
 282     {
 283         GSS_C_REPLAY_FLAG,
 284         pattern6,
 285         sizeof(pattern6)/sizeof(pattern6[0]),
 286         GSS_S_COMPLETE
 287     },
 288     {
 289         GSS_C_REPLAY_FLAG,
 290         pattern7,
 291         sizeof(pattern7)/sizeof(pattern7[0]),
 292         GSS_S_COMPLETE
 293     },
 294     {
 295         GSS_C_SEQUENCE_FLAG,
 296         pattern8,
 297         sizeof(pattern8)/sizeof(pattern8[0]),
 298         GSS_S_COMPLETE,
 299         4294967293U
 300     },
 301     {
 302         GSS_C_SEQUENCE_FLAG,
 303         pattern1,
 304         sizeof(pattern1)/sizeof(pattern1[0]),
 305         0
 306     },
 307     {
 308         GSS_C_SEQUENCE_FLAG,
 309         pattern2,
 310         sizeof(pattern2)/sizeof(pattern2[0]),
 311         GSS_S_GAP_TOKEN
 312     },
 313     {
 314         GSS_C_SEQUENCE_FLAG,
 315         pattern3,
 316         sizeof(pattern3)/sizeof(pattern3[0]),
 317         GSS_S_DUPLICATE_TOKEN
 318     },
 319     {
 320         GSS_C_SEQUENCE_FLAG,
 321         pattern4,
 322         sizeof(pattern4)/sizeof(pattern4[0]),
 323         GSS_S_GAP_TOKEN
 324     },
 325     {
 326         GSS_C_SEQUENCE_FLAG,
 327         pattern5,
 328         sizeof(pattern5)/sizeof(pattern5[0]),
 329         GSS_S_GAP_TOKEN
 330     },
 331     {
 332         GSS_C_SEQUENCE_FLAG,
 333         pattern6,
 334         sizeof(pattern6)/sizeof(pattern6[0]),
 335         GSS_S_COMPLETE
 336     },
 337     {
 338         GSS_C_SEQUENCE_FLAG,
 339         pattern7,
 340         sizeof(pattern7)/sizeof(pattern7[0]),
 341         GSS_S_GAP_TOKEN
 342     },
 343     {
 344         GSS_C_REPLAY_FLAG,
 345         pattern8,
 346         sizeof(pattern8)/sizeof(pattern8[0]),
 347         GSS_S_COMPLETE,
 348         4294967293U
 349     }
 350 };
 351
 352 int
 353 main(int argc, char **argv)
 354 {
 355     int i, failed = 0;
 356
 357     for (i = 0; i < sizeof(pl)/sizeof(pl[0]); i++) {
 358         if (test_seq(i,
 359                      pl[i].flags,
 360                      pl[i].start_seq,
 361                      pl[i].pattern,
 362                      pl[i].pattern_len,
 363                      pl[i].error_code))
 364             failed++;
 365     }
 366     if (failed)
 367         printf("FAILED %d tests\n", failed);
 368     return failed != 0;
 369 }