src/src/pdkim/pdkim.c

   1 /*
   2  *  PDKIM - a RFC4871 (DKIM) implementation
   3  *
   4  *  Copyright (c) The Exim Maintainers 2021 - 2022
   5  *  Copyright (C) 2009 - 2016  Tom Kistner <tom@duncanthrax.net>
   6  *  Copyright (C) 2016 - 2020  Jeremy Harris <jgh@exim.org>
   7  *  SPDX-License-Identifier: GPL-2.0-or-later
   8  *
   9  *  http://duncanthrax.net/pdkim/
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License along
  22  *  with this program; if not, write to the Free Software Foundation, Inc.,
  23  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25
  26 #include "../exim.h"
  27
  28
  29 #ifndef DISABLE_DKIM    /* entire file */
  30
  31 #ifdef DISABLE_TLS
  32 # error Must not DISABLE_TLS, for DKIM
  33 #endif
  34
  35 #include "crypt_ver.h"
  36
  37 #ifdef SIGN_OPENSSL
  38 # include <openssl/rsa.h>
  39 # include <openssl/ssl.h>
  40 # include <openssl/err.h>
  41 #elif defined(SIGN_GNUTLS)
  42 # include <gnutls/gnutls.h>
  43 # include <gnutls/x509.h>
  44 #endif
  45
  46 #include "pdkim.h"
  47 #include "signing.h"
  48
  49 #define PDKIM_SIGNATURE_VERSION     "1"
  50 #define PDKIM_PUB_RECORD_VERSION    US "DKIM1"
  51
  52 #define PDKIM_MAX_HEADER_LEN        65536
  53 #define PDKIM_MAX_HEADERS           512
  54 #define PDKIM_MAX_BODY_LINE_LEN     16384
  55 #define PDKIM_DNS_TXT_MAX_NAMELEN   1024
  56
  57 /* -------------------------------------------------------------------------- */
  58 struct pdkim_stringlist {
  59   uschar * value;
  60   int      tag;
  61   void *   next;
  62 };
  63
  64 /* -------------------------------------------------------------------------- */
  65 /* A bunch of list constants */
  66 const uschar * pdkim_querymethods[] = {
  67   US"dns/txt",
  68   NULL
  69 };
  70 const uschar * pdkim_canons[] = {
  71   US"simple",
  72   US"relaxed",
  73   NULL
  74 };
  75
  76 const pdkim_hashtype pdkim_hashes[] = {
  77   { US"sha1",   HASH_SHA1 },
  78   { US"sha256", HASH_SHA2_256 },
  79   { US"sha512", HASH_SHA2_512 }
  80 };
  81
  82 const uschar * pdkim_keytypes[] = {
  83   [KEYTYPE_RSA] =       US"rsa",
  84 #ifdef SIGN_HAVE_ED25519
  85   [KEYTYPE_ED25519] =   US"ed25519",            /* Works for 3.6.0 GnuTLS, OpenSSL 1.1.1 */
  86 #endif
  87
  88 #ifdef notyet_EC_dkim_extensions        /* https://tools.ietf.org/html/draft-srose-dkim-ecc-00 */
  89   US"eccp256",
  90   US"eccp348",
  91   US"ed448",
  92 #endif
  93 };
  94
  95 typedef struct pdkim_combined_canon_entry {
  96   const uschar *        str;
  97   int                   canon_headers;
  98   int                   canon_body;
  99 } pdkim_combined_canon_entry;
 100
 101 pdkim_combined_canon_entry pdkim_combined_canons[] = {
 102   { US"simple/simple",    PDKIM_CANON_SIMPLE,   PDKIM_CANON_SIMPLE },
 103   { US"simple/relaxed",   PDKIM_CANON_SIMPLE,   PDKIM_CANON_RELAXED },
 104   { US"relaxed/simple",   PDKIM_CANON_RELAXED,  PDKIM_CANON_SIMPLE },
 105   { US"relaxed/relaxed",  PDKIM_CANON_RELAXED,  PDKIM_CANON_RELAXED },
 106   { US"simple",           PDKIM_CANON_SIMPLE,   PDKIM_CANON_SIMPLE },
 107   { US"relaxed",          PDKIM_CANON_RELAXED,  PDKIM_CANON_SIMPLE },
 108   { NULL,                 0,                    0 }
 109 };
 110
 111
 112 static const blob lineending = {.data = US"\r\n", .len = 2};
 113
 114 /* -------------------------------------------------------------------------- */
 115 uschar *
 116 dkim_sig_to_a_tag(const pdkim_signature * sig)
 117 {
 118 if (  sig->keytype < 0  || sig->keytype > nelem(pdkim_keytypes)
 119    || sig->hashtype < 0 || sig->hashtype > nelem(pdkim_hashes))
 120   return US"err";
 121 return string_sprintf("%s-%s",
 122   pdkim_keytypes[sig->keytype], pdkim_hashes[sig->hashtype].dkim_hashname);
 123 }
 124
 125
 126 static int
 127 pdkim_keyname_to_keytype(const uschar * s)
 128 {
 129 for (int i = 0; i < nelem(pdkim_keytypes); i++)
 130   if (Ustrcmp(s, pdkim_keytypes[i]) == 0) return i;
 131 return -1;
 132 }
 133
 134 int
 135 pdkim_hashname_to_hashtype(const uschar * s, unsigned len)
 136 {
 137 if (!len) len = Ustrlen(s);
 138 for (int i = 0; i < nelem(pdkim_hashes); i++)
 139   if (Ustrncmp(s, pdkim_hashes[i].dkim_hashname, len) == 0)
 140     return i;
 141 return -1;
 142 }
 143
 144 void
 145 pdkim_cstring_to_canons(const uschar * s, unsigned len,
 146   int * canon_head, int * canon_body)
 147 {
 148 if (!len) len = Ustrlen(s);
 149 for (int i = 0; pdkim_combined_canons[i].str; i++)
 150   if (  Ustrncmp(s, pdkim_combined_canons[i].str, len) == 0
 151      && len == Ustrlen(pdkim_combined_canons[i].str))
 152     {
 153     *canon_head = pdkim_combined_canons[i].canon_headers;
 154     *canon_body = pdkim_combined_canons[i].canon_body;
 155     break;
 156     }
 157 }
 158
 159
 160
 161 const char *
 162 pdkim_verify_status_str(int status)
 163 {
 164 switch(status)
 165   {
 166   case PDKIM_VERIFY_NONE:    return "PDKIM_VERIFY_NONE";
 167   case PDKIM_VERIFY_INVALID: return "PDKIM_VERIFY_INVALID";
 168   case PDKIM_VERIFY_FAIL:    return "PDKIM_VERIFY_FAIL";
 169   case PDKIM_VERIFY_PASS:    return "PDKIM_VERIFY_PASS";
 170   default:                   return "PDKIM_VERIFY_UNKNOWN";
 171   }
 172 }
 173
 174 const char *
 175 pdkim_verify_ext_status_str(int ext_status)
 176 {
 177 switch(ext_status)
 178   {
 179   case PDKIM_VERIFY_FAIL_BODY: return "PDKIM_VERIFY_FAIL_BODY";
 180   case PDKIM_VERIFY_FAIL_MESSAGE: return "PDKIM_VERIFY_FAIL_MESSAGE";
 181   case PDKIM_VERIFY_FAIL_SIG_ALGO_MISMATCH: return "PDKIM_VERIFY_FAIL_SIG_ALGO_MISMATCH";
 182   case PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE: return "PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE";
 183   case PDKIM_VERIFY_INVALID_BUFFER_SIZE: return "PDKIM_VERIFY_INVALID_BUFFER_SIZE";
 184   case PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD: return "PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD";
 185   case PDKIM_VERIFY_INVALID_PUBKEY_IMPORT: return "PDKIM_VERIFY_INVALID_PUBKEY_IMPORT";
 186   case PDKIM_VERIFY_INVALID_PUBKEY_KEYSIZE: return "PDKIM_VERIFY_INVALID_PUBKEY_KEYSIZE";
 187   case PDKIM_VERIFY_INVALID_SIGNATURE_ERROR: return "PDKIM_VERIFY_INVALID_SIGNATURE_ERROR";
 188   case PDKIM_VERIFY_INVALID_DKIM_VERSION: return "PDKIM_VERIFY_INVALID_DKIM_VERSION";
 189   default: return "PDKIM_VERIFY_UNKNOWN";
 190   }
 191 }
 192
 193 const uschar *
 194 pdkim_errstr(int status)
 195 {
 196 switch(status)
 197   {
 198   case PDKIM_OK:                return US"OK";
 199   case PDKIM_FAIL:              return US"FAIL";
 200   case PDKIM_ERR_RSA_PRIVKEY:   return US"PRIVKEY";
 201   case PDKIM_ERR_RSA_SIGNING:   return US"SIGNING";
 202   case PDKIM_ERR_LONG_LINE:     return US"LONG_LINE";
 203   case PDKIM_ERR_BUFFER_TOO_SMALL:      return US"BUFFER_TOO_SMALL";
 204   case PDKIM_ERR_EXCESS_SIGS:   return US"EXCESS_SIGS";
 205   case PDKIM_SIGN_PRIVKEY_WRAP: return US"PRIVKEY_WRAP";
 206   case PDKIM_SIGN_PRIVKEY_B64D: return US"PRIVKEY_B64D";
 207   default: return US"(unknown)";
 208   }
 209 }
 210
 211
 212 /* -------------------------------------------------------------------------- */
 213 /* Print debugging functions */
 214 void
 215 pdkim_quoteprint(const uschar *data, int len)
 216 {
 217 for (int i = 0; i < len; i++)
 218   {
 219   const int c = data[i];
 220   switch (c)
 221     {
 222     case ' ' : debug_printf("{SP}"); break;
 223     case '\t': debug_printf("{TB}"); break;
 224     case '\r': debug_printf("{CR}"); break;
 225     case '\n': debug_printf("{LF}"); break;
 226     case '{' : debug_printf("{BO}"); break;
 227     case '}' : debug_printf("{BC}"); break;
 228     default:
 229       if ( (c < 32) || (c > 127) )
 230         debug_printf("{%02x}", c);
 231       else
 232         debug_printf("%c", c);
 233       break;
 234     }
 235   }
 236 debug_printf("\n");
 237 }
 238
 239 void
 240 pdkim_hexprint(const uschar *data, int len)
 241 {
 242 if (data) for (int i = 0 ; i < len; i++) debug_printf("%02x", data[i]);
 243 else debug_printf("<NULL>");
 244 debug_printf("\n");
 245 }
 246
 247
 248
 249 static pdkim_stringlist *
 250 pdkim_prepend_stringlist(pdkim_stringlist * base, const uschar * str)
 251 {
 252 pdkim_stringlist * new_entry = store_get(sizeof(pdkim_stringlist), GET_UNTAINTED);
 253
 254 memset(new_entry, 0, sizeof(pdkim_stringlist));
 255 new_entry->value = string_copy(str);
 256 if (base) new_entry->next = base;
 257 return new_entry;
 258 }
 259
 260
 261
 262 /* Trim whitespace fore & aft */
 263
 264 static void
 265 pdkim_strtrim(gstring * str)
 266 {
 267 uschar * p = str->s;
 268 uschar * q;
 269
 270 while (*p == '\t' || *p == ' ')         /* dump the leading whitespace */
 271   { str->size--; str->ptr--; str->s++; }
 272
 273 while (  str->ptr > 0
 274       && ((q = str->s + str->ptr - 1),  (*q == '\t' || *q == ' '))
 275       )
 276   str->ptr--;                           /* dump trailing whitespace */
 277
 278 (void) string_from_gstring(str);
 279 }
 280
 281
 282
 283 /* -------------------------------------------------------------------------- */
 284
 285 DLLEXPORT void
 286 pdkim_free_ctx(pdkim_ctx *ctx)
 287 {
 288 }
 289
 290
 291 /* -------------------------------------------------------------------------- */
 292 /* Matches the name of the passed raw "header" against
 293    the passed colon-separated "tick", and invalidates
 294    the entry in tick.  Entries can be prefixed for multi- or over-signing,
 295    in which case do not invalidate.
 296
 297    Returns OK for a match, or fail-code
 298 */
 299
 300 static int
 301 header_name_match(const uschar * header, uschar * tick)
 302 {
 303 const uschar * ticklist = tick;
 304 int sep = ':';
 305 BOOL multisign;
 306 uschar * hname, * p, * ele;
 307 uschar * hcolon = Ustrchr(header, ':');         /* Get header name */
 308
 309 if (!hcolon)
 310   return PDKIM_FAIL; /* This isn't a header */
 311
 312 /* if we had strncmpic() we wouldn't need this copy */
 313 hname = string_copyn(header, hcolon-header);
 314
 315 while (p = US ticklist, ele = string_nextinlist(&ticklist, &sep, NULL, 0))
 316   {
 317   switch (*ele)
 318   {
 319   case '=': case '+':   multisign = TRUE; ele++; break;
 320   default:              multisign = FALSE; break;
 321   }
 322
 323   if (strcmpic(ele, hname) == 0)
 324     {
 325     if (!multisign)
 326       *p = '_'; /* Invalidate this header name instance in tick-off list */
 327     return PDKIM_OK;
 328     }
 329   }
 330 return PDKIM_FAIL;
 331 }
 332
 333
 334 /* -------------------------------------------------------------------------- */
 335 /* Performs "relaxed" canonicalization of a header. */
 336
 337 uschar *
 338 pdkim_relax_header_n(const uschar * header, int len, BOOL append_crlf)
 339 {
 340 BOOL past_field_name = FALSE;
 341 BOOL seen_wsp = FALSE;
 342 uschar * relaxed = store_get(len+3, GET_TAINTED);
 343 uschar * q = relaxed;
 344
 345 for (const uschar * p = header; p - header < len; p++)
 346   {
 347   uschar c = *p;
 348
 349   if (c == '\r' || c == '\n')   /* Ignore CR & LF */
 350     continue;
 351   if (c == '\t' || c == ' ')
 352     {
 353     if (seen_wsp)
 354       continue;
 355     c = ' ';                    /* Turns WSP into SP */
 356     seen_wsp = TRUE;
 357     }
 358   else
 359     if (!past_field_name && c == ':')
 360       {
 361       if (seen_wsp) q--;        /* This removes WSP immediately before the colon */
 362       seen_wsp = TRUE;          /* This removes WSP immediately after the colon */
 363       past_field_name = TRUE;
 364       }
 365     else
 366       seen_wsp = FALSE;
 367
 368   /* Lowercase header name */
 369   if (!past_field_name) c = tolower(c);
 370   *q++ = c;
 371   }
 372
 373 if (q > relaxed && q[-1] == ' ') q--; /* Squash eventual trailing SP */
 374
 375 if (append_crlf) { *q++ = '\r'; *q++ = '\n'; }
 376 *q = '\0';
 377 return relaxed;
 378 }
 379
 380
 381 uschar *
 382 pdkim_relax_header(const uschar * header, BOOL append_crlf)
 383 {
 384 return pdkim_relax_header_n(header, Ustrlen(header), append_crlf);
 385 }
 386
 387
 388 /* -------------------------------------------------------------------------- */
 389 #define PDKIM_QP_ERROR_DECODE -1
 390
 391 static const uschar *
 392 pdkim_decode_qp_char(const uschar *qp_p, int *c)
 393 {
 394 const uschar *initial_pos = qp_p;
 395
 396 /* Advance one char */
 397 qp_p++;
 398
 399 /* Check for two hex digits and decode them */
 400 if (isxdigit(*qp_p) && isxdigit(qp_p[1]))
 401   {
 402   /* Do hex conversion */
 403   *c = (isdigit(*qp_p) ? *qp_p - '0' : toupper(*qp_p) - 'A' + 10) << 4;
 404   *c |= isdigit(qp_p[1]) ? qp_p[1] - '0' : toupper(qp_p[1]) - 'A' + 10;
 405   return qp_p + 2;
 406   }
 407
 408 /* Illegal char here */
 409 *c = PDKIM_QP_ERROR_DECODE;
 410 return initial_pos;
 411 }
 412
 413
 414 /* -------------------------------------------------------------------------- */
 415
 416 static uschar *
 417 pdkim_decode_qp(const uschar * str)
 418 {
 419 int nchar = 0;
 420 uschar * q;
 421 const uschar * p = str;
 422 uschar * n = store_get(Ustrlen(str)+1, GET_TAINTED);
 423
 424 *n = '\0';
 425 q = n;
 426 while (*p)
 427   {
 428   if (*p == '=')
 429     {
 430     p = pdkim_decode_qp_char(p, &nchar);
 431     if (nchar >= 0)
 432       {
 433       *q++ = nchar;
 434       continue;
 435       }
 436     }
 437   else
 438     *q++ = *p;
 439   p++;
 440   }
 441 *q = '\0';
 442 return n;
 443 }
 444
 445
 446 /* -------------------------------------------------------------------------- */
 447
 448 void
 449 pdkim_decode_base64(const uschar * str, blob * b)
 450 {
 451 int dlen = b64decode(str, &b->data);
 452 if (dlen < 0) b->data = NULL;
 453 b->len = dlen;
 454 }
 455
 456 uschar *
 457 pdkim_encode_base64(blob * b)
 458 {
 459 return b64encode(CUS b->data, b->len);
 460 }
 461
 462
 463 /* -------------------------------------------------------------------------- */
 464 #define PDKIM_HDR_LIMBO 0
 465 #define PDKIM_HDR_TAG   1
 466 #define PDKIM_HDR_VALUE 2
 467
 468 static pdkim_signature *
 469 pdkim_parse_sig_header(pdkim_ctx * ctx, uschar * raw_hdr)
 470 {
 471 pdkim_signature * sig;
 472 uschar *q;
 473 gstring * cur_tag = NULL;
 474 gstring * cur_val = NULL;
 475 BOOL past_hname = FALSE;
 476 BOOL in_b_val = FALSE;
 477 int where = PDKIM_HDR_LIMBO;
 478
 479 sig = store_get(sizeof(pdkim_signature), GET_UNTAINTED);
 480 memset(sig, 0, sizeof(pdkim_signature));
 481 sig->bodylength = -1;
 482
 483 /* Set so invalid/missing data error display is accurate */
 484 sig->version = 0;
 485 sig->keytype = -1;
 486 sig->hashtype = -1;
 487
 488 q = sig->rawsig_no_b_val = store_get(Ustrlen(raw_hdr)+1, GET_TAINTED);
 489
 490 for (uschar * p = raw_hdr; ; p++)
 491   {
 492   char c = *p;
 493
 494   /* Ignore FWS */
 495   if (c == '\r' || c == '\n')
 496     goto NEXT_CHAR;
 497
 498   /* Fast-forward through header name */
 499   if (!past_hname)
 500     {
 501     if (c == ':') past_hname = TRUE;
 502     goto NEXT_CHAR;
 503     }
 504
 505   if (where == PDKIM_HDR_LIMBO)
 506     {
 507     /* In limbo, just wait for a tag-char to appear */
 508     if (!(c >= 'a' && c <= 'z'))
 509       goto NEXT_CHAR;
 510
 511     where = PDKIM_HDR_TAG;
 512     }
 513
 514   if (where == PDKIM_HDR_TAG)
 515     {
 516     if (c >= 'a' && c <= 'z')
 517       cur_tag = string_catn(cur_tag, p, 1);
 518
 519     if (c == '=')
 520       {
 521       if (Ustrcmp(string_from_gstring(cur_tag), "b") == 0)
 522         {
 523         *q++ = '=';
 524         in_b_val = TRUE;
 525         }
 526       where = PDKIM_HDR_VALUE;
 527       goto NEXT_CHAR;
 528       }
 529     }
 530
 531   if (where == PDKIM_HDR_VALUE)
 532     {
 533     if (c == '\r' || c == '\n' || c == ' ' || c == '\t')
 534       goto NEXT_CHAR;
 535
 536     if (c == ';' || c == '\0')
 537       {
 538       /* We must have both tag and value, and tags must be one char except
 539       for the possibility of "bh". */
 540
 541       if (  cur_tag && cur_val
 542          && (cur_tag->ptr == 1 || *cur_tag->s == 'b')
 543          )
 544         {
 545         (void) string_from_gstring(cur_val);
 546         pdkim_strtrim(cur_val);
 547
 548         DEBUG(D_acl) debug_printf(" %s=%s\n", cur_tag->s, cur_val->s);
 549
 550         switch (*cur_tag->s)
 551           {
 552           case 'b':                             /* sig-data or body-hash */
 553             switch (cur_tag->s[1])
 554               {
 555               case '\0': pdkim_decode_base64(cur_val->s, &sig->sighash); break;
 556               case 'h':  if (cur_tag->ptr == 2)
 557                            pdkim_decode_base64(cur_val->s, &sig->bodyhash);
 558                          break;
 559               default:   break;
 560               }
 561             break;
 562           case 'v':                                     /* version */
 563               /* We only support version 1, and that is currently the
 564                  only version there is. */
 565             sig->version =
 566               Ustrcmp(cur_val->s, PDKIM_SIGNATURE_VERSION) == 0 ? 1 : -1;
 567             break;
 568           case 'a':                                     /* algorithm */
 569             {
 570             const uschar * list = cur_val->s;
 571             int sep = '-';
 572             uschar * elem;
 573
 574             if ((elem = string_nextinlist(&list, &sep, NULL, 0)))
 575               sig->keytype = pdkim_keyname_to_keytype(elem);
 576             if ((elem = string_nextinlist(&list, &sep, NULL, 0)))
 577               for (int i = 0; i < nelem(pdkim_hashes); i++)
 578                 if (Ustrcmp(elem, pdkim_hashes[i].dkim_hashname) == 0)
 579                   { sig->hashtype = i; break; }
 580             }
 581
 582           case 'c':                                     /* canonicalization */
 583             pdkim_cstring_to_canons(cur_val->s, 0,
 584                                     &sig->canon_headers, &sig->canon_body);
 585             break;
 586           case 'q':                             /* Query method (for pubkey)*/
 587             for (int i = 0; pdkim_querymethods[i]; i++)
 588               if (Ustrcmp(cur_val->s, pdkim_querymethods[i]) == 0)
 589                 {
 590                 sig->querymethod = i;   /* we never actually use this */
 591                 break;
 592                 }
 593             break;
 594           case 's':                                     /* Selector */
 595             sig->selector = string_copyn(cur_val->s, cur_val->ptr); break;
 596           case 'd':                                     /* SDID */
 597             sig->domain = string_copyn(cur_val->s, cur_val->ptr); break;
 598           case 'i':                                     /* AUID */
 599             sig->identity = pdkim_decode_qp(cur_val->s); break;
 600           case 't':                                     /* Timestamp */
 601             sig->created = strtoul(CS cur_val->s, NULL, 10); break;
 602           case 'x':                                     /* Expiration */
 603             sig->expires = strtoul(CS cur_val->s, NULL, 10); break;
 604           case 'l':                                     /* Body length count */
 605             sig->bodylength = strtol(CS cur_val->s, NULL, 10); break;
 606           case 'h':                                     /* signed header fields */
 607             sig->headernames = string_copyn(cur_val->s, cur_val->ptr); break;
 608           case 'z':                                     /* Copied headfields */
 609             sig->copiedheaders = pdkim_decode_qp(cur_val->s); break;
 610 /*XXX draft-ietf-dcrup-dkim-crypto-05 would need 'p' tag support
 611 for rsafp signatures.  But later discussion is dropping those. */
 612           default:
 613             DEBUG(D_acl) debug_printf(" Unknown tag encountered\n");
 614             break;
 615           }
 616         }
 617       cur_tag = cur_val = NULL;
 618       in_b_val = FALSE;
 619       where = PDKIM_HDR_LIMBO;
 620       }
 621     else
 622       cur_val = string_catn(cur_val, p, 1);
 623     }
 624
 625 NEXT_CHAR:
 626   if (c == '\0')
 627     break;
 628
 629   if (!in_b_val)
 630     *q++ = c;
 631   }
 632
 633 if (sig->keytype < 0 || sig->hashtype < 0)      /* Cannot verify this signature */
 634   return NULL;
 635
 636 *q = '\0';
 637 /* Chomp raw header. The final newline must not be added to the signature. */
 638 while (--q > sig->rawsig_no_b_val  && (*q == '\r' || *q == '\n'))
 639   *q = '\0';
 640
 641 DEBUG(D_acl)
 642   {
 643   debug_printf(
 644           "DKIM >> Raw signature w/o b= tag value >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
 645   pdkim_quoteprint(US sig->rawsig_no_b_val, Ustrlen(sig->rawsig_no_b_val));
 646   debug_printf(
 647           "DKIM >> Sig size: %4u bits\n", (unsigned) sig->sighash.len*8);
 648   debug_printf(
 649           "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
 650   }
 651
 652 if (!pdkim_set_sig_bodyhash(ctx, sig))
 653   return NULL;
 654
 655 return sig;
 656 }
 657
 658
 659 /* -------------------------------------------------------------------------- */
 660
 661 pdkim_pubkey *
 662 pdkim_parse_pubkey_record(const uschar *raw_record)
 663 {
 664 const uschar * ele;
 665 int sep = ';';
 666 pdkim_pubkey * pub;
 667
 668 pub = store_get(sizeof(pdkim_pubkey), GET_TAINTED);
 669 memset(pub, 0, sizeof(pdkim_pubkey));
 670
 671 while ((ele = string_nextinlist(&raw_record, &sep, NULL, 0)))
 672   {
 673   const uschar * val;
 674
 675   if ((val = Ustrchr(ele, '=')))
 676     {
 677     int taglen = val++ - ele;
 678
 679     DEBUG(D_acl) debug_printf(" %.*s=%s\n", taglen, ele, val);
 680     switch (ele[0])
 681       {
 682       case 'v': pub->version = val;                     break;
 683       case 'h': pub->hashes = val;                      break;
 684       case 'k': pub->keytype = val;                     break;
 685       case 'g': pub->granularity = val;                 break;
 686       case 'n': pub->notes = pdkim_decode_qp(val);      break;
 687       case 'p': pdkim_decode_base64(val, &pub->key);    break;
 688       case 's': pub->srvtype = val;                     break;
 689       case 't': if (Ustrchr(val, 'y')) pub->testing = 1;
 690                 if (Ustrchr(val, 's')) pub->no_subdomaining = 1;
 691                 break;
 692       default:  DEBUG(D_acl) debug_printf(" Unknown tag encountered\n"); break;
 693       }
 694     }
 695   }
 696
 697 /* Set fallback defaults */
 698 if (!pub->version)
 699   pub->version = string_copy(PDKIM_PUB_RECORD_VERSION);
 700 else if (Ustrcmp(pub->version, PDKIM_PUB_RECORD_VERSION) != 0)
 701   {
 702   DEBUG(D_acl) debug_printf(" Bad v= field\n");
 703   return NULL;
 704   }
 705
 706 if (!pub->granularity) pub->granularity = US"*";
 707 if (!pub->keytype    ) pub->keytype     = US"rsa";
 708 if (!pub->srvtype    ) pub->srvtype     = US"*";
 709
 710 /* p= is required */
 711 if (pub->key.data)
 712   return pub;
 713
 714 DEBUG(D_acl) debug_printf(" Missing p= field\n");
 715 return NULL;
 716 }
 717
 718
 719 /* -------------------------------------------------------------------------- */
 720
 721 /* Update one bodyhash with some additional data.
 722 If we have to relax the data for this sig, return our copy of it. */
 723
 724 static blob *
 725 pdkim_update_ctx_bodyhash(pdkim_bodyhash * b, const blob * orig_data, blob * relaxed_data)
 726 {
 727 const blob * canon_data = orig_data;
 728 size_t left;
 729
 730 /* Defaults to simple canon (no further treatment necessary) */
 731
 732 if (b->canon_method == PDKIM_CANON_RELAXED)
 733   {
 734   /* Relax the line if not done already */
 735   if (!relaxed_data)
 736     {
 737     BOOL seen_wsp = FALSE;
 738     int q = 0;
 739
 740     /* We want to be able to free this else we allocate
 741     for the entire message which could be many MB. Since
 742     we don't know what allocations the SHA routines might
 743     do, not safe to use store_get()/store_reset(). */
 744
 745     relaxed_data = store_malloc(sizeof(blob) + orig_data->len+1);
 746     relaxed_data->data = US (relaxed_data+1);
 747
 748     for (const uschar * p = orig_data->data, * r = p + orig_data->len; p < r; p++)
 749       {
 750       char c = *p;
 751       if (c == '\r')
 752         {
 753         if (q > 0 && relaxed_data->data[q-1] == ' ')
 754           q--;
 755         }
 756       else if (c == '\t' || c == ' ')
 757         {
 758         c = ' '; /* Turns WSP into SP */
 759         if (seen_wsp)
 760           continue;
 761         seen_wsp = TRUE;
 762         }
 763       else
 764         seen_wsp = FALSE;
 765       relaxed_data->data[q++] = c;
 766       }
 767     relaxed_data->data[q] = '\0';
 768     relaxed_data->len = q;
 769     }
 770   canon_data = relaxed_data;
 771   }
 772
 773 /* Make sure we don't exceed the to-be-signed body length */
 774 left = canon_data->len;
 775 if (  b->bodylength >= 0
 776    && left > (unsigned long)b->bodylength - b->signed_body_bytes
 777    )
 778   left = (unsigned long)b->bodylength - b->signed_body_bytes;
 779
 780 if (left > 0)
 781   {
 782   exim_sha_update(&b->body_hash_ctx, CUS canon_data->data, left);
 783   b->signed_body_bytes += left;
 784   DEBUG(D_acl) pdkim_quoteprint(canon_data->data, left);
 785   }
 786
 787 return relaxed_data;
 788 }
 789
 790
 791 /* -------------------------------------------------------------------------- */
 792
 793 static void
 794 pdkim_finish_bodyhash(pdkim_ctx * ctx)
 795 {
 796 for (pdkim_bodyhash * b = ctx->bodyhash; b; b = b->next)     /* Finish hashes */
 797   {
 798   DEBUG(D_acl) debug_printf("DKIM: finish bodyhash %s/%s/%ld len %ld\n",
 799       pdkim_hashes[b->hashtype].dkim_hashname, pdkim_canons[b->canon_method],
 800       b->bodylength, b->signed_body_bytes);
 801   exim_sha_finish(&b->body_hash_ctx, &b->bh);
 802   }
 803
 804 /* Traverse all signatures */
 805 for (pdkim_signature * sig = ctx->sig; sig; sig = sig->next)
 806   {
 807   pdkim_bodyhash * b = sig->calc_body_hash;
 808
 809   DEBUG(D_acl)
 810     {
 811     debug_printf("DKIM [%s]%s Body bytes (%s) hashed: %lu\n"
 812                  "DKIM [%s]%s Body %s computed: ",
 813         sig->domain, sig->selector, pdkim_canons[b->canon_method], b->signed_body_bytes,
 814         sig->domain, sig->selector, pdkim_hashes[b->hashtype].dkim_hashname);
 815     pdkim_hexprint(CUS b->bh.data, b->bh.len);
 816     }
 817
 818   /* SIGNING -------------------------------------------------------------- */
 819   if (ctx->flags & PDKIM_MODE_SIGN)
 820     {
 821     /* If bodylength limit is set, and we have received less bytes
 822        than the requested amount, effectively remove the limit tag. */
 823     if (b->signed_body_bytes < sig->bodylength)
 824       sig->bodylength = -1;
 825     }
 826
 827   else
 828   /* VERIFICATION --------------------------------------------------------- */
 829   /* Be careful that the header sig included a bodyash */
 830
 831     if (sig->bodyhash.data && sig->bodyhash.len == b->bh.len
 832        && memcmp(b->bh.data, sig->bodyhash.data, b->bh.len) == 0)
 833       {
 834       DEBUG(D_acl) debug_printf("DKIM [%s] Body hash compared OK\n", sig->domain);
 835       }
 836     else
 837       {
 838       DEBUG(D_acl)
 839         {
 840         debug_printf("DKIM [%s] Body hash signature from headers: ", sig->domain);
 841         pdkim_hexprint(sig->bodyhash.data, sig->bodyhash.len);
 842         debug_printf("DKIM [%s] Body hash did NOT verify\n", sig->domain);
 843         }
 844       sig->verify_status     = PDKIM_VERIFY_FAIL;
 845       sig->verify_ext_status = PDKIM_VERIFY_FAIL_BODY;
 846       }
 847   }
 848 }
 849
 850
 851
 852 static void
 853 pdkim_body_complete(pdkim_ctx * ctx)
 854 {
 855 /* In simple body mode, if any empty lines were buffered,
 856 replace with one. rfc 4871 3.4.3 */
 857 /*XXX checking the signed-body-bytes is a gross hack; I think
 858 it indicates that all linebreaks should be buffered, including
 859 the one terminating a text line */
 860
 861 for (pdkim_bodyhash * b = ctx->bodyhash; b; b = b->next)
 862   if (  b->canon_method == PDKIM_CANON_SIMPLE
 863      && b->signed_body_bytes == 0
 864      && b->num_buffered_blanklines > 0
 865      )
 866     (void) pdkim_update_ctx_bodyhash(b, &lineending, NULL);
 867
 868 ctx->flags |= PDKIM_SEEN_EOD;
 869 ctx->linebuf_offset = 0;
 870 }
 871
 872
 873
 874 /* -------------------------------------------------------------------------- */
 875 /* Call from pdkim_feed below for processing complete body lines */
 876 /* NOTE: the line is not NUL-terminated; but we have a count */
 877
 878 static void
 879 pdkim_bodyline_complete(pdkim_ctx * ctx)
 880 {
 881 blob line = {.data = ctx->linebuf, .len = ctx->linebuf_offset};
 882 blob * rnl = NULL;
 883 blob * rline = NULL;
 884
 885 /* Ignore extra data if we've seen the end-of-data marker */
 886 if (ctx->flags & PDKIM_SEEN_EOD) goto all_skip;
 887
 888 /* We've always got one extra byte to stuff a zero ... */
 889 ctx->linebuf[line.len] = '\0';
 890
 891 /* Terminate on EOD marker */
 892 if (ctx->flags & PDKIM_DOT_TERM)
 893   {
 894   if (memcmp(line.data, ".\r\n", 3) == 0)
 895     { pdkim_body_complete(ctx); return; }
 896
 897   /* Unstuff dots */
 898   if (memcmp(line.data, "..", 2) == 0)
 899     { line.data++; line.len--; }
 900   }
 901
 902 /* Empty lines need to be buffered until we find a non-empty line */
 903 if (memcmp(line.data, "\r\n", 2) == 0)
 904   {
 905   for (pdkim_bodyhash * b = ctx->bodyhash; b; b = b->next)
 906     b->num_buffered_blanklines++;
 907   goto all_skip;
 908   }
 909
 910 /* Process line for each bodyhash separately */
 911 for (pdkim_bodyhash * b = ctx->bodyhash; b; b = b->next)
 912   {
 913   if (b->canon_method == PDKIM_CANON_RELAXED)
 914     {
 915     /* Lines with just spaces need to be buffered too */
 916     uschar * cp = line.data;
 917     char c;
 918
 919     while ((c = *cp))
 920       {
 921       if (c == '\r' && cp[1] == '\n') break;
 922       if (c != ' ' && c != '\t') goto hash_process;
 923       cp++;
 924       }
 925
 926     b->num_buffered_blanklines++;
 927     goto hash_skip;
 928     }
 929
 930 hash_process:
 931   /* At this point, we have a non-empty line, so release the buffered ones. */
 932
 933   while (b->num_buffered_blanklines)
 934     {
 935     rnl = pdkim_update_ctx_bodyhash(b, &lineending, rnl);
 936     b->num_buffered_blanklines--;
 937     }
 938
 939   rline = pdkim_update_ctx_bodyhash(b, &line, rline);
 940 hash_skip: ;
 941   }
 942
 943 if (rnl) store_free(rnl);
 944 if (rline) store_free(rline);
 945
 946 all_skip:
 947
 948 ctx->linebuf_offset = 0;
 949 return;
 950 }
 951
 952
 953 /* -------------------------------------------------------------------------- */
 954 /* Callback from pdkim_feed below for processing complete headers */
 955 #define DKIM_SIGNATURE_HEADERNAME "DKIM-Signature:"
 956
 957 static int
 958 pdkim_header_complete(pdkim_ctx * ctx)
 959 {
 960 if ( (ctx->cur_header->ptr > 1) &&
 961      (ctx->cur_header->s[ctx->cur_header->ptr-1] == '\r') )
 962   --ctx->cur_header->ptr;
 963 (void) string_from_gstring(ctx->cur_header);
 964
 965 #ifdef EXPERIMENTAL_ARC
 966 /* Feed the header line to ARC processing */
 967 (void) arc_header_feed(ctx->cur_header, !(ctx->flags & PDKIM_MODE_SIGN));
 968 #endif
 969
 970 if (++ctx->num_headers > PDKIM_MAX_HEADERS) goto BAIL;
 971
 972 /* SIGNING -------------------------------------------------------------- */
 973 if (ctx->flags & PDKIM_MODE_SIGN)
 974   for (pdkim_signature * sig = ctx->sig; sig; sig = sig->next)  /* Traverse all signatures */
 975
 976     /* Add header to the signed headers list (in reverse order) */
 977     sig->headers = pdkim_prepend_stringlist(sig->headers, ctx->cur_header->s);
 978
 979 /* VERIFICATION ----------------------------------------------------------- */
 980 /* DKIM-Signature: headers are added to the verification list */
 981 else
 982   {
 983 #ifdef notdef
 984   DEBUG(D_acl)
 985     {
 986     debug_printf("DKIM >> raw hdr: ");
 987     pdkim_quoteprint(CUS ctx->cur_header->s, ctx->cur_header->ptr);
 988     }
 989 #endif
 990   if (strncasecmp(CCS ctx->cur_header->s,
 991                   DKIM_SIGNATURE_HEADERNAME,
 992                   Ustrlen(DKIM_SIGNATURE_HEADERNAME)) == 0)
 993     {
 994     pdkim_signature * sig, * last_sig;
 995     /* Create and chain new signature block.  We could error-check for all
 996     required tags here, but prefer to create the internal sig and expicitly
 997     fail verification of it later. */
 998
 999     DEBUG(D_acl) debug_printf(
1000         "DKIM >> Found sig, trying to parse >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1001
1002     sig = pdkim_parse_sig_header(ctx, ctx->cur_header->s);
1003
1004     if (!(last_sig = ctx->sig))
1005       ctx->sig = sig;
1006     else
1007       {
1008       while (last_sig->next) last_sig = last_sig->next;
1009       last_sig->next = sig;
1010       }
1011
1012     if (dkim_collect_input && --dkim_collect_input == 0)
1013       {
1014       ctx->headers = pdkim_prepend_stringlist(ctx->headers, ctx->cur_header->s);
1015       ctx->cur_header->s[ctx->cur_header->ptr = 0] = '\0';
1016       return PDKIM_ERR_EXCESS_SIGS;
1017       }
1018     }
1019
1020   /* all headers are stored for signature verification */
1021   ctx->headers = pdkim_prepend_stringlist(ctx->headers, ctx->cur_header->s);
1022   }
1023
1024 BAIL:
1025 ctx->cur_header->s[ctx->cur_header->ptr = 0] = '\0';    /* leave buffer for reuse */
1026 return PDKIM_OK;
1027 }
1028
1029
1030
1031 /* -------------------------------------------------------------------------- */
1032 #define HEADER_BUFFER_FRAG_SIZE 256
1033
1034 DLLEXPORT int
1035 pdkim_feed(pdkim_ctx * ctx, uschar * data, int len)
1036 {
1037 /* Alternate EOD signal, used in non-dotstuffing mode */
1038 if (!data)
1039   pdkim_body_complete(ctx);
1040
1041 else for (int p = 0; p < len; p++)
1042   {
1043   uschar c = data[p];
1044   int rc;
1045
1046   if (ctx->flags & PDKIM_PAST_HDRS)
1047     {
1048     if (c == '\n' && !(ctx->flags & PDKIM_SEEN_CR))     /* emulate the CR */
1049       {
1050       ctx->linebuf[ctx->linebuf_offset++] = '\r';
1051       if (ctx->linebuf_offset == PDKIM_MAX_BODY_LINE_LEN-1)
1052         return PDKIM_ERR_LONG_LINE;
1053       }
1054
1055     /* Processing body byte */
1056     ctx->linebuf[ctx->linebuf_offset++] = c;
1057     if (c == '\r')
1058       ctx->flags |= PDKIM_SEEN_CR;
1059     else if (c == '\n')
1060       {
1061       ctx->flags &= ~PDKIM_SEEN_CR;
1062       pdkim_bodyline_complete(ctx);
1063       }
1064
1065     if (ctx->linebuf_offset == PDKIM_MAX_BODY_LINE_LEN-1)
1066       return PDKIM_ERR_LONG_LINE;
1067     }
1068   else
1069     {
1070     /* Processing header byte */
1071     if (c == '\r')
1072       ctx->flags |= PDKIM_SEEN_CR;
1073     else if (c == '\n')
1074       {
1075       if (!(ctx->flags & PDKIM_SEEN_CR))                /* emulate the CR */
1076         ctx->cur_header = string_catn(ctx->cur_header, CUS "\r", 1);
1077
1078       if (ctx->flags & PDKIM_SEEN_LF)           /* Seen last header line */
1079         {
1080         if ((rc = pdkim_header_complete(ctx)) != PDKIM_OK)
1081           return rc;
1082
1083         ctx->flags = (ctx->flags & ~(PDKIM_SEEN_LF|PDKIM_SEEN_CR)) | PDKIM_PAST_HDRS;
1084         DEBUG(D_acl) debug_printf(
1085             "DKIM >> Body data for hash, canonicalized >>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1086         continue;
1087         }
1088       else
1089         ctx->flags = (ctx->flags & ~PDKIM_SEEN_CR) | PDKIM_SEEN_LF;
1090       }
1091     else if (ctx->flags & PDKIM_SEEN_LF)
1092       {
1093       if (!(c == '\t' || c == ' '))                     /* End of header */
1094         if ((rc = pdkim_header_complete(ctx)) != PDKIM_OK)
1095           return rc;
1096       ctx->flags &= ~PDKIM_SEEN_LF;
1097       }
1098
1099     if (!ctx->cur_header || ctx->cur_header->ptr < PDKIM_MAX_HEADER_LEN)
1100       ctx->cur_header = string_catn(ctx->cur_header, CUS &data[p], 1);
1101     }
1102   }
1103 return PDKIM_OK;
1104 }
1105
1106
1107
1108 /* Extend a growing header with a continuation-linebreak */
1109 static gstring *
1110 pdkim_hdr_cont(gstring * str, int * col)
1111 {
1112 *col = 1;
1113 return string_catn(str, US"\r\n\t", 3);
1114 }
1115
1116
1117
1118 /*
1119  * RFC 5322 specifies that header line length SHOULD be no more than 78
1120  *  pdkim_headcat
1121  *
1122  * Returns gstring (not nul-terminated) appending to one supplied
1123  *
1124  * col: this int holds and receives column number (octets since last '\n')
1125  * str: partial string to append to
1126  * pad: padding, split line or space after before or after eg: ";".
1127  *               Only the initial charater is used.
1128  * intro: - must join to payload eg "h=", usually the tag name
1129  * payload: eg base64 data - long data can be split arbitrarily.
1130  *
1131  * this code doesn't fold the header in some of the places that RFC4871
1132  * allows: As per RFC5322(2.2.3) it only folds before or after tag-value
1133  * pairs and inside long values. it also always spaces or breaks after the
1134  * "pad"
1135  *
1136  * No guarantees are made for output given out-of range input. like tag
1137  * names longer than 78, or bogus col. Input is assumed to be free of line breaks.
1138  */
1139
1140 static gstring *
1141 pdkim_headcat(int * col, gstring * str,
1142   const uschar * pad, const uschar * intro, const uschar * payload)
1143 {
1144 int len, chomp, padded = 0;
1145
1146 /* If we can fit at least the pad at the end of current line, do it now.
1147 Otherwise, wrap if there is a pad. */
1148
1149 if (pad)
1150   if (*col + 1 <= 78)
1151     {
1152     str = string_catn(str, pad, 1);
1153     (*col)++;
1154     pad = NULL;
1155     padded = 1;
1156     }
1157   else
1158     str = pdkim_hdr_cont(str, col);
1159
1160 /* Special case: if the whole addition does not fit at the end of the current
1161 line, but could fit on a new line, wrap to give it its full, dedicated line.  */
1162
1163 len = (pad ? 2 : padded)
1164     + (intro ? Ustrlen(intro) : 0)
1165     + (payload ? Ustrlen(payload) : 0);
1166 if (len <= 77 && *col+len > 78)
1167   {
1168   str = pdkim_hdr_cont(str, col);
1169   padded = 0;
1170   }
1171
1172 /* Either we already dealt with the pad or we know there is room */
1173
1174 if (pad)
1175   {
1176   str = string_catn(str, pad, 1);
1177   str = string_catn(str, US" ", 1);
1178   *col += 2;
1179   }
1180 else if (padded && *col < 78)
1181   {
1182   str = string_catn(str, US" ", 1);
1183   (*col)++;
1184   }
1185
1186 /* Call recursively with intro as payload: it gets the same, special treatment
1187 (that is, not split if < 78).  */
1188
1189 if (intro)
1190   str = pdkim_headcat(col, str, NULL, NULL, intro);
1191
1192 if (payload)
1193   for (len = Ustrlen(payload); len; len -= chomp)
1194     {
1195     if (*col >= 78)
1196       str = pdkim_hdr_cont(str, col);
1197     chomp = *col+len > 78 ? 78 - *col : len;
1198     str = string_catn(str, payload, chomp);
1199     *col += chomp;
1200     payload += chomp;
1201     }
1202
1203 return str;
1204 }
1205
1206
1207 /* -------------------------------------------------------------------------- */
1208
1209 /* Signing: create signature header
1210 */
1211 static uschar *
1212 pdkim_create_header(pdkim_signature * sig, BOOL final)
1213 {
1214 uschar * base64_bh;
1215 uschar * base64_b;
1216 int col = 0;
1217 gstring * hdr;
1218 gstring * canon_all;
1219
1220 canon_all = string_cat (NULL, pdkim_canons[sig->canon_headers]);
1221 canon_all = string_catn(canon_all, US"/", 1);
1222 canon_all = string_cat (canon_all, pdkim_canons[sig->canon_body]);
1223 (void) string_from_gstring(canon_all);
1224
1225 hdr = string_cat(NULL, US"DKIM-Signature: v="PDKIM_SIGNATURE_VERSION);
1226 col = hdr->ptr;
1227
1228 /* Required and static bits */
1229 hdr = pdkim_headcat(&col, hdr, US";", US"a=", dkim_sig_to_a_tag(sig));
1230 hdr = pdkim_headcat(&col, hdr, US";", US"q=", pdkim_querymethods[sig->querymethod]);
1231 hdr = pdkim_headcat(&col, hdr, US";", US"c=", canon_all->s);
1232 hdr = pdkim_headcat(&col, hdr, US";", US"d=", sig->domain);
1233 hdr = pdkim_headcat(&col, hdr, US";", US"s=", sig->selector);
1234
1235 /* list of header names can be split between items. */
1236   {
1237   uschar * n = string_copy(sig->headernames);
1238   uschar * i = US"h=";
1239   uschar * s = US";";
1240
1241   while (*n)
1242     {
1243     uschar * c = Ustrchr(n, ':');
1244
1245     if (c) *c ='\0';
1246
1247     if (!i)
1248       hdr = pdkim_headcat(&col, hdr, NULL, NULL, US":");
1249
1250     hdr = pdkim_headcat(&col, hdr, s, i, n);
1251
1252     if (!c)
1253       break;
1254
1255     n = c+1;
1256     s = NULL;
1257     i = NULL;
1258     }
1259   }
1260
1261 base64_bh = pdkim_encode_base64(&sig->calc_body_hash->bh);
1262 hdr = pdkim_headcat(&col, hdr, US";", US"bh=", base64_bh);
1263
1264 /* Optional bits */
1265 if (sig->identity)
1266   hdr = pdkim_headcat(&col, hdr, US";", US"i=", sig->identity);
1267
1268 if (sig->created > 0)
1269   {
1270   uschar minibuf[21];
1271
1272   snprintf(CS minibuf, sizeof(minibuf), "%lu", sig->created);
1273   hdr = pdkim_headcat(&col, hdr, US";", US"t=", minibuf);
1274 }
1275
1276 if (sig->expires > 0)
1277   {
1278   uschar minibuf[21];
1279
1280   snprintf(CS minibuf, sizeof(minibuf), "%lu", sig->expires);
1281   hdr = pdkim_headcat(&col, hdr, US";", US"x=", minibuf);
1282   }
1283
1284 if (sig->bodylength >= 0)
1285   {
1286   uschar minibuf[21];
1287
1288   snprintf(CS minibuf, sizeof(minibuf), "%lu", sig->bodylength);
1289   hdr = pdkim_headcat(&col, hdr, US";", US"l=", minibuf);
1290   }
1291
1292 /* Preliminary or final version? */
1293 if (final)
1294   {
1295   base64_b = pdkim_encode_base64(&sig->sighash);
1296   hdr = pdkim_headcat(&col, hdr, US";", US"b=", base64_b);
1297
1298   /* add trailing semicolon: I'm not sure if this is actually needed */
1299   hdr = pdkim_headcat(&col, hdr, NULL, US";", US"");
1300   }
1301 else
1302   {
1303   /* To satisfy the rule "all surrounding whitespace [...] deleted"
1304   ( RFC 6376 section 3.7 ) we ensure there is no whitespace here.  Otherwise
1305   the headcat routine could insert a linebreak which the relaxer would reduce
1306   to a single space preceding the terminating semicolon, resulting in an
1307   incorrect header-hash. */
1308   hdr = pdkim_headcat(&col, hdr, US";", US"b=;", US"");
1309   }
1310
1311 return string_from_gstring(hdr);
1312 }
1313
1314
1315 /* -------------------------------------------------------------------------- */
1316
1317 /* According to draft-ietf-dcrup-dkim-crypto-07 "keys are 256 bits" (referring
1318 to DNS, hence the pubkey).  Check for more than 32 bytes; if so assume the
1319 alternate possible representation (still) being discussed: a
1320 SubjectPublickeyInfo wrapped key - and drop all but the trailing 32-bytes (it
1321 should be a DER, with exactly 12 leading bytes - but we could accept a BER also,
1322 which could be any size).  We still rely on the crypto library for checking for
1323 undersize.
1324
1325 When the RFC is published this should be re-addressed. */
1326
1327 static void
1328 check_bare_ed25519_pubkey(pdkim_pubkey * p)
1329 {
1330 int excess = p->key.len - 32;
1331 if (excess > 0)
1332   {
1333   DEBUG(D_acl)
1334     debug_printf("DKIM: unexpected pubkey len %lu\n", (unsigned long) p->key.len);
1335   p->key.data += excess; p->key.len = 32;
1336   }
1337 }
1338
1339
1340 static pdkim_pubkey *
1341 pdkim_key_from_dns(pdkim_ctx * ctx, pdkim_signature * sig, ev_ctx * vctx,
1342   const uschar ** errstr)
1343 {
1344 uschar * dns_txt_name, * dns_txt_reply;
1345 pdkim_pubkey * p;
1346
1347 /* Fetch public key for signing domain, from DNS */
1348
1349 dns_txt_name = string_sprintf("%s._domainkey.%s.", sig->selector, sig->domain);
1350
1351 if (  !(dns_txt_reply = ctx->dns_txt_callback(dns_txt_name))
1352    || dns_txt_reply[0] == '\0'
1353    )
1354   {
1355   sig->verify_status =      PDKIM_VERIFY_INVALID;
1356   sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE;
1357   return NULL;
1358   }
1359
1360 DEBUG(D_acl)
1361   {
1362   debug_printf(
1363     "DKIM >> Parsing public key record >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"
1364     " %s\n"
1365     " Raw record: ",
1366     dns_txt_name);
1367   pdkim_quoteprint(CUS dns_txt_reply, Ustrlen(dns_txt_reply));
1368   }
1369
1370 if (  !(p = pdkim_parse_pubkey_record(CUS dns_txt_reply))
1371    || (Ustrcmp(p->srvtype, "*") != 0 && Ustrcmp(p->srvtype, "email") != 0)
1372    )
1373   {
1374   sig->verify_status =      PDKIM_VERIFY_INVALID;
1375   sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD;
1376
1377   DEBUG(D_acl)
1378     {
1379     if (p)
1380       debug_printf(" Invalid public key service type '%s'\n", p->srvtype);
1381     else
1382       debug_printf(" Error while parsing public key record\n");
1383     debug_printf(
1384       "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1385     }
1386   return NULL;
1387   }
1388
1389 DEBUG(D_acl) debug_printf(
1390       "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1391
1392 /* Import public key */
1393
1394 /* Normally we use the signature a= tag to tell us the pubkey format.
1395 When signing under debug we do a test-import of the pubkey, and at that
1396 time we do not have a signature so we must interpret the pubkey k= tag
1397 instead.  Assume writing on the sig is ok in that case. */
1398
1399 if (sig->keytype < 0)
1400   if ((sig->keytype = pdkim_keyname_to_keytype(p->keytype)) < 0)
1401     {
1402     DEBUG(D_acl) debug_printf("verify_init: unhandled keytype %s\n", p->keytype);
1403     sig->verify_status =      PDKIM_VERIFY_INVALID;
1404     sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_IMPORT;
1405     return NULL;
1406     }
1407
1408 if (sig->keytype == KEYTYPE_ED25519)
1409   check_bare_ed25519_pubkey(p);
1410
1411 if ((*errstr = exim_dkim_verify_init(&p->key,
1412             sig->keytype == KEYTYPE_ED25519 ? KEYFMT_ED25519_BARE : KEYFMT_DER,
1413             vctx, &sig->keybits)))
1414   {
1415   DEBUG(D_acl) debug_printf("verify_init: %s\n", *errstr);
1416   sig->verify_status =      PDKIM_VERIFY_INVALID;
1417   sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_IMPORT;
1418   return NULL;
1419   }
1420
1421 vctx->keytype = sig->keytype;
1422 return p;
1423 }
1424
1425
1426 /* -------------------------------------------------------------------------- */
1427 /* Sort and filter the sigs developed from the message */
1428
1429 static pdkim_signature *
1430 sort_sig_methods(pdkim_signature * siglist)
1431 {
1432 pdkim_signature * yield, ** ss;
1433 const uschar * prefs;
1434 uschar * ele;
1435 int sep;
1436
1437 if (!siglist) return NULL;
1438
1439 /* first select in order of hashtypes */
1440 DEBUG(D_acl) debug_printf("DKIM: dkim_verify_hashes   '%s'\n", dkim_verify_hashes);
1441 for (prefs = dkim_verify_hashes, sep = 0, yield = NULL, ss = &yield;
1442      ele = string_nextinlist(&prefs, &sep, NULL, 0); )
1443   {
1444   int i = pdkim_hashname_to_hashtype(CUS ele, 0);
1445   for (pdkim_signature * s = siglist, * next, ** prev = &siglist; s;
1446        s = next)
1447     {
1448     next = s->next;
1449     if (s->hashtype == i)
1450       { *prev = next; s->next = NULL; *ss = s; ss = &s->next; }
1451     else
1452       prev = &s->next;
1453     }
1454   }
1455
1456 /* then in order of keytypes */
1457 siglist = yield;
1458 DEBUG(D_acl) debug_printf("DKIM: dkim_verify_keytypes '%s'\n", dkim_verify_keytypes);
1459 for (prefs = dkim_verify_keytypes, sep = 0, yield = NULL, ss = &yield;
1460      ele = string_nextinlist(&prefs, &sep, NULL, 0); )
1461   {
1462   int i = pdkim_keyname_to_keytype(CUS ele);
1463   for (pdkim_signature * s = siglist, * next, ** prev = &siglist; s;
1464        s = next)
1465     {
1466     next = s->next;
1467     if (s->keytype == i)
1468       { *prev = next; s->next = NULL; *ss = s; ss = &s->next; }
1469     else
1470       prev = &s->next;
1471     }
1472   }
1473
1474 DEBUG(D_acl) for (pdkim_signature * s = yield; s; s = s->next)
1475   debug_printf(" retain d=%s s=%s a=%s\n",
1476     s->domain, s->selector, dkim_sig_to_a_tag(s));
1477 return yield;
1478 }
1479
1480
1481 /* -------------------------------------------------------------------------- */
1482
1483 DLLEXPORT int
1484 pdkim_feed_finish(pdkim_ctx * ctx, pdkim_signature ** return_signatures,
1485   const uschar ** err)
1486 {
1487 BOOL verify_pass = FALSE;
1488
1489 /* Check if we must still flush a (partial) header. If that is the
1490    case, the message has no body, and we must compute a body hash
1491    out of '<CR><LF>' */
1492 if (ctx->cur_header && ctx->cur_header->ptr > 0)
1493   {
1494   blob * rnl = NULL;
1495   int rc;
1496
1497   if ((rc = pdkim_header_complete(ctx)) != PDKIM_OK)
1498     return rc;
1499
1500   for (pdkim_bodyhash * b = ctx->bodyhash; b; b = b->next)
1501     rnl = pdkim_update_ctx_bodyhash(b, &lineending, rnl);
1502   if (rnl) store_free(rnl);
1503   }
1504 else
1505   DEBUG(D_acl) debug_printf(
1506       "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1507
1508 /* Build (and/or evaluate) body hash.  Do this even if no DKIM sigs, in case we
1509 have a hash to do for ARC. */
1510
1511 pdkim_finish_bodyhash(ctx);
1512
1513 /* Sort and filter the recived signatures */
1514
1515 if (!(ctx->flags & PDKIM_MODE_SIGN))
1516   ctx->sig = sort_sig_methods(ctx->sig);
1517
1518 if (!ctx->sig)
1519   {
1520   DEBUG(D_acl) debug_printf("DKIM: no signatures\n");
1521   *return_signatures = NULL;
1522   return PDKIM_OK;
1523   }
1524
1525 for (pdkim_signature * sig = ctx->sig; sig; sig = sig->next)
1526   {
1527   hctx hhash_ctx;
1528   uschar * sig_hdr = US"";
1529   blob hhash;
1530   gstring * hdata = NULL;
1531   es_ctx sctx;
1532
1533   if (  !(ctx->flags & PDKIM_MODE_SIGN)
1534      && sig->verify_status == PDKIM_VERIFY_FAIL)
1535     {
1536     DEBUG(D_acl)
1537        debug_printf("DKIM: [%s] abandoning this signature\n", sig->domain);
1538     continue;
1539     }
1540
1541   /*XXX The hash of the headers is needed for GCrypt (for which we can do RSA
1542   signing only, as it happens) and for either GnuTLS and OpenSSL when we are
1543   signing with EC (specifically, Ed25519).  The former is because the GCrypt
1544   signing operation is pure (does not do its own hash) so we must hash.  The
1545   latter is because we (stupidly, but this is what the IETF draft is saying)
1546   must hash with the declared hash method, then pass the result to the library
1547   hash-and-sign routine (because that's all the libraries are providing.  And
1548   we're stuck with whatever that hidden hash method is, too).  We may as well
1549   do this hash incrementally.
1550   We don't need the hash we're calculating here for the GnuTLS and OpenSSL
1551   cases of RSA signing, since those library routines can do hash-and-sign.
1552
1553   Some time in the future we could easily avoid doing the hash here for those
1554   cases (which will be common for a long while.  We could also change from
1555   the current copy-all-the-headers-into-one-block, then call the hash-and-sign
1556   implementation  - to a proper incremental one.  Unfortunately, GnuTLS just
1557   cannot do incremental - either signing or verification.  Unsure about GCrypt.
1558   */
1559
1560   /*XXX The header hash is also used (so far) by the verify operation */
1561
1562   if (!exim_sha_init(&hhash_ctx, pdkim_hashes[sig->hashtype].exim_hashmethod))
1563     {
1564     log_write(0, LOG_MAIN|LOG_PANIC,
1565       "DKIM: hash setup error, possibly nonhandled hashtype");
1566     break;
1567     }
1568
1569   if (ctx->flags & PDKIM_MODE_SIGN)
1570     DEBUG(D_acl) debug_printf(
1571         "DKIM >> Headers to be signed:                            >>>>>>>>>>>>\n"
1572         " %s\n",
1573         sig->sign_headers);
1574
1575   DEBUG(D_acl) debug_printf(
1576       "DKIM >> Header data for hash, canonicalized (%-7s), in sequence >>\n",
1577         pdkim_canons[sig->canon_headers]);
1578
1579
1580   /* SIGNING ---------------------------------------------------------------- */
1581   /* When signing, walk through our header list and add them to the hash. As we
1582      go, construct a list of the header's names to use for the h= parameter.
1583      Then append to that list any remaining header names for which there was no
1584      header to sign. */
1585
1586   if (ctx->flags & PDKIM_MODE_SIGN)
1587     {
1588     gstring * g = NULL;
1589     const uschar * l;
1590     uschar * s;
1591     int sep = 0;
1592
1593     /* Import private key, including the keytype which we need for building
1594     the signature header  */
1595
1596     if ((*err = exim_dkim_signing_init(CUS sig->privkey, &sctx)))
1597       {
1598       log_write(0, LOG_MAIN|LOG_PANIC, "signing_init: %s", *err);
1599       return PDKIM_ERR_RSA_PRIVKEY;
1600       }
1601     sig->keytype = sctx.keytype;
1602
1603     sig->headernames = NULL;                    /* Collected signed header names */
1604     for (pdkim_stringlist * p = sig->headers; p; p = p->next)
1605       {
1606       uschar * rh = p->value;
1607
1608       if (header_name_match(rh, sig->sign_headers) == PDKIM_OK)
1609         {
1610         /* Collect header names (Note: colon presence is guaranteed here) */
1611         g = string_append_listele_n(g, ':', rh, Ustrchr(rh, ':') - rh);
1612
1613         if (sig->canon_headers == PDKIM_CANON_RELAXED)
1614           rh = pdkim_relax_header(rh, TRUE);    /* cook header for relaxed canon */
1615
1616         /* Feed header to the hash algorithm */
1617         exim_sha_update_string(&hhash_ctx, CUS rh);
1618
1619         /* Remember headers block for signing (when the library cannot do incremental)  */
1620         /*XXX we could avoid doing this for all but the GnuTLS/RSA case */
1621         hdata = exim_dkim_data_append(hdata, rh);
1622
1623         DEBUG(D_acl) pdkim_quoteprint(rh, Ustrlen(rh));
1624         }
1625       }
1626
1627     /* Any headers we wanted to sign but were not present must also be listed.
1628     Ignore elements that have been ticked-off or are marked as never-oversign. */
1629
1630     l = sig->sign_headers;
1631     while((s = string_nextinlist(&l, &sep, NULL, 0)))
1632       {
1633       if (*s == '+')                    /* skip oversigning marker */
1634         s++;
1635       if (*s != '_' && *s != '=')
1636         g = string_append_listele(g, ':', s);
1637       }
1638     sig->headernames = string_from_gstring(g);
1639
1640     /* Create signature header with b= omitted */
1641     sig_hdr = pdkim_create_header(sig, FALSE);
1642     }
1643
1644   /* VERIFICATION ----------------------------------------------------------- */
1645   /* When verifying, walk through the header name list in the h= parameter and
1646      add the headers to the hash in that order. */
1647   else
1648     {
1649     uschar * p = sig->headernames;
1650     uschar * q;
1651
1652     if (p)
1653       {
1654       /* clear tags */
1655       for (pdkim_stringlist * hdrs = ctx->headers; hdrs; hdrs = hdrs->next)
1656         hdrs->tag = 0;
1657
1658       p = string_copy(p);
1659       while(1)
1660         {
1661         if ((q = Ustrchr(p, ':')))
1662           *q = '\0';
1663
1664   /*XXX walk the list of headers in same order as received. */
1665         for (pdkim_stringlist * hdrs = ctx->headers; hdrs; hdrs = hdrs->next)
1666           if (  hdrs->tag == 0
1667              && strncasecmp(CCS hdrs->value, CCS p, Ustrlen(p)) == 0
1668              && (hdrs->value)[Ustrlen(p)] == ':'
1669              )
1670             {
1671             /* cook header for relaxed canon, or just copy it for simple  */
1672
1673             uschar * rh = sig->canon_headers == PDKIM_CANON_RELAXED
1674               ? pdkim_relax_header(hdrs->value, TRUE)
1675               : string_copy(CUS hdrs->value);
1676
1677             /* Feed header to the hash algorithm */
1678             exim_sha_update_string(&hhash_ctx, CUS rh);
1679
1680             DEBUG(D_acl) pdkim_quoteprint(rh, Ustrlen(rh));
1681             hdrs->tag = 1;
1682             break;
1683             }
1684
1685         if (!q) break;
1686         p = q+1;
1687         }
1688
1689       sig_hdr = string_copy(sig->rawsig_no_b_val);
1690       }
1691     }
1692
1693   DEBUG(D_acl) debug_printf(
1694             "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1695
1696   DEBUG(D_acl)
1697     {
1698     debug_printf(
1699             "DKIM >> Signed DKIM-Signature header, pre-canonicalized >>>>>>>>>>>>>\n");
1700     pdkim_quoteprint(CUS sig_hdr, Ustrlen(sig_hdr));
1701     debug_printf(
1702             "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1703     }
1704
1705   /* Relax header if necessary */
1706   if (sig->canon_headers == PDKIM_CANON_RELAXED)
1707     sig_hdr = pdkim_relax_header(sig_hdr, FALSE);
1708
1709   DEBUG(D_acl)
1710     {
1711     debug_printf("DKIM >> Signed DKIM-Signature header, canonicalized (%-7s) >>>>>>>\n",
1712             pdkim_canons[sig->canon_headers]);
1713     pdkim_quoteprint(CUS sig_hdr, Ustrlen(sig_hdr));
1714     debug_printf(
1715             "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1716     }
1717
1718   /* Finalize header hash */
1719   exim_sha_update_string(&hhash_ctx, CUS sig_hdr);
1720   exim_sha_finish(&hhash_ctx, &hhash);
1721
1722   DEBUG(D_acl)
1723     {
1724     debug_printf("DKIM [%s] Header %s computed: ",
1725       sig->domain, pdkim_hashes[sig->hashtype].dkim_hashname);
1726     pdkim_hexprint(hhash.data, hhash.len);
1727     }
1728
1729   /* Remember headers block for signing (when the signing library cannot do
1730   incremental)  */
1731   if (ctx->flags & PDKIM_MODE_SIGN)
1732     hdata = exim_dkim_data_append(hdata, US sig_hdr);
1733
1734   /* SIGNING ---------------------------------------------------------------- */
1735   if (ctx->flags & PDKIM_MODE_SIGN)
1736     {
1737     hashmethod hm = sig->keytype == KEYTYPE_ED25519
1738 #if defined(SIGN_OPENSSL)
1739       ? HASH_NULL
1740 #else
1741       ? HASH_SHA2_512
1742 #endif
1743       : pdkim_hashes[sig->hashtype].exim_hashmethod;
1744
1745 #ifdef SIGN_HAVE_ED25519
1746     /* For GCrypt, and for EC, we pass the hash-of-headers to the signing
1747     routine.  For anything else we just pass the headers. */
1748
1749     if (sig->keytype != KEYTYPE_ED25519)
1750 #endif
1751       {
1752       hhash.data = hdata->s;
1753       hhash.len = hdata->ptr;
1754       }
1755
1756     if ((*err = exim_dkim_sign(&sctx, hm, &hhash, &sig->sighash)))
1757       {
1758       log_write(0, LOG_MAIN|LOG_PANIC, "signing: %s", *err);
1759       return PDKIM_ERR_RSA_SIGNING;
1760       }
1761
1762     DEBUG(D_acl)
1763       {
1764       debug_printf( "DKIM [%s] b computed: ", sig->domain);
1765       pdkim_hexprint(sig->sighash.data, sig->sighash.len);
1766       }
1767
1768     sig->signature_header = pdkim_create_header(sig, TRUE);
1769     }
1770
1771   /* VERIFICATION ----------------------------------------------------------- */
1772   else
1773     {
1774     ev_ctx vctx;
1775     hashmethod hm;
1776
1777     /* Make sure we have all required signature tags */
1778     if (!(  sig->domain        && *sig->domain
1779          && sig->selector      && *sig->selector
1780          && sig->headernames   && *sig->headernames
1781          && sig->bodyhash.data
1782          && sig->sighash.data
1783          && sig->keytype >= 0
1784          && sig->hashtype >= 0
1785          && sig->version
1786        ) )
1787       {
1788       sig->verify_status     = PDKIM_VERIFY_INVALID;
1789       sig->verify_ext_status = PDKIM_VERIFY_INVALID_SIGNATURE_ERROR;
1790
1791       DEBUG(D_acl) debug_printf(
1792           " Error in DKIM-Signature header: tags missing or invalid (%s)\n"
1793           "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n",
1794           !(sig->domain && *sig->domain) ? "d="
1795           : !(sig->selector && *sig->selector) ? "s="
1796           : !(sig->headernames && *sig->headernames) ? "h="
1797           : !sig->bodyhash.data ? "bh="
1798           : !sig->sighash.data ? "b="
1799           : sig->keytype < 0 || sig->hashtype < 0 ? "a="
1800           : "v="
1801           );
1802       goto NEXT_VERIFY;
1803       }
1804
1805     /* Make sure sig uses supported DKIM version (only v1) */
1806     if (sig->version != 1)
1807       {
1808       sig->verify_status     = PDKIM_VERIFY_INVALID;
1809       sig->verify_ext_status = PDKIM_VERIFY_INVALID_DKIM_VERSION;
1810
1811       DEBUG(D_acl) debug_printf(
1812           " Error in DKIM-Signature header: unsupported DKIM version\n"
1813           "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1814       goto NEXT_VERIFY;
1815       }
1816
1817     DEBUG(D_acl)
1818       {
1819       debug_printf( "DKIM [%s] b from mail: ", sig->domain);
1820       pdkim_hexprint(sig->sighash.data, sig->sighash.len);
1821       }
1822
1823     if (!(sig->pubkey = pdkim_key_from_dns(ctx, sig, &vctx, err)))
1824       {
1825       log_write(0, LOG_MAIN, "DKIM: %s%s %s%s [failed key import]",
1826         sig->domain   ? "d=" : "", sig->domain   ? sig->domain   : US"",
1827         sig->selector ? "s=" : "", sig->selector ? sig->selector : US"");
1828       goto NEXT_VERIFY;
1829       }
1830
1831     /* If the pubkey limits to a list of specific hashes, ignore sigs that
1832     do not have the hash part of the sig algorithm matching */
1833
1834     if (sig->pubkey->hashes)
1835       {
1836       const uschar * list = sig->pubkey->hashes, * ele;
1837       int sep = ':';
1838       while ((ele = string_nextinlist(&list, &sep, NULL, 0)))
1839         if (Ustrcmp(ele, pdkim_hashes[sig->hashtype].dkim_hashname) == 0) break;
1840       if (!ele)
1841         {
1842         DEBUG(D_acl) debug_printf("pubkey h=%s vs. sig a=%s_%s\n",
1843           sig->pubkey->hashes,
1844           pdkim_keytypes[sig->keytype],
1845           pdkim_hashes[sig->hashtype].dkim_hashname);
1846         sig->verify_status =      PDKIM_VERIFY_FAIL;
1847         sig->verify_ext_status =  PDKIM_VERIFY_FAIL_SIG_ALGO_MISMATCH;
1848         goto NEXT_VERIFY;
1849         }
1850       }
1851
1852     hm = sig->keytype == KEYTYPE_ED25519
1853 #if defined(SIGN_OPENSSL)
1854       ? HASH_NULL
1855 #else
1856       ? HASH_SHA2_512
1857 #endif
1858       : pdkim_hashes[sig->hashtype].exim_hashmethod;
1859
1860     /* Check the signature */
1861
1862     if ((*err = exim_dkim_verify(&vctx, hm, &hhash, &sig->sighash)))
1863       {
1864       DEBUG(D_acl) debug_printf("headers verify: %s\n", *err);
1865       sig->verify_status =      PDKIM_VERIFY_FAIL;
1866       sig->verify_ext_status =  PDKIM_VERIFY_FAIL_MESSAGE;
1867       goto NEXT_VERIFY;
1868       }
1869     if (*dkim_verify_min_keysizes)
1870       {
1871       unsigned minbits;
1872       uschar * ss = expand_getkeyed(US pdkim_keytypes[sig->keytype],
1873                                     dkim_verify_min_keysizes);
1874       if (ss &&  (minbits = atoi(CS ss)) > sig->keybits)
1875         {
1876         DEBUG(D_acl) debug_printf("Key too short: Actual: %s %u  Minima '%s'\n",
1877           pdkim_keytypes[sig->keytype], sig->keybits, dkim_verify_min_keysizes);
1878         sig->verify_status =      PDKIM_VERIFY_FAIL;
1879         sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_KEYSIZE;
1880         }
1881       }
1882
1883
1884     /* We have a winner! (if bodyhash was correct earlier) */
1885     if (sig->verify_status == PDKIM_VERIFY_NONE)
1886       {
1887       sig->verify_status = PDKIM_VERIFY_PASS;
1888       verify_pass = TRUE;
1889       if (dkim_verify_minimal) break;
1890       }
1891
1892 NEXT_VERIFY:
1893
1894     DEBUG(D_acl)
1895       {
1896       debug_printf("DKIM [%s] %s signature status: %s",
1897               sig->domain, dkim_sig_to_a_tag(sig),
1898               pdkim_verify_status_str(sig->verify_status));
1899       if (sig->verify_ext_status > 0)
1900         debug_printf(" (%s)\n",
1901                 pdkim_verify_ext_status_str(sig->verify_ext_status));
1902       else
1903         debug_printf("\n");
1904       }
1905     }
1906   }
1907
1908 /* If requested, set return pointer to signature(s) */
1909 if (return_signatures)
1910   *return_signatures = ctx->sig;
1911
1912 return ctx->flags & PDKIM_MODE_SIGN  ||  verify_pass
1913   ? PDKIM_OK : PDKIM_FAIL;
1914 }
1915
1916
1917 /* -------------------------------------------------------------------------- */
1918
1919 DLLEXPORT pdkim_ctx *
1920 pdkim_init_verify(uschar * (*dns_txt_callback)(const uschar *), BOOL dot_stuffing)
1921 {
1922 pdkim_ctx * ctx;
1923
1924 ctx = store_get(sizeof(pdkim_ctx), GET_UNTAINTED);
1925 memset(ctx, 0, sizeof(pdkim_ctx));
1926
1927 if (dot_stuffing) ctx->flags = PDKIM_DOT_TERM;
1928 /* The line-buffer is for message data, hence tainted */
1929 ctx->linebuf = store_get(PDKIM_MAX_BODY_LINE_LEN, GET_TAINTED);
1930 ctx->dns_txt_callback = dns_txt_callback;
1931 ctx->cur_header = string_get_tainted(36, GET_TAINTED);
1932
1933 return ctx;
1934 }
1935
1936
1937 /* -------------------------------------------------------------------------- */
1938
1939 DLLEXPORT pdkim_signature *
1940 pdkim_init_sign(pdkim_ctx * ctx,
1941   uschar * domain, uschar * selector, uschar * privkey,
1942   uschar * hashname, const uschar ** errstr)
1943 {
1944 int hashtype;
1945 pdkim_signature * sig;
1946
1947 if (!domain || !selector || !privkey)
1948   return NULL;
1949
1950 /* Allocate & init one signature struct */
1951
1952 sig = store_get(sizeof(pdkim_signature), GET_UNTAINTED);
1953 memset(sig, 0, sizeof(pdkim_signature));
1954
1955 sig->bodylength = -1;
1956
1957 sig->domain = string_copy(US domain);
1958 sig->selector = string_copy(US selector);
1959 sig->privkey = string_copy(US privkey);
1960 sig->keytype = -1;
1961
1962 for (hashtype = 0; hashtype < nelem(pdkim_hashes); hashtype++)
1963   if (Ustrcmp(hashname, pdkim_hashes[hashtype].dkim_hashname) == 0)
1964   { sig->hashtype = hashtype; break; }
1965 if (hashtype >= nelem(pdkim_hashes))
1966   {
1967   log_write(0, LOG_MAIN|LOG_PANIC,
1968     "DKIM: unrecognised hashname '%s'", hashname);
1969   return NULL;
1970   }
1971
1972 DEBUG(D_acl)
1973   {
1974   pdkim_signature s = *sig;
1975   ev_ctx vctx;
1976
1977   debug_printf("DKIM (checking verify key)>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1978   if (!pdkim_key_from_dns(ctx, &s, &vctx, errstr))
1979     debug_printf("WARNING: bad dkim key in dns\n");
1980   debug_printf("DKIM (finished checking verify key)<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1981   }
1982 return sig;
1983 }
1984
1985
1986 /* -------------------------------------------------------------------------- */
1987
1988 DLLEXPORT void
1989 pdkim_set_optional(pdkim_signature * sig,
1990                        char * sign_headers,
1991                        char * identity,
1992                        int canon_headers,
1993                        int canon_body,
1994                        long bodylength,
1995                        unsigned long created,
1996                        unsigned long expires)
1997 {
1998 if (identity)
1999   sig->identity = string_copy(US identity);
2000
2001 sig->sign_headers = string_copy(sign_headers
2002         ? US sign_headers : US PDKIM_DEFAULT_SIGN_HEADERS);
2003
2004 sig->canon_headers = canon_headers;
2005 sig->canon_body = canon_body;
2006 sig->bodylength = bodylength;
2007 sig->created = created;
2008 sig->expires = expires;
2009
2010 return;
2011 }
2012
2013
2014
2015 /* Set up a blob for calculating the bodyhash according to the
2016 given needs.  Use an existing one if possible, or create a new one.
2017
2018 Return: hashblob pointer, or NULL on error
2019 */
2020 pdkim_bodyhash *
2021 pdkim_set_bodyhash(pdkim_ctx * ctx, int hashtype, int canon_method,
2022         long bodylength)
2023 {
2024 pdkim_bodyhash * b;
2025
2026 if (hashtype == -1 || canon_method == -1) return NULL;
2027
2028 for (b = ctx->bodyhash; b; b = b->next)
2029   if (  hashtype == b->hashtype
2030      && canon_method == b->canon_method
2031      && bodylength == b->bodylength)
2032     {
2033     DEBUG(D_receive) debug_printf("DKIM: using existing bodyhash %s/%s/%ld\n",
2034       pdkim_hashes[hashtype].dkim_hashname, pdkim_canons[canon_method], bodylength);
2035     return b;
2036     }
2037
2038 DEBUG(D_receive) debug_printf("DKIM: new bodyhash %s/%s/%ld\n",
2039     pdkim_hashes[hashtype].dkim_hashname, pdkim_canons[canon_method], bodylength);
2040 b = store_get(sizeof(pdkim_bodyhash), GET_UNTAINTED);
2041 b->next = ctx->bodyhash;
2042 b->hashtype = hashtype;
2043 b->canon_method = canon_method;
2044 b->bodylength = bodylength;
2045 if (!exim_sha_init(&b->body_hash_ctx,           /*XXX hash method: extend for sha512 */
2046                   pdkim_hashes[hashtype].exim_hashmethod))
2047   {
2048   DEBUG(D_acl)
2049     debug_printf("DKIM: hash init error, possibly nonhandled hashtype\n");
2050   return NULL;
2051   }
2052 b->signed_body_bytes = 0;
2053 b->num_buffered_blanklines = 0;
2054 ctx->bodyhash = b;
2055 return b;
2056 }
2057
2058
2059 /* Set up a blob for calculating the bodyhash according to the
2060 needs of this signature.  Use an existing one if possible, or
2061 create a new one.
2062
2063 Return: hashblob pointer, or NULL on error (only used as a boolean).
2064 */
2065 pdkim_bodyhash *
2066 pdkim_set_sig_bodyhash(pdkim_ctx * ctx, pdkim_signature * sig)
2067 {
2068 pdkim_bodyhash * b = pdkim_set_bodyhash(ctx,
2069                         sig->hashtype, sig->canon_body, sig->bodylength);
2070 sig->calc_body_hash = b;
2071 return b;
2072 }
2073
2074
2075 /* -------------------------------------------------------------------------- */
2076
2077
2078 void
2079 pdkim_init_context(pdkim_ctx * ctx, BOOL dot_stuffed,
2080   uschar * (*dns_txt_callback)(const uschar *))
2081 {
2082 memset(ctx, 0, sizeof(pdkim_ctx));
2083 ctx->flags = dot_stuffed ? PDKIM_MODE_SIGN | PDKIM_DOT_TERM : PDKIM_MODE_SIGN;
2084 /* The line buffer is for message data, hence tainted */
2085 ctx->linebuf = store_get(PDKIM_MAX_BODY_LINE_LEN, GET_TAINTED);
2086 DEBUG(D_acl) ctx->dns_txt_callback = dns_txt_callback;
2087 }
2088
2089
2090 void
2091 pdkim_init(void)
2092 {
2093 exim_dkim_init();
2094 }
2095
2096
2097
2098 #endif  /*DISABLE_DKIM*/