resolv/tst-ns_rr_cursor.c

   1 /* Tests for resource record parsing.
   2    Copyright (C) 2022 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <arpa/nameser.h>
  20 #include <string.h>
  21 #include <support/check.h>
  22 #include <support/next_to_fault.h>
  23
  24 /* Reference packet for packet parsing.  */
  25 static const unsigned char valid_packet[] =
  26   { 0x11, 0x12, 0x13, 0x14,
  27     0x00, 0x01,               /* Question count.  */
  28     0x00, 0x02,               /* Answer count.  */
  29     0x21, 0x22, 0x23, 0x24,   /* Other counts (not actually in packet).  */
  30     3, 'w', 'w', 'w', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 0,
  31     0x00, 0x1c,               /* Question type: AAAA.  */
  32     0x00, 0x01,               /* Question class: IN.  */
  33     0xc0, 0x0c,               /* Compression reference to QNAME.  */
  34     0x00, 0x1c,               /* Record type: AAAA.  */
  35     0x00, 0x01,               /* Record class: IN.  */
  36     0x12, 0x34, 0x56, 0x78,   /* Record TTL.  */
  37     0x00, 0x10,               /* Record data length (16 bytes).  */
  38     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
  39     0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, /* IPv6 address.  */
  40     0xc0, 0x0c,               /* Compression reference to QNAME.  */
  41     0x00, 0x1c,               /* Record type: AAAA.  */
  42     0x00, 0x01,               /* Record class: IN.  */
  43     0x11, 0x33, 0x55, 0x77,   /* Record TTL.  */
  44     0x00, 0x10,               /* Record data length (16 bytes).  */
  45     0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  46     0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, /* IPv6 address.  */
  47   };
  48
  49 /* Special offsets in valid_packet.  */
  50 enum
  51   {
  52     offset_of_first_record = 29,
  53     offset_of_second_record = 57,
  54   };
  55
  56 /* Check that parsing valid_packet succeeds.  */
  57 static void
  58 test_valid (void)
  59 {
  60   struct ns_rr_cursor c;
  61   TEST_VERIFY_EXIT (__ns_rr_cursor_init (&c, valid_packet,
  62                                          sizeof (valid_packet)));
  63   TEST_COMPARE (ns_rr_cursor_rcode (&c), 4);
  64   TEST_COMPARE (ns_rr_cursor_ancount (&c), 2);
  65   TEST_COMPARE (ns_rr_cursor_nscount (&c), 0x2122);
  66   TEST_COMPARE (ns_rr_cursor_adcount (&c), 0x2324);
  67   TEST_COMPARE_BLOB (ns_rr_cursor_qname (&c), 13, &valid_packet[12], 13);
  68   TEST_COMPARE (ns_rr_cursor_qtype (&c), T_AAAA);
  69   TEST_COMPARE (ns_rr_cursor_qclass (&c), C_IN);
  70   TEST_COMPARE (c.current - valid_packet, offset_of_first_record);
  71
  72   struct ns_rr_wire r;
  73   TEST_VERIFY_EXIT (__ns_rr_cursor_next (&c, &r));
  74   TEST_COMPARE (r.rtype, T_AAAA);
  75   TEST_COMPARE (r.rclass, C_IN);
  76   TEST_COMPARE (r.ttl, 0x12345678);
  77   TEST_COMPARE_BLOB (r.rdata, r.rdlength,
  78                      "\x90\x91\x92\x93\x94\x95\x96\x97"
  79                      "\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f", 16);
  80   TEST_COMPARE (c.current - valid_packet, offset_of_second_record);
  81   TEST_VERIFY_EXIT (__ns_rr_cursor_next (&c, &r));
  82   TEST_COMPARE (r.rtype, T_AAAA);
  83   TEST_COMPARE (r.rclass, C_IN);
  84   TEST_COMPARE (r.ttl, 0x11335577);
  85   TEST_COMPARE_BLOB (r.rdata, r.rdlength,
  86                      "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7"
  87                      "\xa8\xa9\xaa\xab\xac\xad\xae\xaf", 16);
  88   TEST_VERIFY (c.current == c.end);
  89 }
  90
  91 /* Check that trying to parse a packet with a compressed QNAME fails.  */
  92 static void
  93 test_compressed_qname (void)
  94 {
  95   static const unsigned char packet[] =
  96     { 0x11, 0x12, 0x13, 0x14,
  97       0x00, 0x01,               /* Question count.  */
  98       0x00, 0x00,               /* Answer count.  */
  99       0x00, 0x00, 0x00, 0x00,   /* Other counts.  */
 100       3, 'w', 'w', 'w', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 0xc0, 0x04,
 101       0x00, 0x01,               /* Question type: A.  */
 102       0x00, 0x01,               /* Question class: IN.  */
 103     };
 104
 105   struct ns_rr_cursor c;
 106   TEST_VERIFY_EXIT (!__ns_rr_cursor_init (&c, packet, sizeof (packet)));
 107 }
 108
 109 /* Check that trying to parse a packet with two questions fails.  */
 110 static void
 111 test_two_questions (void)
 112 {
 113   static const unsigned char packet[] =
 114     { 0x11, 0x12, 0x13, 0x14,
 115       0x00, 0x02,               /* Question count.  */
 116       0x00, 0x00,               /* Answer count.  */
 117       0x00, 0x00, 0x00, 0x00,   /* Other counts.  */
 118       3, 'w', 'w', 'w', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 0xc0, 0x04,
 119       0x00, 0x01,               /* Question type: A.  */
 120       0x00, 0x01,               /* Question class: IN.  */
 121       3, 'w', 'w', 'w', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 0xc0, 0x04,
 122       0x00, 0x1c,               /* Question type: AAAA.  */
 123       0x00, 0x01,               /* Question class: IN.  */
 124     };
 125
 126   struct ns_rr_cursor c;
 127   TEST_VERIFY_EXIT (!__ns_rr_cursor_init (&c, packet, sizeof (packet)));
 128 }
 129
 130 /* Used to check that parsing truncated packets does not over-read.  */
 131 static struct support_next_to_fault ntf;
 132
 133 /* Truncated packet in the second resource record.  */
 134 static void
 135 test_truncated_one_rr (size_t length)
 136 {
 137   unsigned char *end = (unsigned char *) ntf.buffer - ntf.length;
 138   unsigned char *start = end - length;
 139
 140   /* Produce the truncated packet.  */
 141   memcpy (start, valid_packet, length);
 142
 143   struct ns_rr_cursor c;
 144   TEST_VERIFY_EXIT (__ns_rr_cursor_init (&c, start, length));
 145   TEST_COMPARE (ns_rr_cursor_rcode (&c), 4);
 146   TEST_COMPARE (ns_rr_cursor_ancount (&c), 2);
 147   TEST_COMPARE (ns_rr_cursor_nscount (&c), 0x2122);
 148   TEST_COMPARE (ns_rr_cursor_adcount (&c), 0x2324);
 149   TEST_COMPARE_BLOB (ns_rr_cursor_qname (&c), 13, &valid_packet[12], 13);
 150   TEST_COMPARE (ns_rr_cursor_qtype (&c), T_AAAA);
 151   TEST_COMPARE (ns_rr_cursor_qclass (&c), C_IN);
 152   TEST_COMPARE (c.current - start, offset_of_first_record);
 153
 154   struct ns_rr_wire r;
 155   TEST_VERIFY_EXIT (__ns_rr_cursor_next (&c, &r));
 156   TEST_COMPARE (r.rtype, T_AAAA);
 157   TEST_COMPARE (r.rclass, C_IN);
 158   TEST_COMPARE (r.ttl, 0x12345678);
 159   TEST_COMPARE_BLOB (r.rdata, r.rdlength,
 160                      "\x90\x91\x92\x93\x94\x95\x96\x97"
 161                      "\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f", 16);
 162   TEST_COMPARE (c.current - start, offset_of_second_record);
 163   TEST_VERIFY (!__ns_rr_cursor_next (&c, &r));
 164 }
 165
 166 /* Truncated packet in the first resource record.  */
 167 static void
 168 test_truncated_no_rr (size_t length)
 169 {
 170   unsigned char *end = (unsigned char *) ntf.buffer - ntf.length;
 171   unsigned char *start = end - length;
 172
 173   /* Produce the truncated packet.  */
 174   memcpy (start, valid_packet, length);
 175
 176   struct ns_rr_cursor c;
 177   TEST_VERIFY_EXIT (__ns_rr_cursor_init (&c, start, length));
 178   TEST_COMPARE (ns_rr_cursor_rcode (&c), 4);
 179   TEST_COMPARE (ns_rr_cursor_ancount (&c), 2);
 180   TEST_COMPARE (ns_rr_cursor_nscount (&c), 0x2122);
 181   TEST_COMPARE (ns_rr_cursor_adcount (&c), 0x2324);
 182   TEST_COMPARE_BLOB (ns_rr_cursor_qname (&c), 13, &valid_packet[12], 13);
 183   TEST_COMPARE (ns_rr_cursor_qtype (&c), T_AAAA);
 184   TEST_COMPARE (ns_rr_cursor_qclass (&c), C_IN);
 185   TEST_COMPARE (c.current - start, offset_of_first_record);
 186
 187   struct ns_rr_wire r;
 188   TEST_VERIFY (!__ns_rr_cursor_next (&c, &r));
 189 }
 190
 191 /* Truncated packet before first resource record.  */
 192 static void
 193 test_truncated_before_rr (size_t length)
 194 {
 195   unsigned char *end = (unsigned char *) ntf.buffer - ntf.length;
 196   unsigned char *start = end - length;
 197
 198   /* Produce the truncated packet.  */
 199   memcpy (start, valid_packet, length);
 200
 201   struct ns_rr_cursor c;
 202   TEST_VERIFY_EXIT (!__ns_rr_cursor_init (&c, start, length));
 203 }
 204
 205 static int
 206 do_test (void)
 207 {
 208   ntf = support_next_to_fault_allocate (sizeof (valid_packet));
 209
 210   test_valid ();
 211   test_compressed_qname ();
 212   test_two_questions ();
 213
 214   for (int length = offset_of_second_record; length < sizeof (valid_packet);
 215        ++length)
 216     test_truncated_one_rr (length);
 217   for (int length = offset_of_first_record; length < offset_of_second_record;
 218        ++length)
 219     test_truncated_no_rr (length);
 220   for (int length = 0; length < offset_of_first_record; ++length)
 221     test_truncated_before_rr (length);
 222
 223   support_next_to_fault_free (&ntf);
 224   return 0;
 225 }
 226
 227 #include <support/test-driver.c>