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