*************************************************/
/* Experimental ARC support for Exim
Copyright (c) Jeremy Harris 2018 - 2020
+ Copyright (c) The Exim Maintainers 2021 - 2023
License: GPL
+ SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "exim.h"
# include "pdkim/pdkim.h"
# include "pdkim/signing.h"
+# ifdef SUPPORT_DMARC
+# include "dmarc.h"
+# endif
+
extern pdkim_ctx * dkim_verify_ctx;
extern pdkim_ctx dkim_sign_ctx;
blob s;
blob c;
blob l;
+ blob ip;
/* tag content sub-portions */
blob a_algo;
#define HDR_AR US"Authentication-Results:"
#define HDRLEN_AR 23
+typedef enum line_extract {
+ le_instance_only,
+ le_instance_plus_ip,
+ le_all
+} line_extract_t;
+
static time_t now;
static time_t expire;
static hdr_rlist * headers_rlist;
static arc_ctx arc_sign_ctx = { NULL };
static arc_ctx arc_verify_ctx = { NULL };
+/* We build a context for either Sign or Verify.
+
+For Verify, it's a fresh new one for ACL verify=arc - there is no connection
+with the single line handling done during reception via the DKIM feed.
+
+For Verify we do it twice; initially during reception (via the DKIM feed)
+and then later for the full verification.
+
+The former only looks at AMS headers, to discover what hash(es) we need done for
+ARC on the message body; we call back to the DKIM code to set up so that it does
+them for us during reception. That call needs info from many of the AMS tags;
+arc_parse_line() for only the AMS is called asking for all the tag types.
+That context is then discarded.
+
+Later, for Verify, we look at ARC headers again and then grab the hash result
+from the DKIM layer. arc_parse_line() is called for all 3 line types,
+gathering info for only 'i' and 'ip' tags from AAR headers,
+for all tag types from AMS and AS headers.
+
+
+For Sign, while running through the existing headers (before adding any for
+this signing operation, we "take copies" of the headers, we call
+arc_parse_line() gathering only the 'i' tag (instance) information.
+*/
+
/******************************************************************************/
}
DEBUG(D_acl) debug_printf("ARC: new instance %u\n", i);
-*pas = as = store_get(sizeof(arc_set), FALSE);
+*pas = as = store_get(sizeof(arc_set), GET_UNTAINTED);
memset(as, 0, sizeof(arc_set));
as->next = next;
as->prev = prev;
/* Inspect a header line, noting known tag fields.
-Check for duplicates. */
+Check for duplicate named tags.
+
+See the file block comment for how this is used.
+
+Return: NULL for good, or an error string
+*/
static uschar *
-arc_parse_line(arc_line * al, header_line * h, unsigned off, BOOL instance_only)
+arc_parse_line(arc_line * al, header_line * h, unsigned off, line_extract_t l_ext)
{
uschar * s = h->text + off;
-uschar * r = NULL; /* compiler-quietening */
+uschar * r = NULL;
uschar c;
al->complete = h;
-if (!instance_only)
+if (l_ext == le_all) /* need to grab rawsig_no_b */
{
- al->rawsig_no_b_val.data = store_get(h->slen + 1, TRUE); /* tainted */
+ al->rawsig_no_b_val.data = store_get(h->slen + 1, GET_TAINTED);
memcpy(al->rawsig_no_b_val.data, h->text, off); /* copy the header name blind */
r = al->rawsig_no_b_val.data + off;
al->rawsig_no_b_val.len = off;
uschar * bstart = NULL, * bend;
/* tag-spec = [FWS] tag-name [FWS] "=" [FWS] tag-value [FWS] */
+ /*X or just a naked FQDN, in a AAR ! */
- s = skip_fws(s); /* FWS */
+ s = skip_fws(s); /* leading FWS */
if (!*s) break;
-/* debug_printf("%s: consider '%s'\n", __FUNCTION__, s); */
tagchar = *s++;
- s = skip_fws(s); /* FWS */
- if (!*s) break;
+ if (!*(s = skip_fws(s))) break; /* FWS */
- if (!instance_only || tagchar == 'i') switch (tagchar)
+ switch (tagchar)
{
case 'a': /* a= AMS algorithm */
- {
- if (*s != '=') return US"no 'a' value";
- if (arc_insert_tagvalue(al, offsetof(arc_line, a), &s)) return US"a tag dup";
-
- /* substructure: algo-hash (eg. rsa-sha256) */
-
- t = al->a_algo.data = al->a.data;
- while (*t != '-')
- if (!*t++ || ++i > al->a.len) return US"no '-' in 'a' value";
- al->a_algo.len = i;
- if (*t++ != '-') return US"no '-' in 'a' value";
- al->a_hash.data = t;
- al->a_hash.len = al->a.len - i - 1;
- }
+ if (l_ext == le_all && *s == '=')
+ {
+ if (arc_insert_tagvalue(al, offsetof(arc_line, a), &s)) return US"a tag dup";
+
+ /* substructure: algo-hash (eg. rsa-sha256) */
+
+ t = al->a_algo.data = al->a.data;
+ while (*t != '-')
+ if (!*t++ || ++i > al->a.len) return US"no '-' in 'a' value";
+ al->a_algo.len = i;
+ if (*t++ != '-') return US"no '-' in 'a' value";
+ al->a_hash.data = t;
+ al->a_hash.len = al->a.len - i - 1;
+ }
break;
case 'b':
- {
- gstring * g = NULL;
-
- switch (*s)
+ if (l_ext == le_all)
{
- case '=': /* b= AMS signature */
- if (al->b.data) return US"already b data";
- bstart = s+1;
-
- /* The signature can have FWS inserted in the content;
- make a stripped copy */
-
- while ((c = *++s) && c != ';')
- if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
- g = string_catn(g, s, 1);
- if (!g) return US"no b= value";
- al->b.data = string_from_gstring(g);
- al->b.len = g->ptr;
- gstring_release_unused(g);
- bend = s;
- break;
- case 'h': /* bh= AMS body hash */
- s = skip_fws(++s); /* FWS */
- if (*s != '=') return US"no bh value";
- if (al->bh.data) return US"already bh data";
-
- /* The bodyhash can have FWS inserted in the content;
- make a stripped copy */
-
- while ((c = *++s) && c != ';')
- if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
- g = string_catn(g, s, 1);
- if (!g) return US"no bh= value";
- al->bh.data = string_from_gstring(g);
- al->bh.len = g->ptr;
- gstring_release_unused(g);
- break;
- default:
- return US"b? tag";
+ gstring * g = NULL;
+
+ switch (*s)
+ {
+ case '=': /* b= AMS signature */
+ if (al->b.data) return US"already b data";
+ bstart = s+1;
+
+ /* The signature can have FWS inserted in the content;
+ make a stripped copy */
+
+ while ((c = *++s) && c != ';')
+ if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
+ g = string_catn(g, s, 1);
+ if (!g) return US"no b= value";
+ al->b.len = len_string_from_gstring(g, &al->b.data);
+ gstring_release_unused(g);
+ bend = s;
+ break;
+ case 'h': /* bh= AMS body hash */
+ s = skip_fws(++s); /* FWS */
+ if (*s == '=')
+ {
+ if (al->bh.data) return US"already bh data";
+
+ /* The bodyhash can have FWS inserted in the content;
+ make a stripped copy */
+
+ while ((c = *++s) && c != ';')
+ if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
+ g = string_catn(g, s, 1);
+ if (!g) return US"no bh= value";
+ al->bh.len = len_string_from_gstring(g, &al->bh.data);
+ gstring_release_unused(g);
+ }
+ break;
+ default:
+ return US"b? tag";
+ }
}
- }
break;
case 'c':
- switch (*s)
+ if (l_ext == le_all) switch (*s)
{
case '=': /* c= AMS canonicalisation */
if (arc_insert_tagvalue(al, offsetof(arc_line, c), &s)) return US"c tag dup";
}
break;
case 'v': /* cv= AS validity */
- if (*++s != '=') return US"cv tag val";
- if (arc_insert_tagvalue(al, offsetof(arc_line, cv), &s)) return US"cv tag dup";
+ s = skip_fws(s);
+ if (*++s == '=')
+ if (arc_insert_tagvalue(al, offsetof(arc_line, cv), &s))
+ return US"cv tag dup";
break;
- default:
- return US"c? tag";
}
break;
case 'd': /* d= AMS domain */
- if (*s != '=') return US"d tag val";
- if (arc_insert_tagvalue(al, offsetof(arc_line, d), &s)) return US"d tag dup";
+ if (l_ext == le_all && *s == '=')
+ if (arc_insert_tagvalue(al, offsetof(arc_line, d), &s))
+ return US"d tag dup";
break;
case 'h': /* h= AMS headers */
- if (*s != '=') return US"h tag val";
- if (arc_insert_tagvalue(al, offsetof(arc_line, h), &s)) return US"h tag dup";
+ if (*s == '=')
+ if (arc_insert_tagvalue(al, offsetof(arc_line, h), &s))
+ return US"h tag dup";
break;
case 'i': /* i= ARC set instance */
- if (*s != '=') return US"i tag val";
- if (arc_insert_tagvalue(al, offsetof(arc_line, i), &s)) return US"i tag dup";
- if (instance_only) goto done;
+ if (*s == '=')
+ {
+ if (arc_insert_tagvalue(al, offsetof(arc_line, i), &s))
+ return US"i tag dup";
+ if (l_ext == le_instance_only)
+ goto done; /* early-out */
+ }
break;
case 'l': /* l= bodylength */
- if (*s != '=') return US"l tag val";
- if (arc_insert_tagvalue(al, offsetof(arc_line, l), &s)) return US"l tag dup";
+ if (l_ext == le_all && *s == '=')
+ if (arc_insert_tagvalue(al, offsetof(arc_line, l), &s))
+ return US"l tag dup";
break;
- case 's': /* s= AMS selector */
- if (*s != '=') return US"s tag val";
- if (arc_insert_tagvalue(al, offsetof(arc_line, s), &s)) return US"s tag dup";
+ case 's':
+ if (*s == '=' && l_ext == le_all)
+ {
+ if (arc_insert_tagvalue(al, offsetof(arc_line, s), &s))
+ return US"s tag dup";
+ }
+ else if ( l_ext == le_instance_plus_ip
+ && Ustrncmp(s, "mtp.remote-ip", 13) == 0)
+ { /* smtp.remote-ip= AAR reception data */
+ s += 13;
+ s = skip_fws(s);
+ if (*s != '=') return US"smtp.remote_ip tag val";
+ if (arc_insert_tagvalue(al, offsetof(arc_line, ip), &s))
+ return US"ip tag dup";
+ }
break;
}
- while ((c = *s) && c != ';') s++;
+ while ((c = *s) && c != ';') s++; /* end of this tag=value */
if (c) s++; /* ; after tag-spec */
/* for all but the b= tag, copy the field including FWS. For the b=,
drop the tag content. */
- if (!instance_only)
+ if (r)
if (bstart)
{
size_t n = bstart - fieldstart;
}
}
-if (!instance_only)
+if (r)
*r = '\0';
done:
static uschar *
arc_insert_hdr(arc_ctx * ctx, header_line * h, unsigned off, unsigned hoff,
- BOOL instance_only, arc_line ** alp_ret)
+ line_extract_t l_ext, arc_line ** alp_ret)
{
unsigned i;
arc_set * as;
-arc_line * al = store_get(sizeof(arc_line), FALSE), ** alp;
+arc_line * al = store_get(sizeof(arc_line), GET_UNTAINTED), ** alp;
uschar * e;
memset(al, 0, sizeof(arc_line));
-if ((e = arc_parse_line(al, h, off, instance_only)))
+if ((e = arc_parse_line(al, h, off, l_ext)))
{
DEBUG(D_acl) if (e) debug_printf("ARC: %s\n", e);
- return US"line parse";
+ return string_sprintf("line parse: %s", e);
}
if (!(i = arc_instance_from_hdr(al))) return US"instance find";
if (i > 50) return US"overlarge instance number";
+/* Called for both Sign and Verify */
static const uschar *
-arc_try_header(arc_ctx * ctx, header_line * h, BOOL instance_only)
+arc_try_header(arc_ctx * ctx, header_line * h, BOOL is_signing)
{
const uschar * e;
debug_printf("ARC: found AAR: %.*s\n", len, h->text);
}
if ((e = arc_insert_hdr(ctx, h, ARC_HDRLEN_AAR, offsetof(arc_set, hdr_aar),
- TRUE, NULL)))
+ is_signing ? le_instance_only : le_instance_plus_ip, NULL)))
{
DEBUG(D_acl) debug_printf("inserting AAR: %s\n", e);
- return US"inserting AAR";
+ return string_sprintf("inserting AAR: %s", e);
}
}
else if (strncmpic(ARC_HDR_AMS, h->text, ARC_HDRLEN_AMS) == 0)
debug_printf("ARC: found AMS: %.*s\n", len, h->text);
}
if ((e = arc_insert_hdr(ctx, h, ARC_HDRLEN_AMS, offsetof(arc_set, hdr_ams),
- instance_only, &ams)))
+ is_signing ? le_instance_only : le_all, &ams)))
{
DEBUG(D_acl) debug_printf("inserting AMS: %s\n", e);
- return US"inserting AMS";
+ return string_sprintf("inserting AMS: %s", e);
}
/* defaults */
debug_printf("ARC: found AS: %.*s\n", len, h->text);
}
if ((e = arc_insert_hdr(ctx, h, ARC_HDRLEN_AS, offsetof(arc_set, hdr_as),
- instance_only, NULL)))
+ is_signing ? le_instance_only : le_all, NULL)))
{
DEBUG(D_acl) debug_printf("inserting AS: %s\n", e);
- return US"inserting AS";
+ return string_sprintf("inserting AS: %s", e);
}
}
return NULL;
/* Gather the chain of arc sets from the headers.
Check for duplicates while that is done. Also build the
-reverse-order headers list;
+reverse-order headers list.
+Called on an ACL verify=arc condition.
Return: ARC state if determined, eg. by lack of any ARC chain.
*/
DEBUG(D_acl) debug_printf("ARC: collecting arc sets\n");
for (h = header_list; h; h = h->next)
{
- r = store_get(sizeof(hdr_rlist), FALSE);
+ r = store_get(sizeof(hdr_rlist), GET_UNTAINTED);
r->prev = rprev;
r->used = FALSE;
r->h = h;
len = Ustrlen(s);
DEBUG(D_acl) pdkim_quoteprint(s, len);
- exim_sha_update(&hhash_ctx, s, Ustrlen(s));
+ exim_sha_update_string(&hhash_ctx, s);
r->used = TRUE;
break;
}
static hdr_rlist *
arc_rlist_entry(hdr_rlist * list, const uschar * s, int len)
{
-hdr_rlist * r = store_get(sizeof(hdr_rlist) + sizeof(header_line), FALSE);
+hdr_rlist * r = store_get(sizeof(hdr_rlist) + sizeof(header_line), GET_UNTAINTED);
header_line * h = r->h = (header_line *)(r+1);
r->prev = list;
h->slen = len;
h->text = US s;
-/* This works for either NL or CRLF lines; also nul-termination */
-while (*++s)
- if (*s == '\n' && s[1] != '\t' && s[1] != ' ') break;
-s++; /* move past end of line */
-
return r;
}
{
int aar_off = gstring_length(g);
arc_set * as =
- store_get(sizeof(arc_set) + sizeof(arc_line) + sizeof(header_line), FALSE);
+ store_get(sizeof(arc_set) + sizeof(arc_line) + sizeof(header_line), GET_UNTAINTED);
arc_line * al = (arc_line *)(as+1);
header_line * h = (header_line *)(al+1);
g = string_catn(g, ARC_HDR_AAR, ARC_HDRLEN_AAR);
-g = string_fmt_append(g, " i=%d; %s;\r\n\t", instance, identity);
+g = string_fmt_append(g, " i=%d; %s; smtp.remote-ip=%s;\r\n\t",
+ instance, identity, sender_host_address);
g = string_catn(g, US ar->data, ar->len);
h->slen = g->ptr - aar_off;
int hashtype = pdkim_hashname_to_hashtype(US"sha256", 6); /*XXX hardwired */
blob sig;
int ams_off;
-arc_line * al = store_get(sizeof(header_line) + sizeof(arc_line), FALSE);
+arc_line * al = store_get(sizeof(header_line) + sizeof(arc_line), GET_UNTAINTED);
header_line * h = (header_line *)(al+1);
/* debug_printf("%s\n", __FUNCTION__); */
/* Construct the to-be-signed AMS pseudo-header: everything but the sig. */
-ams_off = g->ptr;
+ams_off = gstring_length(g);
g = string_fmt_append(g, "%s i=%d; a=rsa-sha256; c=relaxed; d=%s; s=%s",
ARC_HDR_AMS, instance, identity, selector); /*XXX hardwired a= */
if (options & ARC_SIGN_OPT_TSTAMP)
/* Lose the last colon from the h= list */
-if (g->s[g->ptr - 1] == ':') g->ptr--;
+gstring_trim_trailing(g, ':');
g = string_catn(g, US";\r\n\tb=;", 7);
/* Lose the trailing semicolon from the psuedo-header, and append the signature
(folded over lines) and termination to complete it. */
-g->ptr--;
+gstring_trim(g, 1);
g = arc_sign_append_sig(g, &sig);
h->slen = g->ptr - ams_off;
{
gstring * arcset;
uschar * status = arc_ar_cv_status(ar);
-arc_line * al = store_get(sizeof(header_line) + sizeof(arc_line), FALSE);
+arc_line * al = store_get(sizeof(header_line) + sizeof(arc_line), GET_UNTAINTED);
header_line * h = (header_line *)(al+1);
uschar * badline_str;
arc_sign_init(void)
{
memset(&arc_sign_ctx, 0, sizeof(arc_sign_ctx));
+headers_rlist = NULL;
}
static const uschar *
arc_header_sign_feed(gstring * g)
{
-uschar * s = string_copyn(g->s, g->ptr);
+uschar * s = string_copy_from_gstring(g);
headers_rlist = arc_rlist_entry(headers_rlist, s, g->ptr);
return arc_try_header(&arc_sign_ctx, headers_rlist->h, TRUE);
}
/* Parse the signing specification */
-if ( !(identity = string_nextinlist(&signspec, &sep, NULL, 0)) || !*identity
- || !(selector = string_nextinlist(&signspec, &sep, NULL, 0)) || !*selector
- || !(privkey = string_nextinlist(&signspec, &sep, NULL, 0)) || !*privkey
- )
- {
- s = !*identity ? US"identity" : !*selector ? US"selector" : US"private-key";
- goto bad_arg_ret;
- }
+if (!(identity = string_nextinlist(&signspec, &sep, NULL, 0)) || !*identity)
+ { s = US"identity"; goto bad_arg_ret; }
+if (!(selector = string_nextinlist(&signspec, &sep, NULL, 0)) || !*selector)
+ { s = US"selector"; goto bad_arg_ret; }
+if (!(privkey = string_nextinlist(&signspec, &sep, NULL, 0)) || !*privkey)
+ { s = US"privkey"; goto bad_arg_ret; }
if (!arc_valid_id(identity))
{ s = US"identity"; goto bad_arg_ret; }
if (!arc_valid_id(selector))
{ s = US"selector"; goto bad_arg_ret; }
if (*privkey == '/' && !(privkey = expand_file_big_buffer(privkey)))
- return sigheaders ? sigheaders : string_get(0);
+ goto ret_sigheaders;
if ((opts = string_nextinlist(&signspec, &sep, NULL, 0)))
{
if (!(arc_sign_find_ar(headers, identity, &ar)))
{
log_write(0, LOG_MAIN, "ARC: no Authentication-Results header for signing");
- return sigheaders ? sigheaders : string_get(0);
+ goto ret_sigheaders;
}
/* We previously built the data-struct for the existing ARC chain, if any, using a headers
/* Finally, append the dkim headers and return the lot. */
if (sigheaders) g = string_catn(g, sigheaders->s, sigheaders->ptr);
-(void) string_from_gstring(g);
-gstring_release_unused(g);
-return g;
+
+out:
+ if (!g) return string_get(1);
+ (void) string_from_gstring(g);
+ gstring_release_unused(g);
+ return g;
bad_arg_ret:
log_write(0, LOG_MAIN, "ARC: bad signing-specification (%s)", s);
- return sigheaders ? sigheaders : string_get(0);
+ret_sigheaders:
+ g = sigheaders;
+ goto out;
}
DEBUG(D_receive) debug_printf("ARC: spotted AMS header\n");
/* Parse the AMS header */
-h.next = NULL;
-h.slen = g->size;
-h.text = g->s;
memset(&al, 0, sizeof(arc_line));
-if ((errstr = arc_parse_line(&al, &h, ARC_HDRLEN_AMS, FALSE)))
+h.next = NULL;
+h.slen = len_string_from_gstring(g, &h.text);
+if ((errstr = arc_parse_line(&al, &h, ARC_HDRLEN_AMS, le_all)))
{
DEBUG(D_acl) if (errstr) debug_printf("ARC: %s\n", errstr);
goto badline;
else
g = string_catn(g, US":", 1);
}
-return g ? g->s : US"";
+if (!g) return US"";
+return string_from_gstring(g);
}
{
arc_line * highest_ams;
int start = 0; /* Compiler quietening */
- DEBUG(D_acl) start = g->ptr;
+ DEBUG(D_acl) start = gstring_length(g);
g = string_append(g, 2, US";\n\tarc=", arc_state);
if (arc_received_instance > 0)
}
else if (arc_state_reason)
g = string_append(g, 3, US" (", arc_state_reason, US")");
- DEBUG(D_acl) debug_printf("ARC: authres '%.*s'\n",
- g->ptr - start - 3, g->s + start + 3);
+ DEBUG(D_acl) debug_printf("ARC:\tauthres '%.*s'\n",
+ gstring_length(g) - start - 3, g->s + start + 3);
+ }
+else
+ DEBUG(D_acl) debug_printf("ARC:\tno authres\n");
+return g;
+}
+
+
+# ifdef SUPPORT_DMARC
+/* Append a DMARC history record pair for ARC, to the given history set */
+
+gstring *
+arc_dmarc_hist_append(gstring * g)
+{
+if (arc_state)
+ {
+ BOOL first = TRUE;
+ int i = Ustrcmp(arc_state, "pass") == 0 ? ARES_RESULT_PASS
+ : Ustrcmp(arc_state, "fail") == 0 ? ARES_RESULT_FAIL
+ : ARES_RESULT_UNKNOWN;
+ g = string_fmt_append(g, "arc %d\n", i);
+ g = string_fmt_append(g, "arc_policy %d json[",
+ i == ARES_RESULT_PASS ? DMARC_ARC_POLICY_RESULT_PASS
+ : i == ARES_RESULT_FAIL ? DMARC_ARC_POLICY_RESULT_FAIL
+ : DMARC_ARC_POLICY_RESULT_UNUSED);
+ /*XXX would we prefer this backwards? */
+ for (arc_set * as = arc_verify_ctx.arcset_chain; as;
+ as = as->next, first = FALSE)
+ {
+ arc_line * line = as->hdr_as;
+ if (line)
+ {
+ blob * d = &line->d;
+ blob * s = &line->s;
+
+ if (!first)
+ g = string_catn(g, US",", 1);
+
+ g = string_fmt_append(g, " (\"i\":%u," /*)*/
+ " \"d\":\"%.*s\","
+ " \"s\":\"%.*s\"",
+ as->instance,
+ d->data ? (int)d->len : 0, d->data && d->len ? d->data : US"",
+ s->data ? (int)s->len : 0, s->data && s->len ? s->data : US""
+ );
+ if ((line = as->hdr_aar))
+ {
+ blob * ip = &line->ip;
+ if (ip->data && ip->len)
+ g = string_fmt_append(g, ", \"ip\":\"%.*s\"", (int)ip->len, ip->data);
+ }
+
+ g = string_catn(g, US")", 1);
+ }
+ }
+ g = string_catn(g, US" ]\n", 3);
}
else
- DEBUG(D_acl) debug_printf("ARC: no authres\n");
+ g = string_fmt_append(g, "arc %d\narc_policy $d json:[]\n",
+ ARES_RESULT_UNKNOWN, DMARC_ARC_POLICY_RESULT_UNUSED);
return g;
}
+# endif
# endif /* DISABLE_DKIM */
git://git.exim.org / exim.git / blobdiff