src/src/dnsbl.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2018 */
   6 /* Copyright (c) The Exim Maintainers 2020 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8
   9 /* Functions concerned with dnsbls */
  10
  11
  12 #include "exim.h"
  13
  14 /* Structure for caching DNSBL lookups */
  15
  16 typedef struct dnsbl_cache_block {
  17   time_t expiry;
  18   dns_address *rhs;
  19   uschar *text;
  20   int rc;
  21   BOOL text_set;
  22 } dnsbl_cache_block;
  23
  24
  25 /* Anchor for DNSBL cache */
  26
  27 static tree_node *dnsbl_cache = NULL;
  28
  29
  30 /* Bits for match_type in one_check_dnsbl() */
  31
  32 #define MT_NOT 1
  33 #define MT_ALL 2
  34
  35
  36 /*************************************************
  37 *          Perform a single dnsbl lookup         *
  38 *************************************************/
  39
  40 /* This function is called from verify_check_dnsbl() below. It is also called
  41 recursively from within itself when domain and domain_txt are different
  42 pointers, in order to get the TXT record from the alternate domain.
  43
  44 Arguments:
  45   domain         the outer dnsbl domain
  46   domain_txt     alternate domain to lookup TXT record on success; when the
  47                    same domain is to be used, domain_txt == domain (that is,
  48                    the pointers must be identical, not just the text)
  49   keydomain      the current keydomain (for debug message)
  50   prepend        subdomain to lookup (like keydomain, but
  51                    reversed if IP address)
  52   iplist         the list of matching IP addresses, or NULL for "any"
  53   bitmask        true if bitmask matching is wanted
  54   match_type     condition for 'succeed' result
  55                    0 => Any RR in iplist     (=)
  56                    1 => No RR in iplist      (!=)
  57                    2 => All RRs in iplist    (==)
  58                    3 => Some RRs not in iplist (!==)
  59                    the two bits are defined as MT_NOT and MT_ALL
  60   defer_return   what to return for a defer
  61
  62 Returns:         OK if lookup succeeded
  63                  FAIL if not
  64 */
  65
  66 static int
  67 one_check_dnsbl(uschar *domain, uschar *domain_txt, uschar *keydomain,
  68   uschar *prepend, uschar *iplist, BOOL bitmask, int match_type,
  69   int defer_return)
  70 {
  71 dns_answer * dnsa = store_get_dns_answer();
  72 dns_scan dnss;
  73 tree_node *t;
  74 dnsbl_cache_block *cb;
  75 int old_pool = store_pool;
  76 uschar * query;
  77 int qlen, yield;
  78
  79 /* Construct the specific query domainname */
  80
  81 query = string_sprintf("%s.%s", prepend, domain);
  82 if ((qlen = Ustrlen(query)) >= 256)
  83   {
  84   log_write(0, LOG_MAIN|LOG_PANIC, "dnslist query is too long "
  85     "(ignored): %s...", query);
  86   yield = FAIL;
  87   goto out;
  88   }
  89
  90 /* Look for this query in the cache. */
  91
  92 if (  (t = tree_search(dnsbl_cache, query))
  93    && (cb = t->data.ptr)->expiry > time(NULL)
  94    )
  95
  96 /* Previous lookup was cached */
  97
  98   {
  99   HDEBUG(D_dnsbl) debug_printf("dnslists: using result of previous lookup\n");
 100   }
 101
 102 /* If not cached from a previous lookup, we must do a DNS lookup, and
 103 cache the result in permanent memory. */
 104
 105 else
 106   {
 107   uint ttl = 3600;      /* max TTL for positive cache entries */
 108
 109   store_pool = POOL_PERM;
 110
 111   if (t)
 112     {
 113     HDEBUG(D_dnsbl) debug_printf("cached data found but past valid time; ");
 114     }
 115
 116   else
 117     {   /* Set up a tree entry to cache the lookup */
 118     t = store_get(sizeof(tree_node) + qlen + 1 + 1, is_tainted(query));
 119     Ustrcpy(t->name, query);
 120     t->data.ptr = cb = store_get(sizeof(dnsbl_cache_block), FALSE);
 121     (void)tree_insertnode(&dnsbl_cache, t);
 122     }
 123
 124   /* Do the DNS lookup . */
 125
 126   HDEBUG(D_dnsbl) debug_printf("new DNS lookup for %s\n", query);
 127   cb->rc = dns_basic_lookup(dnsa, query, T_A);
 128   cb->text_set = FALSE;
 129   cb->text = NULL;
 130   cb->rhs = NULL;
 131
 132   /* If the lookup succeeded, cache the RHS address. The code allows for
 133   more than one address - this was for complete generality and the possible
 134   use of A6 records. However, A6 records are no longer supported. Leave the code
 135   here, just in case.
 136
 137   Quite apart from one A6 RR generating multiple addresses, there are DNS
 138   lists that return more than one A record, so we must handle multiple
 139   addresses generated in that way as well.
 140
 141   Mark the cache entry with the "now" plus the minimum of the address TTLs,
 142   or the RFC 2308 negative-cache value from the SOA if none were found. */
 143
 144   switch (cb->rc)
 145     {
 146     case DNS_SUCCEED:
 147       {
 148       dns_address ** addrp = &cb->rhs;
 149       dns_address * da;
 150       for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
 151            rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
 152         if (rr->type == T_A && (da = dns_address_from_rr(dnsa, rr)))
 153           {
 154           *addrp = da;
 155           while (da->next) da = da->next;
 156           addrp = &da->next;
 157           if (ttl > rr->ttl) ttl = rr->ttl;
 158           }
 159
 160       if (cb->rhs)
 161         {
 162         cb->expiry = time(NULL) + ttl;
 163         break;
 164         }
 165
 166       /* If we didn't find any A records, change the return code. This can
 167       happen when there is a CNAME record but there are no A records for what
 168       it points to. */
 169
 170       cb->rc = DNS_NODATA;
 171       }
 172       /*FALLTHROUGH*/
 173
 174     case DNS_NOMATCH:
 175     case DNS_NODATA:
 176       {
 177       /* Although there already is a neg-cache layer maintained by
 178       dns_basic_lookup(), we have a dnslist cache entry allocated and
 179       tree-inserted. So we may as well use it. */
 180
 181       time_t soa_negttl = dns_expire_from_soa(dnsa, T_A);
 182       cb->expiry = soa_negttl ? soa_negttl : time(NULL) + ttl;
 183       break;
 184       }
 185
 186     default:
 187       cb->expiry = time(NULL) + ttl;
 188       break;
 189     }
 190
 191   store_pool = old_pool;
 192   HDEBUG(D_dnsbl) debug_printf("dnslists: wrote cache entry, ttl=%d\n",
 193     (int)(cb->expiry - time(NULL)));
 194   }
 195
 196 /* We now have the result of the DNS lookup, either newly done, or cached
 197 from a previous call. If the lookup succeeded, check against the address
 198 list if there is one. This may be a positive equality list (introduced by
 199 "="), a negative equality list (introduced by "!="), a positive bitmask
 200 list (introduced by "&"), or a negative bitmask list (introduced by "!&").*/
 201
 202 if (cb->rc == DNS_SUCCEED)
 203   {
 204   dns_address * da = NULL;
 205   uschar *addlist = cb->rhs->address;
 206
 207   /* For A and AAAA records, there may be multiple addresses from multiple
 208   records. For A6 records (currently not expected to be used) there may be
 209   multiple addresses from a single record. */
 210
 211   for (da = cb->rhs->next; da; da = da->next)
 212     addlist = string_sprintf("%s, %s", addlist, da->address);
 213
 214   HDEBUG(D_dnsbl) debug_printf("DNS lookup for %s succeeded (yielding %s)\n",
 215     query, addlist);
 216
 217   /* Address list check; this can be either for equality, or via a bitmask.
 218   In the latter case, all the bits must match. */
 219
 220   if (iplist)
 221     {
 222     for (da = cb->rhs; da; da = da->next)
 223       {
 224       int ipsep = ',';
 225       const uschar *ptr = iplist;
 226       uschar *res;
 227
 228       /* Handle exact matching */
 229
 230       if (!bitmask)
 231         {
 232         while ((res = string_nextinlist(&ptr, &ipsep, NULL, 0)))
 233           if (Ustrcmp(CS da->address, res) == 0)
 234             break;
 235         }
 236
 237       /* Handle bitmask matching */
 238
 239       else
 240         {
 241         int address[4];
 242         int mask = 0;
 243
 244         /* At present, all known DNS blocking lists use A records, with
 245         IPv4 addresses on the RHS encoding the information they return. I
 246         wonder if this will linger on as the last vestige of IPv4 when IPv6
 247         is ubiquitous? Anyway, for now we use paranoia code to completely
 248         ignore IPv6 addresses. The default mask is 0, which always matches.
 249         We change this only for IPv4 addresses in the list. */
 250
 251         if (host_aton(da->address, address) == 1)
 252           if ((address[0] & 0xff000000) != 0x7f000000)    /* 127.0.0.0/8 */
 253             log_write(0, LOG_MAIN,
 254               "DNS list lookup for %s at %s returned %s;"
 255               " not in 127.0/8 and discarded",
 256               keydomain, domain, da->address);
 257
 258           else
 259             mask = address[0];
 260
 261         /* Scan the returned addresses, skipping any that are IPv6 */
 262
 263         while ((res = string_nextinlist(&ptr, &ipsep, NULL, 0)))
 264           if (host_aton(res, address) == 1)
 265             if ((address[0] & mask) == address[0])
 266               break;
 267         }
 268
 269       /* If either
 270
 271          (a) An IP address in an any ('=') list matched, or
 272          (b) No IP address in an all ('==') list matched
 273
 274       then we're done searching. */
 275
 276       if (((match_type & MT_ALL) != 0) == (res == NULL)) break;
 277       }
 278
 279     /* If da == NULL, either
 280
 281        (a) No IP address in an any ('=') list matched, or
 282        (b) An IP address in an all ('==') list didn't match
 283
 284     so behave as if the DNSBL lookup had not succeeded, i.e. the host is not on
 285     the list. */
 286
 287     if ((match_type == MT_NOT || match_type == MT_ALL) != (da == NULL))
 288       {
 289       HDEBUG(D_dnsbl)
 290         {
 291         uschar *res = NULL;
 292         switch(match_type)
 293           {
 294           case 0:
 295             res = US"was no match"; break;
 296           case MT_NOT:
 297             res = US"was an exclude match"; break;
 298           case MT_ALL:
 299             res = US"was an IP address that did not match"; break;
 300           case MT_NOT|MT_ALL:
 301             res = US"were no IP addresses that did not match"; break;
 302           }
 303         debug_printf("=> but we are not accepting this block class because\n");
 304         debug_printf("=> there %s for %s%c%s\n",
 305           res,
 306           match_type & MT_ALL ? "=" : "",
 307           bitmask ? '&' : '=', iplist);
 308         }
 309       yield = FAIL;
 310       goto out;
 311       }
 312     }
 313
 314   /* No address list check; discard any illegal returns and give up if
 315   none remain. */
 316
 317   else
 318     {
 319     BOOL ok = FALSE;
 320     for (da = cb->rhs; da; da = da->next)
 321       {
 322       int address[4];
 323
 324       if (  host_aton(da->address, address) == 1                /* ipv4 */
 325          && (address[0] & 0xff000000) == 0x7f000000     /* 127.0.0.0/8 */
 326          )
 327         ok = TRUE;
 328       else
 329         log_write(0, LOG_MAIN,
 330             "DNS list lookup for %s at %s returned %s;"
 331             " not in 127.0/8 and discarded",
 332             keydomain, domain, da->address);
 333       }
 334     if (!ok)
 335       {
 336       yield = FAIL;
 337       goto out;
 338       }
 339     }
 340
 341   /* Either there was no IP list, or the record matched, implying that the
 342   domain is on the list. We now want to find a corresponding TXT record. If an
 343   alternate domain is specified for the TXT record, call this function
 344   recursively to look that up; this has the side effect of re-checking that
 345   there is indeed an A record at the alternate domain. */
 346
 347   if (domain_txt != domain)
 348     {
 349     yield = one_check_dnsbl(domain_txt, domain_txt, keydomain, prepend, NULL,
 350       FALSE, match_type, defer_return);
 351     goto out;
 352     }
 353
 354   /* If there is no alternate domain, look up a TXT record in the main domain
 355   if it has not previously been cached. */
 356
 357   if (!cb->text_set)
 358     {
 359     cb->text_set = TRUE;
 360     if (dns_basic_lookup(dnsa, query, T_TXT) == DNS_SUCCEED)
 361       for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
 362            rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
 363         if (rr->type == T_TXT)
 364           {
 365           int len = (rr->data)[0];
 366           if (len > 511) len = 127;
 367           store_pool = POOL_PERM;
 368           cb->text = string_copyn_taint(CUS (rr->data+1), len, TRUE);
 369           store_pool = old_pool;
 370           break;
 371           }
 372     }
 373
 374   dnslist_value = addlist;
 375   dnslist_text = cb->text;
 376   yield = OK;
 377   goto out;
 378   }
 379
 380 /* There was a problem with the DNS lookup */
 381
 382 if (cb->rc != DNS_NOMATCH && cb->rc != DNS_NODATA)
 383   {
 384   log_write(L_dnslist_defer, LOG_MAIN,
 385     "DNS list lookup defer (probably timeout) for %s: %s", query,
 386     defer_return == OK ?   US"assumed in list" :
 387     defer_return == FAIL ? US"assumed not in list" :
 388                             US"returned DEFER");
 389   yield = defer_return;
 390   goto out;
 391   }
 392
 393 /* No entry was found in the DNS; continue for next domain */
 394
 395 HDEBUG(D_dnsbl)
 396   {
 397   debug_printf("DNS lookup for %s failed\n", query);
 398   debug_printf("=> that means %s is not listed at %s\n",
 399      keydomain, domain);
 400   }
 401
 402 yield = FAIL;
 403
 404 out:
 405
 406 store_free_dns_answer(dnsa);
 407 return yield;
 408 }
 409
 410
 411
 412
 413 /*************************************************
 414 *        Check host against DNS black lists      *
 415 *************************************************/
 416
 417 /* This function runs checks against a list of DNS black lists, until one
 418 matches. Each item on the list can be of the form
 419
 420   domain=ip-address/key
 421
 422 The domain is the right-most domain that is used for the query, for example,
 423 blackholes.mail-abuse.org. If the IP address is present, there is a match only
 424 if the DNS lookup returns a matching IP address. Several addresses may be
 425 given, comma-separated, for example: x.y.z=127.0.0.1,127.0.0.2.
 426
 427 If no key is given, what is looked up in the domain is the inverted IP address
 428 of the current client host. If a key is given, it is used to construct the
 429 domain for the lookup. For example:
 430
 431   dsn.rfc-ignorant.org/$sender_address_domain
 432
 433 After finding a match in the DNS, the domain is placed in $dnslist_domain, and
 434 then we check for a TXT record for an error message, and if found, save its
 435 value in $dnslist_text. We also cache everything in a tree, to optimize
 436 multiple lookups.
 437
 438 The TXT record is normally looked up in the same domain as the A record, but
 439 when many lists are combined in a single DNS domain, this will not be a very
 440 specific message. It is possible to specify a different domain for looking up
 441 TXT records; this is given before the main domain, comma-separated. For
 442 example:
 443
 444   dnslists = http.dnsbl.sorbs.net,dnsbl.sorbs.net=127.0.0.2 : \
 445              socks.dnsbl.sorbs.net,dnsbl.sorbs.net=127.0.0.3
 446
 447 The caching ensures that only one lookup in dnsbl.sorbs.net is done.
 448
 449 Note: an address for testing RBL is 192.203.178.39
 450 Note: an address for testing DUL is 192.203.178.4
 451 Note: a domain for testing RFCI is example.tld.dsn.rfc-ignorant.org
 452
 453 Arguments:
 454   where        the acl type
 455   listptr      the domain/address/data list
 456   log_msgptr   log message on error
 457
 458 Returns:    OK      successful lookup (i.e. the address is on the list), or
 459                       lookup deferred after +include_unknown
 460             FAIL    name not found, or no data found for the given type, or
 461                       lookup deferred after +exclude_unknown (default)
 462             DEFER   lookup failure, if +defer_unknown was set
 463 */
 464
 465 int
 466 verify_check_dnsbl(int where, const uschar ** listptr, uschar ** log_msgptr)
 467 {
 468 int sep = 0;
 469 int defer_return = FAIL;
 470 const uschar *list = *listptr;
 471 uschar *domain;
 472 uschar revadd[128];        /* Long enough for IPv6 address */
 473
 474 /* Indicate that the inverted IP address is not yet set up */
 475
 476 revadd[0] = 0;
 477
 478 /* In case this is the first time the DNS resolver is being used. */
 479
 480 dns_init(FALSE, FALSE, FALSE);  /*XXX dnssec? */
 481
 482 /* Loop through all the domains supplied, until something matches */
 483
 484 while ((domain = string_nextinlist(&list, &sep, NULL, 0)))
 485   {
 486   int rc;
 487   BOOL bitmask = FALSE;
 488   int match_type = 0;
 489   uschar *domain_txt;
 490   uschar *comma;
 491   uschar *iplist;
 492   uschar *key;
 493
 494   HDEBUG(D_dnsbl) debug_printf("dnslists check: %s\n", domain);
 495
 496   /* Deal with special values that change the behaviour on defer */
 497
 498   if (domain[0] == '+')
 499     {
 500     if      (strcmpic(domain, US"+include_unknown") == 0) defer_return = OK;
 501     else if (strcmpic(domain, US"+exclude_unknown") == 0) defer_return = FAIL;
 502     else if (strcmpic(domain, US"+defer_unknown") == 0)   defer_return = DEFER;
 503     else
 504       log_write(0, LOG_MAIN|LOG_PANIC, "unknown item in dnslist (ignored): %s",
 505         domain);
 506     continue;
 507     }
 508
 509   /* See if there's explicit data to be looked up */
 510
 511   if ((key = Ustrchr(domain, '/'))) *key++ = 0;
 512
 513   /* See if there's a list of addresses supplied after the domain name. This is
 514   introduced by an = or a & character; if preceded by = we require all matches
 515   and if preceded by ! we invert the result. */
 516
 517   if (!(iplist = Ustrchr(domain, '=')))
 518     {
 519     bitmask = TRUE;
 520     iplist = Ustrchr(domain, '&');
 521     }
 522
 523   if (iplist)                                  /* Found either = or & */
 524     {
 525     if (iplist > domain && iplist[-1] == '!')  /* Handle preceding ! */
 526       {
 527       match_type |= MT_NOT;
 528       iplist[-1] = 0;
 529       }
 530
 531     *iplist++ = 0;                             /* Terminate domain, move on */
 532
 533     /* If we found = (bitmask == FALSE), check for == or =& */
 534
 535     if (!bitmask && (*iplist == '=' || *iplist == '&'))
 536       {
 537       bitmask = *iplist++ == '&';
 538       match_type |= MT_ALL;
 539       }
 540     }
 541
 542
 543   /* If there is a comma in the domain, it indicates that a second domain for
 544   looking up TXT records is provided, before the main domain. Otherwise we must
 545   set domain_txt == domain. */
 546
 547   domain_txt = domain;
 548   if ((comma = Ustrchr(domain, ',')))
 549     {
 550     *comma++ = 0;
 551     domain = comma;
 552     }
 553
 554   /* Check that what we have left is a sensible domain name. There is no reason
 555   why these domains should in fact use the same syntax as hosts and email
 556   domains, but in practice they seem to. However, there is little point in
 557   actually causing an error here, because that would no doubt hold up incoming
 558   mail. Instead, I'll just log it. */
 559
 560   for (uschar * s = domain; *s; s++)
 561     if (!isalnum(*s) && *s != '-' && *s != '.' && *s != '_')
 562       {
 563       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
 564         "strange characters - is this right?", domain);
 565       break;
 566       }
 567
 568   /* Check the alternate domain if present */
 569
 570   if (domain_txt != domain) for (uschar * s = domain_txt; *s; s++)
 571     if (!isalnum(*s) && *s != '-' && *s != '.' && *s != '_')
 572       {
 573       log_write(0, LOG_MAIN, "dnslists domain \"%s\" contains "
 574         "strange characters - is this right?", domain_txt);
 575       break;
 576       }
 577
 578   /* If there is no key string, construct the query by adding the domain name
 579   onto the inverted host address, and perform a single DNS lookup. */
 580
 581   if (!key)
 582     {
 583     if (where == ACL_WHERE_NOTSMTP_START || where == ACL_WHERE_NOTSMTP)
 584       {
 585       *log_msgptr = string_sprintf
 586         ("cannot test auto-keyed dnslists condition in %s ACL",
 587           acl_wherenames[where]);
 588       return ERROR;
 589       }
 590     if (!sender_host_address) return FAIL;    /* can never match */
 591     if (revadd[0] == 0) invert_address(revadd, sender_host_address);
 592     rc = one_check_dnsbl(domain, domain_txt, sender_host_address, revadd,
 593       iplist, bitmask, match_type, defer_return);
 594     if (rc == OK)
 595       {
 596       dnslist_domain = string_copy(domain_txt);
 597       dnslist_matched = string_copy(sender_host_address);
 598       HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n",
 599         sender_host_address, dnslist_domain);
 600       }
 601     if (rc != FAIL) return rc;     /* OK or DEFER */
 602     }
 603
 604   /* If there is a key string, it can be a list of domains or IP addresses to
 605   be concatenated with the main domain. */
 606
 607   else
 608     {
 609     int keysep = 0;
 610     BOOL defer = FALSE;
 611     uschar *keydomain;
 612     uschar keyrevadd[128];
 613
 614     while ((keydomain = string_nextinlist(CUSS &key, &keysep, NULL, 0)))
 615       {
 616       uschar *prepend = keydomain;
 617
 618       if (string_is_ip_address(keydomain, NULL) != 0)
 619         {
 620         invert_address(keyrevadd, keydomain);
 621         prepend = keyrevadd;
 622         }
 623
 624       rc = one_check_dnsbl(domain, domain_txt, keydomain, prepend, iplist,
 625         bitmask, match_type, defer_return);
 626       if (rc == OK)
 627         {
 628         dnslist_domain = string_copy(domain_txt);
 629         dnslist_matched = string_copy(keydomain);
 630         HDEBUG(D_dnsbl) debug_printf("=> that means %s is listed at %s\n",
 631           keydomain, dnslist_domain);
 632         return OK;
 633         }
 634
 635       /* If the lookup deferred, remember this fact. We keep trying the rest
 636       of the list to see if we get a useful result, and if we don't, we return
 637       DEFER at the end. */
 638
 639       if (rc == DEFER) defer = TRUE;
 640       }    /* continue with next keystring domain/address */
 641
 642     if (defer) return DEFER;
 643     }
 644   }        /* continue with next dnsdb outer domain */
 645
 646 return FAIL;
 647 }
 648
 649 /* vi: aw ai sw=2
 650 */
 651 /* End of dnsbl.c.c */