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
   6    License: GPL
   7 */
   8
   9 #include "exim.h"
  10 # if defined DISABLE_DKIM
  11 #  error DKIM must also be enabled for ARC
  12 # else
  13
  14 #  include "functions.h"
  15 #  include "pdkim/pdkim.h"
  16 #  include "pdkim/signing.h"
  17
  18 extern pdkim_ctx * dkim_verify_ctx;
  19 extern pdkim_ctx dkim_sign_ctx;
  20
  21 #define ARC_SIGN_OPT_TSTAMP     BIT(0)
  22 #define ARC_SIGN_OPT_EXPIRE     BIT(1)
  23
  24 #define ARC_SIGN_DEFAULT_EXPIRE_DELTA (60 * 60 * 24 * 30)       /* one month */
  25
  26 /******************************************************************************/
  27
  28 typedef struct hdr_rlist {
  29   struct hdr_rlist *    prev;
  30   BOOL                  used;
  31   header_line *         h;
  32 } hdr_rlist;
  33
  34 typedef struct arc_line {
  35   header_line * complete;       /* including the header name; nul-term */
  36   uschar *      relaxed;
  37
  38   /* identified tag contents */
  39   /*XXX t= for AS? */
  40   blob          i;
  41   blob          cv;
  42   blob          a;
  43   blob          b;
  44   blob          bh;
  45   blob          d;
  46   blob          h;
  47   blob          s;
  48   blob          c;
  49   blob          l;
  50
  51   /* tag content sub-portions */
  52   blob          a_algo;
  53   blob          a_hash;
  54
  55   blob          c_head;
  56   blob          c_body;
  57
  58   /* modified copy of b= field in line */
  59   blob          rawsig_no_b_val;
  60 } arc_line;
  61
  62 typedef struct arc_set {
  63   struct arc_set *      next;
  64   struct arc_set *      prev;
  65
  66   unsigned              instance;
  67   arc_line *            hdr_aar;
  68   arc_line *            hdr_ams;
  69   arc_line *            hdr_as;
  70
  71   const uschar *        ams_verify_done;
  72   BOOL                  ams_verify_passed;
  73 } arc_set;
  74
  75 typedef struct arc_ctx {
  76   arc_set *     arcset_chain;
  77   arc_set *     arcset_chain_last;
  78 } arc_ctx;
  79
  80 #define ARC_HDR_AAR     US"ARC-Authentication-Results:"
  81 #define ARC_HDRLEN_AAR  27
  82 #define ARC_HDR_AMS     US"ARC-Message-Signature:"
  83 #define ARC_HDRLEN_AMS  22
  84 #define ARC_HDR_AS      US"ARC-Seal:"
  85 #define ARC_HDRLEN_AS   9
  86 #define HDR_AR          US"Authentication-Results:"
  87 #define HDRLEN_AR       23
  88
  89 static time_t now;
  90 static time_t expire;
  91 static hdr_rlist * headers_rlist;
  92 static arc_ctx arc_sign_ctx = { NULL };
  93 static arc_ctx arc_verify_ctx = { NULL };
  94
  95
  96 /******************************************************************************/
  97
  98
  99 /* Get the instance number from the header.
 100 Return 0 on error */
 101 static unsigned
 102 arc_instance_from_hdr(const arc_line * al)
 103 {
 104 const uschar * s = al->i.data;
 105 if (!s || !al->i.len) return 0;
 106 return (unsigned) atoi(CCS s);
 107 }
 108
 109
 110 static uschar *
 111 skip_fws(uschar * s)
 112 {
 113 uschar c = *s;
 114 while (c && (c == ' ' || c == '\t' || c == '\n' || c == '\r')) c = *++s;
 115 return s;
 116 }
 117
 118
 119 /* Locate instance struct on chain, inserting a new one if
 120 needed.  The chain is in increasing-instance-number order
 121 by the "next" link, and we have a "prev" link also.
 122 */
 123
 124 static arc_set *
 125 arc_find_set(arc_ctx * ctx, unsigned i)
 126 {
 127 arc_set ** pas, * as, * next, * prev;
 128
 129 for (pas = &ctx->arcset_chain, prev = NULL, next = ctx->arcset_chain;
 130      as = *pas; pas = &as->next)
 131   {
 132   if (as->instance > i) break;
 133   if (as->instance == i)
 134     {
 135     DEBUG(D_acl) debug_printf("ARC: existing instance %u\n", i);
 136     return as;
 137     }
 138   next = as->next;
 139   prev = as;
 140   }
 141
 142 DEBUG(D_acl) debug_printf("ARC: new instance %u\n", i);
 143 *pas = as = store_get(sizeof(arc_set), FALSE);
 144 memset(as, 0, sizeof(arc_set));
 145 as->next = next;
 146 as->prev = prev;
 147 as->instance = i;
 148 if (next)
 149   next->prev = as;
 150 else
 151   ctx->arcset_chain_last = as;
 152 return as;
 153 }
 154
 155
 156
 157 /* Insert a tag content into the line structure.
 158 Note this is a reference to existing data, not a copy.
 159 Check for already-seen tag.
 160 The string-pointer is on the '=' for entry.  Update it past the
 161 content (to the ;) on return;
 162 */
 163
 164 static uschar *
 165 arc_insert_tagvalue(arc_line * al, unsigned loff, uschar ** ss)
 166 {
 167 uschar * s = *ss;
 168 uschar c = *++s;
 169 blob * b = (blob *)(US al + loff);
 170 size_t len = 0;
 171
 172 /* [FWS] tag-value [FWS] */
 173
 174 if (b->data) return US"fail";
 175 s = skip_fws(s);                                                /* FWS */
 176
 177 b->data = s;
 178 while ((c = *s) && c != ';') { len++; s++; }
 179 *ss = s;
 180 while (len && ((c = s[-1]) == ' ' || c == '\t' || c == '\n' || c == '\r'))
 181   { s--; len--; }                                               /* FWS */
 182 b->len = len;
 183 return NULL;
 184 }
 185
 186
 187 /* Inspect a header line, noting known tag fields.
 188 Check for duplicates. */
 189
 190 static uschar *
 191 arc_parse_line(arc_line * al, header_line * h, unsigned off, BOOL instance_only)
 192 {
 193 uschar * s = h->text + off;
 194 uschar * r = NULL;      /* compiler-quietening */
 195 uschar c;
 196
 197 al->complete = h;
 198
 199 if (!instance_only)
 200   {
 201   al->rawsig_no_b_val.data = store_get(h->slen + 1, TRUE);      /* tainted */
 202   memcpy(al->rawsig_no_b_val.data, h->text, off);       /* copy the header name blind */
 203   r = al->rawsig_no_b_val.data + off;
 204   al->rawsig_no_b_val.len = off;
 205   }
 206
 207 /* tag-list  =  tag-spec *( ";" tag-spec ) [ ";" ] */
 208
 209 while ((c = *s))
 210   {
 211   char tagchar;
 212   uschar * t;
 213   unsigned i = 0;
 214   uschar * fieldstart = s;
 215   uschar * bstart = NULL, * bend;
 216
 217   /* tag-spec  =  [FWS] tag-name [FWS] "=" [FWS] tag-value [FWS] */
 218
 219   s = skip_fws(s);                                              /* FWS */
 220   if (!*s) break;
 221 /* debug_printf("%s: consider '%s'\n", __FUNCTION__, s); */
 222   tagchar = *s++;
 223   s = skip_fws(s);                                              /* FWS */
 224   if (!*s) break;
 225
 226   if (!instance_only || tagchar == 'i') switch (tagchar)
 227     {
 228     case 'a':                           /* a= AMS algorithm */
 229       {
 230       if (*s != '=') return US"no 'a' value";
 231       if (arc_insert_tagvalue(al, offsetof(arc_line, a), &s)) return US"a tag dup";
 232
 233       /* substructure: algo-hash   (eg. rsa-sha256) */
 234
 235       t = al->a_algo.data = al->a.data;
 236       while (*t != '-')
 237         if (!*t++ || ++i > al->a.len) return US"no '-' in 'a' value";
 238       al->a_algo.len = i;
 239       if (*t++ != '-') return US"no '-' in 'a' value";
 240       al->a_hash.data = t;
 241       al->a_hash.len = al->a.len - i - 1;
 242       }
 243       break;
 244     case 'b':
 245       {
 246       gstring * g = NULL;
 247
 248       switch (*s)
 249         {
 250         case '=':                       /* b= AMS signature */
 251           if (al->b.data) return US"already b data";
 252           bstart = s+1;
 253
 254           /* The signature can have FWS inserted in the content;
 255           make a stripped copy */
 256
 257           while ((c = *++s) && c != ';')
 258             if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
 259               g = string_catn(g, s, 1);
 260           if (!g) return US"no b= value";
 261           al->b.data = string_from_gstring(g);
 262           al->b.len = g->ptr;
 263           gstring_release_unused(g);
 264           bend = s;
 265           break;
 266         case 'h':                       /* bh= AMS body hash */
 267           s = skip_fws(++s);                                    /* FWS */
 268           if (*s != '=') return US"no bh value";
 269           if (al->bh.data) return US"already bh data";
 270
 271           /* The bodyhash can have FWS inserted in the content;
 272           make a stripped copy */
 273
 274           while ((c = *++s) && c != ';')
 275             if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
 276               g = string_catn(g, s, 1);
 277           if (!g) return US"no bh= value";
 278           al->bh.data = string_from_gstring(g);
 279           al->bh.len = g->ptr;
 280           gstring_release_unused(g);
 281           break;
 282         default:
 283           return US"b? tag";
 284         }
 285       }
 286       break;
 287     case 'c':
 288       switch (*s)
 289         {
 290         case '=':                       /* c= AMS canonicalisation */
 291           if (arc_insert_tagvalue(al, offsetof(arc_line, c), &s)) return US"c tag dup";
 292
 293           /* substructure: head/body   (eg. relaxed/simple)) */
 294
 295           t = al->c_head.data = al->c.data;
 296           while (isalpha(*t))
 297             if (!*t++ || ++i > al->a.len) break;
 298           al->c_head.len = i;
 299           if (*t++ == '/')              /* /body is optional */
 300             {
 301             al->c_body.data = t;
 302             al->c_body.len = al->c.len - i - 1;
 303             }
 304           else
 305             {
 306             al->c_body.data = US"simple";
 307             al->c_body.len = 6;
 308             }
 309           break;
 310         case 'v':                       /* cv= AS validity */
 311           if (*++s != '=') return US"cv tag val";
 312           if (arc_insert_tagvalue(al, offsetof(arc_line, cv), &s)) return US"cv tag dup";
 313           break;
 314         default:
 315           return US"c? tag";
 316         }
 317       break;
 318     case 'd':                           /* d= AMS domain */
 319       if (*s != '=') return US"d tag val";
 320       if (arc_insert_tagvalue(al, offsetof(arc_line, d), &s)) return US"d tag dup";
 321       break;
 322     case 'h':                           /* h= AMS headers */
 323       if (*s != '=') return US"h tag val";
 324       if (arc_insert_tagvalue(al, offsetof(arc_line, h), &s)) return US"h tag dup";
 325       break;
 326     case 'i':                           /* i= ARC set instance */
 327       if (*s != '=') return US"i tag val";
 328       if (arc_insert_tagvalue(al, offsetof(arc_line, i), &s)) return US"i tag dup";
 329       if (instance_only) goto done;
 330       break;
 331     case 'l':                           /* l= bodylength */
 332       if (*s != '=') return US"l tag val";
 333       if (arc_insert_tagvalue(al, offsetof(arc_line, l), &s)) return US"l tag dup";
 334       break;
 335     case 's':                           /* s= AMS selector */
 336       if (*s != '=') return US"s tag val";
 337       if (arc_insert_tagvalue(al, offsetof(arc_line, s), &s)) return US"s tag dup";
 338       break;
 339     }
 340
 341   while ((c = *s) && c != ';') s++;
 342   if (c) s++;                           /* ; after tag-spec */
 343
 344   /* for all but the b= tag, copy the field including FWS.  For the b=,
 345   drop the tag content. */
 346
 347   if (!instance_only)
 348     if (bstart)
 349       {
 350       size_t n = bstart - fieldstart;
 351       memcpy(r, fieldstart, n);         /* FWS "b=" */
 352       r += n;
 353       al->rawsig_no_b_val.len += n;
 354       n = s - bend;
 355       memcpy(r, bend, n);               /* FWS ";" */
 356       r += n;
 357       al->rawsig_no_b_val.len += n;
 358       }
 359     else
 360       {
 361       size_t n = s - fieldstart;
 362       memcpy(r, fieldstart, n);
 363       r += n;
 364       al->rawsig_no_b_val.len += n;
 365       }
 366   }
 367
 368 if (!instance_only)
 369   *r = '\0';
 370
 371 done:
 372 /* debug_printf("%s: finshed\n", __FUNCTION__); */
 373 return NULL;
 374 }
 375
 376
 377 /* Insert one header line in the correct set of the chain,
 378 adding instances as needed and checking for duplicate lines.
 379 */
 380
 381 static uschar *
 382 arc_insert_hdr(arc_ctx * ctx, header_line * h, unsigned off, unsigned hoff,
 383   BOOL instance_only)
 384 {
 385 unsigned i;
 386 arc_set * as;
 387 arc_line * al = store_get(sizeof(arc_line), FALSE), ** alp;
 388 uschar * e;
 389
 390 memset(al, 0, sizeof(arc_line));
 391
 392 if ((e = arc_parse_line(al, h, off, instance_only)))
 393   {
 394   DEBUG(D_acl) if (e) debug_printf("ARC: %s\n", e);
 395   return US"line parse";
 396   }
 397 if (!(i = arc_instance_from_hdr(al)))   return US"instance find";
 398 if (i > 50)                             return US"overlarge instance number";
 399 if (!(as = arc_find_set(ctx, i)))       return US"set find";
 400 if (*(alp = (arc_line **)(US as + hoff))) return US"dup hdr";
 401
 402 *alp = al;
 403 return NULL;
 404 }
 405
 406
 407
 408
 409 static const uschar *
 410 arc_try_header(arc_ctx * ctx, header_line * h, BOOL instance_only)
 411 {
 412 const uschar * e;
 413
 414 /*debug_printf("consider hdr '%s'\n", h->text);*/
 415 if (strncmpic(ARC_HDR_AAR, h->text, ARC_HDRLEN_AAR) == 0)
 416   {
 417   DEBUG(D_acl)
 418     {
 419     int len = h->slen;
 420     uschar * s;
 421     for (s = h->text + h->slen; s[-1] == '\r' || s[-1] == '\n'; )
 422       s--, len--;
 423     debug_printf("ARC: found AAR: %.*s\n", len, h->text);
 424     }
 425   if ((e = arc_insert_hdr(ctx, h, ARC_HDRLEN_AAR, offsetof(arc_set, hdr_aar),
 426                           TRUE)))
 427     {
 428     DEBUG(D_acl) debug_printf("inserting AAR: %s\n", e);
 429     return US"inserting AAR";
 430     }
 431   }
 432 else if (strncmpic(ARC_HDR_AMS, h->text, ARC_HDRLEN_AMS) == 0)
 433   {
 434   arc_line * ams;
 435
 436   DEBUG(D_acl)
 437     {
 438     int len = h->slen;
 439     uschar * s;
 440     for (s = h->text + h->slen; s[-1] == '\r' || s[-1] == '\n'; )
 441       s--, len--;
 442     debug_printf("ARC: found AMS: %.*s\n", len, h->text);
 443     }
 444   if ((e = arc_insert_hdr(ctx, h, ARC_HDRLEN_AMS, offsetof(arc_set, hdr_ams),
 445                           instance_only)))
 446     {
 447     DEBUG(D_acl) debug_printf("inserting AMS: %s\n", e);
 448     return US"inserting AMS";
 449     }
 450
 451   /* defaults */
 452   /*XXX dubious selection of ams here */
 453   ams = ctx->arcset_chain->hdr_ams;
 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)))
 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), FALSE);
 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(&hhash_ctx, s, Ustrlen(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)))
 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)))
 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), FALSE);
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 /* This works for either NL or CRLF lines; also nul-termination */
1116 while (*++s)
1117   if (*s == '\n' && s[1] != '\t' && s[1] != ' ') break;
1118 s++;            /* move past end of line */
1119
1120 return r;
1121 }
1122
1123
1124 /* Walk the given headers strings identifying each header, and construct
1125 a reverse-order list.
1126 */
1127
1128 static hdr_rlist *
1129 arc_sign_scan_headers(arc_ctx * ctx, gstring * sigheaders)
1130 {
1131 const uschar * s;
1132 hdr_rlist * rheaders = NULL;
1133
1134 s = sigheaders ? sigheaders->s : NULL;
1135 if (s) while (*s)
1136   {
1137   const uschar * s2 = s;
1138
1139   /* This works for either NL or CRLF lines; also nul-termination */
1140   while (*++s2)
1141     if (*s2 == '\n' && s2[1] != '\t' && s2[1] != ' ') break;
1142   s2++;         /* move past end of line */
1143
1144   rheaders = arc_rlist_entry(rheaders, s, s2 - s);
1145   s = s2;
1146   }
1147 return rheaders;
1148 }
1149
1150
1151
1152 /* Return the A-R content, without identity, with line-ending and
1153 NUL termination. */
1154
1155 static BOOL
1156 arc_sign_find_ar(header_line * headers, const uschar * identity, blob * ret)
1157 {
1158 header_line * h;
1159 int ilen = Ustrlen(identity);
1160
1161 ret->data = NULL;
1162 for(h = headers; h; h = h->next)
1163   {
1164   uschar * s = h->text, c;
1165   int len = h->slen;
1166
1167   if (Ustrncmp(s, HDR_AR, HDRLEN_AR) != 0) continue;
1168   s += HDRLEN_AR, len -= HDRLEN_AR;             /* header name */
1169   while (  len > 0
1170         && (c = *s) && (c == ' ' || c == '\t' || c == '\r' || c == '\n'))
1171     s++, len--;                                 /* FWS */
1172   if (Ustrncmp(s, identity, ilen) != 0) continue;
1173   s += ilen; len -= ilen;                       /* identity */
1174   if (len <= 0) continue;
1175   if ((c = *s) && c == ';') s++, len--;         /* identity terminator */
1176   while (  len > 0
1177         && (c = *s) && (c == ' ' || c == '\t' || c == '\r' || c == '\n'))
1178     s++, len--;                                 /* FWS */
1179   if (len <= 0) continue;
1180   ret->data = s;
1181   ret->len = len;
1182   return TRUE;
1183   }
1184 return FALSE;
1185 }
1186
1187
1188
1189 /* Append a constructed AAR including CRLF.  Add it to the arc_ctx too.  */
1190
1191 static gstring *
1192 arc_sign_append_aar(gstring * g, arc_ctx * ctx,
1193   const uschar * identity, int instance, blob * ar)
1194 {
1195 int aar_off = g ? g->ptr : 0;
1196 arc_set * as =
1197   store_get(sizeof(arc_set) + sizeof(arc_line) + sizeof(header_line), FALSE);
1198 arc_line * al = (arc_line *)(as+1);
1199 header_line * h = (header_line *)(al+1);
1200
1201 g = string_catn(g, ARC_HDR_AAR, ARC_HDRLEN_AAR);
1202 g = string_fmt_append(g, " i=%d; %s;\r\n\t", instance, identity);
1203 g = string_catn(g, US ar->data, ar->len);
1204
1205 h->slen = g->ptr - aar_off;
1206 h->text = g->s + aar_off;
1207 al->complete = h;
1208 as->next = NULL;
1209 as->prev = ctx->arcset_chain_last;
1210 as->instance = instance;
1211 as->hdr_aar = al;
1212 if (instance == 1)
1213   ctx->arcset_chain = as;
1214 else
1215   ctx->arcset_chain_last->next = as;
1216 ctx->arcset_chain_last = as;
1217
1218 DEBUG(D_transport) debug_printf("ARC: AAR '%.*s'\n", h->slen - 2, h->text);
1219 return g;
1220 }
1221
1222
1223
1224 static BOOL
1225 arc_sig_from_pseudoheader(gstring * hdata, int hashtype, const uschar * privkey,
1226   blob * sig, const uschar * why)
1227 {
1228 hashmethod hm = /*sig->keytype == KEYTYPE_ED25519*/ FALSE
1229   ? HASH_SHA2_512 : pdkim_hashes[hashtype].exim_hashmethod;
1230 blob hhash;
1231 es_ctx sctx;
1232 const uschar * errstr;
1233
1234 DEBUG(D_transport)
1235   {
1236   hctx hhash_ctx;
1237   debug_printf("ARC: %s header data for signing:\n", why);
1238   pdkim_quoteprint(hdata->s, hdata->ptr);
1239
1240   (void) exim_sha_init(&hhash_ctx, pdkim_hashes[hashtype].exim_hashmethod);
1241   exim_sha_update(&hhash_ctx, hdata->s, hdata->ptr);
1242   exim_sha_finish(&hhash_ctx, &hhash);
1243   debug_printf("ARC: header hash: "); pdkim_hexprint(hhash.data, hhash.len);
1244   }
1245
1246 if (FALSE /*need hash for Ed25519 or GCrypt signing*/ )
1247   {
1248   hctx hhash_ctx;
1249   (void) exim_sha_init(&hhash_ctx, pdkim_hashes[hashtype].exim_hashmethod);
1250   exim_sha_update(&hhash_ctx, hdata->s, hdata->ptr);
1251   exim_sha_finish(&hhash_ctx, &hhash);
1252   }
1253 else
1254   {
1255   hhash.data = hdata->s;
1256   hhash.len = hdata->ptr;
1257   }
1258
1259 if (  (errstr = exim_dkim_signing_init(privkey, &sctx))
1260    || (errstr = exim_dkim_sign(&sctx, hm, &hhash, sig)))
1261   {
1262   log_write(0, LOG_MAIN, "ARC: %s signing: %s\n", why, errstr);
1263   DEBUG(D_transport)
1264     debug_printf("private key, or private-key file content, was: '%s'\n",
1265       privkey);
1266   return FALSE;
1267   }
1268 return TRUE;
1269 }
1270
1271
1272
1273 static gstring *
1274 arc_sign_append_sig(gstring * g, blob * sig)
1275 {
1276 /*debug_printf("%s: raw sig ", __FUNCTION__); pdkim_hexprint(sig->data, sig->len);*/
1277 sig->data = pdkim_encode_base64(sig);
1278 sig->len = Ustrlen(sig->data);
1279 for (;;)
1280   {
1281   int len = MIN(sig->len, 74);
1282   g = string_catn(g, sig->data, len);
1283   if ((sig->len -= len) == 0) break;
1284   sig->data += len;
1285   g = string_catn(g, US"\r\n\t  ", 5);
1286   }
1287 g = string_catn(g, US";\r\n", 3);
1288 gstring_release_unused(g);
1289 string_from_gstring(g);
1290 return g;
1291 }
1292
1293
1294 /* Append a constructed AMS including CRLF.  Add it to the arc_ctx too. */
1295
1296 static gstring *
1297 arc_sign_append_ams(gstring * g, arc_ctx * ctx, int instance,
1298   const uschar * identity, const uschar * selector, blob * bodyhash,
1299   hdr_rlist * rheaders, const uschar * privkey, unsigned options)
1300 {
1301 uschar * s;
1302 gstring * hdata = NULL;
1303 int col;
1304 int hashtype = pdkim_hashname_to_hashtype(US"sha256", 6);       /*XXX hardwired */
1305 blob sig;
1306 int ams_off;
1307 arc_line * al = store_get(sizeof(header_line) + sizeof(arc_line), FALSE);
1308 header_line * h = (header_line *)(al+1);
1309
1310 /* debug_printf("%s\n", __FUNCTION__); */
1311
1312 /* Construct the to-be-signed AMS pseudo-header: everything but the sig. */
1313
1314 ams_off = g->ptr;
1315 g = string_fmt_append(g, "%s i=%d; a=rsa-sha256; c=relaxed; d=%s; s=%s",
1316       ARC_HDR_AMS, instance, identity, selector);       /*XXX hardwired a= */
1317 if (options & ARC_SIGN_OPT_TSTAMP)
1318   g = string_fmt_append(g, "; t=%lu", (u_long)now);
1319 if (options & ARC_SIGN_OPT_EXPIRE)
1320   g = string_fmt_append(g, "; x=%lu", (u_long)expire);
1321 g = string_fmt_append(g, ";\r\n\tbh=%s;\r\n\th=",
1322       pdkim_encode_base64(bodyhash));
1323
1324 for(col = 3; rheaders; rheaders = rheaders->prev)
1325   {
1326   const uschar * hnames = US"DKIM-Signature:" PDKIM_DEFAULT_SIGN_HEADERS;
1327   uschar * name, * htext = rheaders->h->text;
1328   int sep = ':';
1329
1330   /* Spot headers of interest */
1331
1332   while ((name = string_nextinlist(&hnames, &sep, NULL, 0)))
1333     {
1334     int len = Ustrlen(name);
1335     if (strncasecmp(CCS htext, CCS name, len) == 0)
1336       {
1337       /* If too long, fold line in h= field */
1338
1339       if (col + len > 78) g = string_catn(g, US"\r\n\t  ", 5), col = 3;
1340
1341       /* Add name to h= list */
1342
1343       g = string_catn(g, name, len);
1344       g = string_catn(g, US":", 1);
1345       col += len + 1;
1346
1347       /* Accumulate header for hashing/signing */
1348
1349       hdata = string_cat(hdata,
1350                 pdkim_relax_header_n(htext, rheaders->h->slen, TRUE));  /*XXX hardwired */
1351       break;
1352       }
1353     }
1354   }
1355
1356 /* Lose the last colon from the h= list */
1357
1358 if (g->s[g->ptr - 1] == ':') g->ptr--;
1359
1360 g = string_catn(g, US";\r\n\tb=;", 7);
1361
1362 /* Include the pseudo-header in the accumulation */
1363
1364 s = pdkim_relax_header_n(g->s + ams_off, g->ptr - ams_off, FALSE);
1365 hdata = string_cat(hdata, s);
1366
1367 /* Calculate the signature from the accumulation */
1368 /*XXX does that need further relaxation? there are spaces embedded in the b= strings! */
1369
1370 if (!arc_sig_from_pseudoheader(hdata, hashtype, privkey, &sig, US"AMS"))
1371   return NULL;
1372
1373 /* Lose the trailing semicolon from the psuedo-header, and append the signature
1374 (folded over lines) and termination to complete it. */
1375
1376 g->ptr--;
1377 g = arc_sign_append_sig(g, &sig);
1378
1379 h->slen = g->ptr - ams_off;
1380 h->text = g->s + ams_off;
1381 al->complete = h;
1382 ctx->arcset_chain_last->hdr_ams = al;
1383
1384 DEBUG(D_transport) debug_printf("ARC: AMS '%.*s'\n", h->slen - 2, h->text);
1385 return g;
1386 }
1387
1388
1389
1390 /* Look for an arc= result in an A-R header blob.  We know that its data
1391 happens to be a NUL-term string. */
1392
1393 static uschar *
1394 arc_ar_cv_status(blob * ar)
1395 {
1396 const uschar * resinfo = ar->data;
1397 int sep = ';';
1398 uschar * methodspec, * s;
1399
1400 while ((methodspec = string_nextinlist(&resinfo, &sep, NULL, 0)))
1401   if (Ustrncmp(methodspec, US"arc=", 4) == 0)
1402     {
1403     uschar c;
1404     for (s = methodspec += 4;
1405          (c = *s) && c != ';' && c != ' ' && c != '\r' && c != '\n'; ) s++;
1406     return string_copyn(methodspec, s - methodspec);
1407     }
1408 return US"none";
1409 }
1410
1411
1412
1413 /* Build the AS header and prepend it */
1414
1415 static gstring *
1416 arc_sign_prepend_as(gstring * arcset_interim, arc_ctx * ctx,
1417   int instance, const uschar * identity, const uschar * selector, blob * ar,
1418   const uschar * privkey, unsigned options)
1419 {
1420 gstring * arcset;
1421 arc_set * as;
1422 uschar * status = arc_ar_cv_status(ar);
1423 arc_line * al = store_get(sizeof(header_line) + sizeof(arc_line), FALSE);
1424 header_line * h = (header_line *)(al+1);
1425
1426 gstring * hdata = NULL;
1427 int hashtype = pdkim_hashname_to_hashtype(US"sha256", 6);       /*XXX hardwired */
1428 blob sig;
1429
1430 /*
1431 - Generate AS
1432   - no body coverage
1433   - no h= tag; implicit coverage
1434   - arc status from A-R
1435     - if fail:
1436       - coverage is just the new ARC set
1437         including self (but with an empty b= in self)
1438     - if non-fail:
1439       - all ARC set headers, set-number order, aar then ams then as,
1440         including self (but with an empty b= in self)
1441 */
1442
1443 /* Construct the AS except for the signature */
1444
1445 arcset = string_append(NULL, 9,
1446           ARC_HDR_AS,
1447           US" i=", string_sprintf("%d", instance),
1448           US"; cv=", status,
1449           US"; a=rsa-sha256; d=", identity,                     /*XXX hardwired */
1450           US"; s=", selector);                                  /*XXX same as AMS */
1451 if (options & ARC_SIGN_OPT_TSTAMP)
1452   arcset = string_append(arcset, 2,
1453       US"; t=", string_sprintf("%lu", (u_long)now));
1454 arcset = string_cat(arcset,
1455           US";\r\n\t b=;");
1456
1457 h->slen = arcset->ptr;
1458 h->text = arcset->s;
1459 al->complete = h;
1460 ctx->arcset_chain_last->hdr_as = al;
1461
1462 /* For any but "fail" chain-verify status, walk the entire chain in order by
1463 instance.  For fail, only the new arc-set.  Accumulate the elements walked. */
1464
1465 for (as = Ustrcmp(status, US"fail") == 0
1466         ? ctx->arcset_chain_last : ctx->arcset_chain;
1467      as; as = as->next)
1468   {
1469   /* Accumulate AAR then AMS then AS.  Relaxed canonicalisation
1470   is required per standard. */
1471
1472   h = as->hdr_aar->complete;
1473   hdata = string_cat(hdata, pdkim_relax_header_n(h->text, h->slen, TRUE));
1474   h = as->hdr_ams->complete;
1475   hdata = string_cat(hdata, pdkim_relax_header_n(h->text, h->slen, TRUE));
1476   h = as->hdr_as->complete;
1477   hdata = string_cat(hdata, pdkim_relax_header_n(h->text, h->slen, !!as->next));
1478   }
1479
1480 /* Calculate the signature from the accumulation */
1481
1482 if (!arc_sig_from_pseudoheader(hdata, hashtype, privkey, &sig, US"AS"))
1483   return NULL;
1484
1485 /* Lose the trailing semicolon */
1486 arcset->ptr--;
1487 arcset = arc_sign_append_sig(arcset, &sig);
1488 DEBUG(D_transport) debug_printf("ARC: AS  '%.*s'\n", arcset->ptr - 2, arcset->s);
1489
1490 /* Finally, append the AMS and AAR to the new AS */
1491
1492 return string_catn(arcset, arcset_interim->s, arcset_interim->ptr);
1493 }
1494
1495
1496 /**************************************/
1497
1498 /* Return pointer to pdkim_bodyhash for given hash method, creating new
1499 method if needed.
1500 */
1501
1502 void *
1503 arc_ams_setup_sign_bodyhash(void)
1504 {
1505 int canon_head, canon_body;
1506
1507 DEBUG(D_transport) debug_printf("ARC: requesting bodyhash\n");
1508 pdkim_cstring_to_canons(US"relaxed", 7, &canon_head, &canon_body);      /*XXX hardwired */
1509 return pdkim_set_bodyhash(&dkim_sign_ctx,
1510         pdkim_hashname_to_hashtype(US"sha256", 6),                      /*XXX hardwired */
1511         canon_body,
1512         -1);
1513 }
1514
1515
1516
1517 void
1518 arc_sign_init(void)
1519 {
1520 memset(&arc_sign_ctx, 0, sizeof(arc_sign_ctx));
1521 }
1522
1523
1524
1525 /* A "normal" header line, identified by DKIM processing.  These arrive before
1526 the call to arc_sign(), which carries any newly-created DKIM headers - and
1527 those go textually before the normal ones in the message.
1528
1529 We have to take the feed from DKIM as, in the transport-filter case, the
1530 headers are not in memory at the time of the call to arc_sign().
1531
1532 Take a copy of the header and construct a reverse-order list.
1533 Also parse ARC-chain headers and build the chain struct, retaining pointers
1534 into the copies.
1535 */
1536
1537 static const uschar *
1538 arc_header_sign_feed(gstring * g)
1539 {
1540 uschar * s = string_copyn(g->s, g->ptr);
1541 headers_rlist = arc_rlist_entry(headers_rlist, s, g->ptr);
1542 return arc_try_header(&arc_sign_ctx, headers_rlist->h, TRUE);
1543 }
1544
1545
1546
1547 /* ARC signing.  Called from the smtp transport, if the arc_sign option is set.
1548 The dkim_exim_sign() function has already been called, so will have hashed the
1549 message body for us so long as we requested a hash previously.
1550
1551 Arguments:
1552   signspec      Three-element colon-sep list: identity, selector, privkey.
1553                 Optional fourth element: comma-sep list of options.
1554                 Already expanded
1555   sigheaders    Any signature headers already generated, eg. by DKIM, or NULL
1556   errstr        Error string
1557
1558 Return value
1559   Set of headers to prepend to the message, including the supplied sigheaders
1560   but not the plainheaders.
1561 */
1562
1563 gstring *
1564 arc_sign(const uschar * signspec, gstring * sigheaders, uschar ** errstr)
1565 {
1566 const uschar * identity, * selector, * privkey, * opts, * s;
1567 unsigned options = 0;
1568 int sep = 0;
1569 header_line * headers;
1570 hdr_rlist * rheaders;
1571 blob ar;
1572 int instance;
1573 gstring * g = NULL;
1574 pdkim_bodyhash * b;
1575
1576 expire = now = 0;
1577
1578 /* Parse the signing specification */
1579
1580 identity = string_nextinlist(&signspec, &sep, NULL, 0);
1581 selector = string_nextinlist(&signspec, &sep, NULL, 0);
1582 if (  !*identity || !*selector
1583    || !(privkey = string_nextinlist(&signspec, &sep, NULL, 0)) || !*privkey)
1584   {
1585   log_write(0, LOG_MAIN, "ARC: bad signing-specification (%s)",
1586     !*identity ? "identity" : !*selector ? "selector" : "private-key");
1587   return sigheaders ? sigheaders : string_get(0);
1588   }
1589 if (*privkey == '/' && !(privkey = expand_file_big_buffer(privkey)))
1590   return sigheaders ? sigheaders : string_get(0);
1591
1592 if ((opts = string_nextinlist(&signspec, &sep, NULL, 0)))
1593   {
1594   int osep = ',';
1595   while ((s = string_nextinlist(&opts, &osep, NULL, 0)))
1596     if (Ustrcmp(s, "timestamps") == 0)
1597       {
1598       options |= ARC_SIGN_OPT_TSTAMP;
1599       if (!now) now = time(NULL);
1600       }
1601     else if (Ustrncmp(s, "expire", 6) == 0)
1602       {
1603       options |= ARC_SIGN_OPT_EXPIRE;
1604       if (*(s += 6) == '=')
1605         if (*++s == '+')
1606           {
1607           if (!(expire = (time_t)atoi(CS ++s)))
1608             expire = ARC_SIGN_DEFAULT_EXPIRE_DELTA;
1609           if (!now) now = time(NULL);
1610           expire += now;
1611           }
1612         else
1613           expire = (time_t)atol(CS s);
1614       else
1615         {
1616         if (!now) now = time(NULL);
1617         expire = now + ARC_SIGN_DEFAULT_EXPIRE_DELTA;
1618         }
1619       }
1620   }
1621
1622 DEBUG(D_transport) debug_printf("ARC: sign for %s\n", identity);
1623
1624 /* Make an rlist of any new DKIM headers, then add the "normals" rlist to it.
1625 Then scan the list for an A-R header. */
1626
1627 string_from_gstring(sigheaders);
1628 if ((rheaders = arc_sign_scan_headers(&arc_sign_ctx, sigheaders)))
1629   {
1630   hdr_rlist ** rp;
1631   for (rp = &headers_rlist; *rp; ) rp = &(*rp)->prev;
1632   *rp = rheaders;
1633   }
1634
1635 /* Finally, build a normal-order headers list */
1636 /*XXX only needed for hunt-the-AR? */
1637 /*XXX also, we really should be accepting any number of ADMD-matching ARs */
1638   {
1639   header_line * hnext = NULL;
1640   for (rheaders = headers_rlist; rheaders;
1641        hnext = rheaders->h, rheaders = rheaders->prev)
1642     rheaders->h->next = hnext;
1643   headers = hnext;
1644   }
1645
1646 if (!(arc_sign_find_ar(headers, identity, &ar)))
1647   {
1648   log_write(0, LOG_MAIN, "ARC: no Authentication-Results header for signing");
1649   return sigheaders ? sigheaders : string_get(0);
1650   }
1651
1652 /* We previously built the data-struct for the existing ARC chain, if any, using a headers
1653 feed from the DKIM module.  Use that to give the instance number for the ARC set we are
1654 about to build. */
1655
1656 DEBUG(D_transport)
1657   if (arc_sign_ctx.arcset_chain_last)
1658     debug_printf("ARC: existing chain highest instance: %d\n",
1659       arc_sign_ctx.arcset_chain_last->instance);
1660   else
1661     debug_printf("ARC: no existing chain\n");
1662
1663 instance = arc_sign_ctx.arcset_chain_last ? arc_sign_ctx.arcset_chain_last->instance + 1 : 1;
1664
1665 /*
1666 - Generate AAR
1667   - copy the A-R; prepend i= & identity
1668 */
1669
1670 g = arc_sign_append_aar(g, &arc_sign_ctx, identity, instance, &ar);
1671
1672 /*
1673 - Generate AMS
1674   - Looks fairly like a DKIM sig
1675   - Cover all DKIM sig headers as well as the usuals
1676     - ? oversigning?
1677   - Covers the data
1678   - we must have requested a suitable bodyhash previously
1679 */
1680
1681 b = arc_ams_setup_sign_bodyhash();
1682 g = arc_sign_append_ams(g, &arc_sign_ctx, instance, identity, selector,
1683       &b->bh, headers_rlist, privkey, options);
1684
1685 /*
1686 - Generate AS
1687   - no body coverage
1688   - no h= tag; implicit coverage
1689   - arc status from A-R
1690     - if fail:
1691       - coverage is just the new ARC set
1692         including self (but with an empty b= in self)
1693     - if non-fail:
1694       - all ARC set headers, set-number order, aar then ams then as,
1695         including self (but with an empty b= in self)
1696 */
1697
1698 if (g)
1699   g = arc_sign_prepend_as(g, &arc_sign_ctx, instance, identity, selector, &ar,
1700       privkey, options);
1701
1702 /* Finally, append the dkim headers and return the lot. */
1703
1704 if (sigheaders) g = string_catn(g, sigheaders->s, sigheaders->ptr);
1705 (void) string_from_gstring(g);
1706 gstring_release_unused(g);
1707 return g;
1708 }
1709
1710
1711 /******************************************************************************/
1712
1713 /* Check to see if the line is an AMS and if so, set up to validate it.
1714 Called from the DKIM input processing.  This must be done now as the message
1715 body data is hashed during input.
1716
1717 We call the DKIM code to request a body-hash; it has the facility already
1718 and the hash parameters might be common with other requests.
1719 */
1720
1721 static const uschar *
1722 arc_header_vfy_feed(gstring * g)
1723 {
1724 header_line h;
1725 arc_line al;
1726 pdkim_bodyhash * b;
1727 uschar * errstr;
1728
1729 if (!dkim_verify_ctx) return US"no dkim context";
1730
1731 if (strncmpic(ARC_HDR_AMS, g->s, ARC_HDRLEN_AMS) != 0) return US"not AMS";
1732
1733 DEBUG(D_receive) debug_printf("ARC: spotted AMS header\n");
1734 /* Parse the AMS header */
1735
1736 h.next = NULL;
1737 h.slen = g->size;
1738 h.text = g->s;
1739 memset(&al, 0, sizeof(arc_line));
1740 if ((errstr = arc_parse_line(&al, &h, ARC_HDRLEN_AMS, FALSE)))
1741   {
1742   DEBUG(D_acl) if (errstr) debug_printf("ARC: %s\n", errstr);
1743   goto badline;
1744   }
1745
1746 if (!al.a_hash.data)
1747   {
1748   DEBUG(D_acl) debug_printf("ARC: no a_hash from '%.*s'\n", h.slen, h.text);
1749   goto badline;
1750   }
1751
1752 /* defaults */
1753 if (!al.c.data)
1754   {
1755   al.c_body.data = US"simple"; al.c_body.len = 6;
1756   al.c_head = al.c_body;
1757   }
1758
1759 /* Ask the dkim code to calc a bodyhash with those specs */
1760
1761 if (!(b = arc_ams_setup_vfy_bodyhash(&al)))
1762   return US"dkim hash setup fail";
1763
1764 /* Discard the reference; search again at verify time, knowing that one
1765 should have been created here. */
1766
1767 return NULL;
1768
1769 badline:
1770   return US"line parsing error";
1771 }
1772
1773
1774
1775 /* A header line has been identified by DKIM processing.
1776
1777 Arguments:
1778   g             Header line
1779   is_vfy        TRUE for verify mode or FALSE for signing mode
1780
1781 Return:
1782   NULL for success, or an error string (probably unused)
1783 */
1784
1785 const uschar *
1786 arc_header_feed(gstring * g, BOOL is_vfy)
1787 {
1788 return is_vfy ? arc_header_vfy_feed(g) : arc_header_sign_feed(g);
1789 }
1790
1791
1792
1793 /******************************************************************************/
1794
1795 /* Construct the list of domains from the ARC chain after validation */
1796
1797 uschar *
1798 fn_arc_domains(void)
1799 {
1800 arc_set * as;
1801 unsigned inst;
1802 gstring * g = NULL;
1803
1804 for (as = arc_verify_ctx.arcset_chain, inst = 1; as; as = as->next, inst++)
1805   {
1806   arc_line * hdr_as = as->hdr_as;
1807   if (hdr_as)
1808     {
1809     blob * d = &hdr_as->d;
1810
1811     for (; inst < as->instance; inst++)
1812       g = string_catn(g, US":", 1);
1813
1814     g = d->data && d->len
1815       ? string_append_listele_n(g, ':', d->data, d->len)
1816       : string_catn(g, US":", 1);
1817     }
1818   else
1819     g = string_catn(g, US":", 1);
1820   }
1821 return g ? g->s : US"";
1822 }
1823
1824
1825 /* Construct an Authentication-Results header portion, for the ARC module */
1826
1827 gstring *
1828 authres_arc(gstring * g)
1829 {
1830 if (arc_state)
1831   {
1832   arc_line * highest_ams;
1833   int start = 0;                /* Compiler quietening */
1834   DEBUG(D_acl) start = g->ptr;
1835
1836   g = string_append(g, 2, US";\n\tarc=", arc_state);
1837   if (arc_received_instance > 0)
1838     {
1839     g = string_fmt_append(g, " (i=%d)", arc_received_instance);
1840     if (arc_state_reason)
1841       g = string_append(g, 3, US"(", arc_state_reason, US")");
1842     g = string_catn(g, US" header.s=", 10);
1843     highest_ams = arc_received->hdr_ams;
1844     g = string_catn(g, highest_ams->s.data, highest_ams->s.len);
1845
1846     g = string_fmt_append(g, " arc.oldest-pass=%d", arc_oldest_pass);
1847
1848     if (sender_host_address)
1849       g = string_append(g, 2, US" smtp.remote-ip=", sender_host_address);
1850     }
1851   else if (arc_state_reason)
1852     g = string_append(g, 3, US" (", arc_state_reason, US")");
1853   DEBUG(D_acl) debug_printf("ARC:  authres '%.*s'\n",
1854                   g->ptr - start - 3, g->s + start + 3);
1855   }
1856 else
1857   DEBUG(D_acl) debug_printf("ARC:  no authres\n");
1858 return g;
1859 }
1860
1861
1862 # endif /* DISABLE_DKIM */
1863 #endif /* EXPERIMENTAL_ARC */
1864 /* vi: aw ai sw=2
1865  */