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"
17 int dkim_verify_oldpool;
18 pdkim_ctx *dkim_verify_ctx = NULL;
19 pdkim_signature *dkim_signatures = NULL;
20 pdkim_signature *dkim_cur_sig = NULL;
21 static const uschar * dkim_collect_error = NULL;
24 dkim_exim_query_dns_txt(char *name, char *answer)
30 lookup_dnssec_authenticated = NULL;
31 if (dns_lookup(&dnsa, US name, T_TXT, NULL) != DNS_SUCCEED)
32 return PDKIM_FAIL; /*XXX better error detail? logging? */
34 /* Search for TXT record */
36 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
38 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
39 if (rr->type == T_TXT)
42 int answer_offset = 0;
44 /* Copy record content to the answer buffer */
46 while (rr_offset < rr->size)
48 uschar len = rr->data[rr_offset++];
49 snprintf(answer + answer_offset,
50 PDKIM_DNS_TXT_MAX_RECLEN - answer_offset,
51 "%.*s", (int)len, (char *) (rr->data + rr_offset));
54 if (answer_offset >= PDKIM_DNS_TXT_MAX_RECLEN)
55 return PDKIM_FAIL; /*XXX better error detail? logging? */
60 return PDKIM_FAIL; /*XXX better error detail? logging? */
73 dkim_exim_verify_init(BOOL dot_stuffing)
75 /* There is a store-reset between header & body reception
76 so cannot use the main pool. Any allocs done by Exim
77 memory-handling must use the perm pool. */
79 dkim_verify_oldpool = store_pool;
80 store_pool = POOL_PERM;
82 /* Free previous context if there is one */
85 pdkim_free_ctx(dkim_verify_ctx);
87 /* Create new context */
89 dkim_verify_ctx = pdkim_init_verify(&dkim_exim_query_dns_txt, dot_stuffing);
90 dkim_collect_input = !!dkim_verify_ctx;
91 dkim_collect_error = NULL;
93 /* Start feed up with any cached data */
96 store_pool = dkim_verify_oldpool;
101 dkim_exim_verify_feed(uschar * data, int len)
105 store_pool = POOL_PERM;
106 if ( dkim_collect_input
107 && (rc = pdkim_feed(dkim_verify_ctx, data, len)) != PDKIM_OK)
109 dkim_collect_error = pdkim_errstr(rc);
110 log_write(0, LOG_MAIN,
111 "DKIM: validation error: %.100s", dkim_collect_error);
112 dkim_collect_input = FALSE;
114 store_pool = dkim_verify_oldpool;
119 dkim_exim_verify_finish(void)
121 pdkim_signature * sig = NULL;
122 int dkim_signers_size = 0, dkim_signers_ptr = 0, rc;
123 const uschar * errstr;
125 store_pool = POOL_PERM;
127 /* Delete eventual previous signature chain */
130 dkim_signatures = NULL;
132 if (dkim_collect_error)
134 log_write(0, LOG_MAIN,
135 "DKIM: Error during validation, disabling signature verification: %.100s",
137 dkim_disable_verify = TRUE;
141 dkim_collect_input = FALSE;
143 /* Finish DKIM operation and fetch link to signatures chain */
145 rc = pdkim_feed_finish(dkim_verify_ctx, &dkim_signatures, &errstr);
148 log_write(0, LOG_MAIN, "DKIM: validation error: %.100s%s%s", pdkim_errstr(rc),
149 errstr ? ": " : "", errstr ? errstr : US"");
153 for (sig = dkim_signatures; sig; sig = sig->next)
155 int size = 0, ptr = 0;
156 uschar * logmsg = NULL, * s;
158 /* Log a line for each signature */
160 if (!(s = sig->domain)) s = US"<UNSET>";
161 logmsg = string_append(logmsg, &size, &ptr, 2, "d=", s);
162 if (!(s = sig->selector)) s = US"<UNSET>";
163 logmsg = string_append(logmsg, &size, &ptr, 2, " s=", s);
164 logmsg = string_append(logmsg, &size, &ptr, 7,
165 " c=", sig->canon_headers == PDKIM_CANON_SIMPLE ? "simple" : "relaxed",
166 "/", sig->canon_body == PDKIM_CANON_SIMPLE ? "simple" : "relaxed",
167 " a=", sig->algo == PDKIM_ALGO_RSA_SHA256
169 : sig->algo == PDKIM_ALGO_RSA_SHA1 ? "rsa-sha1" : "err",
170 string_sprintf(" b=%d",
171 (int)sig->sighash.len > -1 ? sig->sighash.len * 8 : 0));
172 if ((s= sig->identity)) logmsg = string_append(logmsg, &size, &ptr, 2, " i=", s);
173 if (sig->created > 0) logmsg = string_append(logmsg, &size, &ptr, 1,
174 string_sprintf(" t=%lu", sig->created));
175 if (sig->expires > 0) logmsg = string_append(logmsg, &size, &ptr, 1,
176 string_sprintf(" x=%lu", sig->expires));
177 if (sig->bodylength > -1) logmsg = string_append(logmsg, &size, &ptr, 1,
178 string_sprintf(" l=%lu", sig->bodylength));
180 switch (sig->verify_status)
182 case PDKIM_VERIFY_NONE:
183 logmsg = string_append(logmsg, &size, &ptr, 1, " [not verified]");
186 case PDKIM_VERIFY_INVALID:
187 logmsg = string_append(logmsg, &size, &ptr, 1, " [invalid - ");
188 switch (sig->verify_ext_status)
190 case PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE:
191 logmsg = string_append(logmsg, &size, &ptr, 1,
192 "public key record (currently?) unavailable]");
195 case PDKIM_VERIFY_INVALID_BUFFER_SIZE:
196 logmsg = string_append(logmsg, &size, &ptr, 1,
197 "overlong public key record]");
200 case PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD:
201 case PDKIM_VERIFY_INVALID_PUBKEY_IMPORT:
202 logmsg = string_append(logmsg, &size, &ptr, 1,
203 "syntax error in public key record]");
206 case PDKIM_VERIFY_INVALID_SIGNATURE_ERROR:
207 logmsg = string_append(logmsg, &size, &ptr, 1,
208 "signature tag missing or invalid]");
211 case PDKIM_VERIFY_INVALID_DKIM_VERSION:
212 logmsg = string_append(logmsg, &size, &ptr, 1,
213 "unsupported DKIM version]");
217 logmsg = string_append(logmsg, &size, &ptr, 1,
218 "unspecified problem]");
222 case PDKIM_VERIFY_FAIL:
224 string_append(logmsg, &size, &ptr, 1, " [verification failed - ");
225 switch (sig->verify_ext_status)
227 case PDKIM_VERIFY_FAIL_BODY:
228 logmsg = string_append(logmsg, &size, &ptr, 1,
229 "body hash mismatch (body probably modified in transit)]");
232 case PDKIM_VERIFY_FAIL_MESSAGE:
233 logmsg = string_append(logmsg, &size, &ptr, 1,
234 "signature did not verify (headers probably modified in transit)]");
238 logmsg = string_append(logmsg, &size, &ptr, 1, "unspecified reason]");
242 case PDKIM_VERIFY_PASS:
244 string_append(logmsg, &size, &ptr, 1, " [verification succeeded]");
249 log_write(0, LOG_MAIN, "DKIM: %s", logmsg);
251 /* Build a colon-separated list of signing domains (and identities, if present) in dkim_signers */
254 dkim_signers = string_append_listele(dkim_signers, &dkim_signers_size,
255 &dkim_signers_ptr, ':', sig->domain);
258 dkim_signers = string_append_listele(dkim_signers, &dkim_signers_size,
259 &dkim_signers_ptr, ':', sig->identity);
261 /* Process next signature */
265 store_pool = dkim_verify_oldpool;
270 dkim_exim_acl_setup(uschar * id)
272 pdkim_signature * sig;
276 dkim_cur_signer = id;
278 if (dkim_disable_verify || !id || !dkim_verify_ctx)
281 /* Find signature to run ACL on */
283 for (sig = dkim_signatures; sig; sig = sig->next)
284 if ( (cmp_val = Ustrchr(id, '@') != NULL ? US sig->identity : US sig->domain)
285 && strcmpic(cmp_val, id) == 0
290 /* The "dkim_domain" and "dkim_selector" expansion variables have
291 related globals, since they are used in the signing code too.
292 Instead of inventing separate names for verification, we set
293 them here. This is easy since a domain and selector is guaranteed
294 to be in a signature. The other dkim_* expansion items are
295 dynamically fetched from dkim_cur_sig at expansion time (see
298 dkim_signing_domain = US sig->domain;
299 dkim_signing_selector = US sig->selector;
300 dkim_key_length = sig->sighash.len * 8;
307 dkim_exim_expand_defaults(int what)
311 case DKIM_ALGO: return US"";
312 case DKIM_BODYLENGTH: return US"9999999999999";
313 case DKIM_CANON_BODY: return US"";
314 case DKIM_CANON_HEADERS: return US"";
315 case DKIM_COPIEDHEADERS: return US"";
316 case DKIM_CREATED: return US"0";
317 case DKIM_EXPIRES: return US"9999999999999";
318 case DKIM_HEADERNAMES: return US"";
319 case DKIM_IDENTITY: return US"";
320 case DKIM_KEY_GRANULARITY: return US"*";
321 case DKIM_KEY_SRVTYPE: return US"*";
322 case DKIM_KEY_NOTES: return US"";
323 case DKIM_KEY_TESTING: return US"0";
324 case DKIM_NOSUBDOMAINS: return US"0";
325 case DKIM_VERIFY_STATUS: return US"none";
326 case DKIM_VERIFY_REASON: return US"";
327 default: return US"";
333 dkim_exim_expand_query(int what)
335 if (!dkim_verify_ctx || dkim_disable_verify || !dkim_cur_sig)
336 return dkim_exim_expand_defaults(what);
341 switch (dkim_cur_sig->algo)
343 case PDKIM_ALGO_RSA_SHA1: return US"rsa-sha1";
344 case PDKIM_ALGO_RSA_SHA256:
345 default: return US"rsa-sha256";
348 case DKIM_BODYLENGTH:
349 return dkim_cur_sig->bodylength >= 0
350 ? string_sprintf(OFF_T_FMT, (LONGLONG_T) dkim_cur_sig->bodylength)
351 : dkim_exim_expand_defaults(what);
353 case DKIM_CANON_BODY:
354 switch (dkim_cur_sig->canon_body)
356 case PDKIM_CANON_RELAXED: return US"relaxed";
357 case PDKIM_CANON_SIMPLE:
358 default: return US"simple";
361 case DKIM_CANON_HEADERS:
362 switch (dkim_cur_sig->canon_headers)
364 case PDKIM_CANON_RELAXED: return US"relaxed";
365 case PDKIM_CANON_SIMPLE:
366 default: return US"simple";
369 case DKIM_COPIEDHEADERS:
370 return dkim_cur_sig->copiedheaders
371 ? US dkim_cur_sig->copiedheaders : dkim_exim_expand_defaults(what);
374 return dkim_cur_sig->created > 0
375 ? string_sprintf("%llu", dkim_cur_sig->created)
376 : dkim_exim_expand_defaults(what);
379 return dkim_cur_sig->expires > 0
380 ? string_sprintf("%llu", dkim_cur_sig->expires)
381 : dkim_exim_expand_defaults(what);
383 case DKIM_HEADERNAMES:
384 return dkim_cur_sig->headernames
385 ? dkim_cur_sig->headernames : dkim_exim_expand_defaults(what);
388 return dkim_cur_sig->identity
389 ? US dkim_cur_sig->identity : dkim_exim_expand_defaults(what);
391 case DKIM_KEY_GRANULARITY:
392 return dkim_cur_sig->pubkey
393 ? dkim_cur_sig->pubkey->granularity
394 ? US dkim_cur_sig->pubkey->granularity
395 : dkim_exim_expand_defaults(what)
396 : dkim_exim_expand_defaults(what);
398 case DKIM_KEY_SRVTYPE:
399 return dkim_cur_sig->pubkey
400 ? dkim_cur_sig->pubkey->srvtype
401 ? US dkim_cur_sig->pubkey->srvtype
402 : dkim_exim_expand_defaults(what)
403 : dkim_exim_expand_defaults(what);
406 return dkim_cur_sig->pubkey
407 ? dkim_cur_sig->pubkey->notes
408 ? US dkim_cur_sig->pubkey->notes
409 : dkim_exim_expand_defaults(what)
410 : dkim_exim_expand_defaults(what);
412 case DKIM_KEY_TESTING:
413 return dkim_cur_sig->pubkey
414 ? dkim_cur_sig->pubkey->testing
416 : dkim_exim_expand_defaults(what)
417 : dkim_exim_expand_defaults(what);
419 case DKIM_NOSUBDOMAINS:
420 return dkim_cur_sig->pubkey
421 ? dkim_cur_sig->pubkey->no_subdomaining
423 : dkim_exim_expand_defaults(what)
424 : dkim_exim_expand_defaults(what);
426 case DKIM_VERIFY_STATUS:
427 switch (dkim_cur_sig->verify_status)
429 case PDKIM_VERIFY_INVALID: return US"invalid";
430 case PDKIM_VERIFY_FAIL: return US"fail";
431 case PDKIM_VERIFY_PASS: return US"pass";
432 case PDKIM_VERIFY_NONE:
433 default: return US"none";
436 case DKIM_VERIFY_REASON:
437 switch (dkim_cur_sig->verify_ext_status)
439 case PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE:
440 return US"pubkey_unavailable";
441 case PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD:return US"pubkey_dns_syntax";
442 case PDKIM_VERIFY_INVALID_PUBKEY_IMPORT: return US"pubkey_der_syntax";
443 case PDKIM_VERIFY_FAIL_BODY: return US"bodyhash_mismatch";
444 case PDKIM_VERIFY_FAIL_MESSAGE: return US"signature_incorrect";
453 /* Generate signatures for the given file, returning a string.
454 If a prefix is given, prepend it to the file for the calculations.
458 dkim_exim_sign(int fd, off_t off, uschar * prefix,
459 struct ob_dkim * dkim, const uschar ** errstr)
461 const uschar * dkim_domain;
463 uschar *seen_items = NULL;
464 int seen_items_size = 0;
465 int seen_items_offset = 0;
466 uschar *dkim_canon_expanded;
467 uschar *dkim_sign_headers_expanded;
468 uschar *dkim_private_key_expanded;
469 pdkim_ctx *ctx = NULL;
471 uschar *sigbuf = NULL;
474 pdkim_signature *signature;
480 int old_pool = store_pool;
482 store_pool = POOL_MAIN;
484 if (!(dkim_domain = expand_cstring(dkim->dkim_domain)))
486 /* expansion error, do not send message. */
487 log_write(0, LOG_MAIN | LOG_PANIC, "failed to expand "
488 "dkim_domain: %s", expand_string_message);
492 /* Set $dkim_domain expansion variable to each unique domain in list. */
494 while ((dkim_signing_domain = string_nextinlist(&dkim_domain, &sep, NULL, 0)))
496 if (dkim_signing_domain[0] == '\0')
499 /* Only sign once for each domain, no matter how often it
500 appears in the expanded list. */
504 const uschar *seen_items_list = seen_items;
505 if (match_isinlist(dkim_signing_domain,
506 &seen_items_list, 0, NULL, NULL, MCL_STRING, TRUE,
511 string_append(seen_items, &seen_items_size, &seen_items_offset, 1, ":");
515 string_append(seen_items, &seen_items_size, &seen_items_offset, 1,
516 dkim_signing_domain);
517 seen_items[seen_items_offset] = '\0';
519 /* Set up $dkim_selector expansion variable. */
521 if (!(dkim_signing_selector = expand_string(dkim->dkim_selector)))
523 log_write(0, LOG_MAIN | LOG_PANIC, "failed to expand "
524 "dkim_selector: %s", expand_string_message);
528 /* Get canonicalization to use */
530 dkim_canon_expanded = dkim->dkim_canon
531 ? expand_string(dkim->dkim_canon) : US"relaxed";
532 if (!dkim_canon_expanded)
534 /* expansion error, do not send message. */
535 log_write(0, LOG_MAIN | LOG_PANIC, "failed to expand "
536 "dkim_canon: %s", expand_string_message);
540 if (Ustrcmp(dkim_canon_expanded, "relaxed") == 0)
541 pdkim_canon = PDKIM_CANON_RELAXED;
542 else if (Ustrcmp(dkim_canon_expanded, "simple") == 0)
543 pdkim_canon = PDKIM_CANON_SIMPLE;
546 log_write(0, LOG_MAIN,
547 "DKIM: unknown canonicalization method '%s', defaulting to 'relaxed'.\n",
548 dkim_canon_expanded);
549 pdkim_canon = PDKIM_CANON_RELAXED;
552 dkim_sign_headers_expanded = NULL;
553 if (dkim->dkim_sign_headers)
554 if (!(dkim_sign_headers_expanded = expand_string(dkim->dkim_sign_headers)))
556 log_write(0, LOG_MAIN | LOG_PANIC, "failed to expand "
557 "dkim_sign_headers: %s", expand_string_message);
560 /* else pass NULL, which means default header list */
562 /* Get private key to use. */
564 if (!(dkim_private_key_expanded = expand_string(dkim->dkim_private_key)))
566 log_write(0, LOG_MAIN | LOG_PANIC, "failed to expand "
567 "dkim_private_key: %s", expand_string_message);
571 if ( Ustrlen(dkim_private_key_expanded) == 0
572 || Ustrcmp(dkim_private_key_expanded, "0") == 0
573 || Ustrcmp(dkim_private_key_expanded, "false") == 0
575 continue; /* don't sign, but no error */
577 if (dkim_private_key_expanded[0] == '/')
579 int privkey_fd, off = 0, len;
581 /* Looks like a filename, load the private key. */
583 memset(big_buffer, 0, big_buffer_size);
585 if ((privkey_fd = open(CS dkim_private_key_expanded, O_RDONLY)) < 0)
587 log_write(0, LOG_MAIN | LOG_PANIC, "unable to open "
588 "private key file for reading: %s",
589 dkim_private_key_expanded);
595 if ((len = read(privkey_fd, big_buffer + off, big_buffer_size - 2 - off)) < 0)
597 (void) close(privkey_fd);
598 log_write(0, LOG_MAIN|LOG_PANIC, "unable to read private key file: %s",
599 dkim_private_key_expanded);
606 (void) close(privkey_fd);
607 big_buffer[off] = '\0';
608 dkim_private_key_expanded = big_buffer;
611 if (!(ctx = pdkim_init_sign(CS dkim_signing_domain,
612 CS dkim_signing_selector,
613 CS dkim_private_key_expanded,
614 PDKIM_ALGO_RSA_SHA256,
616 &dkim_exim_query_dns_txt,
620 dkim_private_key_expanded[0] = '\0';
621 pdkim_set_optional(ctx,
622 CS dkim_sign_headers_expanded,
625 pdkim_canon, -1, 0, 0);
628 pdkim_feed(ctx, prefix, Ustrlen(prefix));
630 if (lseek(fd, off, SEEK_SET) < 0)
633 while ((sread = read(fd, &buf, sizeof(buf))) > 0)
634 if ((pdkim_rc = pdkim_feed(ctx, buf, sread)) != PDKIM_OK)
637 /* Handle failed read above. */
640 debug_printf("DKIM: Error reading -K file.\n");
645 if ((pdkim_rc = pdkim_feed_finish(ctx, &signature, errstr)) != PDKIM_OK)
648 sigbuf = string_append(sigbuf, &sigsize, &sigptr, 2,
649 US signature->signature_header, US"\r\n");
657 sigbuf[sigptr] = '\0';
666 store_pool = old_pool;
671 log_write(0, LOG_MAIN|LOG_PANIC,
672 "DKIM: signing failed: %.100s", pdkim_errstr(pdkim_rc));