test/packettest.c

   1 /*
   2  * Copyright 2015-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 "../ssl/packet_locl.h"
  11 #include "testutil.h"
  12 #include "test_main.h"
  13
  14 #define BUF_LEN 255
  15
  16 static unsigned char smbuf[BUF_LEN];
  17
  18 static int test_PACKET_remaining()
  19 {
  20     PACKET pkt;
  21
  22     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
  23             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
  24             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
  25             || !TEST_size_t_eq(PACKET_remaining(&pkt), 1)
  26             || !TEST_true(PACKET_forward(&pkt, 1))
  27             || !TEST_size_t_eq(PACKET_remaining(&pkt), 0)))
  28         return 0;
  29
  30     return 1;
  31 }
  32
  33 static int test_PACKET_end()
  34 {
  35     PACKET pkt;
  36
  37     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
  38             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
  39             || !TEST_ptr_ne(PACKET_end(&pkt), smbuf + BUF_LEN)
  40             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
  41             || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
  42             || !TEST_true(PACKET_forward(&pkt, 1))
  43             || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)))
  44         return 0;
  45
  46     return 1;
  47 }
  48
  49 static int test_PACKET_get_1()
  50 {
  51     unsigned int i;
  52     PACKET pkt;
  53
  54     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
  55             || !TEST_true(PACKET_get_1(&pkt, &i))
  56             || !TEST_uint_eq(i, 0x02)
  57             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 2))
  58             || !TEST_true(PACKET_get_1(&pkt, &i))
  59             || !TEST_uint_eq(i, 0xfe)
  60             || !TEST_false(PACKET_get_1(&pkt, &i)))
  61         return 0;
  62
  63     return 1;
  64 }
  65
  66 static int test_PACKET_get_4()
  67 {
  68     unsigned long i;
  69     PACKET pkt;
  70
  71     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
  72             || !TEST_true(PACKET_get_4(&pkt, &i))
  73             || !TEST_ulong_eq(i, 0x08060402UL)
  74             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
  75             || !TEST_true(PACKET_get_4(&pkt, &i))
  76             || !TEST_ulong_eq(i, 0xfefcfaf8UL)
  77             || !TEST_false(PACKET_get_4(&pkt, &i)))
  78         return 0;
  79
  80     return 1;
  81 }
  82
  83 static int test_PACKET_get_net_2()
  84 {
  85     unsigned int i;
  86     PACKET pkt;
  87
  88     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
  89             || !TEST_true(PACKET_get_net_2(&pkt, &i))
  90             || !TEST_uint_eq(i, 0x0204)
  91             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 4))
  92             || !TEST_true(PACKET_get_net_2(&pkt, &i))
  93             || !TEST_uint_eq(i, 0xfcfe)
  94             || !TEST_false(PACKET_get_net_2(&pkt, &i)))
  95         return 0;
  96
  97     return 1;
  98 }
  99
 100 static int test_PACKET_get_net_3()
 101 {
 102     unsigned long i;
 103     PACKET pkt;
 104
 105     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
 106             || !TEST_true(PACKET_get_net_3(&pkt, &i))
 107             || !TEST_ulong_eq(i, 0x020406UL)
 108             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 6))
 109             || !TEST_true(PACKET_get_net_3(&pkt, &i))
 110             || !TEST_ulong_eq(i, 0xfafcfeUL)
 111             || !TEST_false(PACKET_get_net_3(&pkt, &i)))
 112         return 0;
 113
 114     return 1;
 115 }
 116
 117 static int test_PACKET_get_net_4()
 118 {
 119     unsigned long i;
 120     PACKET pkt;
 121
 122     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
 123             || !TEST_true(PACKET_get_net_4(&pkt, &i))
 124             || !TEST_ulong_eq(i, 0x02040608UL)
 125             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
 126             || !TEST_true(PACKET_get_net_4(&pkt, &i))
 127             || !TEST_ulong_eq(i, 0xf8fafcfeUL)
 128             || !TEST_false(PACKET_get_net_4(&pkt, &i)))
 129         return 0;
 130
 131     return 1;
 132 }
 133
 134 static int test_PACKET_get_sub_packet()
 135 {
 136     PACKET pkt, subpkt;
 137     unsigned long i;
 138
 139     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
 140             || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
 141             || !TEST_true(PACKET_get_net_4(&subpkt, &i))
 142             || !TEST_ulong_eq(i, 0x02040608UL)
 143             || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
 144             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
 145             || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
 146             || !TEST_true(PACKET_get_net_4(&subpkt, &i))
 147             || !TEST_ulong_eq(i, 0xf8fafcfeUL)
 148             || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
 149             || !TEST_false(PACKET_get_sub_packet(&pkt, &subpkt, 4)))
 150         return 0;
 151
 152     return 1;
 153 }
 154
 155 static int test_PACKET_get_bytes()
 156 {
 157     const unsigned char *bytes;
 158     PACKET pkt;
 159
 160     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
 161             || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
 162             || !TEST_uchar_eq(bytes[0], 2)
 163             || !TEST_uchar_eq(bytes[1], 4)
 164             || !TEST_uchar_eq(bytes[2], 6)
 165             || !TEST_uchar_eq(bytes[3], 8)
 166             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN -4)
 167             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
 168             || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
 169             || !TEST_uchar_eq(bytes[0], 0xf8)
 170             || !TEST_uchar_eq(bytes[1], 0xfa)
 171             || !TEST_uchar_eq(bytes[2], 0xfc)
 172             || !TEST_uchar_eq(bytes[3], 0xfe)
 173             || !TEST_false(PACKET_remaining(&pkt)))
 174         return 0;
 175
 176     return 1;
 177 }
 178
 179 static int test_PACKET_copy_bytes()
 180 {
 181     unsigned char bytes[4];
 182     PACKET pkt;
 183
 184     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
 185             || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
 186             || !TEST_char_eq(bytes[0], 2)
 187             || !TEST_char_eq(bytes[1], 4)
 188             || !TEST_char_eq(bytes[2], 6)
 189             || !TEST_char_eq(bytes[3], 8)
 190             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN - 4)
 191             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
 192             || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
 193             || !TEST_uchar_eq(bytes[0], 0xf8)
 194             || !TEST_uchar_eq(bytes[1], 0xfa)
 195             || !TEST_uchar_eq(bytes[2], 0xfc)
 196             || !TEST_uchar_eq(bytes[3], 0xfe)
 197             || !TEST_false(PACKET_remaining(&pkt)))
 198         return 0;
 199
 200     return 1;
 201 }
 202
 203 static int test_PACKET_copy_all()
 204 {
 205     unsigned char tmp[BUF_LEN];
 206     PACKET pkt;
 207     size_t len;
 208
 209     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
 210             || !TEST_true(PACKET_copy_all(&pkt, tmp, BUF_LEN, &len))
 211             || !TEST_size_t_eq(len, BUF_LEN)
 212             || !TEST_mem_eq(smbuf, BUF_LEN, tmp, BUF_LEN)
 213             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
 214             || !TEST_false(PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)))
 215         return 0;
 216
 217     return 1;
 218 }
 219
 220 static int test_PACKET_memdup()
 221 {
 222     unsigned char *data = NULL;
 223     size_t len;
 224     PACKET pkt;
 225     int result = 0;
 226
 227     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
 228             || !TEST_true(PACKET_memdup(&pkt, &data, &len))
 229             || !TEST_size_t_eq(len, BUF_LEN)
 230             || !TEST_mem_eq(data, len, PACKET_data(&pkt), len)
 231             || !TEST_true(PACKET_forward(&pkt, 10))
 232             || !TEST_true(PACKET_memdup(&pkt, &data, &len))
 233             || !TEST_size_t_eq(len, BUF_LEN - 10)
 234             || !TEST_mem_eq(data, len, PACKET_data(&pkt), len))
 235         goto end;
 236     result = 1;
 237 end:
 238     OPENSSL_free(data);
 239     return result;
 240 }
 241
 242 static int test_PACKET_strndup()
 243 {
 244     char buf1[10], buf2[10];
 245     char *data = NULL;
 246     PACKET pkt;
 247     int result = 0;
 248
 249     memset(buf1, 'x', 10);
 250     memset(buf2, 'y', 10);
 251     buf2[5] = '\0';
 252
 253     if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
 254             || !TEST_true(PACKET_strndup(&pkt, &data))
 255             || !TEST_size_t_eq(strlen(data), 10)
 256             || !TEST_strn_eq(data, buf1, 10)
 257             || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
 258             || !TEST_true(PACKET_strndup(&pkt, &data))
 259             || !TEST_size_t_eq(strlen(data), 5)
 260             || !TEST_str_eq(data, buf2))
 261         goto end;
 262
 263     result = 1;
 264 end:
 265     OPENSSL_free(data);
 266     return result;
 267 }
 268
 269 static int test_PACKET_contains_zero_byte()
 270 {
 271     char buf1[10], buf2[10];
 272     PACKET pkt;
 273
 274     memset(buf1, 'x', 10);
 275     memset(buf2, 'y', 10);
 276     buf2[5] = '\0';
 277
 278     if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
 279             || !TEST_false(PACKET_contains_zero_byte(&pkt))
 280             || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
 281             || !TEST_true(PACKET_contains_zero_byte(&pkt)))
 282         return 0;
 283
 284     return 1;
 285 }
 286
 287 static int test_PACKET_forward()
 288 {
 289     const unsigned char *byte;
 290     PACKET pkt;
 291
 292     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
 293             || !TEST_true(PACKET_forward(&pkt, 1))
 294             || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
 295             || !TEST_uchar_eq(byte[0], 4)
 296             || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 3))
 297             || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
 298             || !TEST_uchar_eq(byte[0], 0xfe))
 299         return 0;
 300
 301     return 1;
 302 }
 303
 304 static int test_PACKET_buf_init()
 305 {
 306     unsigned char buf1[BUF_LEN];
 307     PACKET pkt;
 308
 309     /* Also tests PACKET_remaining() */
 310     if (!TEST_true(PACKET_buf_init(&pkt, buf1, 4))
 311             || !TEST_size_t_eq(PACKET_remaining(&pkt), 4)
 312             || !TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
 313             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
 314             || !TEST_false(PACKET_buf_init(&pkt, buf1, -1)))
 315         return 0;
 316
 317     return 1;
 318 }
 319
 320 static int test_PACKET_null_init()
 321 {
 322     PACKET pkt;
 323
 324     PACKET_null_init(&pkt);
 325     if (!TEST_size_t_eq(PACKET_remaining(&pkt), 0)
 326             || !TEST_false(PACKET_forward(&pkt, 1)))
 327         return 0;
 328
 329     return 1;
 330 }
 331
 332 static int test_PACKET_equal()
 333 {
 334     PACKET pkt;
 335
 336     if (!TEST_true(PACKET_buf_init(&pkt, smbuf, 4))
 337             || !TEST_true(PACKET_equal(&pkt, smbuf, 4))
 338             || !TEST_false(PACKET_equal(&pkt, smbuf + 1, 4))
 339             || !TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
 340             || !TEST_true(PACKET_equal(&pkt, smbuf, BUF_LEN))
 341             || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN - 1))
 342             || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN + 1))
 343             || !TEST_false(PACKET_equal(&pkt, smbuf, 0)))
 344         return 0;
 345
 346     return 1;
 347 }
 348
 349 static int test_PACKET_get_length_prefixed_1()
 350 {
 351     unsigned char buf1[BUF_LEN];
 352     const size_t len = 16;
 353     unsigned int i;
 354     PACKET pkt, short_pkt, subpkt = {0};
 355
 356     buf1[0] = len;
 357     for (i = 1; i < BUF_LEN; i++)
 358         buf1[i] = (i * 2) & 0xff;
 359
 360     if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
 361             || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
 362             || !TEST_true(PACKET_get_length_prefixed_1(&pkt, &subpkt))
 363             || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
 364             || !TEST_true(PACKET_get_net_2(&subpkt, &i))
 365             || !TEST_uint_eq(i, 0x0204)
 366             || !TEST_false(PACKET_get_length_prefixed_1(&short_pkt, &subpkt))
 367             || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
 368         return 0;
 369
 370     return 1;
 371 }
 372
 373 static int test_PACKET_get_length_prefixed_2()
 374 {
 375     unsigned char buf1[1024];
 376     const size_t len = 516;  /* 0x0204 */
 377     unsigned int i;
 378     PACKET pkt, short_pkt, subpkt = {0};
 379
 380     for (i = 1; i <= 1024; i++)
 381         buf1[i - 1] = (i * 2) & 0xff;
 382
 383     if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
 384             || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
 385             || !TEST_true(PACKET_get_length_prefixed_2(&pkt, &subpkt))
 386             || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
 387             || !TEST_true(PACKET_get_net_2(&subpkt, &i))
 388             || !TEST_uint_eq(i, 0x0608)
 389             || !TEST_false(PACKET_get_length_prefixed_2(&short_pkt, &subpkt))
 390             || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
 391         return 0;
 392
 393     return 1;
 394 }
 395
 396 static int test_PACKET_get_length_prefixed_3()
 397 {
 398     unsigned char buf1[1024];
 399     const size_t len = 516;  /* 0x000204 */
 400     unsigned int i;
 401     PACKET pkt, short_pkt, subpkt = {0};
 402
 403     for (i = 0; i < 1024; i++)
 404         buf1[i] = (i * 2) & 0xff;
 405
 406     if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
 407             || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
 408             || !TEST_true(PACKET_get_length_prefixed_3(&pkt, &subpkt))
 409             || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
 410             || !TEST_true(PACKET_get_net_2(&subpkt, &i))
 411             || !TEST_uint_eq(i, 0x0608)
 412             || !TEST_false(PACKET_get_length_prefixed_3(&short_pkt, &subpkt))
 413             || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
 414         return 0;
 415
 416     return 1;
 417 }
 418
 419 static int test_PACKET_as_length_prefixed_1()
 420 {
 421     unsigned char buf1[BUF_LEN];
 422     const size_t len = 16;
 423     unsigned int i;
 424     PACKET pkt, exact_pkt, subpkt;
 425
 426     buf1[0] = len;
 427     for (i = 1; i < BUF_LEN; i++)
 428         buf1[i] = (i * 2) & 0xff;
 429
 430     if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
 431             || !TEST_true(PACKET_buf_init(&exact_pkt, buf1, len + 1))
 432             || !TEST_false(PACKET_as_length_prefixed_1(&pkt, &subpkt))
 433             || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
 434             || !TEST_true(PACKET_as_length_prefixed_1(&exact_pkt, &subpkt)
 435             || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
 436             || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)))
 437         return 0;
 438
 439     return 1;
 440 }
 441
 442 static int test_PACKET_as_length_prefixed_2()
 443 {
 444     unsigned char buf[1024];
 445     const size_t len = 516;  /* 0x0204 */
 446     unsigned int i;
 447     PACKET pkt, exact_pkt, subpkt;
 448
 449     for (i = 1; i <= 1024; i++)
 450         buf[i-1] = (i * 2) & 0xff;
 451
 452     if (!TEST_true(PACKET_buf_init(&pkt, buf, 1024))
 453             || !TEST_true(PACKET_buf_init(&exact_pkt, buf, len + 2))
 454             || !TEST_false(PACKET_as_length_prefixed_2(&pkt, &subpkt))
 455             || !TEST_size_t_eq(PACKET_remaining(&pkt), 1024)
 456             || !TEST_true(PACKET_as_length_prefixed_2(&exact_pkt, &subpkt))
 457             || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
 458             || !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
 459         return 0;
 460
 461     return 1;
 462 }
 463
 464 void register_tests(void)
 465 {
 466     unsigned int i;
 467
 468     for (i = 1; i <= BUF_LEN; i++)
 469         smbuf[i - 1] = (i * 2) & 0xff;
 470
 471     ADD_TEST(test_PACKET_buf_init);
 472     ADD_TEST(test_PACKET_null_init);
 473     ADD_TEST(test_PACKET_remaining);
 474     ADD_TEST(test_PACKET_end);
 475     ADD_TEST(test_PACKET_equal);
 476     ADD_TEST(test_PACKET_get_1);
 477     ADD_TEST(test_PACKET_get_4);
 478     ADD_TEST(test_PACKET_get_net_2);
 479     ADD_TEST(test_PACKET_get_net_3);
 480     ADD_TEST(test_PACKET_get_net_4);
 481     ADD_TEST(test_PACKET_get_sub_packet);
 482     ADD_TEST(test_PACKET_get_bytes);
 483     ADD_TEST(test_PACKET_copy_bytes);
 484     ADD_TEST(test_PACKET_copy_all);
 485     ADD_TEST(test_PACKET_memdup);
 486     ADD_TEST(test_PACKET_strndup);
 487     ADD_TEST(test_PACKET_contains_zero_byte);
 488     ADD_TEST(test_PACKET_forward);
 489     ADD_TEST(test_PACKET_get_length_prefixed_1);
 490     ADD_TEST(test_PACKET_get_length_prefixed_2);
 491     ADD_TEST(test_PACKET_get_length_prefixed_3);
 492     ADD_TEST(test_PACKET_as_length_prefixed_1);
 493     ADD_TEST(test_PACKET_as_length_prefixed_2);
 494 }