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