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