src/src/arc.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4 /* Experimental ARC support for Exim
   5    Copyright (c) Jeremy Harris 2018 - 2020
   6    Copyright (c) The Exim Maintainers 2021 - 2022
   7    License: GPL
   8    SPDX-License-Identifier: GPL-2.0-or-later
   9 */
  10
  11 #include "exim.h"
  12 #if defined EXPERIMENTAL_ARC
  13 # if defined DISABLE_DKIM
  14 #  error DKIM must also be enabled for ARC
  15 # else
  16
  17 #  include "functions.h"
  18 #  include "pdkim/pdkim.h"
  19 #  include "pdkim/signing.h"
  20
  21 extern pdkim_ctx * dkim_verify_ctx;
  22 extern pdkim_ctx dkim_sign_ctx;
  23
  24 #define ARC_SIGN_OPT_TSTAMP     BIT(0)
  25 #define ARC_SIGN_OPT_EXPIRE     BIT(1)
  26
  27 #define ARC_SIGN_DEFAULT_EXPIRE_DELTA (60 * 60 * 24 * 30)       /* one month */
  28
  29 /******************************************************************************/
  30
  31 typedef struct hdr_rlist {
  32   struct hdr_rlist *    prev;
  33   BOOL                  used;
  34   header_line *         h;
  35 } hdr_rlist;
  36
  37 typedef struct arc_line {
  38   header_line * complete;       /* including the header name; nul-term */
  39   uschar *      relaxed;
  40
  41   /* identified tag contents */
  42   /*XXX t= for AS? */
  43   blob          i;
  44   blob          cv;
  45   blob          a;
  46   blob          b;
  47   blob          bh;
  48   blob          d;
  49   blob          h;
  50   blob          s;
  51   blob          c;
  52   blob          l;
  53
  54   /* tag content sub-portions */
  55   blob          a_algo;
  56   blob          a_hash;
  57
  58   blob          c_head;
  59   blob          c_body;
  60
  61   /* modified copy of b= field in line */
  62   blob          rawsig_no_b_val;
  63 } arc_line;
  64
  65 typedef struct arc_set {
  66   struct arc_set *      next;
  67   struct arc_set *      prev;
  68
  69   unsigned              instance;
  70   arc_line *            hdr_aar;
  71   arc_line *            hdr_ams;
  72   arc_line *            hdr_as;
  73
  74   const uschar *        ams_verify_done;
  75   BOOL                  ams_verify_passed;
  76 } arc_set;
  77
  78 typedef struct arc_ctx {
  79   arc_set *     arcset_chain;
  80   arc_set *     arcset_chain_last;
  81 } arc_ctx;
  82
  83 #define ARC_HDR_AAR     US"ARC-Authentication-Results:"
  84 #define ARC_HDRLEN_AAR  27
  85 #define ARC_HDR_AMS     US"ARC-Message-Signature:"
  86 #define ARC_HDRLEN_AMS  22
  87 #define ARC_HDR_AS      US"ARC-Seal:"
  88 #define ARC_HDRLEN_AS   9
  89 #define HDR_AR          US"Authentication-Results:"
  90 #define HDRLEN_AR       23
  91
  92 static time_t now;
  93 static time_t expire;
  94 static hdr_rlist * headers_rlist;
  95 static arc_ctx arc_sign_ctx = { NULL };
  96 static arc_ctx arc_verify_ctx = { NULL };
  97
  98
  99 /******************************************************************************/
 100
 101
 102 /* Get the instance number from the header.
 103 Return 0 on error */
 104 static unsigned
 105 arc_instance_from_hdr(const arc_line * al)
 106 {
 107 const uschar * s = al->i.data;
 108 if (!s || !al->i.len) return 0;
 109 return (unsigned) atoi(CCS s);
 110 }
 111
 112
 113 static uschar *
 114 skip_fws(uschar * s)
 115 {
 116 uschar c = *s;
 117 while (c && (c == ' ' || c == '\t' || c == '\n' || c == '\r')) c = *++s;
 118 return s;
 119 }
 120
 121
 122 /* Locate instance struct on chain, inserting a new one if
 123 needed.  The chain is in increasing-instance-number order
 124 by the "next" link, and we have a "prev" link also.
 125 */
 126
 127 static arc_set *
 128 arc_find_set(arc_ctx * ctx, unsigned i)
 129 {
 130 arc_set ** pas, * as, * next, * prev;
 131
 132 for (pas = &ctx->arcset_chain, prev = NULL, next = ctx->arcset_chain;
 133      as = *pas; pas = &as->next)
 134   {
 135   if (as->instance > i) break;
 136   if (as->instance == i)
 137     {
 138     DEBUG(D_acl) debug_printf("ARC: existing instance %u\n", i);
 139     return as;
 140     }
 141   next = as->next;
 142   prev = as;
 143   }
 144
 145 DEBUG(D_acl) debug_printf("ARC: new instance %u\n", i);
 146 *pas = as = store_get(sizeof(arc_set), GET_UNTAINTED);
 147 memset(as, 0, sizeof(arc_set));
 148 as->next = next;
 149 as->prev = prev;
 150 as->instance = i;
 151 if (next)
 152   next->prev = as;
 153 else
 154   ctx->arcset_chain_last = as;
 155 return as;
 156 }
 157
 158
 159
 160 /* Insert a tag content into the line structure.
 161 Note this is a reference to existing data, not a copy.
 162 Check for already-seen tag.
 163 The string-pointer is on the '=' for entry.  Update it past the
 164 content (to the ;) on return;
 165 */
 166
 167 static uschar *
 168 arc_insert_tagvalue(arc_line * al, unsigned loff, uschar ** ss)
 169 {
 170 uschar * s = *ss;
 171 uschar c = *++s;
 172 blob * b = (blob *)(US al + loff);
 173 size_t len = 0;
 174
 175 /* [FWS] tag-value [FWS] */
 176
 177 if (b->data) return US"fail";
 178 s = skip_fws(s);                                                /* FWS */
 179
 180 b->data = s;
 181 while ((c = *s) && c != ';') { len++; s++; }
 182 *ss = s;
 183 while (len && ((c = s[-1]) == ' ' || c == '\t' || c == '\n' || c == '\r'))
 184   { s--; len--; }                                               /* FWS */
 185 b->len = len;
 186 return NULL;
 187 }
 188
 189
 190 /* Inspect a header line, noting known tag fields.
 191 Check for duplicates. */
 192
 193 static uschar *
 194 arc_parse_line(arc_line * al, header_line * h, unsigned off, BOOL instance_only)
 195 {
 196 uschar * s = h->text + off;
 197 uschar * r = NULL;      /* compiler-quietening */
 198 uschar c;
 199
 200 al->complete = h;
 201
 202 if (!instance_only)
 203   {
 204   al->rawsig_no_b_val.data = store_get(h->slen + 1, GET_TAINTED);
 205   memcpy(al->rawsig_no_b_val.data, h->text, off);       /* copy the header name blind */
 206   r = al->rawsig_no_b_val.data + off;
 207   al->rawsig_no_b_val.len = off;
 208   }
 209
 210 /* tag-list  =  tag-spec *( ";" tag-spec ) [ ";" ] */
 211
 212 while ((c = *s))
 213   {
 214   char tagchar;
 215   uschar * t;
 216   unsigned i = 0;
 217   uschar * fieldstart = s;
 218   uschar * bstart = NULL, * bend;
 219
 220   /* tag-spec  =  [FWS] tag-name [FWS] "=" [FWS] tag-value [FWS] */
 221
 222   s = skip_fws(s);                                              /* FWS */
 223   if (!*s) break;
 224 /* debug_printf("%s: consider '%s'\n", __FUNCTION__, s); */
 225   tagchar = *s++;
 226   s = skip_fws(s);                                              /* FWS */
 227   if (!*s) break;
 228
 229   if (!instance_only || tagchar == 'i') switch (tagchar)
 230     {
 231     case 'a':                           /* a= AMS algorithm */
 232       {
 233       if (*s != '=') return US"no 'a' value";
 234       if (arc_insert_tagvalue(al, offsetof(arc_line, a), &s)) return US"a tag dup";
 235
 236       /* substructure: algo-hash   (eg. rsa-sha256) */
 237
 238       t = al->a_algo.data = al->a.data;
 239       while (*t != '-')
 240         if (!*t++ || ++i > al->a.len) return US"no '-' in 'a' value";
 241       al->a_algo.len = i;
 242       if (*t++ != '-') return US"no '-' in 'a' value";
 243       al->a_hash.data = t;
 244       al->a_hash.len = al->a.len - i - 1;
 245       }
 246       break;
 247     case 'b':
 248       {
 249       gstring * g = NULL;
 250
 251       switch (*s)
 252         {
 253         case '=':                       /* b= AMS signature */
 254           if (al->b.data) return US"already b data";
 255           bstart = s+1;
 256
 257           /* The signature can have FWS inserted in the content;
 258           make a stripped copy */
 259
 260           while ((c = *++s) && c != ';')
 261             if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
 262               g = string_catn(g, s, 1);
 263           if (!g) return US"no b= value";
 264           al->b.len = len_string_from_gstring(g, &al->b.data);
 265           gstring_release_unused(g);
 266           bend = s;
 267           break;
 268         case 'h':                       /* bh= AMS body hash */
 269           s = skip_fws(++s);                                    /* FWS */
 270           if (*s != '=') return US"no bh value";
 271           if (al->bh.data) return US"already bh data";
 272
 273           /* The bodyhash can have FWS inserted in the content;
 274           make a stripped copy */
 275
 276           while ((c = *++s) && c != ';')
 277             if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
 278               g = string_catn(g, s, 1);
 279           if (!g) return US"no bh= value";
 280           al->bh.len = len_string_from_gstring(g, &al->bh.data);
 281           gstring_release_unused(g);
 282           break;
 283         default:
 284           return US"b? tag";
 285         }
 286       }
 287       break;
 288     case 'c':
 289       switch (*s)
 290         {
 291         case '=':                       /* c= AMS canonicalisation */
 292           if (arc_insert_tagvalue(al, offsetof(arc_line, c), &s)) return US"c tag dup";
 293
 294           /* substructure: head/body   (eg. relaxed/simple)) */
 295
 296           t = al->c_head.data = al->c.data;
 297           while (isalpha(*t))
 298             if (!*t++ || ++i > al->a.len) break;
 299           al->c_head.len = i;
 300           if (*t++ == '/')              /* /body is optional */
 301             {
 302             al->c_body.data = t;
 303             al->c_body.len = al->c.len - i - 1;
 304             }
 305           else
 306             {
 307             al->c_body.data = US"simple";
 308             al->c_body.len = 6;
 309             }
 310           break;
 311         case 'v':                       /* cv= AS validity */
 312           if (*++s != '=') return US"cv tag val";
 313           if (arc_insert_tagvalue(al, offsetof(arc_line, cv), &s)) return US"cv tag dup";
 314           break;
 315         default:
 316           return US"c? tag";
 317         }
 318       break;
 319     case 'd':                           /* d= AMS domain */
 320       if (*s != '=') return US"d tag val";
 321       if (arc_insert_tagvalue(al, offsetof(arc_line, d), &s)) return US"d tag dup";
 322       break;
 323     case 'h':                           /* h= AMS headers */
 324       if (*s != '=') return US"h tag val";
 325       if (arc_insert_tagvalue(al, offsetof(arc_line, h), &s)) return US"h tag dup";
 326       break;
 327     case 'i':                           /* i= ARC set instance */
 328       if (*s != '=') return US"i tag val";
 329       if (arc_insert_tagvalue(al, offsetof(arc_line, i), &s)) return US"i tag dup";
 330       if (instance_only) goto done;
 331       break;
 332     case 'l':                           /* l= bodylength */
 333       if (*s != '=') return US"l tag val";
 334       if (arc_insert_tagvalue(al, offsetof(arc_line, l), &s)) return US"l tag dup";
 335       break;
 336     case 's':                           /* s= AMS selector */
 337       if (*s != '=') return US"s tag val";
 338       if (arc_insert_tagvalue(al, offsetof(arc_line, s), &s)) return US"s tag dup";
 339       break;
 340     }
 341
 342   while ((c = *s) && c != ';') s++;
 343   if (c) s++;                           /* ; after tag-spec */
 344
 345   /* for all but the b= tag, copy the field including FWS.  For the b=,
 346   drop the tag content. */
 347
 348   if (!instance_only)
 349     if (bstart)
 350       {
 351       size_t n = bstart - fieldstart;
 352       memcpy(r, fieldstart, n);         /* FWS "b=" */
 353       r += n;
 354       al->rawsig_no_b_val.len += n;
 355       n = s - bend;
 356       memcpy(r, bend, n);               /* FWS ";" */
 357       r += n;
 358       al->rawsig_no_b_val.len += n;
 359       }
 360     else
 361       {
 362       size_t n = s - fieldstart;
 363       memcpy(r, fieldstart, n);
 364       r += n;
 365       al->rawsig_no_b_val.len += n;
 366       }
 367   }
 368
 369 if (!instance_only)
 370   *r = '\0';
 371
 372 done:
 373 /* debug_printf("%s: finshed\n", __FUNCTION__); */
 374 return NULL;
 375 }
 376
 377
 378 /* Insert one header line in the correct set of the chain,
 379 adding instances as needed and checking for duplicate lines.
 380 */
 381
 382 static uschar *
 383 arc_insert_hdr(arc_ctx * ctx, header_line * h, unsigned off, unsigned hoff,
 384   BOOL instance_only, arc_line ** alp_ret)
 385 {
 386 unsigned i;
 387 arc_set * as;
 388 arc_line * al = store_get(sizeof(arc_line), GET_UNTAINTED), ** alp;
 389 uschar * e;
 390
 391 memset(al, 0, sizeof(arc_line));
 392
 393 if ((e = arc_parse_line(al, h, off, instance_only)))
 394   {
 395   DEBUG(D_acl) if (e) debug_printf("ARC: %s\n", e);
 396   return US"line parse";
 397   }
 398 if (!(i = arc_instance_from_hdr(al)))   return US"instance find";
 399 if (i > 50)                             return US"overlarge instance number";
 400 if (!(as = arc_find_set(ctx, i)))       return US"set find";
 401 if (*(alp = (arc_line **)(US as + hoff))) return US"dup hdr";
 402
 403 *alp = al;
 404 if (alp_ret) *alp_ret = al;
 405 return NULL;
 406 }
 407
 408
 409
 410
 411 static const uschar *
 412 arc_try_header(arc_ctx * ctx, header_line * h, BOOL instance_only)
 413 {
 414 const uschar * e;
 415
 416 /*debug_printf("consider hdr '%s'\n", h->text);*/
 417 if (strncmpic(ARC_HDR_AAR, h->text, ARC_HDRLEN_AAR) == 0)
 418   {
 419   DEBUG(D_acl)
 420     {
 421     int len = h->slen;
 422     uschar * s;
 423     for (s = h->text + h->slen; s[-1] == '\r' || s[-1] == '\n'; )
 424       s--, len--;
 425     debug_printf("ARC: found AAR: %.*s\n", len, h->text);
 426     }
 427   if ((e = arc_insert_hdr(ctx, h, ARC_HDRLEN_AAR, offsetof(arc_set, hdr_aar),
 428                           TRUE, NULL)))
 429     {
 430     DEBUG(D_acl) debug_printf("inserting AAR: %s\n", e);
 431     return US"inserting AAR";
 432     }
 433   }
 434 else if (strncmpic(ARC_HDR_AMS, h->text, ARC_HDRLEN_AMS) == 0)
 435   {
 436   arc_line * ams;
 437
 438   DEBUG(D_acl)
 439     {
 440     int len = h->slen;
 441     uschar * s;
 442     for (s = h->text + h->slen; s[-1] == '\r' || s[-1] == '\n'; )
 443       s--, len--;
 444     debug_printf("ARC: found AMS: %.*s\n", len, h->text);
 445     }
 446   if ((e = arc_insert_hdr(ctx, h, ARC_HDRLEN_AMS, offsetof(arc_set, hdr_ams),
 447                           instance_only, &ams)))
 448     {
 449     DEBUG(D_acl) debug_printf("inserting AMS: %s\n", e);
 450     return US"inserting AMS";
 451     }
 452
 453   /* defaults */
 454   if (!ams->c.data)
 455     {
 456     ams->c_head.data = US"simple"; ams->c_head.len = 6;
 457     ams->c_body = ams->c_head;
 458     }
 459   }
 460 else if (strncmpic(ARC_HDR_AS, h->text, ARC_HDRLEN_AS) == 0)
 461   {
 462   DEBUG(D_acl)
 463     {
 464     int len = h->slen;
 465     uschar * s;
 466     for (s = h->text + h->slen; s[-1] == '\r' || s[-1] == '\n'; )
 467       s--, len--;
 468     debug_printf("ARC: found AS: %.*s\n", len, h->text);
 469     }
 470   if ((e = arc_insert_hdr(ctx, h, ARC_HDRLEN_AS, offsetof(arc_set, hdr_as),
 471                           instance_only, NULL)))
 472     {
 473     DEBUG(D_acl) debug_printf("inserting AS: %s\n", e);
 474     return US"inserting AS";
 475     }
 476   }
 477 return NULL;
 478 }
 479
 480
 481
 482 /* Gather the chain of arc sets from the headers.
 483 Check for duplicates while that is done.  Also build the
 484 reverse-order headers list;
 485
 486 Return: ARC state if determined, eg. by lack of any ARC chain.
 487 */
 488
 489 static const uschar *
 490 arc_vfy_collect_hdrs(arc_ctx * ctx)
 491 {
 492 header_line * h;
 493 hdr_rlist * r = NULL, * rprev = NULL;
 494 const uschar * e;
 495
 496 DEBUG(D_acl) debug_printf("ARC: collecting arc sets\n");
 497 for (h = header_list; h; h = h->next)
 498   {
 499   r = store_get(sizeof(hdr_rlist), GET_UNTAINTED);
 500   r->prev = rprev;
 501   r->used = FALSE;
 502   r->h = h;
 503   rprev = r;
 504
 505   if ((e = arc_try_header(ctx, h, FALSE)))
 506     {
 507     arc_state_reason = string_sprintf("collecting headers: %s", e);
 508     return US"fail";
 509     }
 510   }
 511 headers_rlist = r;
 512
 513 if (!ctx->arcset_chain) return US"none";
 514 return NULL;
 515 }
 516
 517
 518 static BOOL
 519 arc_cv_match(arc_line * al, const uschar * s)
 520 {
 521 return Ustrncmp(s, al->cv.data, al->cv.len) == 0;
 522 }
 523
 524 /******************************************************************************/
 525
 526 /* Return the hash of headers from the message that the AMS claims it
 527 signed.
 528 */
 529
 530 static void
 531 arc_get_verify_hhash(arc_ctx * ctx, arc_line * ams, blob * hhash)
 532 {
 533 const uschar * headernames = string_copyn(ams->h.data, ams->h.len);
 534 const uschar * hn;
 535 int sep = ':';
 536 hdr_rlist * r;
 537 BOOL relaxed = Ustrncmp(US"relaxed", ams->c_head.data, ams->c_head.len) == 0;
 538 int hashtype = pdkim_hashname_to_hashtype(
 539                     ams->a_hash.data, ams->a_hash.len);
 540 hctx hhash_ctx;
 541 const uschar * s;
 542 int len;
 543
 544 if (  hashtype == -1
 545    || !exim_sha_init(&hhash_ctx, pdkim_hashes[hashtype].exim_hashmethod))
 546   {
 547   DEBUG(D_acl)
 548       debug_printf("ARC: hash setup error, possibly nonhandled hashtype\n");
 549   return;
 550   }
 551
 552 /* For each headername in the list from the AMS (walking in order)
 553 walk the message headers in reverse order, adding to the hash any
 554 found for the first time. For that last point, maintain used-marks
 555 on the list of message headers. */
 556
 557 DEBUG(D_acl) debug_printf("ARC: AMS header data for verification:\n");
 558
 559 for (r = headers_rlist; r; r = r->prev)
 560   r->used = FALSE;
 561 while ((hn = string_nextinlist(&headernames, &sep, NULL, 0)))
 562   for (r = headers_rlist; r; r = r->prev)
 563     if (  !r->used
 564        && strncasecmp(CCS (s = r->h->text), CCS hn, Ustrlen(hn)) == 0
 565        )
 566       {
 567       if (relaxed) s = pdkim_relax_header_n(s, r->h->slen, TRUE);
 568
 569       len = Ustrlen(s);
 570       DEBUG(D_acl) pdkim_quoteprint(s, len);
 571       exim_sha_update_string(&hhash_ctx, s);
 572       r->used = TRUE;
 573       break;
 574       }
 575
 576 /* Finally add in the signature header (with the b= tag stripped); no CRLF */
 577
 578 s = ams->rawsig_no_b_val.data, len = ams->rawsig_no_b_val.len;
 579 if (relaxed)
 580   len = Ustrlen(s = pdkim_relax_header_n(s, len, FALSE));
 581 DEBUG(D_acl) pdkim_quoteprint(s, len);
 582 exim_sha_update(&hhash_ctx, s, len);
 583
 584 exim_sha_finish(&hhash_ctx, hhash);
 585 DEBUG(D_acl)
 586   { debug_printf("ARC: header hash: "); pdkim_hexprint(hhash->data, hhash->len); }
 587 return;
 588 }
 589
 590
 591
 592
 593 static pdkim_pubkey *
 594 arc_line_to_pubkey(arc_line * al)
 595 {
 596 uschar * dns_txt;
 597 pdkim_pubkey * p;
 598
 599 if (!(dns_txt = dkim_exim_query_dns_txt(string_sprintf("%.*s._domainkey.%.*s",
 600           (int)al->s.len, al->s.data, (int)al->d.len, al->d.data))))
 601   {
 602   DEBUG(D_acl) debug_printf("pubkey dns lookup fail\n");
 603   return NULL;
 604   }
 605
 606 if (  !(p = pdkim_parse_pubkey_record(dns_txt))
 607    || (Ustrcmp(p->srvtype, "*") != 0 && Ustrcmp(p->srvtype, "email") != 0)
 608    )
 609   {
 610   DEBUG(D_acl) debug_printf("pubkey dns lookup format error\n");
 611   return NULL;
 612   }
 613
 614 /* If the pubkey limits use to specified hashes, reject unusable
 615 signatures. XXX should we have looked for multiple dns records? */
 616
 617 if (p->hashes)
 618   {
 619   const uschar * list = p->hashes, * ele;
 620   int sep = ':';
 621
 622   while ((ele = string_nextinlist(&list, &sep, NULL, 0)))
 623     if (Ustrncmp(ele, al->a_hash.data, al->a_hash.len) == 0) break;
 624   if (!ele)
 625     {
 626     DEBUG(D_acl) debug_printf("pubkey h=%s vs sig a=%.*s\n",
 627                               p->hashes, (int)al->a.len, al->a.data);
 628     return NULL;
 629     }
 630   }
 631 return p;
 632 }
 633
 634
 635
 636
 637 static pdkim_bodyhash *
 638 arc_ams_setup_vfy_bodyhash(arc_line * ams)
 639 {
 640 int canon_head = -1, canon_body = -1;
 641 long bodylen;
 642
 643 if (!ams->c.data) ams->c.data = US"simple";     /* RFC 6376 (DKIM) default */
 644 pdkim_cstring_to_canons(ams->c.data, ams->c.len, &canon_head, &canon_body);
 645 bodylen = ams->l.data
 646         ? strtol(CS string_copyn(ams->l.data, ams->l.len), NULL, 10) : -1;
 647
 648 return pdkim_set_bodyhash(dkim_verify_ctx,
 649         pdkim_hashname_to_hashtype(ams->a_hash.data, ams->a_hash.len),
 650         canon_body,
 651         bodylen);
 652 }
 653
 654
 655
 656 /* Verify an AMS. This is a DKIM-sig header, but with an ARC i= tag
 657 and without a DKIM v= tag.
 658 */
 659
 660 static const uschar *
 661 arc_ams_verify(arc_ctx * ctx, arc_set * as)
 662 {
 663 arc_line * ams = as->hdr_ams;
 664 pdkim_bodyhash * b;
 665 pdkim_pubkey * p;
 666 blob sighash;
 667 blob hhash;
 668 ev_ctx vctx;
 669 int hashtype;
 670 const uschar * errstr;
 671
 672 as->ams_verify_done = US"in-progress";
 673
 674 /* Check the AMS has all the required tags:
 675    "a="  algorithm
 676    "b="  signature
 677    "bh=" body hash
 678    "d="  domain (for key lookup)
 679    "h="  headers (included in signature)
 680    "s="  key-selector (for key lookup)
 681 */
 682 if (  !ams->a.data || !ams->b.data || !ams->bh.data || !ams->d.data
 683    || !ams->h.data || !ams->s.data)
 684   {
 685   as->ams_verify_done = arc_state_reason = US"required tag missing";
 686   return US"fail";
 687   }
 688
 689
 690 /* The bodyhash should have been created earlier, and the dkim code should
 691 have managed calculating it during message input.  Find the reference to it. */
 692
 693 if (!(b = arc_ams_setup_vfy_bodyhash(ams)))
 694   {
 695   as->ams_verify_done = arc_state_reason = US"internal hash setup error";
 696   return US"fail";
 697   }
 698
 699 DEBUG(D_acl)
 700   {
 701   debug_printf("ARC i=%d AMS   Body bytes hashed: %lu\n"
 702                "              Body %.*s computed: ",
 703                as->instance, b->signed_body_bytes,
 704                (int)ams->a_hash.len, ams->a_hash.data);
 705   pdkim_hexprint(CUS b->bh.data, b->bh.len);
 706   }
 707
 708 /* We know the bh-tag blob is of a nul-term string, so safe as a string */
 709
 710 if (  !ams->bh.data
 711    || (pdkim_decode_base64(ams->bh.data, &sighash), sighash.len != b->bh.len)
 712    || memcmp(sighash.data, b->bh.data, b->bh.len) != 0
 713    )
 714   {
 715   DEBUG(D_acl)
 716     {
 717     debug_printf("ARC i=%d AMS Body hash from headers: ", as->instance);
 718     pdkim_hexprint(sighash.data, sighash.len);
 719     debug_printf("ARC i=%d AMS Body hash did NOT match\n", as->instance);
 720     }
 721   return as->ams_verify_done = arc_state_reason = US"AMS body hash miscompare";
 722   }
 723
 724 DEBUG(D_acl) debug_printf("ARC i=%d AMS Body hash compared OK\n", as->instance);
 725
 726 /* Get the public key from DNS */
 727
 728 if (!(p = arc_line_to_pubkey(ams)))
 729   return as->ams_verify_done = arc_state_reason = US"pubkey problem";
 730
 731 /* We know the b-tag blob is of a nul-term string, so safe as a string */
 732 pdkim_decode_base64(ams->b.data, &sighash);
 733
 734 arc_get_verify_hhash(ctx, ams, &hhash);
 735
 736 /* Setup the interface to the signing library */
 737
 738 if ((errstr = exim_dkim_verify_init(&p->key, KEYFMT_DER, &vctx, NULL)))
 739   {
 740   DEBUG(D_acl) debug_printf("ARC verify init: %s\n", errstr);
 741   as->ams_verify_done = arc_state_reason = US"internal sigverify init error";
 742   return US"fail";
 743   }
 744
 745 hashtype = pdkim_hashname_to_hashtype(ams->a_hash.data, ams->a_hash.len);
 746 if (hashtype == -1)
 747   {
 748   DEBUG(D_acl) debug_printf("ARC i=%d AMS verify bad a_hash\n", as->instance);
 749   return as->ams_verify_done = arc_state_reason = US"AMS sig nonverify";
 750   }
 751
 752 if ((errstr = exim_dkim_verify(&vctx,
 753           pdkim_hashes[hashtype].exim_hashmethod, &hhash, &sighash)))
 754   {
 755   DEBUG(D_acl) debug_printf("ARC i=%d AMS verify %s\n", as->instance, errstr);
 756   return as->ams_verify_done = arc_state_reason = US"AMS sig nonverify";
 757   }
 758
 759 DEBUG(D_acl) debug_printf("ARC i=%d AMS verify pass\n", as->instance);
 760 as->ams_verify_passed = TRUE;
 761 return NULL;
 762 }
 763
 764
 765
 766 /* Check the sets are instance-continuous and that all
 767 members are present.  Check that no arc_seals are "fail".
 768 Set the highest instance number global.
 769 Verify the latest AMS.
 770 */
 771 static uschar *
 772 arc_headers_check(arc_ctx * ctx)
 773 {
 774 arc_set * as;
 775 int inst;
 776 BOOL ams_fail_found = FALSE;
 777
 778 if (!(as = ctx->arcset_chain_last))
 779   return US"none";
 780
 781 for(inst = as->instance; as; as = as->prev, inst--)
 782   {
 783   if (as->instance != inst)
 784     arc_state_reason = string_sprintf("i=%d (sequence; expected %d)",
 785       as->instance, inst);
 786   else if (!as->hdr_aar || !as->hdr_ams || !as->hdr_as)
 787     arc_state_reason = string_sprintf("i=%d (missing header)", as->instance);
 788   else if (arc_cv_match(as->hdr_as, US"fail"))
 789     arc_state_reason = string_sprintf("i=%d (cv)", as->instance);
 790   else
 791     goto good;
 792
 793   DEBUG(D_acl) debug_printf("ARC chain fail at %s\n", arc_state_reason);
 794   return US"fail";
 795
 796   good:
 797   /* Evaluate the oldest-pass AMS validation while we're here.
 798   It does not affect the AS chain validation but is reported as
 799   auxilary info. */
 800
 801   if (!ams_fail_found)
 802     if (arc_ams_verify(ctx, as))
 803       ams_fail_found = TRUE;
 804     else
 805       arc_oldest_pass = inst;
 806   arc_state_reason = NULL;
 807   }
 808 if (inst != 0)
 809   {
 810   arc_state_reason = string_sprintf("(sequence; expected i=%d)", inst);
 811   DEBUG(D_acl) debug_printf("ARC chain fail %s\n", arc_state_reason);
 812   return US"fail";
 813   }
 814
 815 arc_received = ctx->arcset_chain_last;
 816 arc_received_instance = arc_received->instance;
 817
 818 /* We can skip the latest-AMS validation, if we already did it. */
 819
 820 as = ctx->arcset_chain_last;
 821 if (!as->ams_verify_passed)
 822   {
 823   if (as->ams_verify_done)
 824     {
 825     arc_state_reason = as->ams_verify_done;
 826     return US"fail";
 827     }
 828   if (!!arc_ams_verify(ctx, as))
 829     return US"fail";
 830   }
 831 return NULL;
 832 }
 833
 834
 835 /******************************************************************************/
 836 static const uschar *
 837 arc_seal_verify(arc_ctx * ctx, arc_set * as)
 838 {
 839 arc_line * hdr_as = as->hdr_as;
 840 arc_set * as2;
 841 int hashtype;
 842 hctx hhash_ctx;
 843 blob hhash_computed;
 844 blob sighash;
 845 ev_ctx vctx;
 846 pdkim_pubkey * p;
 847 const uschar * errstr;
 848
 849 DEBUG(D_acl) debug_printf("ARC: AS vfy i=%d\n", as->instance);
 850 /*
 851        1.  If the value of the "cv" tag on that seal is "fail", the
 852            chain state is "fail" and the algorithm stops here.  (This
 853            step SHOULD be skipped if the earlier step (2.1) was
 854            performed) [it was]
 855
 856        2.  In Boolean nomenclature: if ((i == 1 && cv != "none") or (cv
 857            == "none" && i != 1)) then the chain state is "fail" and the
 858            algorithm stops here (note that the ordering of the logic is
 859            structured for short-circuit evaluation).
 860 */
 861
 862 if (  as->instance == 1 && !arc_cv_match(hdr_as, US"none")
 863    || arc_cv_match(hdr_as, US"none") && as->instance != 1
 864    )
 865   {
 866   arc_state_reason = US"seal cv state";
 867   return US"fail";
 868   }
 869
 870 /*
 871        3.  Initialize a hash function corresponding to the "a" tag of
 872            the ARC-Seal.
 873 */
 874
 875 hashtype = pdkim_hashname_to_hashtype(hdr_as->a_hash.data, hdr_as->a_hash.len);
 876
 877 if (  hashtype == -1
 878    || !exim_sha_init(&hhash_ctx, pdkim_hashes[hashtype].exim_hashmethod))
 879   {
 880   DEBUG(D_acl)
 881       debug_printf("ARC: hash setup error, possibly nonhandled hashtype\n");
 882   arc_state_reason = US"seal hash setup error";
 883   return US"fail";
 884   }
 885
 886 /*
 887        4.  Compute the canonicalized form of the ARC header fields, in
 888            the order described in Section 5.4.2, using the "relaxed"
 889            header canonicalization defined in Section 3.4.2 of
 890            [RFC6376].  Pass the canonicalized result to the hash
 891            function.
 892
 893 Headers are CRLF-separated, but the last one is not crlf-terminated.
 894 */
 895
 896 DEBUG(D_acl) debug_printf("ARC: AS header data for verification:\n");
 897 for (as2 = ctx->arcset_chain;
 898      as2 && as2->instance <= as->instance;
 899      as2 = as2->next)
 900   {
 901   arc_line * al;
 902   uschar * s;
 903   int len;
 904
 905   al = as2->hdr_aar;
 906   if (!(s = al->relaxed))
 907     al->relaxed = s = pdkim_relax_header_n(al->complete->text,
 908                                             al->complete->slen, TRUE);
 909   len = Ustrlen(s);
 910   DEBUG(D_acl) pdkim_quoteprint(s, len);
 911   exim_sha_update(&hhash_ctx, s, len);
 912
 913   al = as2->hdr_ams;
 914   if (!(s = al->relaxed))
 915     al->relaxed = s = pdkim_relax_header_n(al->complete->text,
 916                                             al->complete->slen, TRUE);
 917   len = Ustrlen(s);
 918   DEBUG(D_acl) pdkim_quoteprint(s, len);
 919   exim_sha_update(&hhash_ctx, s, len);
 920
 921   al = as2->hdr_as;
 922   if (as2->instance == as->instance)
 923     s = pdkim_relax_header_n(al->rawsig_no_b_val.data,
 924                                         al->rawsig_no_b_val.len, FALSE);
 925   else if (!(s = al->relaxed))
 926     al->relaxed = s = pdkim_relax_header_n(al->complete->text,
 927                                             al->complete->slen, TRUE);
 928   len = Ustrlen(s);
 929   DEBUG(D_acl) pdkim_quoteprint(s, len);
 930   exim_sha_update(&hhash_ctx, s, len);
 931   }
 932
 933 /*
 934        5.  Retrieve the final digest from the hash function.
 935 */
 936
 937 exim_sha_finish(&hhash_ctx, &hhash_computed);
 938 DEBUG(D_acl)
 939   {
 940   debug_printf("ARC i=%d AS Header %.*s computed: ",
 941     as->instance, (int)hdr_as->a_hash.len, hdr_as->a_hash.data);
 942   pdkim_hexprint(hhash_computed.data, hhash_computed.len);
 943   }
 944
 945
 946 /*
 947        6.  Retrieve the public key identified by the "s" and "d" tags in
 948            the ARC-Seal, as described in Section 4.1.6.
 949 */
 950
 951 if (!(p = arc_line_to_pubkey(hdr_as)))
 952   return US"pubkey problem";
 953
 954 /*
 955        7.  Determine whether the signature portion ("b" tag) of the ARC-
 956            Seal and the digest computed above are valid according to the
 957            public key.  (See also Section Section 8.4 for failure case
 958            handling)
 959
 960        8.  If the signature is not valid, the chain state is "fail" and
 961            the algorithm stops here.
 962 */
 963
 964 /* We know the b-tag blob is of a nul-term string, so safe as a string */
 965 pdkim_decode_base64(hdr_as->b.data, &sighash);
 966
 967 if ((errstr = exim_dkim_verify_init(&p->key, KEYFMT_DER, &vctx, NULL)))
 968   {
 969   DEBUG(D_acl) debug_printf("ARC verify init: %s\n", errstr);
 970   return US"fail";
 971   }
 972
 973 if ((errstr = exim_dkim_verify(&vctx,
 974               pdkim_hashes[hashtype].exim_hashmethod,
 975               &hhash_computed, &sighash)))
 976   {
 977   DEBUG(D_acl)
 978     debug_printf("ARC i=%d AS headers verify: %s\n", as->instance, errstr);
 979   arc_state_reason = US"seal sigverify error";
 980   return US"fail";
 981   }
 982
 983 DEBUG(D_acl) debug_printf("ARC: AS vfy i=%d pass\n", as->instance);
 984 return NULL;
 985 }
 986
 987
 988 static const uschar *
 989 arc_verify_seals(arc_ctx * ctx)
 990 {
 991 arc_set * as = ctx->arcset_chain_last;
 992
 993 if (!as)
 994   return US"none";
 995
 996 for ( ; as; as = as->prev) if (arc_seal_verify(ctx, as)) return US"fail";
 997
 998 DEBUG(D_acl) debug_printf("ARC: AS vfy overall pass\n");
 999 return NULL;
1000 }
1001 /******************************************************************************/
1002
1003 /* Do ARC verification.  Called from DATA ACL, on a verify = arc
1004 condition.  No arguments; we are checking globals.
1005
1006 Return:  The ARC state, or NULL on error.
1007 */
1008
1009 const uschar *
1010 acl_verify_arc(void)
1011 {
1012 const uschar * res;
1013
1014 memset(&arc_verify_ctx, 0, sizeof(arc_verify_ctx));
1015
1016 if (!dkim_verify_ctx)
1017   {
1018   DEBUG(D_acl) debug_printf("ARC: no DKIM verify context\n");
1019   return NULL;
1020   }
1021
1022 /* AS evaluation, per
1023 https://tools.ietf.org/html/draft-ietf-dmarc-arc-protocol-10#section-6
1024 */
1025 /* 1.  Collect all ARC sets currently on the message.  If there were
1026        none, the ARC state is "none" and the algorithm stops here.
1027 */
1028
1029 if ((res = arc_vfy_collect_hdrs(&arc_verify_ctx)))
1030   goto out;
1031
1032 /* 2.  If the form of any ARC set is invalid (e.g., does not contain
1033        exactly one of each of the three ARC-specific header fields),
1034        then the chain state is "fail" and the algorithm stops here.
1035
1036        1.  To avoid the overhead of unnecessary computation and delay
1037            from crypto and DNS operations, the cv value for all ARC-
1038            Seal(s) MAY be checked at this point.  If any of the values
1039            are "fail", then the overall state of the chain is "fail" and
1040            the algorithm stops here.
1041
1042    3.  Conduct verification of the ARC-Message-Signature header field
1043        bearing the highest instance number.  If this verification fails,
1044        then the chain state is "fail" and the algorithm stops here.
1045 */
1046
1047 if ((res = arc_headers_check(&arc_verify_ctx)))
1048   goto out;
1049
1050 /* 4.  For each ARC-Seal from the "N"th instance to the first, apply the
1051        following logic:
1052
1053        1.  If the value of the "cv" tag on that seal is "fail", the
1054            chain state is "fail" and the algorithm stops here.  (This
1055            step SHOULD be skipped if the earlier step (2.1) was
1056            performed)
1057
1058        2.  In Boolean nomenclature: if ((i == 1 && cv != "none") or (cv
1059            == "none" && i != 1)) then the chain state is "fail" and the
1060            algorithm stops here (note that the ordering of the logic is
1061            structured for short-circuit evaluation).
1062
1063        3.  Initialize a hash function corresponding to the "a" tag of
1064            the ARC-Seal.
1065
1066        4.  Compute the canonicalized form of the ARC header fields, in
1067            the order described in Section 5.4.2, using the "relaxed"
1068            header canonicalization defined in Section 3.4.2 of
1069            [RFC6376].  Pass the canonicalized result to the hash
1070            function.
1071
1072        5.  Retrieve the final digest from the hash function.
1073
1074        6.  Retrieve the public key identified by the "s" and "d" tags in
1075            the ARC-Seal, as described in Section 4.1.6.
1076
1077        7.  Determine whether the signature portion ("b" tag) of the ARC-
1078            Seal and the digest computed above are valid according to the
1079            public key.  (See also Section Section 8.4 for failure case
1080            handling)
1081
1082        8.  If the signature is not valid, the chain state is "fail" and
1083            the algorithm stops here.
1084
1085    5.  If all seals pass validation, then the chain state is "pass", and
1086        the algorithm is complete.
1087 */
1088
1089 if ((res = arc_verify_seals(&arc_verify_ctx)))
1090   goto out;
1091
1092 res = US"pass";
1093
1094 out:
1095   return res;
1096 }
1097
1098 /******************************************************************************/
1099
1100 /* Prepend the header to the rlist */
1101
1102 static hdr_rlist *
1103 arc_rlist_entry(hdr_rlist * list, const uschar * s, int len)
1104 {
1105 hdr_rlist * r = store_get(sizeof(hdr_rlist) + sizeof(header_line), GET_UNTAINTED);
1106 header_line * h = r->h = (header_line *)(r+1);
1107
1108 r->prev = list;
1109 r->used = FALSE;
1110 h->next = NULL;
1111 h->type = 0;
1112 h->slen = len;
1113 h->text = US s;
1114
1115 return r;
1116 }
1117
1118
1119 /* Walk the given headers strings identifying each header, and construct
1120 a reverse-order list.
1121 */
1122
1123 static hdr_rlist *
1124 arc_sign_scan_headers(arc_ctx * ctx, gstring * sigheaders)
1125 {
1126 const uschar * s;
1127 hdr_rlist * rheaders = NULL;
1128
1129 s = sigheaders ? sigheaders->s : NULL;
1130 if (s) while (*s)
1131   {
1132   const uschar * s2 = s;
1133
1134   /* This works for either NL or CRLF lines; also nul-termination */
1135   while (*++s2)
1136     if (*s2 == '\n' && s2[1] != '\t' && s2[1] != ' ') break;
1137   s2++;         /* move past end of line */
1138
1139   rheaders = arc_rlist_entry(rheaders, s, s2 - s);
1140   s = s2;
1141   }
1142 return rheaders;
1143 }
1144
1145
1146
1147 /* Return the A-R content, without identity, with line-ending and
1148 NUL termination. */
1149
1150 static BOOL
1151 arc_sign_find_ar(header_line * headers, const uschar * identity, blob * ret)
1152 {
1153 header_line * h;
1154 int ilen = Ustrlen(identity);
1155
1156 ret->data = NULL;
1157 for(h = headers; h; h = h->next)
1158   {
1159   uschar * s = h->text, c;
1160   int len = h->slen;
1161
1162   if (Ustrncmp(s, HDR_AR, HDRLEN_AR) != 0) continue;
1163   s += HDRLEN_AR, len -= HDRLEN_AR;             /* header name */
1164   while (  len > 0
1165         && (c = *s) && (c == ' ' || c == '\t' || c == '\r' || c == '\n'))
1166     s++, len--;                                 /* FWS */
1167   if (Ustrncmp(s, identity, ilen) != 0) continue;
1168   s += ilen; len -= ilen;                       /* identity */
1169   if (len <= 0) continue;
1170   if ((c = *s) && c == ';') s++, len--;         /* identity terminator */
1171   while (  len > 0
1172         && (c = *s) && (c == ' ' || c == '\t' || c == '\r' || c == '\n'))
1173     s++, len--;                                 /* FWS */
1174   if (len <= 0) continue;
1175   ret->data = s;
1176   ret->len = len;
1177   return TRUE;
1178   }
1179 return FALSE;
1180 }
1181
1182
1183
1184 /* Append a constructed AAR including CRLF.  Add it to the arc_ctx too.  */
1185
1186 static gstring *
1187 arc_sign_append_aar(gstring * g, arc_ctx * ctx,
1188   const uschar * identity, int instance, blob * ar)
1189 {
1190 int aar_off = gstring_length(g);
1191 arc_set * as =
1192   store_get(sizeof(arc_set) + sizeof(arc_line) + sizeof(header_line), GET_UNTAINTED);
1193 arc_line * al = (arc_line *)(as+1);
1194 header_line * h = (header_line *)(al+1);
1195
1196 g = string_catn(g, ARC_HDR_AAR, ARC_HDRLEN_AAR);
1197 g = string_fmt_append(g, " i=%d; %s;\r\n\t", instance, identity);
1198 g = string_catn(g, US ar->data, ar->len);
1199
1200 h->slen = g->ptr - aar_off;
1201 h->text = g->s + aar_off;
1202 al->complete = h;
1203 as->next = NULL;
1204 as->prev = ctx->arcset_chain_last;
1205 as->instance = instance;
1206 as->hdr_aar = al;
1207 if (instance == 1)
1208   ctx->arcset_chain = as;
1209 else
1210   ctx->arcset_chain_last->next = as;
1211 ctx->arcset_chain_last = as;
1212
1213 DEBUG(D_transport) debug_printf("ARC: AAR '%.*s'\n", h->slen - 2, h->text);
1214 return g;
1215 }
1216
1217
1218
1219 static BOOL
1220 arc_sig_from_pseudoheader(gstring * hdata, int hashtype, const uschar * privkey,
1221   blob * sig, const uschar * why)
1222 {
1223 hashmethod hm = /*sig->keytype == KEYTYPE_ED25519*/ FALSE
1224   ? HASH_SHA2_512 : pdkim_hashes[hashtype].exim_hashmethod;
1225 blob hhash;
1226 es_ctx sctx;
1227 const uschar * errstr;
1228
1229 DEBUG(D_transport)
1230   {
1231   hctx hhash_ctx;
1232   debug_printf("ARC: %s header data for signing:\n", why);
1233   pdkim_quoteprint(hdata->s, hdata->ptr);
1234
1235   (void) exim_sha_init(&hhash_ctx, pdkim_hashes[hashtype].exim_hashmethod);
1236   exim_sha_update(&hhash_ctx, hdata->s, hdata->ptr);
1237   exim_sha_finish(&hhash_ctx, &hhash);
1238   debug_printf("ARC: header hash: "); pdkim_hexprint(hhash.data, hhash.len);
1239   }
1240
1241 if (FALSE /*need hash for Ed25519 or GCrypt signing*/ )
1242   {
1243   hctx hhash_ctx;
1244   (void) exim_sha_init(&hhash_ctx, pdkim_hashes[hashtype].exim_hashmethod);
1245   exim_sha_update(&hhash_ctx, hdata->s, hdata->ptr);
1246   exim_sha_finish(&hhash_ctx, &hhash);
1247   }
1248 else
1249   {
1250   hhash.data = hdata->s;
1251   hhash.len = hdata->ptr;
1252   }
1253
1254 if (  (errstr = exim_dkim_signing_init(privkey, &sctx))
1255    || (errstr = exim_dkim_sign(&sctx, hm, &hhash, sig)))
1256   {
1257   log_write(0, LOG_MAIN, "ARC: %s signing: %s\n", why, errstr);
1258   DEBUG(D_transport)
1259     debug_printf("private key, or private-key file content, was: '%s'\n",
1260       privkey);
1261   return FALSE;
1262   }
1263 return TRUE;
1264 }
1265
1266
1267
1268 static gstring *
1269 arc_sign_append_sig(gstring * g, blob * sig)
1270 {
1271 /*debug_printf("%s: raw sig ", __FUNCTION__); pdkim_hexprint(sig->data, sig->len);*/
1272 sig->data = pdkim_encode_base64(sig);
1273 sig->len = Ustrlen(sig->data);
1274 for (;;)
1275   {
1276   int len = MIN(sig->len, 74);
1277   g = string_catn(g, sig->data, len);
1278   if ((sig->len -= len) == 0) break;
1279   sig->data += len;
1280   g = string_catn(g, US"\r\n\t  ", 5);
1281   }
1282 g = string_catn(g, US";\r\n", 3);
1283 gstring_release_unused(g);
1284 string_from_gstring(g);
1285 return g;
1286 }
1287
1288
1289 /* Append a constructed AMS including CRLF.  Add it to the arc_ctx too. */
1290
1291 static gstring *
1292 arc_sign_append_ams(gstring * g, arc_ctx * ctx, int instance,
1293   const uschar * identity, const uschar * selector, blob * bodyhash,
1294   hdr_rlist * rheaders, const uschar * privkey, unsigned options)
1295 {
1296 uschar * s;
1297 gstring * hdata = NULL;
1298 int col;
1299 int hashtype = pdkim_hashname_to_hashtype(US"sha256", 6);       /*XXX hardwired */
1300 blob sig;
1301 int ams_off;
1302 arc_line * al = store_get(sizeof(header_line) + sizeof(arc_line), GET_UNTAINTED);
1303 header_line * h = (header_line *)(al+1);
1304
1305 /* debug_printf("%s\n", __FUNCTION__); */
1306
1307 /* Construct the to-be-signed AMS pseudo-header: everything but the sig. */
1308
1309 ams_off = gstring_length(g);
1310 g = string_fmt_append(g, "%s i=%d; a=rsa-sha256; c=relaxed; d=%s; s=%s",
1311       ARC_HDR_AMS, instance, identity, selector);       /*XXX hardwired a= */
1312 if (options & ARC_SIGN_OPT_TSTAMP)
1313   g = string_fmt_append(g, "; t=%lu", (u_long)now);
1314 if (options & ARC_SIGN_OPT_EXPIRE)
1315   g = string_fmt_append(g, "; x=%lu", (u_long)expire);
1316 g = string_fmt_append(g, ";\r\n\tbh=%s;\r\n\th=",
1317       pdkim_encode_base64(bodyhash));
1318
1319 for(col = 3; rheaders; rheaders = rheaders->prev)
1320   {
1321   const uschar * hnames = US"DKIM-Signature:" PDKIM_DEFAULT_SIGN_HEADERS;
1322   uschar * name, * htext = rheaders->h->text;
1323   int sep = ':';
1324
1325   /* Spot headers of interest */
1326
1327   while ((name = string_nextinlist(&hnames, &sep, NULL, 0)))
1328     {
1329     int len = Ustrlen(name);
1330     if (strncasecmp(CCS htext, CCS name, len) == 0)
1331       {
1332       /* If too long, fold line in h= field */
1333
1334       if (col + len > 78) g = string_catn(g, US"\r\n\t  ", 5), col = 3;
1335
1336       /* Add name to h= list */
1337
1338       g = string_catn(g, name, len);
1339       g = string_catn(g, US":", 1);
1340       col += len + 1;
1341
1342       /* Accumulate header for hashing/signing */
1343
1344       hdata = string_cat(hdata,
1345                 pdkim_relax_header_n(htext, rheaders->h->slen, TRUE));  /*XXX hardwired */
1346       break;
1347       }
1348     }
1349   }
1350
1351 /* Lose the last colon from the h= list */
1352
1353 gstring_trim_trailing(g, ':');
1354
1355 g = string_catn(g, US";\r\n\tb=;", 7);
1356
1357 /* Include the pseudo-header in the accumulation */
1358
1359 s = pdkim_relax_header_n(g->s + ams_off, g->ptr - ams_off, FALSE);
1360 hdata = string_cat(hdata, s);
1361
1362 /* Calculate the signature from the accumulation */
1363 /*XXX does that need further relaxation? there are spaces embedded in the b= strings! */
1364
1365 if (!arc_sig_from_pseudoheader(hdata, hashtype, privkey, &sig, US"AMS"))
1366   return NULL;
1367
1368 /* Lose the trailing semicolon from the psuedo-header, and append the signature
1369 (folded over lines) and termination to complete it. */
1370
1371 gstring_trim(g, 1);
1372 g = arc_sign_append_sig(g, &sig);
1373
1374 h->slen = g->ptr - ams_off;
1375 h->text = g->s + ams_off;
1376 al->complete = h;
1377 ctx->arcset_chain_last->hdr_ams = al;
1378
1379 DEBUG(D_transport) debug_printf("ARC: AMS '%.*s'\n", h->slen - 2, h->text);
1380 return g;
1381 }
1382
1383
1384
1385 /* Look for an arc= result in an A-R header blob.  We know that its data
1386 happens to be a NUL-term string. */
1387
1388 static uschar *
1389 arc_ar_cv_status(blob * ar)
1390 {
1391 const uschar * resinfo = ar->data;
1392 int sep = ';';
1393 uschar * methodspec, * s;
1394
1395 while ((methodspec = string_nextinlist(&resinfo, &sep, NULL, 0)))
1396   if (Ustrncmp(methodspec, US"arc=", 4) == 0)
1397     {
1398     uschar c;
1399     for (s = methodspec += 4;
1400          (c = *s) && c != ';' && c != ' ' && c != '\r' && c != '\n'; ) s++;
1401     return string_copyn(methodspec, s - methodspec);
1402     }
1403 return US"none";
1404 }
1405
1406
1407
1408 /* Build the AS header and prepend it */
1409
1410 static gstring *
1411 arc_sign_prepend_as(gstring * arcset_interim, arc_ctx * ctx,
1412   int instance, const uschar * identity, const uschar * selector, blob * ar,
1413   const uschar * privkey, unsigned options)
1414 {
1415 gstring * arcset;
1416 uschar * status = arc_ar_cv_status(ar);
1417 arc_line * al = store_get(sizeof(header_line) + sizeof(arc_line), GET_UNTAINTED);
1418 header_line * h = (header_line *)(al+1);
1419 uschar * badline_str;
1420
1421 gstring * hdata = NULL;
1422 int hashtype = pdkim_hashname_to_hashtype(US"sha256", 6);       /*XXX hardwired */
1423 blob sig;
1424
1425 /*
1426 - Generate AS
1427   - no body coverage
1428   - no h= tag; implicit coverage
1429   - arc status from A-R
1430     - if fail:
1431       - coverage is just the new ARC set
1432         including self (but with an empty b= in self)
1433     - if non-fail:
1434       - all ARC set headers, set-number order, aar then ams then as,
1435         including self (but with an empty b= in self)
1436 */
1437 DEBUG(D_transport) debug_printf("ARC: building AS for status '%s'\n", status);
1438
1439 /* Construct the AS except for the signature */
1440
1441 arcset = string_append(NULL, 9,
1442           ARC_HDR_AS,
1443           US" i=", string_sprintf("%d", instance),
1444           US"; cv=", status,
1445           US"; a=rsa-sha256; d=", identity,                     /*XXX hardwired */
1446           US"; s=", selector);                                  /*XXX same as AMS */
1447 if (options & ARC_SIGN_OPT_TSTAMP)
1448   arcset = string_append(arcset, 2,
1449       US"; t=", string_sprintf("%lu", (u_long)now));
1450 arcset = string_cat(arcset,
1451           US";\r\n\t b=;");
1452
1453 h->slen = arcset->ptr;
1454 h->text = arcset->s;
1455 al->complete = h;
1456 ctx->arcset_chain_last->hdr_as = al;
1457
1458 /* For any but "fail" chain-verify status, walk the entire chain in order by
1459 instance.  For fail, only the new arc-set.  Accumulate the elements walked. */
1460
1461 for (arc_set * as = Ustrcmp(status, US"fail") == 0
1462         ? ctx->arcset_chain_last : ctx->arcset_chain;
1463      as; as = as->next)
1464   {
1465   arc_line * l;
1466   /* Accumulate AAR then AMS then AS.  Relaxed canonicalisation
1467   is required per standard. */
1468
1469   badline_str = US"aar";
1470   if (!(l = as->hdr_aar)) goto badline;
1471   h = l->complete;
1472   hdata = string_cat(hdata, pdkim_relax_header_n(h->text, h->slen, TRUE));
1473   badline_str = US"ams";
1474   if (!(l = as->hdr_ams)) goto badline;
1475   h = l->complete;
1476   hdata = string_cat(hdata, pdkim_relax_header_n(h->text, h->slen, TRUE));
1477   badline_str = US"as";
1478   if (!(l = as->hdr_as)) goto badline;
1479   h = l->complete;
1480   hdata = string_cat(hdata, pdkim_relax_header_n(h->text, h->slen, !!as->next));
1481   }
1482
1483 /* Calculate the signature from the accumulation */
1484
1485 if (!arc_sig_from_pseudoheader(hdata, hashtype, privkey, &sig, US"AS"))
1486   return NULL;
1487
1488 /* Lose the trailing semicolon */
1489 arcset->ptr--;
1490 arcset = arc_sign_append_sig(arcset, &sig);
1491 DEBUG(D_transport) debug_printf("ARC: AS  '%.*s'\n", arcset->ptr - 2, arcset->s);
1492
1493 /* Finally, append the AMS and AAR to the new AS */
1494
1495 return string_catn(arcset, arcset_interim->s, arcset_interim->ptr);
1496
1497 badline:
1498   DEBUG(D_transport)
1499     debug_printf("ARC: while building AS, missing %s in chain\n", badline_str);
1500   return NULL;
1501 }
1502
1503
1504 /**************************************/
1505
1506 /* Return pointer to pdkim_bodyhash for given hash method, creating new
1507 method if needed.
1508 */
1509
1510 void *
1511 arc_ams_setup_sign_bodyhash(void)
1512 {
1513 int canon_head, canon_body;
1514
1515 DEBUG(D_transport) debug_printf("ARC: requesting bodyhash\n");
1516 pdkim_cstring_to_canons(US"relaxed", 7, &canon_head, &canon_body);      /*XXX hardwired */
1517 return pdkim_set_bodyhash(&dkim_sign_ctx,
1518         pdkim_hashname_to_hashtype(US"sha256", 6),                      /*XXX hardwired */
1519         canon_body,
1520         -1);
1521 }
1522
1523
1524
1525 void
1526 arc_sign_init(void)
1527 {
1528 memset(&arc_sign_ctx, 0, sizeof(arc_sign_ctx));
1529 headers_rlist = NULL;
1530 }
1531
1532
1533
1534 /* A "normal" header line, identified by DKIM processing.  These arrive before
1535 the call to arc_sign(), which carries any newly-created DKIM headers - and
1536 those go textually before the normal ones in the message.
1537
1538 We have to take the feed from DKIM as, in the transport-filter case, the
1539 headers are not in memory at the time of the call to arc_sign().
1540
1541 Take a copy of the header and construct a reverse-order list.
1542 Also parse ARC-chain headers and build the chain struct, retaining pointers
1543 into the copies.
1544 */
1545
1546 static const uschar *
1547 arc_header_sign_feed(gstring * g)
1548 {
1549 uschar * s = string_copy_from_gstring(g);
1550 headers_rlist = arc_rlist_entry(headers_rlist, s, g->ptr);
1551 return arc_try_header(&arc_sign_ctx, headers_rlist->h, TRUE);
1552 }
1553
1554
1555
1556 /* Per RFCs 6376, 7489 the only allowed chars in either an ADMD id
1557 or a selector are ALPHA/DIGGIT/'-'/'.'
1558
1559 Check, to help catch misconfigurations such as a missing selector
1560 element in the arc_sign list.
1561 */
1562
1563 static BOOL
1564 arc_valid_id(const uschar * s)
1565 {
1566 for (uschar c; c = *s++; )
1567   if (!isalnum(c) && c != '-' && c != '.') return FALSE;
1568 return TRUE;
1569 }
1570
1571
1572
1573 /* ARC signing.  Called from the smtp transport, if the arc_sign option is set.
1574 The dkim_exim_sign() function has already been called, so will have hashed the
1575 message body for us so long as we requested a hash previously.
1576
1577 Arguments:
1578   signspec      Three-element colon-sep list: identity, selector, privkey.
1579                 Optional fourth element: comma-sep list of options.
1580                 Already expanded
1581   sigheaders    Any signature headers already generated, eg. by DKIM, or NULL
1582   errstr        Error string
1583
1584 Return value
1585   Set of headers to prepend to the message, including the supplied sigheaders
1586   but not the plainheaders.
1587 */
1588
1589 gstring *
1590 arc_sign(const uschar * signspec, gstring * sigheaders, uschar ** errstr)
1591 {
1592 const uschar * identity, * selector, * privkey, * opts, * s;
1593 unsigned options = 0;
1594 int sep = 0;
1595 header_line * headers;
1596 hdr_rlist * rheaders;
1597 blob ar;
1598 int instance;
1599 gstring * g = NULL;
1600 pdkim_bodyhash * b;
1601
1602 expire = now = 0;
1603
1604 /* Parse the signing specification */
1605
1606 if (!(identity = string_nextinlist(&signspec, &sep, NULL, 0)) || !*identity)
1607   { s = US"identity"; goto bad_arg_ret; }
1608 if (!(selector = string_nextinlist(&signspec, &sep, NULL, 0)) || !*selector)
1609   { s = US"selector"; goto bad_arg_ret; }
1610 if (!(privkey = string_nextinlist(&signspec, &sep, NULL, 0))  || !*privkey)
1611   { s = US"privkey"; goto bad_arg_ret; }
1612 if (!arc_valid_id(identity))
1613   { s = US"identity"; goto bad_arg_ret; }
1614 if (!arc_valid_id(selector))
1615   { s = US"selector"; goto bad_arg_ret; }
1616 if (*privkey == '/' && !(privkey = expand_file_big_buffer(privkey)))
1617   goto ret_sigheaders;
1618
1619 if ((opts = string_nextinlist(&signspec, &sep, NULL, 0)))
1620   {
1621   int osep = ',';
1622   while ((s = string_nextinlist(&opts, &osep, NULL, 0)))
1623     if (Ustrcmp(s, "timestamps") == 0)
1624       {
1625       options |= ARC_SIGN_OPT_TSTAMP;
1626       if (!now) now = time(NULL);
1627       }
1628     else if (Ustrncmp(s, "expire", 6) == 0)
1629       {
1630       options |= ARC_SIGN_OPT_EXPIRE;
1631       if (*(s += 6) == '=')
1632         if (*++s == '+')
1633           {
1634           if (!(expire = (time_t)atoi(CS ++s)))
1635             expire = ARC_SIGN_DEFAULT_EXPIRE_DELTA;
1636           if (!now) now = time(NULL);
1637           expire += now;
1638           }
1639         else
1640           expire = (time_t)atol(CS s);
1641       else
1642         {
1643         if (!now) now = time(NULL);
1644         expire = now + ARC_SIGN_DEFAULT_EXPIRE_DELTA;
1645         }
1646       }
1647   }
1648
1649 DEBUG(D_transport) debug_printf("ARC: sign for %s\n", identity);
1650
1651 /* Make an rlist of any new DKIM headers, then add the "normals" rlist to it.
1652 Then scan the list for an A-R header. */
1653
1654 string_from_gstring(sigheaders);
1655 if ((rheaders = arc_sign_scan_headers(&arc_sign_ctx, sigheaders)))
1656   {
1657   hdr_rlist ** rp;
1658   for (rp = &headers_rlist; *rp; ) rp = &(*rp)->prev;
1659   *rp = rheaders;
1660   }
1661
1662 /* Finally, build a normal-order headers list */
1663 /*XXX only needed for hunt-the-AR? */
1664 /*XXX also, we really should be accepting any number of ADMD-matching ARs */
1665   {
1666   header_line * hnext = NULL;
1667   for (rheaders = headers_rlist; rheaders;
1668        hnext = rheaders->h, rheaders = rheaders->prev)
1669     rheaders->h->next = hnext;
1670   headers = hnext;
1671   }
1672
1673 if (!(arc_sign_find_ar(headers, identity, &ar)))
1674   {
1675   log_write(0, LOG_MAIN, "ARC: no Authentication-Results header for signing");
1676   goto ret_sigheaders;
1677   }
1678
1679 /* We previously built the data-struct for the existing ARC chain, if any, using a headers
1680 feed from the DKIM module.  Use that to give the instance number for the ARC set we are
1681 about to build. */
1682
1683 DEBUG(D_transport)
1684   if (arc_sign_ctx.arcset_chain_last)
1685     debug_printf("ARC: existing chain highest instance: %d\n",
1686       arc_sign_ctx.arcset_chain_last->instance);
1687   else
1688     debug_printf("ARC: no existing chain\n");
1689
1690 instance = arc_sign_ctx.arcset_chain_last ? arc_sign_ctx.arcset_chain_last->instance + 1 : 1;
1691
1692 /*
1693 - Generate AAR
1694   - copy the A-R; prepend i= & identity
1695 */
1696
1697 g = arc_sign_append_aar(g, &arc_sign_ctx, identity, instance, &ar);
1698
1699 /*
1700 - Generate AMS
1701   - Looks fairly like a DKIM sig
1702   - Cover all DKIM sig headers as well as the usuals
1703     - ? oversigning?
1704   - Covers the data
1705   - we must have requested a suitable bodyhash previously
1706 */
1707
1708 b = arc_ams_setup_sign_bodyhash();
1709 g = arc_sign_append_ams(g, &arc_sign_ctx, instance, identity, selector,
1710       &b->bh, headers_rlist, privkey, options);
1711
1712 /*
1713 - Generate AS
1714   - no body coverage
1715   - no h= tag; implicit coverage
1716   - arc status from A-R
1717     - if fail:
1718       - coverage is just the new ARC set
1719         including self (but with an empty b= in self)
1720     - if non-fail:
1721       - all ARC set headers, set-number order, aar then ams then as,
1722         including self (but with an empty b= in self)
1723 */
1724
1725 if (g)
1726   g = arc_sign_prepend_as(g, &arc_sign_ctx, instance, identity, selector, &ar,
1727       privkey, options);
1728
1729 /* Finally, append the dkim headers and return the lot. */
1730
1731 if (sigheaders) g = string_catn(g, sigheaders->s, sigheaders->ptr);
1732
1733 out:
1734   if (!g) return string_get(1);
1735   (void) string_from_gstring(g);
1736   gstring_release_unused(g);
1737   return g;
1738
1739
1740 bad_arg_ret:
1741   log_write(0, LOG_MAIN, "ARC: bad signing-specification (%s)", s);
1742 ret_sigheaders:
1743   g = sigheaders;
1744   goto out;
1745 }
1746
1747
1748 /******************************************************************************/
1749
1750 /* Check to see if the line is an AMS and if so, set up to validate it.
1751 Called from the DKIM input processing.  This must be done now as the message
1752 body data is hashed during input.
1753
1754 We call the DKIM code to request a body-hash; it has the facility already
1755 and the hash parameters might be common with other requests.
1756 */
1757
1758 static const uschar *
1759 arc_header_vfy_feed(gstring * g)
1760 {
1761 header_line h;
1762 arc_line al;
1763 pdkim_bodyhash * b;
1764 uschar * errstr;
1765
1766 if (!dkim_verify_ctx) return US"no dkim context";
1767
1768 if (strncmpic(ARC_HDR_AMS, g->s, ARC_HDRLEN_AMS) != 0) return US"not AMS";
1769
1770 DEBUG(D_receive) debug_printf("ARC: spotted AMS header\n");
1771 /* Parse the AMS header */
1772
1773 memset(&al, 0, sizeof(arc_line));
1774 h.next = NULL;
1775 h.slen = len_string_from_gstring(g, &h.text);
1776 if ((errstr = arc_parse_line(&al, &h, ARC_HDRLEN_AMS, FALSE)))
1777   {
1778   DEBUG(D_acl) if (errstr) debug_printf("ARC: %s\n", errstr);
1779   goto badline;
1780   }
1781
1782 if (!al.a_hash.data)
1783   {
1784   DEBUG(D_acl) debug_printf("ARC: no a_hash from '%.*s'\n", h.slen, h.text);
1785   goto badline;
1786   }
1787
1788 /* defaults */
1789 if (!al.c.data)
1790   {
1791   al.c_body.data = US"simple"; al.c_body.len = 6;
1792   al.c_head = al.c_body;
1793   }
1794
1795 /* Ask the dkim code to calc a bodyhash with those specs */
1796
1797 if (!(b = arc_ams_setup_vfy_bodyhash(&al)))
1798   return US"dkim hash setup fail";
1799
1800 /* Discard the reference; search again at verify time, knowing that one
1801 should have been created here. */
1802
1803 return NULL;
1804
1805 badline:
1806   return US"line parsing error";
1807 }
1808
1809
1810
1811 /* A header line has been identified by DKIM processing.
1812
1813 Arguments:
1814   g             Header line
1815   is_vfy        TRUE for verify mode or FALSE for signing mode
1816
1817 Return:
1818   NULL for success, or an error string (probably unused)
1819 */
1820
1821 const uschar *
1822 arc_header_feed(gstring * g, BOOL is_vfy)
1823 {
1824 return is_vfy ? arc_header_vfy_feed(g) : arc_header_sign_feed(g);
1825 }
1826
1827
1828
1829 /******************************************************************************/
1830
1831 /* Construct the list of domains from the ARC chain after validation */
1832
1833 uschar *
1834 fn_arc_domains(void)
1835 {
1836 arc_set * as;
1837 unsigned inst;
1838 gstring * g = NULL;
1839
1840 for (as = arc_verify_ctx.arcset_chain, inst = 1; as; as = as->next, inst++)
1841   {
1842   arc_line * hdr_as = as->hdr_as;
1843   if (hdr_as)
1844     {
1845     blob * d = &hdr_as->d;
1846
1847     for (; inst < as->instance; inst++)
1848       g = string_catn(g, US":", 1);
1849
1850     g = d->data && d->len
1851       ? string_append_listele_n(g, ':', d->data, d->len)
1852       : string_catn(g, US":", 1);
1853     }
1854   else
1855     g = string_catn(g, US":", 1);
1856   }
1857 if (!g) return US"";
1858 return string_from_gstring(g);
1859 }
1860
1861
1862 /* Construct an Authentication-Results header portion, for the ARC module */
1863
1864 gstring *
1865 authres_arc(gstring * g)
1866 {
1867 if (arc_state)
1868   {
1869   arc_line * highest_ams;
1870   int start = 0;                /* Compiler quietening */
1871   DEBUG(D_acl) start = gstring_length(g);
1872
1873   g = string_append(g, 2, US";\n\tarc=", arc_state);
1874   if (arc_received_instance > 0)
1875     {
1876     g = string_fmt_append(g, " (i=%d)", arc_received_instance);
1877     if (arc_state_reason)
1878       g = string_append(g, 3, US"(", arc_state_reason, US")");
1879     g = string_catn(g, US" header.s=", 10);
1880     highest_ams = arc_received->hdr_ams;
1881     g = string_catn(g, highest_ams->s.data, highest_ams->s.len);
1882
1883     g = string_fmt_append(g, " arc.oldest-pass=%d", arc_oldest_pass);
1884
1885     if (sender_host_address)
1886       g = string_append(g, 2, US" smtp.remote-ip=", sender_host_address);
1887     }
1888   else if (arc_state_reason)
1889     g = string_append(g, 3, US" (", arc_state_reason, US")");
1890   DEBUG(D_acl) debug_printf("ARC:  authres '%.*s'\n",
1891                   gstring_length(g) - start - 3, g->s + start + 3);
1892   }
1893 else
1894   DEBUG(D_acl) debug_printf("ARC:  no authres\n");
1895 return g;
1896 }
1897
1898
1899 # endif /* DISABLE_DKIM */
1900 #endif /* EXPERIMENTAL_ARC */
1901 /* vi: aw ai sw=2
1902  */