src/src/dkim.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge, 1995 - 2018 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Code for DKIM support. Other DKIM relevant code is in
   9    receive.c, transport.c and transports/smtp.c */
  10
  11 #include "exim.h"
  12
  13 #ifndef DISABLE_DKIM
  14
  15 # include "pdkim/pdkim.h"
  16
  17 # ifdef MACRO_PREDEF
  18 #  include "macro_predef.h"
  19
  20 void
  21 params_dkim(void)
  22 {
  23 builtin_macro_create_var(US"_DKIM_SIGN_HEADERS", US PDKIM_DEFAULT_SIGN_HEADERS);
  24 builtin_macro_create_var(US"_DKIM_OVERSIGN_HEADERS", US PDKIM_OVERSIGN_HEADERS);
  25 }
  26 # else  /*!MACRO_PREDEF*/
  27
  28
  29
  30 pdkim_ctx dkim_sign_ctx;
  31
  32 int dkim_verify_oldpool;
  33 pdkim_ctx *dkim_verify_ctx = NULL;
  34 pdkim_signature *dkim_cur_sig = NULL;
  35 static const uschar * dkim_collect_error = NULL;
  36
  37 #define DKIM_MAX_SIGNATURES 20
  38
  39
  40
  41 /* Look up the DKIM record in DNS for the given hostname.
  42 Will use the first found if there are multiple.
  43 The return string is tainted, having come from off-site.
  44 */
  45
  46 uschar *
  47 dkim_exim_query_dns_txt(const uschar * name)
  48 {
  49 dns_answer * dnsa = store_get_dns_answer();
  50 dns_scan dnss;
  51 rmark reset_point = store_mark();
  52 gstring * g = NULL;
  53
  54 lookup_dnssec_authenticated = NULL;
  55 if (dns_lookup(dnsa, name, T_TXT, NULL) != DNS_SUCCEED)
  56   return NULL;  /*XXX better error detail?  logging? */
  57
  58 /* Search for TXT record */
  59
  60 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
  61      rr;
  62      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
  63   if (rr->type == T_TXT)
  64     {
  65     int rr_offset = 0;
  66
  67     /* Copy record content to the answer buffer */
  68
  69     while (rr_offset < rr->size)
  70       {
  71       uschar len = rr->data[rr_offset++];
  72
  73       g = string_catn(g, US(rr->data + rr_offset), len);
  74       if (g->ptr >= PDKIM_DNS_TXT_MAX_RECLEN)
  75         goto bad;
  76
  77       rr_offset += len;
  78       }
  79
  80     /* check if this looks like a DKIM record */
  81     if (Ustrncmp(g->s, "v=", 2) != 0 || strncasecmp(CS g->s, "v=dkim", 6) == 0)
  82       {
  83       gstring_release_unused(g);
  84       return string_from_gstring(g);
  85       }
  86
  87     if (g) g->ptr = 0;          /* overwrite previous record */
  88     }
  89
  90 bad:
  91 store_reset(reset_point);
  92 return NULL;    /*XXX better error detail?  logging? */
  93 }
  94
  95
  96 void
  97 dkim_exim_init(void)
  98 {
  99 if (f.dkim_init_done) return;
 100 f.dkim_init_done = TRUE;
 101 pdkim_init();
 102 }
 103
 104
 105
 106 void
 107 dkim_exim_verify_init(BOOL dot_stuffing)
 108 {
 109 dkim_exim_init();
 110
 111 /* There is a store-reset between header & body reception
 112 so cannot use the main pool. Any allocs done by Exim
 113 memory-handling must use the perm pool. */
 114
 115 dkim_verify_oldpool = store_pool;
 116 store_pool = POOL_PERM;
 117
 118 /* Free previous context if there is one */
 119
 120 if (dkim_verify_ctx)
 121   pdkim_free_ctx(dkim_verify_ctx);
 122
 123 /* Create new context */
 124
 125 dkim_verify_ctx = pdkim_init_verify(&dkim_exim_query_dns_txt, dot_stuffing);
 126 dkim_collect_input = dkim_verify_ctx ? DKIM_MAX_SIGNATURES : 0;
 127 dkim_collect_error = NULL;
 128
 129 /* Start feed up with any cached data */
 130 receive_get_cache();
 131
 132 store_pool = dkim_verify_oldpool;
 133 }
 134
 135
 136 void
 137 dkim_exim_verify_feed(uschar * data, int len)
 138 {
 139 int rc;
 140
 141 store_pool = POOL_PERM;
 142 if (  dkim_collect_input
 143    && (rc = pdkim_feed(dkim_verify_ctx, data, len)) != PDKIM_OK)
 144   {
 145   dkim_collect_error = pdkim_errstr(rc);
 146   log_write(0, LOG_MAIN,
 147              "DKIM: validation error: %.100s", dkim_collect_error);
 148   dkim_collect_input = 0;
 149   }
 150 store_pool = dkim_verify_oldpool;
 151 }
 152
 153
 154 /* Log the result for the given signature */
 155 static void
 156 dkim_exim_verify_log_sig(pdkim_signature * sig)
 157 {
 158 gstring * logmsg;
 159 uschar * s;
 160
 161 if (!sig) return;
 162
 163 /* Remember the domain for the first pass result */
 164
 165 if (  !dkim_verify_overall
 166    && dkim_verify_status
 167       ? Ustrcmp(dkim_verify_status, US"pass") == 0
 168       : sig->verify_status == PDKIM_VERIFY_PASS
 169    )
 170   dkim_verify_overall = string_copy(sig->domain);
 171
 172 /* Rewrite the sig result if the ACL overrode it.  This is only
 173 needed because the DMARC code (sigh) peeks at the dkim sigs.
 174 Mark the sig for this having been done. */
 175
 176 if (  dkim_verify_status
 177    && (  dkim_verify_status != dkim_exim_expand_query(DKIM_VERIFY_STATUS)
 178       || dkim_verify_reason != dkim_exim_expand_query(DKIM_VERIFY_REASON)
 179    )  )
 180   {                     /* overridden by ACL */
 181   sig->verify_ext_status = -1;
 182   if (Ustrcmp(dkim_verify_status, US"fail") == 0)
 183     sig->verify_status = PDKIM_VERIFY_POLICY | PDKIM_VERIFY_FAIL;
 184   else if (Ustrcmp(dkim_verify_status, US"invalid") == 0)
 185     sig->verify_status = PDKIM_VERIFY_POLICY | PDKIM_VERIFY_INVALID;
 186   else if (Ustrcmp(dkim_verify_status, US"none") == 0)
 187     sig->verify_status = PDKIM_VERIFY_POLICY | PDKIM_VERIFY_NONE;
 188   else if (Ustrcmp(dkim_verify_status, US"pass") == 0)
 189     sig->verify_status = PDKIM_VERIFY_POLICY | PDKIM_VERIFY_PASS;
 190   else
 191     sig->verify_status = -1;
 192   }
 193
 194 if (!LOGGING(dkim_verbose)) return;
 195
 196
 197 logmsg = string_catn(NULL, US"DKIM: ", 6);
 198 if (!(s = sig->domain)) s = US"<UNSET>";
 199 logmsg = string_append(logmsg, 2, "d=", s);
 200 if (!(s = sig->selector)) s = US"<UNSET>";
 201 logmsg = string_append(logmsg, 2, " s=", s);
 202 logmsg = string_fmt_append(logmsg, " c=%s/%s a=%s b=" SIZE_T_FMT,
 203           sig->canon_headers == PDKIM_CANON_SIMPLE ? "simple" : "relaxed",
 204           sig->canon_body    == PDKIM_CANON_SIMPLE ? "simple" : "relaxed",
 205           dkim_sig_to_a_tag(sig),
 206           (int)sig->sighash.len > -1 ? sig->sighash.len * 8 : (size_t)0);
 207 if ((s= sig->identity)) logmsg = string_append(logmsg, 2, " i=", s);
 208 if (sig->created > 0) logmsg = string_fmt_append(logmsg, " t=%lu",
 209                                     sig->created);
 210 if (sig->expires > 0) logmsg = string_fmt_append(logmsg, " x=%lu",
 211                                     sig->expires);
 212 if (sig->bodylength > -1) logmsg = string_fmt_append(logmsg, " l=%lu",
 213                                     sig->bodylength);
 214
 215 if (sig->verify_status & PDKIM_VERIFY_POLICY)
 216   logmsg = string_append(logmsg, 5,
 217             US" [", dkim_verify_status, US" - ", dkim_verify_reason, US"]");
 218 else
 219   switch (sig->verify_status)
 220     {
 221     case PDKIM_VERIFY_NONE:
 222       logmsg = string_cat(logmsg, US" [not verified]");
 223       break;
 224
 225     case PDKIM_VERIFY_INVALID:
 226       logmsg = string_cat(logmsg, US" [invalid - ");
 227       switch (sig->verify_ext_status)
 228         {
 229         case PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE:
 230           logmsg = string_cat(logmsg,
 231                         US"public key record (currently?) unavailable]");
 232           break;
 233
 234         case PDKIM_VERIFY_INVALID_BUFFER_SIZE:
 235           logmsg = string_cat(logmsg, US"overlong public key record]");
 236           break;
 237
 238         case PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD:
 239         case PDKIM_VERIFY_INVALID_PUBKEY_IMPORT:
 240           logmsg = string_cat(logmsg, US"syntax error in public key record]");
 241           break;
 242
 243         case PDKIM_VERIFY_INVALID_SIGNATURE_ERROR:
 244           logmsg = string_cat(logmsg, US"signature tag missing or invalid]");
 245           break;
 246
 247         case PDKIM_VERIFY_INVALID_DKIM_VERSION:
 248           logmsg = string_cat(logmsg, US"unsupported DKIM version]");
 249           break;
 250
 251         default:
 252           logmsg = string_cat(logmsg, US"unspecified problem]");
 253         }
 254       break;
 255
 256     case PDKIM_VERIFY_FAIL:
 257       logmsg = string_cat(logmsg, US" [verification failed - ");
 258       switch (sig->verify_ext_status)
 259         {
 260         case PDKIM_VERIFY_FAIL_BODY:
 261           logmsg = string_cat(logmsg,
 262                US"body hash mismatch (body probably modified in transit)]");
 263           break;
 264
 265         case PDKIM_VERIFY_FAIL_MESSAGE:
 266           logmsg = string_cat(logmsg,
 267                 US"signature did not verify "
 268                 "(headers probably modified in transit)]");
 269           break;
 270
 271         case PDKIM_VERIFY_INVALID_PUBKEY_KEYSIZE:
 272           logmsg = string_cat(logmsg,
 273                 US"signature invalid (key too short)]");
 274           break;
 275
 276         default:
 277           logmsg = string_cat(logmsg, US"unspecified reason]");
 278         }
 279       break;
 280
 281     case PDKIM_VERIFY_PASS:
 282       logmsg = string_cat(logmsg, US" [verification succeeded]");
 283       break;
 284     }
 285
 286 log_write(0, LOG_MAIN, "%s", string_from_gstring(logmsg));
 287 return;
 288 }
 289
 290
 291 /* Log a line for each signature */
 292 void
 293 dkim_exim_verify_log_all(void)
 294 {
 295 for (pdkim_signature * sig = dkim_signatures; sig; sig = sig->next)
 296   dkim_exim_verify_log_sig(sig);
 297 }
 298
 299
 300 void
 301 dkim_exim_verify_finish(void)
 302 {
 303 int rc;
 304 gstring * g = NULL;
 305 const uschar * errstr = NULL;
 306
 307 store_pool = POOL_PERM;
 308
 309 /* Delete eventual previous signature chain */
 310
 311 dkim_signers = NULL;
 312 dkim_signatures = NULL;
 313
 314 if (dkim_collect_error)
 315   {
 316   log_write(0, LOG_MAIN,
 317       "DKIM: Error during validation, disabling signature verification: %.100s",
 318       dkim_collect_error);
 319   f.dkim_disable_verify = TRUE;
 320   goto out;
 321   }
 322
 323 dkim_collect_input = 0;
 324
 325 /* Finish DKIM operation and fetch link to signatures chain */
 326
 327 rc = pdkim_feed_finish(dkim_verify_ctx, (pdkim_signature **)&dkim_signatures,
 328                         &errstr);
 329 if (rc != PDKIM_OK && errstr)
 330   log_write(0, LOG_MAIN, "DKIM: validation error: %s", errstr);
 331
 332 /* Build a colon-separated list of signing domains (and identities, if present) in dkim_signers */
 333
 334 for (pdkim_signature * sig = dkim_signatures; sig; sig = sig->next)
 335   {
 336   if (sig->domain)   g = string_append_listele(g, ':', sig->domain);
 337   if (sig->identity) g = string_append_listele(g, ':', sig->identity);
 338   }
 339
 340 if (g) dkim_signers = g->s;
 341
 342 out:
 343 store_pool = dkim_verify_oldpool;
 344 }
 345
 346
 347
 348 /* Args as per dkim_exim_acl_run() below */
 349 static int
 350 dkim_acl_call(uschar * id, gstring ** res_ptr,
 351   uschar ** user_msgptr, uschar ** log_msgptr)
 352 {
 353 int rc;
 354 DEBUG(D_receive)
 355   debug_printf("calling acl_smtp_dkim for dkim_cur_signer='%s'\n", id);
 356
 357 rc = acl_check(ACL_WHERE_DKIM, NULL, acl_smtp_dkim, user_msgptr, log_msgptr);
 358 dkim_exim_verify_log_sig(dkim_cur_sig);
 359 *res_ptr = string_append_listele(*res_ptr, ':', dkim_verify_status);
 360 return rc;
 361 }
 362
 363
 364
 365 /* For the given identity, run the DKIM ACL once for each matching signature.
 366
 367 Arguments
 368  id             Identity to look for in dkim signatures
 369  res_ptr        ptr to growable string-list of status results,
 370                 appended to per ACL run
 371  user_msgptr    where to put a user error (for SMTP response)
 372  log_msgptr     where to put a logging message (not for SMTP response)
 373
 374 Returns:       OK         access is granted by an ACCEPT verb
 375                DISCARD    access is granted by a DISCARD verb
 376                FAIL       access is denied
 377                FAIL_DROP  access is denied; drop the connection
 378                DEFER      can't tell at the moment
 379                ERROR      disaster
 380 */
 381
 382 int
 383 dkim_exim_acl_run(uschar * id, gstring ** res_ptr,
 384   uschar ** user_msgptr, uschar ** log_msgptr)
 385 {
 386 uschar * cmp_val;
 387 int rc = -1;
 388
 389 dkim_verify_status = US"none";
 390 dkim_verify_reason = US"";
 391 dkim_cur_signer = id;
 392
 393 if (f.dkim_disable_verify || !id || !dkim_verify_ctx)
 394   return OK;
 395
 396 /* Find signatures to run ACL on */
 397
 398 for (pdkim_signature * sig = dkim_signatures; sig; sig = sig->next)
 399   if (  (cmp_val = Ustrchr(id, '@') != NULL ? US sig->identity : US sig->domain)
 400      && strcmpic(cmp_val, id) == 0
 401      )
 402     {
 403     /* The "dkim_domain" and "dkim_selector" expansion variables have
 404     related globals, since they are used in the signing code too.
 405     Instead of inventing separate names for verification, we set
 406     them here. This is easy since a domain and selector is guaranteed
 407     to be in a signature. The other dkim_* expansion items are
 408     dynamically fetched from dkim_cur_sig at expansion time (see
 409     dkim_exim_expand_query() below). */
 410
 411     dkim_cur_sig = sig;
 412     dkim_signing_domain = US sig->domain;
 413     dkim_signing_selector = US sig->selector;
 414     dkim_key_length = sig->keybits;
 415
 416     /* These two return static strings, so we can compare the addr
 417     later to see if the ACL overwrote them.  Check that when logging */
 418
 419     dkim_verify_status = dkim_exim_expand_query(DKIM_VERIFY_STATUS);
 420     dkim_verify_reason = dkim_exim_expand_query(DKIM_VERIFY_REASON);
 421
 422     if ((rc = dkim_acl_call(id, res_ptr, user_msgptr, log_msgptr)) != OK)
 423       return rc;
 424     }
 425
 426 if (rc != -1)
 427   return rc;
 428
 429 /* No matching sig found.  Call ACL once anyway. */
 430
 431 dkim_cur_sig = NULL;
 432 return dkim_acl_call(id, res_ptr, user_msgptr, log_msgptr);
 433 }
 434
 435
 436 static uschar *
 437 dkim_exim_expand_defaults(int what)
 438 {
 439 switch (what)
 440   {
 441   case DKIM_ALGO:               return US"";
 442   case DKIM_BODYLENGTH:         return US"9999999999999";
 443   case DKIM_CANON_BODY:         return US"";
 444   case DKIM_CANON_HEADERS:      return US"";
 445   case DKIM_COPIEDHEADERS:      return US"";
 446   case DKIM_CREATED:            return US"0";
 447   case DKIM_EXPIRES:            return US"9999999999999";
 448   case DKIM_HEADERNAMES:        return US"";
 449   case DKIM_IDENTITY:           return US"";
 450   case DKIM_KEY_GRANULARITY:    return US"*";
 451   case DKIM_KEY_SRVTYPE:        return US"*";
 452   case DKIM_KEY_NOTES:          return US"";
 453   case DKIM_KEY_TESTING:        return US"0";
 454   case DKIM_NOSUBDOMAINS:       return US"0";
 455   case DKIM_VERIFY_STATUS:      return US"none";
 456   case DKIM_VERIFY_REASON:      return US"";
 457   default:                      return US"";
 458   }
 459 }
 460
 461
 462 uschar *
 463 dkim_exim_expand_query(int what)
 464 {
 465 if (!dkim_verify_ctx || f.dkim_disable_verify || !dkim_cur_sig)
 466   return dkim_exim_expand_defaults(what);
 467
 468 switch (what)
 469   {
 470   case DKIM_ALGO:
 471     return dkim_sig_to_a_tag(dkim_cur_sig);
 472
 473   case DKIM_BODYLENGTH:
 474     return dkim_cur_sig->bodylength >= 0
 475       ? string_sprintf("%ld", dkim_cur_sig->bodylength)
 476       : dkim_exim_expand_defaults(what);
 477
 478   case DKIM_CANON_BODY:
 479     switch (dkim_cur_sig->canon_body)
 480       {
 481       case PDKIM_CANON_RELAXED: return US"relaxed";
 482       case PDKIM_CANON_SIMPLE:
 483       default:                  return US"simple";
 484       }
 485
 486   case DKIM_CANON_HEADERS:
 487     switch (dkim_cur_sig->canon_headers)
 488       {
 489       case PDKIM_CANON_RELAXED: return US"relaxed";
 490       case PDKIM_CANON_SIMPLE:
 491       default:                  return US"simple";
 492       }
 493
 494   case DKIM_COPIEDHEADERS:
 495     return dkim_cur_sig->copiedheaders
 496       ? US dkim_cur_sig->copiedheaders : dkim_exim_expand_defaults(what);
 497
 498   case DKIM_CREATED:
 499     return dkim_cur_sig->created > 0
 500       ? string_sprintf("%lu", dkim_cur_sig->created)
 501       : dkim_exim_expand_defaults(what);
 502
 503   case DKIM_EXPIRES:
 504     return dkim_cur_sig->expires > 0
 505       ? string_sprintf("%lu", dkim_cur_sig->expires)
 506       : dkim_exim_expand_defaults(what);
 507
 508   case DKIM_HEADERNAMES:
 509     return dkim_cur_sig->headernames
 510       ? dkim_cur_sig->headernames : dkim_exim_expand_defaults(what);
 511
 512   case DKIM_IDENTITY:
 513     return dkim_cur_sig->identity
 514       ? US dkim_cur_sig->identity : dkim_exim_expand_defaults(what);
 515
 516   case DKIM_KEY_GRANULARITY:
 517     return dkim_cur_sig->pubkey
 518       ? dkim_cur_sig->pubkey->granularity
 519       ? US dkim_cur_sig->pubkey->granularity
 520       : dkim_exim_expand_defaults(what)
 521       : dkim_exim_expand_defaults(what);
 522
 523   case DKIM_KEY_SRVTYPE:
 524     return dkim_cur_sig->pubkey
 525       ? dkim_cur_sig->pubkey->srvtype
 526       ? US dkim_cur_sig->pubkey->srvtype
 527       : dkim_exim_expand_defaults(what)
 528       : dkim_exim_expand_defaults(what);
 529
 530   case DKIM_KEY_NOTES:
 531     return dkim_cur_sig->pubkey
 532       ? dkim_cur_sig->pubkey->notes
 533       ? US dkim_cur_sig->pubkey->notes
 534       : dkim_exim_expand_defaults(what)
 535       : dkim_exim_expand_defaults(what);
 536
 537   case DKIM_KEY_TESTING:
 538     return dkim_cur_sig->pubkey
 539       ? dkim_cur_sig->pubkey->testing
 540       ? US"1"
 541       : dkim_exim_expand_defaults(what)
 542       : dkim_exim_expand_defaults(what);
 543
 544   case DKIM_NOSUBDOMAINS:
 545     return dkim_cur_sig->pubkey
 546       ? dkim_cur_sig->pubkey->no_subdomaining
 547       ? US"1"
 548       : dkim_exim_expand_defaults(what)
 549       : dkim_exim_expand_defaults(what);
 550
 551   case DKIM_VERIFY_STATUS:
 552     switch (dkim_cur_sig->verify_status)
 553       {
 554       case PDKIM_VERIFY_INVALID:        return US"invalid";
 555       case PDKIM_VERIFY_FAIL:           return US"fail";
 556       case PDKIM_VERIFY_PASS:           return US"pass";
 557       case PDKIM_VERIFY_NONE:
 558       default:                          return US"none";
 559       }
 560
 561   case DKIM_VERIFY_REASON:
 562     switch (dkim_cur_sig->verify_ext_status)
 563       {
 564       case PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE:
 565                                                 return US"pubkey_unavailable";
 566       case PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD:return US"pubkey_dns_syntax";
 567       case PDKIM_VERIFY_INVALID_PUBKEY_IMPORT:  return US"pubkey_der_syntax";
 568       case PDKIM_VERIFY_INVALID_PUBKEY_KEYSIZE: return US"pubkey_too_short";
 569       case PDKIM_VERIFY_FAIL_BODY:              return US"bodyhash_mismatch";
 570       case PDKIM_VERIFY_FAIL_MESSAGE:           return US"signature_incorrect";
 571       }
 572
 573   default:
 574     return US"";
 575   }
 576 }
 577
 578
 579 void
 580 dkim_exim_sign_init(void)
 581 {
 582 int old_pool = store_pool;
 583
 584 dkim_exim_init();
 585 store_pool = POOL_MAIN;
 586 pdkim_init_context(&dkim_sign_ctx, FALSE, &dkim_exim_query_dns_txt);
 587 store_pool = old_pool;
 588 }
 589
 590
 591 /* Generate signatures for the given file.
 592 If a prefix is given, prepend it to the file for the calculations.
 593
 594 Return:
 595   NULL:         error; error string written
 596   string:       signature header(s), or a zero-length string (not an error)
 597 */
 598
 599 gstring *
 600 dkim_exim_sign(int fd, off_t off, uschar * prefix,
 601   struct ob_dkim * dkim, const uschar ** errstr)
 602 {
 603 const uschar * dkim_domain = NULL;
 604 int sep = 0;
 605 gstring * seen_doms = NULL;
 606 pdkim_signature * sig;
 607 gstring * sigbuf;
 608 int pdkim_rc;
 609 int sread;
 610 uschar buf[4096];
 611 int save_errno = 0;
 612 int old_pool = store_pool;
 613 uschar * errwhen;
 614 const uschar * s;
 615
 616 if (dkim->dot_stuffed)
 617   dkim_sign_ctx.flags |= PDKIM_DOT_TERM;
 618
 619 store_pool = POOL_MAIN;
 620
 621 if ((s = dkim->dkim_domain) && !(dkim_domain = expand_cstring(s)))
 622   /* expansion error, do not send message. */
 623   { errwhen = US"dkim_domain"; goto expand_bad; }
 624
 625 /* Set $dkim_domain expansion variable to each unique domain in list. */
 626
 627 if (dkim_domain)
 628   while ((dkim_signing_domain = string_nextinlist(&dkim_domain, &sep, NULL, 0)))
 629   {
 630   const uschar * dkim_sel;
 631   int sel_sep = 0;
 632
 633   if (dkim_signing_domain[0] == '\0')
 634     continue;
 635
 636   /* Only sign once for each domain, no matter how often it
 637   appears in the expanded list. */
 638
 639   dkim_signing_domain = string_copylc(dkim_signing_domain);
 640   if (match_isinlist(dkim_signing_domain, CUSS &seen_doms,
 641       0, NULL, NULL, MCL_STRING, TRUE, NULL) == OK)
 642     continue;
 643
 644   seen_doms = string_append_listele(seen_doms, ':', dkim_signing_domain);
 645
 646   /* Set $dkim_selector expansion variable to each selector in list,
 647   for this domain. */
 648
 649   if (!(dkim_sel = expand_string(dkim->dkim_selector)))
 650     { errwhen = US"dkim_selector"; goto expand_bad; }
 651
 652   while ((dkim_signing_selector = string_nextinlist(&dkim_sel, &sel_sep,
 653           NULL, 0)))
 654     {
 655     uschar * dkim_canon_expanded;
 656     int pdkim_canon;
 657     uschar * dkim_sign_headers_expanded = NULL;
 658     uschar * dkim_private_key_expanded;
 659     uschar * dkim_hash_expanded;
 660     uschar * dkim_identity_expanded = NULL;
 661     uschar * dkim_timestamps_expanded = NULL;
 662     unsigned long tval = 0, xval = 0;
 663
 664     /* Get canonicalization to use */
 665
 666     dkim_canon_expanded = dkim->dkim_canon
 667       ? expand_string(dkim->dkim_canon) : US"relaxed";
 668     if (!dkim_canon_expanded)   /* expansion error, do not send message. */
 669       { errwhen = US"dkim_canon"; goto expand_bad; }
 670
 671     if (Ustrcmp(dkim_canon_expanded, "relaxed") == 0)
 672       pdkim_canon = PDKIM_CANON_RELAXED;
 673     else if (Ustrcmp(dkim_canon_expanded, "simple") == 0)
 674       pdkim_canon = PDKIM_CANON_SIMPLE;
 675     else
 676       {
 677       log_write(0, LOG_MAIN,
 678                  "DKIM: unknown canonicalization method '%s', defaulting to 'relaxed'.\n",
 679                  dkim_canon_expanded);
 680       pdkim_canon = PDKIM_CANON_RELAXED;
 681       }
 682
 683     if (  dkim->dkim_sign_headers
 684        && !(dkim_sign_headers_expanded = expand_string(dkim->dkim_sign_headers)))
 685       { errwhen = US"dkim_sign_header"; goto expand_bad; }
 686     /* else pass NULL, which means default header list */
 687
 688     /* Get private key to use. */
 689
 690     if (!(dkim_private_key_expanded = expand_string(dkim->dkim_private_key)))
 691       { errwhen = US"dkim_private_key"; goto expand_bad; }
 692
 693     if (  Ustrlen(dkim_private_key_expanded) == 0
 694        || Ustrcmp(dkim_private_key_expanded, "0") == 0
 695        || Ustrcmp(dkim_private_key_expanded, "false") == 0
 696        )
 697       continue;         /* don't sign, but no error */
 698
 699     if (  dkim_private_key_expanded[0] == '/'
 700        && !(dkim_private_key_expanded =
 701              expand_file_big_buffer(dkim_private_key_expanded)))
 702       goto bad;
 703
 704     if (!(dkim_hash_expanded = expand_string(dkim->dkim_hash)))
 705       { errwhen = US"dkim_hash"; goto expand_bad; }
 706
 707     if (dkim->dkim_identity)
 708       if (!(dkim_identity_expanded = expand_string(dkim->dkim_identity)))
 709         { errwhen = US"dkim_identity"; goto expand_bad; }
 710       else if (!*dkim_identity_expanded)
 711         dkim_identity_expanded = NULL;
 712
 713     if (dkim->dkim_timestamps)
 714       if (!(dkim_timestamps_expanded = expand_string(dkim->dkim_timestamps)))
 715         { errwhen = US"dkim_timestamps"; goto expand_bad; }
 716       else
 717         xval = (tval = (unsigned long) time(NULL))
 718               + strtoul(CCS dkim_timestamps_expanded, NULL, 10);
 719
 720     if (!(sig = pdkim_init_sign(&dkim_sign_ctx, dkim_signing_domain,
 721                           dkim_signing_selector,
 722                           dkim_private_key_expanded,
 723                           dkim_hash_expanded,
 724                           errstr
 725                           )))
 726       goto bad;
 727     dkim_private_key_expanded[0] = '\0';
 728
 729     pdkim_set_optional(sig,
 730                         CS dkim_sign_headers_expanded,
 731                         CS dkim_identity_expanded,
 732                         pdkim_canon,
 733                         pdkim_canon, -1, tval, xval);
 734
 735     if (!pdkim_set_sig_bodyhash(&dkim_sign_ctx, sig))
 736       goto bad;
 737
 738     if (!dkim_sign_ctx.sig)             /* link sig to context chain */
 739       dkim_sign_ctx.sig = sig;
 740     else
 741       {
 742       pdkim_signature * n = dkim_sign_ctx.sig;
 743       while (n->next) n = n->next;
 744       n->next = sig;
 745       }
 746     }
 747   }
 748
 749 /* We may need to carry on with the data-feed even if there are no DKIM sigs to
 750 produce, if some other package (eg. ARC) is signing. */
 751
 752 if (!dkim_sign_ctx.sig && !dkim->force_bodyhash)
 753   {
 754   DEBUG(D_transport) debug_printf("DKIM: no viable signatures to use\n");
 755   sigbuf = string_get(1);       /* return a zero-len string */
 756   }
 757 else
 758   {
 759   if (prefix && (pdkim_rc = pdkim_feed(&dkim_sign_ctx, prefix, Ustrlen(prefix))) != PDKIM_OK)
 760     goto pk_bad;
 761
 762   if (lseek(fd, off, SEEK_SET) < 0)
 763     sread = -1;
 764   else
 765     while ((sread = read(fd, &buf, sizeof(buf))) > 0)
 766       if ((pdkim_rc = pdkim_feed(&dkim_sign_ctx, buf, sread)) != PDKIM_OK)
 767         goto pk_bad;
 768
 769   /* Handle failed read above. */
 770   if (sread == -1)
 771     {
 772     debug_printf("DKIM: Error reading -K file.\n");
 773     save_errno = errno;
 774     goto bad;
 775     }
 776
 777   /* Build string of headers, one per signature */
 778
 779   if ((pdkim_rc = pdkim_feed_finish(&dkim_sign_ctx, &sig, errstr)) != PDKIM_OK)
 780     goto pk_bad;
 781
 782   if (!sig)
 783     {
 784     DEBUG(D_transport) debug_printf("DKIM: no signatures to use\n");
 785     sigbuf = string_get(1);     /* return a zero-len string */
 786     }
 787   else for (sigbuf = NULL; sig; sig = sig->next)
 788     sigbuf = string_append(sigbuf, 2, US sig->signature_header, US"\r\n");
 789   }
 790
 791 CLEANUP:
 792   (void) string_from_gstring(sigbuf);
 793   store_pool = old_pool;
 794   errno = save_errno;
 795   return sigbuf;
 796
 797 pk_bad:
 798   log_write(0, LOG_MAIN|LOG_PANIC,
 799                 "DKIM: signing failed: %.100s", pdkim_errstr(pdkim_rc));
 800 bad:
 801   sigbuf = NULL;
 802   goto CLEANUP;
 803
 804 expand_bad:
 805   *errstr = string_sprintf("failed to expand %s: %s",
 806               errwhen, expand_string_message);
 807   log_write(0, LOG_MAIN | LOG_PANIC, "%s", *errstr);
 808   goto bad;
 809 }
 810
 811
 812
 813
 814 gstring *
 815 authres_dkim(gstring * g)
 816 {
 817 int start = 0;          /* compiler quietening */
 818
 819 DEBUG(D_acl) start = g->ptr;
 820
 821 for (pdkim_signature * sig = dkim_signatures; sig; sig = sig->next)
 822   {
 823   g = string_catn(g, US";\n\tdkim=", 8);
 824
 825   if (sig->verify_status & PDKIM_VERIFY_POLICY)
 826     g = string_append(g, 5,
 827       US"policy (", dkim_verify_status, US" - ", dkim_verify_reason, US")");
 828   else switch(sig->verify_status)
 829     {
 830     case PDKIM_VERIFY_NONE:    g = string_cat(g, US"none"); break;
 831     case PDKIM_VERIFY_INVALID:
 832       switch (sig->verify_ext_status)
 833         {
 834         case PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE:
 835           g = string_cat(g, US"tmperror (pubkey unavailable)\n\t\t"); break;
 836         case PDKIM_VERIFY_INVALID_BUFFER_SIZE:
 837           g = string_cat(g, US"permerror (overlong public key record)\n\t\t"); break;
 838         case PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD:
 839         case PDKIM_VERIFY_INVALID_PUBKEY_IMPORT:
 840           g = string_cat(g, US"neutral (public key record import problem)\n\t\t");
 841           break;
 842         case PDKIM_VERIFY_INVALID_SIGNATURE_ERROR:
 843           g = string_cat(g, US"neutral (signature tag missing or invalid)\n\t\t");
 844           break;
 845         case PDKIM_VERIFY_INVALID_DKIM_VERSION:
 846           g = string_cat(g, US"neutral (unsupported DKIM version)\n\t\t");
 847           break;
 848         default:
 849           g = string_cat(g, US"permerror (unspecified problem)\n\t\t"); break;
 850         }
 851       break;
 852     case PDKIM_VERIFY_FAIL:
 853       switch (sig->verify_ext_status)
 854         {
 855         case PDKIM_VERIFY_FAIL_BODY:
 856           g = string_cat(g,
 857             US"fail (body hash mismatch; body probably modified in transit)\n\t\t");
 858           break;
 859         case PDKIM_VERIFY_FAIL_MESSAGE:
 860           g = string_cat(g,
 861             US"fail (signature did not verify; headers probably modified in transit)\n\t\t");
 862           break;
 863         case PDKIM_VERIFY_INVALID_PUBKEY_KEYSIZE:       /* should this really be "polcy"? */
 864           g = string_fmt_append(g, "fail (public key too short: %u bits)\n\t\t", sig->keybits);
 865           break;
 866         default:
 867           g = string_cat(g, US"fail (unspecified reason)\n\t\t");
 868           break;
 869         }
 870       break;
 871     case PDKIM_VERIFY_PASS:    g = string_cat(g, US"pass"); break;
 872     default:                   g = string_cat(g, US"permerror"); break;
 873     }
 874   if (sig->domain)   g = string_append(g, 2, US" header.d=", sig->domain);
 875   if (sig->identity) g = string_append(g, 2, US" header.i=", sig->identity);
 876   if (sig->selector) g = string_append(g, 2, US" header.s=", sig->selector);
 877   g = string_append(g, 2, US" header.a=", dkim_sig_to_a_tag(sig));
 878   }
 879
 880 DEBUG(D_acl)
 881   if (g->ptr == start)
 882     debug_printf("DKIM: no authres\n");
 883   else
 884     debug_printf("DKIM: authres '%.*s'\n", g->ptr - start - 3, g->s + start + 3);
 885 return g;
 886 }
 887
 888
 889 # endif /*!MACRO_PREDEF*/
 890 #endif  /*!DISABLE_DKIM*/