resolv/tst-resolv-invalid-cname.c

   1 /* Test handling of CNAMEs with non-host domain names (bug 12154).
   2    Copyright (C) 2022-2024 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 <errno.h>
  20 #include <netdb.h>
  21 #include <resolv.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <support/check.h>
  25 #include <support/check_nss.h>
  26 #include <support/resolv_test.h>
  27 #include <support/support.h>
  28 #include <support/xmemstream.h>
  29
  30 /* Query strings describe the CNAME chain in the response.  They have
  31    the format "bitsBITS.countCOUNT.example.", where BITS and COUNT are
  32    replaced by unsigned decimal numbers.  COUNT is the number of CNAME
  33    records in the response.  BITS has two bits for each CNAME record,
  34    describing a special prefix that is added to that CNAME.
  35
  36    0: No special leading label.
  37    1: Starting with "*.".
  38    2: Starting with "-x.".
  39    3: Starting with "star.*.".
  40
  41    The first CNAME in the response using the two least significant
  42    bits.
  43
  44    For PTR queries, the QNAME format is different, it is either
  45    COUNT.BITS.168.192.in-addr.arpa. (with BITS and COUNT still
  46    decimal), or:
  47
  48 COUNT.BITS0.BITS1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa.
  49
  50    where BITS and COUNT are hexadecimal.  */
  51
  52 static void
  53 response (const struct resolv_response_context *ctx,
  54           struct resolv_response_builder *b,
  55           const char *qname, uint16_t qclass, uint16_t qtype)
  56 {
  57   TEST_COMPARE (qclass, C_IN);
  58
  59   /* The only other query type besides A is PTR.  */
  60   if (qtype != T_A && qtype != T_AAAA)
  61     TEST_COMPARE (qtype, T_PTR);
  62
  63   unsigned int bits, bits1, count;
  64   char *tail = NULL;
  65   if (sscanf (qname, "bits%u.count%u.%ms", &bits, &count, &tail) == 3)
  66     TEST_COMPARE_STRING (tail, "example");
  67   else if (strstr (qname, "in-addr.arpa") != NULL
  68            && sscanf (qname, "%u.%u.%ms", &bits, &count, &tail) == 3)
  69     TEST_COMPARE_STRING (tail, "168.192.in-addr.arpa");
  70   else if (sscanf (qname, "%x.%x.%x.%ms", &bits, &bits1, &count, &tail) == 4)
  71     {
  72       TEST_COMPARE_STRING (tail, "\
  73 0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa");
  74       bits |= bits1 << 4;
  75     }
  76   else
  77     FAIL_EXIT1 ("invalid QNAME: %s\n", qname);
  78   free (tail);
  79
  80   struct resolv_response_flags flags = {};
  81   resolv_response_init (b, flags);
  82   resolv_response_add_question (b, qname, qclass, qtype);
  83   resolv_response_section (b, ns_s_an);
  84
  85   /* Provide the requested number of CNAME records.  */
  86   char *previous_name = (char *) qname;
  87   unsigned int original_bits = bits;
  88   for (int unique = 0; unique < count; ++unique)
  89     {
  90       resolv_response_open_record (b, previous_name, qclass, T_CNAME, 60);
  91
  92       static const char bits_to_prefix[4][8] = { "", "*.", "-x.", "star.*." };
  93       char *new_name = xasprintf ("%sunique%d.example",
  94                                   bits_to_prefix[bits & 3], unique);
  95       bits >>= 2;
  96       resolv_response_add_name (b, new_name);
  97       resolv_response_close_record (b);
  98
  99       if (previous_name != qname)
 100         free (previous_name);
 101       previous_name = new_name;
 102     }
 103
 104   /* Actual answer record.  */
 105   resolv_response_open_record (b, previous_name, qclass, qtype, 60);
 106   switch (qtype)
 107     {
 108     case T_A:
 109       {
 110         char ipv4[4] = {192, 168, count, original_bits};
 111         resolv_response_add_data (b, &ipv4, sizeof (ipv4));
 112       }
 113       break;
 114     case T_AAAA:
 115       {
 116         char ipv6[16] =
 117           {
 118             0x20, 0x01, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 119             count, original_bits
 120           };
 121         resolv_response_add_data (b, &ipv6, sizeof (ipv6));
 122       }
 123       break;
 124
 125     case T_PTR:
 126       {
 127         char *name = xasprintf ("bits%u.count%u.example",
 128                                 original_bits, count);
 129         resolv_response_add_name (b, name);
 130         free (name);
 131       }
 132       break;
 133     }
 134   resolv_response_close_record (b);
 135
 136   if (previous_name != qname)
 137     free (previous_name);
 138 }
 139
 140 /* Controls which name resolution function is invoked.  */
 141 enum test_mode
 142   {
 143     byname,                     /* gethostbyname.  */
 144     byname2,                    /* gethostbyname2.  */
 145     gai,                        /* getaddrinfo without AI_CANONNAME.  */
 146     gai_canon,                  /* getaddrinfo with AI_CANONNAME.  */
 147
 148     test_mode_num               /* Number of enum values.  */
 149   };
 150
 151 static const char *
 152 test_mode_to_string (enum test_mode mode)
 153 {
 154   switch (mode)
 155     {
 156     case byname:
 157       return "byname";
 158     case byname2:
 159       return "byname2";
 160     case gai:
 161       return "gai";
 162     case gai_canon:
 163       return "gai_canon";
 164     case test_mode_num:
 165       break;                    /* Report error below.  */
 166     }
 167   FAIL_EXIT1 ("invalid test_mode: %d", mode);
 168 }
 169
 170 /* Append the name and aliases to OUT.  */
 171 static void
 172 append_names (FILE *out, const char *qname, int bits, int count,
 173               enum test_mode mode)
 174 {
 175   /* Largest valid index which has a corresponding zero in bits
 176      (meaning a syntactically valid CNAME).  */
 177   int last_valid_cname = -1;
 178
 179   for (int i = 0; i < count; ++i)
 180     if ((bits & (3 << (i * 2))) == 0)
 181       last_valid_cname = i;
 182
 183   if (mode != gai)
 184     {
 185       const char *label;
 186       if (mode == gai_canon)
 187         label = "canonname";
 188       else
 189         label = "name";
 190       if (last_valid_cname >= 0)
 191         fprintf (out, "%s: unique%d.example\n", label, last_valid_cname);
 192       else
 193         fprintf (out, "%s: %s\n", label, qname);
 194     }
 195
 196   if (mode == byname || mode == byname2)
 197     {
 198       if (last_valid_cname >= 0)
 199         fprintf (out, "alias: %s\n", qname);
 200       for (int i = 0; i < count; ++i)
 201         {
 202           if ((bits & (3 << (i * 2))) == 0 && i != last_valid_cname)
 203             fprintf (out, "alias: unique%d.example\n", i);
 204         }
 205     }
 206 }
 207
 208 /* Append the address information to OUT.  */
 209 static void
 210 append_addresses (FILE *out, int af, int bits, int count, enum test_mode mode)
 211 {
 212   int last = count * 256 + bits;
 213   if (mode == gai || mode == gai_canon)
 214     {
 215       if (af == AF_INET || af == AF_UNSPEC)
 216         fprintf (out, "address: STREAM/TCP 192.168.%d.%d 80\n", count, bits);
 217       if (af == AF_INET6 || af == AF_UNSPEC)
 218         {
 219           if (last == 0)
 220             fprintf (out, "address: STREAM/TCP 2001:db8:: 80\n");
 221           else
 222             fprintf (out, "address: STREAM/TCP 2001:db8::%x 80\n", last);
 223         }
 224     }
 225   else
 226     {
 227       TEST_VERIFY (af != AF_UNSPEC);
 228       if (af == AF_INET)
 229         fprintf (out, "address: 192.168.%d.%d\n", count, bits);
 230       if (af == AF_INET6)
 231         {
 232           if (last == 0)
 233             fprintf (out, "address: 2001:db8::\n");
 234           else
 235             fprintf (out, "address: 2001:db8::%x\n", last);
 236         }
 237     }
 238 }
 239
 240 /* Perform one test using a forward lookup.  */
 241 static void
 242 check_forward (int af, int bits, int count, enum test_mode mode)
 243 {
 244   char *qname = xasprintf ("bits%d.count%d.example", bits, count);
 245   char *label = xasprintf ("af=%d bits=%d count=%d mode=%s qname=%s",
 246                            af, bits, count, test_mode_to_string (mode), qname);
 247
 248   struct xmemstream expected;
 249   xopen_memstream (&expected);
 250   if (mode == gai_canon)
 251     fprintf (expected.out, "flags: AI_CANONNAME\n");
 252   append_names (expected.out, qname, bits, count, mode);
 253   append_addresses (expected.out, af, bits, count, mode);
 254   xfclose_memstream (&expected);
 255
 256   if (mode == gai || mode == gai_canon)
 257     {
 258       struct addrinfo *ai;
 259       struct addrinfo hints =
 260         {
 261           .ai_family = af,
 262           .ai_socktype = SOCK_STREAM,
 263         };
 264       if (mode == gai_canon)
 265         hints.ai_flags |= AI_CANONNAME;
 266       int ret = getaddrinfo (qname, "80", &hints, &ai);
 267       check_addrinfo (label, ai, ret, expected.buffer);
 268       if (ret == 0)
 269         freeaddrinfo (ai);
 270     }
 271   else
 272     {
 273       struct hostent *e;
 274       if (mode == gai)
 275         {
 276           TEST_COMPARE (af, AF_INET);
 277           e = gethostbyname (qname);
 278         }
 279       else
 280         {
 281           if (af != AF_INET)
 282             TEST_COMPARE (af, AF_INET6);
 283           e = gethostbyname2 (qname, af);
 284         }
 285       check_hostent (label, e, expected.buffer);
 286     }
 287
 288   free (expected.buffer);
 289   free (label);
 290   free (qname);
 291 }
 292
 293 /* Perform one check using a reverse lookup.  */
 294
 295 static void
 296 check_reverse (int af, int bits, int count)
 297 {
 298   TEST_VERIFY (af == AF_INET || af == AF_INET6);
 299
 300   char *label = xasprintf ("af=%d bits=%d count=%d", af, bits, count);
 301   char *fqdn = xasprintf ("bits%d.count%d.example", bits, count);
 302
 303   struct xmemstream expected;
 304   xopen_memstream (&expected);
 305   fprintf (expected.out, "name: %s\n", fqdn);
 306   append_addresses (expected.out, af, bits, count, byname);
 307   xfclose_memstream (&expected);
 308
 309   char addr[16] = { 0 };
 310   socklen_t addrlen;
 311   if (af == AF_INET)
 312     {
 313       addr[0] = 192;
 314       addr[1] = 168;
 315       addr[2] = count;
 316       addr[3] = bits;
 317       addrlen = 4;
 318     }
 319   else
 320     {
 321       addr[0] = 0x20;
 322       addr[1] = 0x01;
 323       addr[2] = 0x0d;
 324       addr[3] = 0xb8;
 325       addr[14] = count;
 326       addr[15] = bits;
 327       addrlen = 16;
 328     }
 329
 330   struct hostent *e = gethostbyaddr (addr, addrlen, af);
 331   check_hostent (label, e, expected.buffer);
 332
 333   /* getnameinfo check is different.  There is no generic check_*
 334      function for it.  */
 335   {
 336     struct sockaddr_in sin = { };
 337     struct sockaddr_in6 sin6 = { };
 338     void *sa;
 339     socklen_t salen;
 340     if (af == AF_INET)
 341       {
 342         sin.sin_family = AF_INET;
 343         memcpy (&sin.sin_addr, addr, addrlen);
 344         sin.sin_port = htons (80);
 345         sa = &sin;
 346         salen = sizeof (sin);
 347       }
 348     else
 349       {
 350         sin6.sin6_family = AF_INET6;
 351         memcpy (&sin6.sin6_addr, addr, addrlen);
 352         sin6.sin6_port = htons (80);
 353         sa = &sin6;
 354         salen = sizeof (sin6);
 355       }
 356
 357     char host[64];
 358     char service[64];
 359     int ret = getnameinfo (sa, salen, host,
 360                            sizeof (host), service, sizeof (service),
 361                            NI_NAMEREQD | NI_NUMERICSERV);
 362     TEST_COMPARE (ret, 0);
 363     TEST_COMPARE_STRING (host, fqdn);
 364     TEST_COMPARE_STRING (service, "80");
 365   }
 366
 367   free (expected.buffer);
 368   free (fqdn);
 369   free (label);
 370 }
 371
 372 static int
 373 do_test (void)
 374 {
 375   struct resolv_test *obj = resolv_test_start
 376     ((struct resolv_redirect_config)
 377      {
 378        .response_callback = response
 379      });
 380
 381   for (int count = 0; count <= 3; ++count)
 382     for (int bits = 0; bits <= 1 << (count * 2); ++bits)
 383       {
 384         if (count > 0 && bits == count)
 385           /* The last bits value is only checked if count == 0.  */
 386           continue;
 387
 388         for (enum test_mode mode = 0; mode < test_mode_num; ++mode)
 389           {
 390             check_forward (AF_INET, bits, count, mode);
 391             if (mode != byname)
 392               check_forward (AF_INET6, bits, count, mode);
 393             if (mode == gai || mode == gai_canon)
 394               check_forward (AF_UNSPEC, bits, count, mode);
 395           }
 396
 397         check_reverse (AF_INET, bits, count);
 398         check_reverse (AF_INET6, bits, count);
 399       }
 400
 401   resolv_test_end (obj);
 402
 403   return 0;
 404 }
 405
 406 #include <support/test-driver.c>