src/src/dkim.c

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