test/wpackettest.c

   1 /*
   2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <string.h>
  11 #include <openssl/buffer.h>
  12 #include "../ssl/packet_locl.h"
  13 #include "testutil.h"
  14 #include "test_main_custom.h"
  15
  16 const static unsigned char simple1[] = { 0xff };
  17 const static unsigned char simple2[] = { 0x01, 0xff };
  18 const static unsigned char simple3[] = { 0x00, 0x00, 0x00, 0x01, 0xff };
  19 const static unsigned char nestedsub[] = { 0x03, 0xff, 0x01, 0xff };
  20 const static unsigned char seqsub[] = { 0x01, 0xff, 0x01, 0xff };
  21 const static unsigned char empty[] = { 0x00 };
  22 const static unsigned char alloc[] = { 0x02, 0xfe, 0xff };
  23 const static unsigned char submem[] = { 0x03, 0x02, 0xfe, 0xff };
  24 const static unsigned char fixed[] = { 0xff, 0xff, 0xff };
  25
  26 static BUF_MEM *buf;
  27
  28 static int cleanup(WPACKET *pkt)
  29 {
  30     WPACKET_cleanup(pkt);
  31     return 0;
  32 }
  33
  34 static int test_WPACKET_init(void)
  35 {
  36     WPACKET pkt;
  37     int i;
  38     size_t written;
  39     unsigned char sbuf[3];
  40
  41     if (!TEST_true(WPACKET_init(&pkt, buf))
  42             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
  43                 /* Closing a top level WPACKET should fail */
  44             || !TEST_false(WPACKET_close(&pkt))
  45                 /* Finishing a top level WPACKET should succeed */
  46             || !TEST_true(WPACKET_finish(&pkt))
  47                 /*
  48                  * Can't call close or finish on a WPACKET that's already
  49                  * finished.
  50                  */
  51             || !TEST_false(WPACKET_close(&pkt))
  52             || !TEST_false(WPACKET_finish(&pkt))
  53             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
  54             || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
  55         return cleanup(&pkt);
  56
  57     /* Now try with a one byte length prefix */
  58     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
  59             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
  60             || !TEST_true(WPACKET_finish(&pkt))
  61             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
  62             || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
  63         return cleanup(&pkt);
  64
  65     /* And a longer length prefix */
  66     if (!TEST_true(WPACKET_init_len(&pkt, buf, 4))
  67             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
  68             || !TEST_true(WPACKET_finish(&pkt))
  69             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
  70             || !TEST_mem_eq(buf->data, written, simple3, sizeof(simple3)))
  71         return cleanup(&pkt);
  72
  73     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1)))
  74         return cleanup(&pkt);
  75     for (i = 1; i < 257; i++) {
  76         /*
  77          * Putting more bytes in than fit for the size of the length prefix
  78          * should fail
  79          */
  80         if (!TEST_int_eq(WPACKET_put_bytes_u8(&pkt, 0xff), i < 256))
  81             return cleanup(&pkt);
  82     }
  83     if (!TEST_true(WPACKET_finish(&pkt)))
  84         return cleanup(&pkt);
  85
  86     /* Test initialising from a fixed size buffer */
  87     if (!TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0))
  88                 /* Adding 3 bytes should succeed */
  89             || !TEST_true(WPACKET_put_bytes_u24(&pkt, 0xffffff))
  90                 /* Adding 1 more byte should fail */
  91             || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
  92                 /* Finishing the top level WPACKET should succeed */
  93             || !TEST_true(WPACKET_finish(&pkt))
  94             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
  95             || !TEST_mem_eq(sbuf, written, fixed, sizeof(sbuf))
  96                 /* Initialise with 1 len byte */
  97             || !TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1))
  98                 /* Adding 2 bytes should succeed */
  99             || !TEST_true(WPACKET_put_bytes_u16(&pkt, 0xfeff))
 100                 /* Adding 1 more byte should fail */
 101             || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
 102             || !TEST_true(WPACKET_finish(&pkt))
 103             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 104             || !TEST_mem_eq(sbuf, written, alloc, sizeof(alloc)))
 105         return cleanup(&pkt);
 106
 107     return 1;
 108 }
 109
 110 static int test_WPACKET_set_max_size(void)
 111 {
 112     WPACKET pkt;
 113     size_t written;
 114
 115     if (!TEST_true(WPACKET_init(&pkt, buf))
 116                 /*
 117                  * No previous lenbytes set so we should be ok to set the max
 118                  * possible max size
 119                  */
 120             || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
 121                 /* We should be able to set it smaller too */
 122             || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX -1))
 123                 /* And setting it bigger again should be ok */
 124             || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
 125             || !TEST_true(WPACKET_finish(&pkt)))
 126         return cleanup(&pkt);
 127
 128     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
 129                 /*
 130                  * Should fail because we already consumed 1 byte with the
 131                  * length
 132                  */
 133             || !TEST_false(WPACKET_set_max_size(&pkt, 0))
 134                 /*
 135                  * Max size can't be bigger than biggest that will fit in
 136                  * lenbytes
 137                  */
 138             || !TEST_false(WPACKET_set_max_size(&pkt, 0x0101))
 139                 /* It can be the same as the maximum possible size */
 140             || !TEST_true(WPACKET_set_max_size(&pkt, 0x0100))
 141                 /* Or it can be less */
 142             || !TEST_true(WPACKET_set_max_size(&pkt, 0x01))
 143                 /* Should fail because packet is already filled */
 144             || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
 145                 /* You can't put in more bytes than max size */
 146             || !TEST_true(WPACKET_set_max_size(&pkt, 0x02))
 147             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 148             || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
 149             || !TEST_true(WPACKET_finish(&pkt))
 150             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 151             || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
 152         return cleanup(&pkt);
 153
 154     return 1;
 155 }
 156
 157 static int test_WPACKET_start_sub_packet(void)
 158 {
 159     WPACKET pkt;
 160     size_t written;
 161     size_t len;
 162
 163     if (!TEST_true(WPACKET_init(&pkt, buf))
 164             || !TEST_true(WPACKET_start_sub_packet(&pkt))
 165             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 166                 /* Can't finish because we have a sub packet */
 167             || !TEST_false(WPACKET_finish(&pkt))
 168             || !TEST_true(WPACKET_close(&pkt))
 169                 /* Sub packet is closed so can't close again */
 170             || !TEST_false(WPACKET_close(&pkt))
 171                 /* Now a top level so finish should succeed */
 172             || !TEST_true(WPACKET_finish(&pkt))
 173             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 174             || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
 175         return cleanup(&pkt);
 176
 177    /* Single sub-packet with length prefix */
 178     if (!TEST_true(WPACKET_init(&pkt, buf))
 179             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
 180             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 181             || !TEST_true(WPACKET_close(&pkt))
 182             || !TEST_true(WPACKET_finish(&pkt))
 183             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 184             || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
 185         return cleanup(&pkt);
 186
 187     /* Nested sub-packets with length prefixes */
 188     if (!TEST_true(WPACKET_init(&pkt, buf))
 189             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
 190             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 191             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
 192             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 193             || !TEST_true(WPACKET_get_length(&pkt, &len))
 194             || !TEST_size_t_eq(len, 1)
 195             || !TEST_true(WPACKET_close(&pkt))
 196             || !TEST_true(WPACKET_get_length(&pkt, &len))
 197             || !TEST_size_t_eq(len, 3)
 198             || !TEST_true(WPACKET_close(&pkt))
 199             || !TEST_true(WPACKET_finish(&pkt))
 200             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 201             || !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub)))
 202         return cleanup(&pkt);
 203
 204     /* Sequential sub-packets with length prefixes */
 205     if (!TEST_true(WPACKET_init(&pkt, buf))
 206             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
 207             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 208             || !TEST_true(WPACKET_close(&pkt))
 209             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
 210             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 211             || !TEST_true(WPACKET_close(&pkt))
 212             || !TEST_true(WPACKET_finish(&pkt))
 213             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 214             || !TEST_mem_eq(buf->data, written, seqsub, sizeof(seqsub)))
 215         return cleanup(&pkt);
 216
 217     /* Nested sub-packets with lengths filled before finish */
 218     if (!TEST_true(WPACKET_init(&pkt, buf))
 219             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
 220             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 221             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
 222             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 223             || !TEST_true(WPACKET_get_length(&pkt, &len))
 224             || !TEST_size_t_eq(len, 1)
 225             || !TEST_true(WPACKET_close(&pkt))
 226             || !TEST_true(WPACKET_get_length(&pkt, &len))
 227             || !TEST_size_t_eq(len, 3)
 228             || !TEST_true(WPACKET_close(&pkt))
 229             || !TEST_true(WPACKET_fill_lengths(&pkt))
 230             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 231             || !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub))
 232             || !TEST_true(WPACKET_finish(&pkt)))
 233         return cleanup(&pkt);
 234
 235     return 1;
 236 }
 237
 238
 239 static int test_WPACKET_set_flags(void)
 240 {
 241     WPACKET pkt;
 242     size_t written;
 243
 244     /* Set packet to be non-zero length */
 245     if (!TEST_true(WPACKET_init(&pkt, buf))
 246             || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
 247                 /* Should fail because of zero length */
 248             || !TEST_false(WPACKET_finish(&pkt))
 249             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 250             || !TEST_true(WPACKET_finish(&pkt))
 251             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 252             || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
 253         return cleanup(&pkt);
 254
 255     /* Repeat above test in a sub-packet */
 256     if (!TEST_true(WPACKET_init(&pkt, buf))
 257             || !TEST_true(WPACKET_start_sub_packet(&pkt))
 258             || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
 259                 /* Should fail because of zero length */
 260             || !TEST_false(WPACKET_close(&pkt))
 261             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 262             || !TEST_true(WPACKET_close(&pkt))
 263             || !TEST_true(WPACKET_finish(&pkt))
 264             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 265             || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
 266         return cleanup(&pkt);
 267
 268     /* Set packet to abandon non-zero length */
 269     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
 270             || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
 271             || !TEST_true(WPACKET_finish(&pkt))
 272             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 273             || !TEST_size_t_eq(written, 0))
 274         return cleanup(&pkt);
 275
 276     /* Repeat above test but only abandon a sub-packet */
 277     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
 278             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
 279             || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
 280             || !TEST_true(WPACKET_close(&pkt))
 281             || !TEST_true(WPACKET_finish(&pkt))
 282             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 283             || !TEST_mem_eq(buf->data, written, empty, sizeof(empty)))
 284         return cleanup(&pkt);
 285
 286     /* And repeat with a non empty sub-packet */
 287     if (!TEST_true(WPACKET_init(&pkt, buf))
 288             || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
 289             || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
 290             || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
 291             || !TEST_true(WPACKET_close(&pkt))
 292             || !TEST_true(WPACKET_finish(&pkt))
 293             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 294             || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
 295         return cleanup(&pkt);
 296     return 1;
 297 }
 298
 299 static int test_WPACKET_allocate_bytes(void)
 300 {
 301     WPACKET pkt;
 302     size_t written;
 303     unsigned char *bytes;
 304
 305     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
 306             || !TEST_true(WPACKET_allocate_bytes(&pkt, 2, &bytes)))
 307         return cleanup(&pkt);
 308     bytes[0] = 0xfe;
 309     bytes[1] = 0xff;
 310     if (!TEST_true(WPACKET_finish(&pkt))
 311             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 312             || !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
 313         return cleanup(&pkt);
 314
 315     /* Repeat with WPACKET_sub_allocate_bytes */
 316     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
 317             || !TEST_true(WPACKET_sub_allocate_bytes_u8(&pkt, 2, &bytes)))
 318         return cleanup(&pkt);
 319     bytes[0] = 0xfe;
 320     bytes[1] = 0xff;
 321     if (!TEST_true(WPACKET_finish(&pkt))
 322             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 323             || !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
 324         return cleanup(&pkt);
 325
 326     return 1;
 327 }
 328
 329 static int test_WPACKET_memcpy(void)
 330 {
 331     WPACKET pkt;
 332     size_t written;
 333     const unsigned char bytes[] = { 0xfe, 0xff };
 334
 335     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
 336             || !TEST_true(WPACKET_memcpy(&pkt, bytes, sizeof(bytes)))
 337             || !TEST_true(WPACKET_finish(&pkt))
 338             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 339             || !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
 340         return cleanup(&pkt);
 341
 342     /* Repeat with WPACKET_sub_memcpy() */
 343     if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
 344             || !TEST_true(WPACKET_sub_memcpy_u8(&pkt, bytes, sizeof(bytes)))
 345             || !TEST_true(WPACKET_finish(&pkt))
 346             || !TEST_true(WPACKET_get_total_written(&pkt, &written))
 347             || !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
 348         return cleanup(&pkt);
 349
 350     return 1;
 351 }
 352
 353 int test_main(int argc, char *argv[])
 354 {
 355     int testresult = 0;
 356
 357     if (!TEST_ptr(buf = BUF_MEM_new()))
 358             return 0;
 359
 360     ADD_TEST(test_WPACKET_init);
 361     ADD_TEST(test_WPACKET_set_max_size);
 362     ADD_TEST(test_WPACKET_start_sub_packet);
 363     ADD_TEST(test_WPACKET_set_flags);
 364     ADD_TEST(test_WPACKET_allocate_bytes);
 365     ADD_TEST(test_WPACKET_memcpy);
 366     testresult = run_tests(argv[0]);
 367
 368     BUF_MEM_free(buf);
 369     return testresult;
 370 }