1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge, 1995 - 2017 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Code for DKIM support. Other DKIM relevant code is in
9 receive.c, transport.c and transports/smtp.c */
15 # include "pdkim/pdkim.h"
18 # include "macro_predef.h"
23 builtin_macro_create_var(US"_DKIM_SIGN_HEADERS", US PDKIM_DEFAULT_SIGN_HEADERS);
25 # else /*!MACRO_PREDEF*/
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;
38 /*XXX the caller only uses the first record if we return multiple.
39 Could we hand back an allocated string?
43 dkim_exim_query_dns_txt(char *name, char *answer)
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? */
53 /* Search for TXT record */
55 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
57 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
58 if (rr->type == T_TXT)
61 int answer_offset = 0;
63 /* Copy record content to the answer buffer */
65 while (rr_offset < rr->size)
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));
73 if (answer_offset >= PDKIM_DNS_TXT_MAX_RECLEN)
74 return PDKIM_FAIL; /*XXX better error detail? logging? */
79 return PDKIM_FAIL; /*XXX better error detail? logging? */
92 dkim_exim_verify_init(BOOL dot_stuffing)
94 /* There is a store-reset between header & body reception
95 so cannot use the main pool. Any allocs done by Exim
96 memory-handling must use the perm pool. */
98 dkim_verify_oldpool = store_pool;
99 store_pool = POOL_PERM;
101 /* Free previous context if there is one */
104 pdkim_free_ctx(dkim_verify_ctx);
106 /* Create new context */
108 dkim_verify_ctx = pdkim_init_verify(&dkim_exim_query_dns_txt, dot_stuffing);
109 dkim_collect_input = !!dkim_verify_ctx;
110 dkim_collect_error = NULL;
112 /* Start feed up with any cached data */
115 store_pool = dkim_verify_oldpool;
120 dkim_exim_verify_feed(uschar * data, int len)
124 store_pool = POOL_PERM;
125 if ( dkim_collect_input
126 && (rc = pdkim_feed(dkim_verify_ctx, data, len)) != PDKIM_OK)
128 dkim_collect_error = pdkim_errstr(rc);
129 log_write(0, LOG_MAIN,
130 "DKIM: validation error: %.100s", dkim_collect_error);
131 dkim_collect_input = FALSE;
133 store_pool = dkim_verify_oldpool;
137 /* Log the result for the given signature */
139 dkim_exim_verify_log_sig(pdkim_signature * sig)
146 logmsg = string_catn(NULL, US"DKIM: ", 6);
147 if (!(s = sig->domain)) s = US"<UNSET>";
148 logmsg = string_append(logmsg, 2, "d=", s);
149 if (!(s = sig->selector)) s = US"<UNSET>";
150 logmsg = string_append(logmsg, 2, " s=", s);
151 logmsg = string_append(logmsg, 7,
152 " c=", sig->canon_headers == PDKIM_CANON_SIMPLE ? "simple" : "relaxed",
153 "/", sig->canon_body == PDKIM_CANON_SIMPLE ? "simple" : "relaxed",
154 " a=", dkim_sig_to_a_tag(sig),
155 string_sprintf(" b=" SIZE_T_FMT,
156 (int)sig->sighash.len > -1 ? sig->sighash.len * 8 : 0));
157 if ((s= sig->identity)) logmsg = string_append(logmsg, 2, " i=", s);
158 if (sig->created > 0) logmsg = string_cat(logmsg,
159 string_sprintf(" t=%lu", sig->created));
160 if (sig->expires > 0) logmsg = string_cat(logmsg,
161 string_sprintf(" x=%lu", sig->expires));
162 if (sig->bodylength > -1) logmsg = string_cat(logmsg,
163 string_sprintf(" l=%lu", sig->bodylength));
165 if ( !dkim_verify_status
166 || ( dkim_verify_status == dkim_exim_expand_query(DKIM_VERIFY_STATUS)
167 && dkim_verify_reason == dkim_exim_expand_query(DKIM_VERIFY_REASON)
169 switch (sig->verify_status)
171 case PDKIM_VERIFY_NONE:
172 logmsg = string_cat(logmsg, US" [not verified]");
175 case PDKIM_VERIFY_INVALID:
176 logmsg = string_cat(logmsg, US" [invalid - ");
177 switch (sig->verify_ext_status)
179 case PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE:
180 logmsg = string_cat(logmsg,
181 US"public key record (currently?) unavailable]");
184 case PDKIM_VERIFY_INVALID_BUFFER_SIZE:
185 logmsg = string_cat(logmsg, US"overlong public key record]");
188 case PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD:
189 case PDKIM_VERIFY_INVALID_PUBKEY_IMPORT:
190 logmsg = string_cat(logmsg, US"syntax error in public key record]");
193 case PDKIM_VERIFY_INVALID_SIGNATURE_ERROR:
194 logmsg = string_cat(logmsg, US"signature tag missing or invalid]");
197 case PDKIM_VERIFY_INVALID_DKIM_VERSION:
198 logmsg = string_cat(logmsg, US"unsupported DKIM version]");
202 logmsg = string_cat(logmsg, US"unspecified problem]");
206 case PDKIM_VERIFY_FAIL:
207 logmsg = string_cat(logmsg, US" [verification failed - ");
208 switch (sig->verify_ext_status)
210 case PDKIM_VERIFY_FAIL_BODY:
211 logmsg = string_cat(logmsg,
212 US"body hash mismatch (body probably modified in transit)]");
215 case PDKIM_VERIFY_FAIL_MESSAGE:
216 logmsg = string_cat(logmsg,
217 US"signature did not verify "
218 "(headers probably modified in transit)]");
222 logmsg = string_cat(logmsg, US"unspecified reason]");
226 case PDKIM_VERIFY_PASS:
227 logmsg = string_cat(logmsg, US" [verification succeeded]");
231 logmsg = string_append(logmsg, 5,
232 US" [", dkim_verify_status, US" - ", dkim_verify_reason, US"]");
234 log_write(0, LOG_MAIN, "%s", string_from_gstring(logmsg));
239 /* Log a line for each signature */
241 dkim_exim_verify_log_all(void)
243 pdkim_signature * sig;
244 for (sig = dkim_signatures; sig; sig = sig->next) dkim_exim_verify_log_sig(sig);
249 dkim_exim_verify_finish(void)
251 pdkim_signature * sig;
254 const uschar * errstr;
256 store_pool = POOL_PERM;
258 /* Delete eventual previous signature chain */
261 dkim_signatures = NULL;
263 if (dkim_collect_error)
265 log_write(0, LOG_MAIN,
266 "DKIM: Error during validation, disabling signature verification: %.100s",
268 dkim_disable_verify = TRUE;
272 dkim_collect_input = FALSE;
274 /* Finish DKIM operation and fetch link to signatures chain */
276 rc = pdkim_feed_finish(dkim_verify_ctx, &dkim_signatures, &errstr);
279 log_write(0, LOG_MAIN, "DKIM: validation error: %.100s%s%s", pdkim_errstr(rc),
280 errstr ? ": " : "", errstr ? errstr : US"");
284 /* Build a colon-separated list of signing domains (and identities, if present) in dkim_signers */
286 for (sig = dkim_signatures; sig; sig = sig->next)
288 if (sig->domain) g = string_append_listele(g, ':', sig->domain);
289 if (sig->identity) g = string_append_listele(g, ':', sig->identity);
292 if (g) dkim_signers = g->s;
295 store_pool = dkim_verify_oldpool;
300 /* Args as per dkim_exim_acl_run() below */
302 dkim_acl_call(uschar * id, gstring ** res_ptr,
303 uschar ** user_msgptr, uschar ** log_msgptr)
307 debug_printf("calling acl_smtp_dkim for dkim_cur_signer='%s'\n", id);
309 rc = acl_check(ACL_WHERE_DKIM, NULL, acl_smtp_dkim, user_msgptr, log_msgptr);
310 dkim_exim_verify_log_sig(dkim_cur_sig);
311 *res_ptr = string_append_listele(*res_ptr, ':', dkim_verify_status);
317 /* For the given identity, run the DKIM ACL once for each matching signature.
320 id Identity to look for in dkim signatures
321 res_ptr ptr to growable string-list of status results,
322 appended to per ACL run
323 user_msgptr where to put a user error (for SMTP response)
324 log_msgptr where to put a logging message (not for SMTP response)
326 Returns: OK access is granted by an ACCEPT verb
327 DISCARD access is granted by a DISCARD verb
328 FAIL access is denied
329 FAIL_DROP access is denied; drop the connection
330 DEFER can't tell at the moment
335 dkim_exim_acl_run(uschar * id, gstring ** res_ptr,
336 uschar ** user_msgptr, uschar ** log_msgptr)
338 pdkim_signature * sig;
342 dkim_verify_status = US"none";
343 dkim_verify_reason = US"";
344 dkim_cur_signer = id;
346 if (dkim_disable_verify || !id || !dkim_verify_ctx)
349 /* Find signatures to run ACL on */
351 for (sig = dkim_signatures; sig; sig = sig->next)
352 if ( (cmp_val = Ustrchr(id, '@') != NULL ? US sig->identity : US sig->domain)
353 && strcmpic(cmp_val, id) == 0
356 /* The "dkim_domain" and "dkim_selector" expansion variables have
357 related globals, since they are used in the signing code too.
358 Instead of inventing separate names for verification, we set
359 them here. This is easy since a domain and selector is guaranteed
360 to be in a signature. The other dkim_* expansion items are
361 dynamically fetched from dkim_cur_sig at expansion time (see
365 dkim_signing_domain = US sig->domain;
366 dkim_signing_selector = US sig->selector;
367 dkim_key_length = sig->sighash.len * 8;
369 /* These two return static strings, so we can compare the addr
370 later to see if the ACL overwrote them. Check that when logging */
372 dkim_verify_status = dkim_exim_expand_query(DKIM_VERIFY_STATUS);
373 dkim_verify_reason = dkim_exim_expand_query(DKIM_VERIFY_REASON);
375 if ((rc = dkim_acl_call(id, res_ptr, user_msgptr, log_msgptr)) != OK)
382 /* No matching sig found. Call ACL once anyway. */
385 return dkim_acl_call(id, res_ptr, user_msgptr, log_msgptr);
390 dkim_exim_expand_defaults(int what)
394 case DKIM_ALGO: return US"";
395 case DKIM_BODYLENGTH: return US"9999999999999";
396 case DKIM_CANON_BODY: return US"";
397 case DKIM_CANON_HEADERS: return US"";
398 case DKIM_COPIEDHEADERS: return US"";
399 case DKIM_CREATED: return US"0";
400 case DKIM_EXPIRES: return US"9999999999999";
401 case DKIM_HEADERNAMES: return US"";
402 case DKIM_IDENTITY: return US"";
403 case DKIM_KEY_GRANULARITY: return US"*";
404 case DKIM_KEY_SRVTYPE: return US"*";
405 case DKIM_KEY_NOTES: return US"";
406 case DKIM_KEY_TESTING: return US"0";
407 case DKIM_NOSUBDOMAINS: return US"0";
408 case DKIM_VERIFY_STATUS: return US"none";
409 case DKIM_VERIFY_REASON: return US"";
410 default: return US"";
416 dkim_exim_expand_query(int what)
418 if (!dkim_verify_ctx || dkim_disable_verify || !dkim_cur_sig)
419 return dkim_exim_expand_defaults(what);
424 return dkim_sig_to_a_tag(dkim_cur_sig);
426 case DKIM_BODYLENGTH:
427 return dkim_cur_sig->bodylength >= 0
428 ? string_sprintf("%ld", dkim_cur_sig->bodylength)
429 : dkim_exim_expand_defaults(what);
431 case DKIM_CANON_BODY:
432 switch (dkim_cur_sig->canon_body)
434 case PDKIM_CANON_RELAXED: return US"relaxed";
435 case PDKIM_CANON_SIMPLE:
436 default: return US"simple";
439 case DKIM_CANON_HEADERS:
440 switch (dkim_cur_sig->canon_headers)
442 case PDKIM_CANON_RELAXED: return US"relaxed";
443 case PDKIM_CANON_SIMPLE:
444 default: return US"simple";
447 case DKIM_COPIEDHEADERS:
448 return dkim_cur_sig->copiedheaders
449 ? US dkim_cur_sig->copiedheaders : dkim_exim_expand_defaults(what);
452 return dkim_cur_sig->created > 0
453 ? string_sprintf("%lu", dkim_cur_sig->created)
454 : dkim_exim_expand_defaults(what);
457 return dkim_cur_sig->expires > 0
458 ? string_sprintf("%lu", dkim_cur_sig->expires)
459 : dkim_exim_expand_defaults(what);
461 case DKIM_HEADERNAMES:
462 return dkim_cur_sig->headernames
463 ? dkim_cur_sig->headernames : dkim_exim_expand_defaults(what);
466 return dkim_cur_sig->identity
467 ? US dkim_cur_sig->identity : dkim_exim_expand_defaults(what);
469 case DKIM_KEY_GRANULARITY:
470 return dkim_cur_sig->pubkey
471 ? dkim_cur_sig->pubkey->granularity
472 ? US dkim_cur_sig->pubkey->granularity
473 : dkim_exim_expand_defaults(what)
474 : dkim_exim_expand_defaults(what);
476 case DKIM_KEY_SRVTYPE:
477 return dkim_cur_sig->pubkey
478 ? dkim_cur_sig->pubkey->srvtype
479 ? US dkim_cur_sig->pubkey->srvtype
480 : dkim_exim_expand_defaults(what)
481 : dkim_exim_expand_defaults(what);
484 return dkim_cur_sig->pubkey
485 ? dkim_cur_sig->pubkey->notes
486 ? US dkim_cur_sig->pubkey->notes
487 : dkim_exim_expand_defaults(what)
488 : dkim_exim_expand_defaults(what);
490 case DKIM_KEY_TESTING:
491 return dkim_cur_sig->pubkey
492 ? dkim_cur_sig->pubkey->testing
494 : dkim_exim_expand_defaults(what)
495 : dkim_exim_expand_defaults(what);
497 case DKIM_NOSUBDOMAINS:
498 return dkim_cur_sig->pubkey
499 ? dkim_cur_sig->pubkey->no_subdomaining
501 : dkim_exim_expand_defaults(what)
502 : dkim_exim_expand_defaults(what);
504 case DKIM_VERIFY_STATUS:
505 switch (dkim_cur_sig->verify_status)
507 case PDKIM_VERIFY_INVALID: return US"invalid";
508 case PDKIM_VERIFY_FAIL: return US"fail";
509 case PDKIM_VERIFY_PASS: return US"pass";
510 case PDKIM_VERIFY_NONE:
511 default: return US"none";
514 case DKIM_VERIFY_REASON:
515 switch (dkim_cur_sig->verify_ext_status)
517 case PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE:
518 return US"pubkey_unavailable";
519 case PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD:return US"pubkey_dns_syntax";
520 case PDKIM_VERIFY_INVALID_PUBKEY_IMPORT: return US"pubkey_der_syntax";
521 case PDKIM_VERIFY_FAIL_BODY: return US"bodyhash_mismatch";
522 case PDKIM_VERIFY_FAIL_MESSAGE: return US"signature_incorrect";
531 /* Generate signatures for the given file, returning a string.
532 If a prefix is given, prepend it to the file for the calculations.
536 dkim_exim_sign(int fd, off_t off, uschar * prefix,
537 struct ob_dkim * dkim, const uschar ** errstr)
539 const uschar * dkim_domain;
541 gstring * seen_doms = NULL;
543 pdkim_signature * sig;
549 int old_pool = store_pool;
552 store_pool = POOL_MAIN;
554 pdkim_init_context(&ctx, dkim->dot_stuffed, &dkim_exim_query_dns_txt);
556 if (!(dkim_domain = expand_cstring(dkim->dkim_domain)))
557 /* expansion error, do not send message. */
558 { errwhen = US"dkim_domain"; goto expand_bad; }
560 /* Set $dkim_domain expansion variable to each unique domain in list. */
562 while ((dkim_signing_domain = string_nextinlist(&dkim_domain, &sep, NULL, 0)))
564 const uschar * dkim_sel;
567 if (dkim_signing_domain[0] == '\0')
570 /* Only sign once for each domain, no matter how often it
571 appears in the expanded list. */
573 if (match_isinlist(dkim_signing_domain, CUSS &seen_doms,
574 0, NULL, NULL, MCL_STRING, TRUE, NULL) == OK)
577 seen_doms = string_append_listele(seen_doms, ':', dkim_signing_domain);
579 /* Set $dkim_selector expansion variable to each selector in list,
582 if (!(dkim_sel = expand_string(dkim->dkim_selector)))
583 if (!(dkim_signing_selector = expand_string(dkim->dkim_selector)))
584 { errwhen = US"dkim_selector"; goto expand_bad; }
586 while ((dkim_signing_selector = string_nextinlist(&dkim_sel, &sel_sep,
589 uschar * dkim_canon_expanded;
591 uschar * dkim_sign_headers_expanded = NULL;
592 uschar * dkim_private_key_expanded;
593 uschar * dkim_hash_expanded;
594 uschar * dkim_identity_expanded = NULL;
596 /* Get canonicalization to use */
598 dkim_canon_expanded = dkim->dkim_canon
599 ? expand_string(dkim->dkim_canon) : US"relaxed";
600 if (!dkim_canon_expanded) /* expansion error, do not send message. */
601 { errwhen = US"dkim_canon"; goto expand_bad; }
603 if (Ustrcmp(dkim_canon_expanded, "relaxed") == 0)
604 pdkim_canon = PDKIM_CANON_RELAXED;
605 else if (Ustrcmp(dkim_canon_expanded, "simple") == 0)
606 pdkim_canon = PDKIM_CANON_SIMPLE;
609 log_write(0, LOG_MAIN,
610 "DKIM: unknown canonicalization method '%s', defaulting to 'relaxed'.\n",
611 dkim_canon_expanded);
612 pdkim_canon = PDKIM_CANON_RELAXED;
615 if ( dkim->dkim_sign_headers
616 && !(dkim_sign_headers_expanded = expand_string(dkim->dkim_sign_headers)))
617 { errwhen = US"dkim_sign_header"; goto expand_bad; }
618 /* else pass NULL, which means default header list */
620 /* Get private key to use. */
622 if (!(dkim_private_key_expanded = expand_string(dkim->dkim_private_key)))
623 { errwhen = US"dkim_private_key"; goto expand_bad; }
625 if ( Ustrlen(dkim_private_key_expanded) == 0
626 || Ustrcmp(dkim_private_key_expanded, "0") == 0
627 || Ustrcmp(dkim_private_key_expanded, "false") == 0
629 continue; /* don't sign, but no error */
631 if (dkim_private_key_expanded[0] == '/')
633 int privkey_fd, off = 0, len;
635 /* Looks like a filename, load the private key. */
637 memset(big_buffer, 0, big_buffer_size);
639 if ((privkey_fd = open(CS dkim_private_key_expanded, O_RDONLY)) < 0)
641 log_write(0, LOG_MAIN | LOG_PANIC, "unable to open "
642 "private key file for reading: %s",
643 dkim_private_key_expanded);
649 if ((len = read(privkey_fd, big_buffer + off, big_buffer_size - 2 - off)) < 0)
651 (void) close(privkey_fd);
652 log_write(0, LOG_MAIN|LOG_PANIC, "unable to read private key file: %s",
653 dkim_private_key_expanded);
660 (void) close(privkey_fd);
661 big_buffer[off] = '\0';
662 dkim_private_key_expanded = big_buffer;
665 if (!(dkim_hash_expanded = expand_string(dkim->dkim_hash)))
666 { errwhen = US"dkim_hash"; goto expand_bad; }
668 if (dkim->dkim_identity)
669 if (!(dkim_identity_expanded = expand_string(dkim->dkim_identity)))
670 { errwhen = US"dkim_identity"; goto expand_bad; }
671 else if (!*dkim_identity_expanded)
672 dkim_identity_expanded = NULL;
674 /*XXX so we currently nail signing to RSA + this hash.
675 Need to extract algo from privkey and check for disallowed combos. */
677 if (!(sig = pdkim_init_sign(&ctx, dkim_signing_domain,
678 dkim_signing_selector,
679 dkim_private_key_expanded,
684 dkim_private_key_expanded[0] = '\0';
686 pdkim_set_optional(sig,
687 CS dkim_sign_headers_expanded,
688 dkim_identity_expanded,
690 pdkim_canon, -1, 0, 0);
692 if (!ctx.sig) /* link sig to context chain */
696 pdkim_signature * n = ctx.sig;
697 while (n->next) n = n->next;
704 pdkim_feed(&ctx, prefix, Ustrlen(prefix));
706 if (lseek(fd, off, SEEK_SET) < 0)
709 while ((sread = read(fd, &buf, sizeof(buf))) > 0)
710 if ((pdkim_rc = pdkim_feed(&ctx, buf, sread)) != PDKIM_OK)
713 /* Handle failed read above. */
716 debug_printf("DKIM: Error reading -K file.\n");
721 /* Build string of headers, one per signature */
723 if ((pdkim_rc = pdkim_feed_finish(&ctx, &sig, errstr)) != PDKIM_OK)
726 for (sigbuf = NULL; sig; sig = sig->next)
727 sigbuf = string_append(sigbuf, 2, US sig->signature_header, US"\r\n");
729 (void) string_from_gstring(sigbuf);
732 store_pool = old_pool;
737 log_write(0, LOG_MAIN|LOG_PANIC,
738 "DKIM: signing failed: %.100s", pdkim_errstr(pdkim_rc));
744 log_write(0, LOG_MAIN | LOG_PANIC, "failed to expand %s: %s",
745 errwhen, expand_string_message);
749 # endif /*!MACRO_PREDEF*/
750 #endif /*!DISABLE_DKIM*/