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, str);
 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   gstring_trim_trailing(ctx->cur_header, '\r');
 962 (void) string_from_gstring(ctx->cur_header);
 963
 964 #ifdef EXPERIMENTAL_ARC
 965 /* Feed the header line to ARC processing */
 966 (void) arc_header_feed(ctx->cur_header, !(ctx->flags & PDKIM_MODE_SIGN));
 967 #endif
 968
 969 if (++ctx->num_headers > PDKIM_MAX_HEADERS) goto BAIL;
 970
 971 /* SIGNING -------------------------------------------------------------- */
 972 if (ctx->flags & PDKIM_MODE_SIGN)
 973   for (pdkim_signature * sig = ctx->sig; sig; sig = sig->next)  /* Traverse all signatures */
 974
 975     /* Add header to the signed headers list (in reverse order) */
 976     sig->headers = pdkim_prepend_stringlist(sig->headers, ctx->cur_header->s);
 977
 978 /* VERIFICATION ----------------------------------------------------------- */
 979 /* DKIM-Signature: headers are added to the verification list */
 980 else
 981   {
 982 #ifdef notdef
 983   DEBUG(D_acl)
 984     {
 985     debug_printf("DKIM >> raw hdr: ");
 986     pdkim_quoteprint(CUS ctx->cur_header->s, ctx->cur_header->ptr);
 987     }
 988 #endif
 989   if (strncasecmp(CCS ctx->cur_header->s,
 990                   DKIM_SIGNATURE_HEADERNAME,
 991                   Ustrlen(DKIM_SIGNATURE_HEADERNAME)) == 0)
 992     {
 993     pdkim_signature * sig, * last_sig;
 994     /* Create and chain new signature block.  We could error-check for all
 995     required tags here, but prefer to create the internal sig and expicitly
 996     fail verification of it later. */
 997
 998     DEBUG(D_acl) debug_printf(
 999         "DKIM >> Found sig, trying to parse >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1000
1001     sig = pdkim_parse_sig_header(ctx, ctx->cur_header->s);
1002
1003     if (!(last_sig = ctx->sig))
1004       ctx->sig = sig;
1005     else
1006       {
1007       while (last_sig->next) last_sig = last_sig->next;
1008       last_sig->next = sig;
1009       }
1010
1011     if (dkim_collect_input && --dkim_collect_input == 0)
1012       {
1013       ctx->headers = pdkim_prepend_stringlist(ctx->headers, ctx->cur_header->s);
1014       ctx->cur_header->s[ctx->cur_header->ptr = 0] = '\0';
1015       return PDKIM_ERR_EXCESS_SIGS;
1016       }
1017     }
1018
1019   /* all headers are stored for signature verification */
1020   ctx->headers = pdkim_prepend_stringlist(ctx->headers, ctx->cur_header->s);
1021   }
1022
1023 BAIL:
1024 ctx->cur_header->s[ctx->cur_header->ptr = 0] = '\0';    /* leave buffer for reuse */
1025 return PDKIM_OK;
1026 }
1027
1028
1029
1030 /* -------------------------------------------------------------------------- */
1031 #define HEADER_BUFFER_FRAG_SIZE 256
1032
1033 DLLEXPORT int
1034 pdkim_feed(pdkim_ctx * ctx, uschar * data, int len)
1035 {
1036 /* Alternate EOD signal, used in non-dotstuffing mode */
1037 if (!data)
1038   pdkim_body_complete(ctx);
1039
1040 else for (int p = 0; p < len; p++)
1041   {
1042   uschar c = data[p];
1043   int rc;
1044
1045   if (ctx->flags & PDKIM_PAST_HDRS)
1046     {
1047     if (c == '\n' && !(ctx->flags & PDKIM_SEEN_CR))     /* emulate the CR */
1048       {
1049       ctx->linebuf[ctx->linebuf_offset++] = '\r';
1050       if (ctx->linebuf_offset == PDKIM_MAX_BODY_LINE_LEN-1)
1051         return PDKIM_ERR_LONG_LINE;
1052       }
1053
1054     /* Processing body byte */
1055     ctx->linebuf[ctx->linebuf_offset++] = c;
1056     if (c == '\r')
1057       ctx->flags |= PDKIM_SEEN_CR;
1058     else if (c == '\n')
1059       {
1060       ctx->flags &= ~PDKIM_SEEN_CR;
1061       pdkim_bodyline_complete(ctx);
1062       }
1063
1064     if (ctx->linebuf_offset == PDKIM_MAX_BODY_LINE_LEN-1)
1065       return PDKIM_ERR_LONG_LINE;
1066     }
1067   else
1068     {
1069     /* Processing header byte */
1070     if (c == '\r')
1071       ctx->flags |= PDKIM_SEEN_CR;
1072     else if (c == '\n')
1073       {
1074       if (!(ctx->flags & PDKIM_SEEN_CR))                /* emulate the CR */
1075         ctx->cur_header = string_catn(ctx->cur_header, CUS "\r", 1);
1076
1077       if (ctx->flags & PDKIM_SEEN_LF)           /* Seen last header line */
1078         {
1079         if ((rc = pdkim_header_complete(ctx)) != PDKIM_OK)
1080           return rc;
1081
1082         ctx->flags = (ctx->flags & ~(PDKIM_SEEN_LF|PDKIM_SEEN_CR)) | PDKIM_PAST_HDRS;
1083         DEBUG(D_acl) debug_printf(
1084             "DKIM >> Body data for hash, canonicalized >>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1085         continue;
1086         }
1087       else
1088         ctx->flags = (ctx->flags & ~PDKIM_SEEN_CR) | PDKIM_SEEN_LF;
1089       }
1090     else if (ctx->flags & PDKIM_SEEN_LF)
1091       {
1092       if (!(c == '\t' || c == ' '))                     /* End of header */
1093         if ((rc = pdkim_header_complete(ctx)) != PDKIM_OK)
1094           return rc;
1095       ctx->flags &= ~PDKIM_SEEN_LF;
1096       }
1097
1098     if (!ctx->cur_header || ctx->cur_header->ptr < PDKIM_MAX_HEADER_LEN)
1099       ctx->cur_header = string_catn(ctx->cur_header, CUS &data[p], 1);
1100     }
1101   }
1102 return PDKIM_OK;
1103 }
1104
1105
1106
1107 /* Extend a growing header with a continuation-linebreak */
1108 static gstring *
1109 pdkim_hdr_cont(gstring * str, int * col)
1110 {
1111 *col = 1;
1112 return string_catn(str, US"\r\n\t", 3);
1113 }
1114
1115
1116
1117 /*
1118  * RFC 5322 specifies that header line length SHOULD be no more than 78
1119  *  pdkim_headcat
1120  *
1121  * Returns gstring (not nul-terminated) appending to one supplied
1122  *
1123  * col: this int holds and receives column number (octets since last '\n')
1124  * str: partial string to append to
1125  * pad: padding, split line or space after before or after eg: ";".
1126  *               Only the initial charater is used.
1127  * intro: - must join to payload eg "h=", usually the tag name
1128  * payload: eg base64 data - long data can be split arbitrarily.
1129  *
1130  * this code doesn't fold the header in some of the places that RFC4871
1131  * allows: As per RFC5322(2.2.3) it only folds before or after tag-value
1132  * pairs and inside long values. it also always spaces or breaks after the
1133  * "pad"
1134  *
1135  * No guarantees are made for output given out-of range input. like tag
1136  * names longer than 78, or bogus col. Input is assumed to be free of line breaks.
1137  */
1138
1139 static gstring *
1140 pdkim_headcat(int * col, gstring * str,
1141   const uschar * pad, const uschar * intro, const uschar * payload)
1142 {
1143 int len, chomp, padded = 0;
1144
1145 /* If we can fit at least the pad at the end of current line, do it now.
1146 Otherwise, wrap if there is a pad. */
1147
1148 if (pad)
1149   if (*col + 1 <= 78)
1150     {
1151     str = string_catn(str, pad, 1);
1152     (*col)++;
1153     pad = NULL;
1154     padded = 1;
1155     }
1156   else
1157     str = pdkim_hdr_cont(str, col);
1158
1159 /* Special case: if the whole addition does not fit at the end of the current
1160 line, but could fit on a new line, wrap to give it its full, dedicated line.  */
1161
1162 len = (pad ? 2 : padded)
1163     + (intro ? Ustrlen(intro) : 0)
1164     + (payload ? Ustrlen(payload) : 0);
1165 if (len <= 77 && *col+len > 78)
1166   {
1167   str = pdkim_hdr_cont(str, col);
1168   padded = 0;
1169   }
1170
1171 /* Either we already dealt with the pad or we know there is room */
1172
1173 if (pad)
1174   {
1175   str = string_catn(str, pad, 1);
1176   str = string_catn(str, US" ", 1);
1177   *col += 2;
1178   }
1179 else if (padded && *col < 78)
1180   {
1181   str = string_catn(str, US" ", 1);
1182   (*col)++;
1183   }
1184
1185 /* Call recursively with intro as payload: it gets the same, special treatment
1186 (that is, not split if < 78).  */
1187
1188 if (intro)
1189   str = pdkim_headcat(col, str, NULL, NULL, intro);
1190
1191 if (payload)
1192   for (len = Ustrlen(payload); len; len -= chomp)
1193     {
1194     if (*col >= 78)
1195       str = pdkim_hdr_cont(str, col);
1196     chomp = *col+len > 78 ? 78 - *col : len;
1197     str = string_catn(str, payload, chomp);
1198     *col += chomp;
1199     payload += chomp;
1200     }
1201
1202 return str;
1203 }
1204
1205
1206 /* -------------------------------------------------------------------------- */
1207
1208 /* Signing: create signature header
1209 */
1210 static uschar *
1211 pdkim_create_header(pdkim_signature * sig, BOOL final)
1212 {
1213 uschar * base64_bh;
1214 uschar * base64_b;
1215 int col = 0;
1216 gstring * hdr;
1217 gstring * canon_all;
1218
1219 canon_all = string_cat (NULL, pdkim_canons[sig->canon_headers]);
1220 canon_all = string_catn(canon_all, US"/", 1);
1221 canon_all = string_cat (canon_all, pdkim_canons[sig->canon_body]);
1222 (void) string_from_gstring(canon_all);
1223
1224 hdr = string_cat(NULL, US"DKIM-Signature: v="PDKIM_SIGNATURE_VERSION);
1225 col = hdr->ptr;
1226
1227 /* Required and static bits */
1228 hdr = pdkim_headcat(&col, hdr, US";", US"a=", dkim_sig_to_a_tag(sig));
1229 hdr = pdkim_headcat(&col, hdr, US";", US"q=", pdkim_querymethods[sig->querymethod]);
1230 hdr = pdkim_headcat(&col, hdr, US";", US"c=", canon_all->s);
1231 hdr = pdkim_headcat(&col, hdr, US";", US"d=", sig->domain);
1232 hdr = pdkim_headcat(&col, hdr, US";", US"s=", sig->selector);
1233
1234 /* list of header names can be split between items. */
1235   {
1236   uschar * n = string_copy(sig->headernames);
1237   uschar * i = US"h=";
1238   uschar * s = US";";
1239
1240   while (*n)
1241     {
1242     uschar * c = Ustrchr(n, ':');
1243
1244     if (c) *c ='\0';
1245
1246     if (!i)
1247       hdr = pdkim_headcat(&col, hdr, NULL, NULL, US":");
1248
1249     hdr = pdkim_headcat(&col, hdr, s, i, n);
1250
1251     if (!c)
1252       break;
1253
1254     n = c+1;
1255     s = NULL;
1256     i = NULL;
1257     }
1258   }
1259
1260 base64_bh = pdkim_encode_base64(&sig->calc_body_hash->bh);
1261 hdr = pdkim_headcat(&col, hdr, US";", US"bh=", base64_bh);
1262
1263 /* Optional bits */
1264 if (sig->identity)
1265   hdr = pdkim_headcat(&col, hdr, US";", US"i=", sig->identity);
1266
1267 if (sig->created > 0)
1268   {
1269   uschar minibuf[21];
1270
1271   snprintf(CS minibuf, sizeof(minibuf), "%lu", sig->created);
1272   hdr = pdkim_headcat(&col, hdr, US";", US"t=", minibuf);
1273 }
1274
1275 if (sig->expires > 0)
1276   {
1277   uschar minibuf[21];
1278
1279   snprintf(CS minibuf, sizeof(minibuf), "%lu", sig->expires);
1280   hdr = pdkim_headcat(&col, hdr, US";", US"x=", minibuf);
1281   }
1282
1283 if (sig->bodylength >= 0)
1284   {
1285   uschar minibuf[21];
1286
1287   snprintf(CS minibuf, sizeof(minibuf), "%lu", sig->bodylength);
1288   hdr = pdkim_headcat(&col, hdr, US";", US"l=", minibuf);
1289   }
1290
1291 /* Preliminary or final version? */
1292 if (final)
1293   {
1294   base64_b = pdkim_encode_base64(&sig->sighash);
1295   hdr = pdkim_headcat(&col, hdr, US";", US"b=", base64_b);
1296
1297   /* add trailing semicolon: I'm not sure if this is actually needed */
1298   hdr = pdkim_headcat(&col, hdr, NULL, US";", US"");
1299   }
1300 else
1301   {
1302   /* To satisfy the rule "all surrounding whitespace [...] deleted"
1303   ( RFC 6376 section 3.7 ) we ensure there is no whitespace here.  Otherwise
1304   the headcat routine could insert a linebreak which the relaxer would reduce
1305   to a single space preceding the terminating semicolon, resulting in an
1306   incorrect header-hash. */
1307   hdr = pdkim_headcat(&col, hdr, US";", US"b=;", US"");
1308   }
1309
1310 return string_from_gstring(hdr);
1311 }
1312
1313
1314 /* -------------------------------------------------------------------------- */
1315
1316 /* According to draft-ietf-dcrup-dkim-crypto-07 "keys are 256 bits" (referring
1317 to DNS, hence the pubkey).  Check for more than 32 bytes; if so assume the
1318 alternate possible representation (still) being discussed: a
1319 SubjectPublickeyInfo wrapped key - and drop all but the trailing 32-bytes (it
1320 should be a DER, with exactly 12 leading bytes - but we could accept a BER also,
1321 which could be any size).  We still rely on the crypto library for checking for
1322 undersize.
1323
1324 When the RFC is published this should be re-addressed. */
1325
1326 static void
1327 check_bare_ed25519_pubkey(pdkim_pubkey * p)
1328 {
1329 int excess = p->key.len - 32;
1330 if (excess > 0)
1331   {
1332   DEBUG(D_acl)
1333     debug_printf("DKIM: unexpected pubkey len %lu\n", (unsigned long) p->key.len);
1334   p->key.data += excess; p->key.len = 32;
1335   }
1336 }
1337
1338
1339 static pdkim_pubkey *
1340 pdkim_key_from_dns(pdkim_ctx * ctx, pdkim_signature * sig, ev_ctx * vctx,
1341   const uschar ** errstr)
1342 {
1343 uschar * dns_txt_name, * dns_txt_reply;
1344 pdkim_pubkey * p;
1345
1346 /* Fetch public key for signing domain, from DNS */
1347
1348 dns_txt_name = string_sprintf("%s._domainkey.%s.", sig->selector, sig->domain);
1349
1350 if (  !(dns_txt_reply = ctx->dns_txt_callback(dns_txt_name))
1351    || dns_txt_reply[0] == '\0'
1352    )
1353   {
1354   sig->verify_status =      PDKIM_VERIFY_INVALID;
1355   sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE;
1356   return NULL;
1357   }
1358
1359 DEBUG(D_acl)
1360   {
1361   debug_printf(
1362     "DKIM >> Parsing public key record >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"
1363     " %s\n"
1364     " Raw record: ",
1365     dns_txt_name);
1366   pdkim_quoteprint(CUS dns_txt_reply, Ustrlen(dns_txt_reply));
1367   }
1368
1369 if (  !(p = pdkim_parse_pubkey_record(CUS dns_txt_reply))
1370    || (Ustrcmp(p->srvtype, "*") != 0 && Ustrcmp(p->srvtype, "email") != 0)
1371    )
1372   {
1373   sig->verify_status =      PDKIM_VERIFY_INVALID;
1374   sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD;
1375
1376   DEBUG(D_acl)
1377     {
1378     if (p)
1379       debug_printf(" Invalid public key service type '%s'\n", p->srvtype);
1380     else
1381       debug_printf(" Error while parsing public key record\n");
1382     debug_printf(
1383       "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1384     }
1385   return NULL;
1386   }
1387
1388 DEBUG(D_acl) debug_printf(
1389       "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1390
1391 /* Import public key */
1392
1393 /* Normally we use the signature a= tag to tell us the pubkey format.
1394 When signing under debug we do a test-import of the pubkey, and at that
1395 time we do not have a signature so we must interpret the pubkey k= tag
1396 instead.  Assume writing on the sig is ok in that case. */
1397
1398 if (sig->keytype < 0)
1399   if ((sig->keytype = pdkim_keyname_to_keytype(p->keytype)) < 0)
1400     {
1401     DEBUG(D_acl) debug_printf("verify_init: unhandled keytype %s\n", p->keytype);
1402     sig->verify_status =      PDKIM_VERIFY_INVALID;
1403     sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_IMPORT;
1404     return NULL;
1405     }
1406
1407 if (sig->keytype == KEYTYPE_ED25519)
1408   check_bare_ed25519_pubkey(p);
1409
1410 if ((*errstr = exim_dkim_verify_init(&p->key,
1411             sig->keytype == KEYTYPE_ED25519 ? KEYFMT_ED25519_BARE : KEYFMT_DER,
1412             vctx, &sig->keybits)))
1413   {
1414   DEBUG(D_acl) debug_printf("verify_init: %s\n", *errstr);
1415   sig->verify_status =      PDKIM_VERIFY_INVALID;
1416   sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_IMPORT;
1417   return NULL;
1418   }
1419
1420 vctx->keytype = sig->keytype;
1421 return p;
1422 }
1423
1424
1425 /* -------------------------------------------------------------------------- */
1426 /* Sort and filter the sigs developed from the message */
1427
1428 static pdkim_signature *
1429 sort_sig_methods(pdkim_signature * siglist)
1430 {
1431 pdkim_signature * yield, ** ss;
1432 const uschar * prefs;
1433 uschar * ele;
1434 int sep;
1435
1436 if (!siglist) return NULL;
1437
1438 /* first select in order of hashtypes */
1439 DEBUG(D_acl) debug_printf("DKIM: dkim_verify_hashes   '%s'\n", dkim_verify_hashes);
1440 for (prefs = dkim_verify_hashes, sep = 0, yield = NULL, ss = &yield;
1441      ele = string_nextinlist(&prefs, &sep, NULL, 0); )
1442   {
1443   int i = pdkim_hashname_to_hashtype(CUS ele, 0);
1444   for (pdkim_signature * s = siglist, * next, ** prev = &siglist; s;
1445        s = next)
1446     {
1447     next = s->next;
1448     if (s->hashtype == i)
1449       { *prev = next; s->next = NULL; *ss = s; ss = &s->next; }
1450     else
1451       prev = &s->next;
1452     }
1453   }
1454
1455 /* then in order of keytypes */
1456 siglist = yield;
1457 DEBUG(D_acl) debug_printf("DKIM: dkim_verify_keytypes '%s'\n", dkim_verify_keytypes);
1458 for (prefs = dkim_verify_keytypes, sep = 0, yield = NULL, ss = &yield;
1459      ele = string_nextinlist(&prefs, &sep, NULL, 0); )
1460   {
1461   int i = pdkim_keyname_to_keytype(CUS ele);
1462   for (pdkim_signature * s = siglist, * next, ** prev = &siglist; s;
1463        s = next)
1464     {
1465     next = s->next;
1466     if (s->keytype == i)
1467       { *prev = next; s->next = NULL; *ss = s; ss = &s->next; }
1468     else
1469       prev = &s->next;
1470     }
1471   }
1472
1473 DEBUG(D_acl) for (pdkim_signature * s = yield; s; s = s->next)
1474   debug_printf(" retain d=%s s=%s a=%s\n",
1475     s->domain, s->selector, dkim_sig_to_a_tag(s));
1476 return yield;
1477 }
1478
1479
1480 /* -------------------------------------------------------------------------- */
1481
1482 DLLEXPORT int
1483 pdkim_feed_finish(pdkim_ctx * ctx, pdkim_signature ** return_signatures,
1484   const uschar ** err)
1485 {
1486 BOOL verify_pass = FALSE;
1487
1488 /* Check if we must still flush a (partial) header. If that is the
1489    case, the message has no body, and we must compute a body hash
1490    out of '<CR><LF>' */
1491 if (ctx->cur_header && ctx->cur_header->ptr > 0)
1492   {
1493   blob * rnl = NULL;
1494   int rc;
1495
1496   if ((rc = pdkim_header_complete(ctx)) != PDKIM_OK)
1497     return rc;
1498
1499   for (pdkim_bodyhash * b = ctx->bodyhash; b; b = b->next)
1500     rnl = pdkim_update_ctx_bodyhash(b, &lineending, rnl);
1501   if (rnl) store_free(rnl);
1502   }
1503 else
1504   DEBUG(D_acl) debug_printf(
1505       "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1506
1507 /* Build (and/or evaluate) body hash.  Do this even if no DKIM sigs, in case we
1508 have a hash to do for ARC. */
1509
1510 pdkim_finish_bodyhash(ctx);
1511
1512 /* Sort and filter the recived signatures */
1513
1514 if (!(ctx->flags & PDKIM_MODE_SIGN))
1515   ctx->sig = sort_sig_methods(ctx->sig);
1516
1517 if (!ctx->sig)
1518   {
1519   DEBUG(D_acl) debug_printf("DKIM: no signatures\n");
1520   *return_signatures = NULL;
1521   return PDKIM_OK;
1522   }
1523
1524 for (pdkim_signature * sig = ctx->sig; sig; sig = sig->next)
1525   {
1526   hctx hhash_ctx;
1527   uschar * sig_hdr = US"";
1528   blob hhash;
1529   gstring * hdata = NULL;
1530   es_ctx sctx;
1531
1532   if (  !(ctx->flags & PDKIM_MODE_SIGN)
1533      && sig->verify_status == PDKIM_VERIFY_FAIL)
1534     {
1535     DEBUG(D_acl)
1536        debug_printf("DKIM: [%s] abandoning this signature\n", sig->domain);
1537     continue;
1538     }
1539
1540   /*XXX The hash of the headers is needed for GCrypt (for which we can do RSA
1541   signing only, as it happens) and for either GnuTLS and OpenSSL when we are
1542   signing with EC (specifically, Ed25519).  The former is because the GCrypt
1543   signing operation is pure (does not do its own hash) so we must hash.  The
1544   latter is because we (stupidly, but this is what the IETF draft is saying)
1545   must hash with the declared hash method, then pass the result to the library
1546   hash-and-sign routine (because that's all the libraries are providing.  And
1547   we're stuck with whatever that hidden hash method is, too).  We may as well
1548   do this hash incrementally.
1549   We don't need the hash we're calculating here for the GnuTLS and OpenSSL
1550   cases of RSA signing, since those library routines can do hash-and-sign.
1551
1552   Some time in the future we could easily avoid doing the hash here for those
1553   cases (which will be common for a long while.  We could also change from
1554   the current copy-all-the-headers-into-one-block, then call the hash-and-sign
1555   implementation  - to a proper incremental one.  Unfortunately, GnuTLS just
1556   cannot do incremental - either signing or verification.  Unsure about GCrypt.
1557   */
1558
1559   /*XXX The header hash is also used (so far) by the verify operation */
1560
1561   if (!exim_sha_init(&hhash_ctx, pdkim_hashes[sig->hashtype].exim_hashmethod))
1562     {
1563     log_write(0, LOG_MAIN|LOG_PANIC,
1564       "DKIM: hash setup error, possibly nonhandled hashtype");
1565     break;
1566     }
1567
1568   if (ctx->flags & PDKIM_MODE_SIGN)
1569     DEBUG(D_acl) debug_printf(
1570         "DKIM >> Headers to be signed:                            >>>>>>>>>>>>\n"
1571         " %s\n",
1572         sig->sign_headers);
1573
1574   DEBUG(D_acl) debug_printf(
1575       "DKIM >> Header data for hash, canonicalized (%-7s), in sequence >>\n",
1576         pdkim_canons[sig->canon_headers]);
1577
1578
1579   /* SIGNING ---------------------------------------------------------------- */
1580   /* When signing, walk through our header list and add them to the hash. As we
1581      go, construct a list of the header's names to use for the h= parameter.
1582      Then append to that list any remaining header names for which there was no
1583      header to sign. */
1584
1585   if (ctx->flags & PDKIM_MODE_SIGN)
1586     {
1587     gstring * g = NULL;
1588     const uschar * l;
1589     uschar * s;
1590     int sep = 0;
1591
1592     /* Import private key, including the keytype which we need for building
1593     the signature header  */
1594
1595     if ((*err = exim_dkim_signing_init(CUS sig->privkey, &sctx)))
1596       {
1597       log_write(0, LOG_MAIN|LOG_PANIC, "signing_init: %s", *err);
1598       return PDKIM_ERR_RSA_PRIVKEY;
1599       }
1600     sig->keytype = sctx.keytype;
1601
1602     sig->headernames = NULL;                    /* Collected signed header names */
1603     for (pdkim_stringlist * p = sig->headers; p; p = p->next)
1604       {
1605       uschar * rh = p->value;
1606
1607       if (header_name_match(rh, sig->sign_headers) == PDKIM_OK)
1608         {
1609         /* Collect header names (Note: colon presence is guaranteed here) */
1610         g = string_append_listele_n(g, ':', rh, Ustrchr(rh, ':') - rh);
1611
1612         if (sig->canon_headers == PDKIM_CANON_RELAXED)
1613           rh = pdkim_relax_header(rh, TRUE);    /* cook header for relaxed canon */
1614
1615         /* Feed header to the hash algorithm */
1616         exim_sha_update_string(&hhash_ctx, CUS rh);
1617
1618         /* Remember headers block for signing (when the library cannot do incremental)  */
1619         /*XXX we could avoid doing this for all but the GnuTLS/RSA case */
1620         hdata = exim_dkim_data_append(hdata, rh);
1621
1622         DEBUG(D_acl) pdkim_quoteprint(rh, Ustrlen(rh));
1623         }
1624       }
1625
1626     /* Any headers we wanted to sign but were not present must also be listed.
1627     Ignore elements that have been ticked-off or are marked as never-oversign. */
1628
1629     l = sig->sign_headers;
1630     while((s = string_nextinlist(&l, &sep, NULL, 0)))
1631       {
1632       if (*s == '+')                    /* skip oversigning marker */
1633         s++;
1634       if (*s != '_' && *s != '=')
1635         g = string_append_listele(g, ':', s);
1636       }
1637     sig->headernames = string_from_gstring(g);
1638
1639     /* Create signature header with b= omitted */
1640     sig_hdr = pdkim_create_header(sig, FALSE);
1641     }
1642
1643   /* VERIFICATION ----------------------------------------------------------- */
1644   /* When verifying, walk through the header name list in the h= parameter and
1645      add the headers to the hash in that order. */
1646   else
1647     {
1648     uschar * p = sig->headernames;
1649     uschar * q;
1650
1651     if (p)
1652       {
1653       /* clear tags */
1654       for (pdkim_stringlist * hdrs = ctx->headers; hdrs; hdrs = hdrs->next)
1655         hdrs->tag = 0;
1656
1657       p = string_copy(p);
1658       while(1)
1659         {
1660         if ((q = Ustrchr(p, ':')))
1661           *q = '\0';
1662
1663   /*XXX walk the list of headers in same order as received. */
1664         for (pdkim_stringlist * hdrs = ctx->headers; hdrs; hdrs = hdrs->next)
1665           if (  hdrs->tag == 0
1666              && strncasecmp(CCS hdrs->value, CCS p, Ustrlen(p)) == 0
1667              && (hdrs->value)[Ustrlen(p)] == ':'
1668              )
1669             {
1670             /* cook header for relaxed canon, or just copy it for simple  */
1671
1672             uschar * rh = sig->canon_headers == PDKIM_CANON_RELAXED
1673               ? pdkim_relax_header(hdrs->value, TRUE)
1674               : string_copy(CUS hdrs->value);
1675
1676             /* Feed header to the hash algorithm */
1677             exim_sha_update_string(&hhash_ctx, CUS rh);
1678
1679             DEBUG(D_acl) pdkim_quoteprint(rh, Ustrlen(rh));
1680             hdrs->tag = 1;
1681             break;
1682             }
1683
1684         if (!q) break;
1685         p = q+1;
1686         }
1687
1688       sig_hdr = string_copy(sig->rawsig_no_b_val);
1689       }
1690     }
1691
1692   DEBUG(D_acl) debug_printf(
1693             "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1694
1695   DEBUG(D_acl)
1696     {
1697     debug_printf(
1698             "DKIM >> Signed DKIM-Signature header, pre-canonicalized >>>>>>>>>>>>>\n");
1699     pdkim_quoteprint(CUS sig_hdr, Ustrlen(sig_hdr));
1700     debug_printf(
1701             "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1702     }
1703
1704   /* Relax header if necessary */
1705   if (sig->canon_headers == PDKIM_CANON_RELAXED)
1706     sig_hdr = pdkim_relax_header(sig_hdr, FALSE);
1707
1708   DEBUG(D_acl)
1709     {
1710     debug_printf("DKIM >> Signed DKIM-Signature header, canonicalized (%-7s) >>>>>>>\n",
1711             pdkim_canons[sig->canon_headers]);
1712     pdkim_quoteprint(CUS sig_hdr, Ustrlen(sig_hdr));
1713     debug_printf(
1714             "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1715     }
1716
1717   /* Finalize header hash */
1718   exim_sha_update_string(&hhash_ctx, CUS sig_hdr);
1719   exim_sha_finish(&hhash_ctx, &hhash);
1720
1721   DEBUG(D_acl)
1722     {
1723     debug_printf("DKIM [%s] Header %s computed: ",
1724       sig->domain, pdkim_hashes[sig->hashtype].dkim_hashname);
1725     pdkim_hexprint(hhash.data, hhash.len);
1726     }
1727
1728   /* Remember headers block for signing (when the signing library cannot do
1729   incremental)  */
1730   if (ctx->flags & PDKIM_MODE_SIGN)
1731     hdata = exim_dkim_data_append(hdata, US sig_hdr);
1732
1733   /* SIGNING ---------------------------------------------------------------- */
1734   if (ctx->flags & PDKIM_MODE_SIGN)
1735     {
1736     hashmethod hm = sig->keytype == KEYTYPE_ED25519
1737 #if defined(SIGN_OPENSSL)
1738       ? HASH_NULL
1739 #else
1740       ? HASH_SHA2_512
1741 #endif
1742       : pdkim_hashes[sig->hashtype].exim_hashmethod;
1743
1744 #ifdef SIGN_HAVE_ED25519
1745     /* For GCrypt, and for EC, we pass the hash-of-headers to the signing
1746     routine.  For anything else we just pass the headers. */
1747
1748     if (sig->keytype != KEYTYPE_ED25519)
1749 #endif
1750       {
1751       hhash.data = hdata->s;
1752       hhash.len = hdata->ptr;
1753       }
1754
1755     if ((*err = exim_dkim_sign(&sctx, hm, &hhash, &sig->sighash)))
1756       {
1757       log_write(0, LOG_MAIN|LOG_PANIC, "signing: %s", *err);
1758       return PDKIM_ERR_RSA_SIGNING;
1759       }
1760
1761     DEBUG(D_acl)
1762       {
1763       debug_printf( "DKIM [%s] b computed: ", sig->domain);
1764       pdkim_hexprint(sig->sighash.data, sig->sighash.len);
1765       }
1766
1767     sig->signature_header = pdkim_create_header(sig, TRUE);
1768     }
1769
1770   /* VERIFICATION ----------------------------------------------------------- */
1771   else
1772     {
1773     ev_ctx vctx;
1774     hashmethod hm;
1775
1776     /* Make sure we have all required signature tags */
1777     if (!(  sig->domain        && *sig->domain
1778          && sig->selector      && *sig->selector
1779          && sig->headernames   && *sig->headernames
1780          && sig->bodyhash.data
1781          && sig->sighash.data
1782          && sig->keytype >= 0
1783          && sig->hashtype >= 0
1784          && sig->version
1785        ) )
1786       {
1787       sig->verify_status     = PDKIM_VERIFY_INVALID;
1788       sig->verify_ext_status = PDKIM_VERIFY_INVALID_SIGNATURE_ERROR;
1789
1790       DEBUG(D_acl) debug_printf(
1791           " Error in DKIM-Signature header: tags missing or invalid (%s)\n"
1792           "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n",
1793           !(sig->domain && *sig->domain) ? "d="
1794           : !(sig->selector && *sig->selector) ? "s="
1795           : !(sig->headernames && *sig->headernames) ? "h="
1796           : !sig->bodyhash.data ? "bh="
1797           : !sig->sighash.data ? "b="
1798           : sig->keytype < 0 || sig->hashtype < 0 ? "a="
1799           : "v="
1800           );
1801       goto NEXT_VERIFY;
1802       }
1803
1804     /* Make sure sig uses supported DKIM version (only v1) */
1805     if (sig->version != 1)
1806       {
1807       sig->verify_status     = PDKIM_VERIFY_INVALID;
1808       sig->verify_ext_status = PDKIM_VERIFY_INVALID_DKIM_VERSION;
1809
1810       DEBUG(D_acl) debug_printf(
1811           " Error in DKIM-Signature header: unsupported DKIM version\n"
1812           "DKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1813       goto NEXT_VERIFY;
1814       }
1815
1816     DEBUG(D_acl)
1817       {
1818       debug_printf( "DKIM [%s] b from mail: ", sig->domain);
1819       pdkim_hexprint(sig->sighash.data, sig->sighash.len);
1820       }
1821
1822     if (!(sig->pubkey = pdkim_key_from_dns(ctx, sig, &vctx, err)))
1823       {
1824       log_write(0, LOG_MAIN, "DKIM: %s%s %s%s [failed key import]",
1825         sig->domain   ? "d=" : "", sig->domain   ? sig->domain   : US"",
1826         sig->selector ? "s=" : "", sig->selector ? sig->selector : US"");
1827       goto NEXT_VERIFY;
1828       }
1829
1830     /* If the pubkey limits to a list of specific hashes, ignore sigs that
1831     do not have the hash part of the sig algorithm matching */
1832
1833     if (sig->pubkey->hashes)
1834       {
1835       const uschar * list = sig->pubkey->hashes, * ele;
1836       int sep = ':';
1837       while ((ele = string_nextinlist(&list, &sep, NULL, 0)))
1838         if (Ustrcmp(ele, pdkim_hashes[sig->hashtype].dkim_hashname) == 0) break;
1839       if (!ele)
1840         {
1841         DEBUG(D_acl) debug_printf("pubkey h=%s vs. sig a=%s_%s\n",
1842           sig->pubkey->hashes,
1843           pdkim_keytypes[sig->keytype],
1844           pdkim_hashes[sig->hashtype].dkim_hashname);
1845         sig->verify_status =      PDKIM_VERIFY_FAIL;
1846         sig->verify_ext_status =  PDKIM_VERIFY_FAIL_SIG_ALGO_MISMATCH;
1847         goto NEXT_VERIFY;
1848         }
1849       }
1850
1851     hm = sig->keytype == KEYTYPE_ED25519
1852 #if defined(SIGN_OPENSSL)
1853       ? HASH_NULL
1854 #else
1855       ? HASH_SHA2_512
1856 #endif
1857       : pdkim_hashes[sig->hashtype].exim_hashmethod;
1858
1859     /* Check the signature */
1860
1861     if ((*err = exim_dkim_verify(&vctx, hm, &hhash, &sig->sighash)))
1862       {
1863       DEBUG(D_acl) debug_printf("headers verify: %s\n", *err);
1864       sig->verify_status =      PDKIM_VERIFY_FAIL;
1865       sig->verify_ext_status =  PDKIM_VERIFY_FAIL_MESSAGE;
1866       goto NEXT_VERIFY;
1867       }
1868     if (*dkim_verify_min_keysizes)
1869       {
1870       unsigned minbits;
1871       uschar * ss = expand_getkeyed(US pdkim_keytypes[sig->keytype],
1872                                     dkim_verify_min_keysizes);
1873       if (ss &&  (minbits = atoi(CS ss)) > sig->keybits)
1874         {
1875         DEBUG(D_acl) debug_printf("Key too short: Actual: %s %u  Minima '%s'\n",
1876           pdkim_keytypes[sig->keytype], sig->keybits, dkim_verify_min_keysizes);
1877         sig->verify_status =      PDKIM_VERIFY_FAIL;
1878         sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_KEYSIZE;
1879         }
1880       }
1881
1882
1883     /* We have a winner! (if bodyhash was correct earlier) */
1884     if (sig->verify_status == PDKIM_VERIFY_NONE)
1885       {
1886       sig->verify_status = PDKIM_VERIFY_PASS;
1887       verify_pass = TRUE;
1888       if (dkim_verify_minimal) break;
1889       }
1890
1891 NEXT_VERIFY:
1892
1893     DEBUG(D_acl)
1894       {
1895       debug_printf("DKIM [%s] %s signature status: %s",
1896               sig->domain, dkim_sig_to_a_tag(sig),
1897               pdkim_verify_status_str(sig->verify_status));
1898       if (sig->verify_ext_status > 0)
1899         debug_printf(" (%s)\n",
1900                 pdkim_verify_ext_status_str(sig->verify_ext_status));
1901       else
1902         debug_printf("\n");
1903       }
1904     }
1905   }
1906
1907 /* If requested, set return pointer to signature(s) */
1908 if (return_signatures)
1909   *return_signatures = ctx->sig;
1910
1911 return ctx->flags & PDKIM_MODE_SIGN  ||  verify_pass
1912   ? PDKIM_OK : PDKIM_FAIL;
1913 }
1914
1915
1916 /* -------------------------------------------------------------------------- */
1917
1918 DLLEXPORT pdkim_ctx *
1919 pdkim_init_verify(uschar * (*dns_txt_callback)(const uschar *), BOOL dot_stuffing)
1920 {
1921 pdkim_ctx * ctx;
1922
1923 ctx = store_get(sizeof(pdkim_ctx), GET_UNTAINTED);
1924 memset(ctx, 0, sizeof(pdkim_ctx));
1925
1926 if (dot_stuffing) ctx->flags = PDKIM_DOT_TERM;
1927 /* The line-buffer is for message data, hence tainted */
1928 ctx->linebuf = store_get(PDKIM_MAX_BODY_LINE_LEN, GET_TAINTED);
1929 ctx->dns_txt_callback = dns_txt_callback;
1930 ctx->cur_header = string_get_tainted(36, GET_TAINTED);
1931
1932 return ctx;
1933 }
1934
1935
1936 /* -------------------------------------------------------------------------- */
1937
1938 DLLEXPORT pdkim_signature *
1939 pdkim_init_sign(pdkim_ctx * ctx,
1940   uschar * domain, uschar * selector, uschar * privkey,
1941   uschar * hashname, const uschar ** errstr)
1942 {
1943 int hashtype;
1944 pdkim_signature * sig;
1945
1946 if (!domain || !selector || !privkey)
1947   return NULL;
1948
1949 /* Allocate & init one signature struct */
1950
1951 sig = store_get(sizeof(pdkim_signature), GET_UNTAINTED);
1952 memset(sig, 0, sizeof(pdkim_signature));
1953
1954 sig->bodylength = -1;
1955
1956 sig->domain = string_copy(US domain);
1957 sig->selector = string_copy(US selector);
1958 sig->privkey = string_copy(US privkey);
1959 sig->keytype = -1;
1960
1961 for (hashtype = 0; hashtype < nelem(pdkim_hashes); hashtype++)
1962   if (Ustrcmp(hashname, pdkim_hashes[hashtype].dkim_hashname) == 0)
1963   { sig->hashtype = hashtype; break; }
1964 if (hashtype >= nelem(pdkim_hashes))
1965   {
1966   log_write(0, LOG_MAIN|LOG_PANIC,
1967     "DKIM: unrecognised hashname '%s'", hashname);
1968   return NULL;
1969   }
1970
1971 DEBUG(D_acl)
1972   {
1973   pdkim_signature s = *sig;
1974   ev_ctx vctx;
1975
1976   debug_printf("DKIM (checking verify key)>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1977   if (!pdkim_key_from_dns(ctx, &s, &vctx, errstr))
1978     debug_printf("WARNING: bad dkim key in dns\n");
1979   debug_printf("DKIM (finished checking verify key)<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1980   }
1981 return sig;
1982 }
1983
1984
1985 /* -------------------------------------------------------------------------- */
1986
1987 DLLEXPORT void
1988 pdkim_set_optional(pdkim_signature * sig,
1989                        char * sign_headers,
1990                        char * identity,
1991                        int canon_headers,
1992                        int canon_body,
1993                        long bodylength,
1994                        unsigned long created,
1995                        unsigned long expires)
1996 {
1997 if (identity)
1998   sig->identity = string_copy(US identity);
1999
2000 sig->sign_headers = string_copy(sign_headers
2001         ? US sign_headers : US PDKIM_DEFAULT_SIGN_HEADERS);
2002
2003 sig->canon_headers = canon_headers;
2004 sig->canon_body = canon_body;
2005 sig->bodylength = bodylength;
2006 sig->created = created;
2007 sig->expires = expires;
2008
2009 return;
2010 }
2011
2012
2013
2014 /* Set up a blob for calculating the bodyhash according to the
2015 given needs.  Use an existing one if possible, or create a new one.
2016
2017 Return: hashblob pointer, or NULL on error
2018 */
2019 pdkim_bodyhash *
2020 pdkim_set_bodyhash(pdkim_ctx * ctx, int hashtype, int canon_method,
2021         long bodylength)
2022 {
2023 pdkim_bodyhash * b;
2024
2025 if (hashtype == -1 || canon_method == -1) return NULL;
2026
2027 for (b = ctx->bodyhash; b; b = b->next)
2028   if (  hashtype == b->hashtype
2029      && canon_method == b->canon_method
2030      && bodylength == b->bodylength)
2031     {
2032     DEBUG(D_receive) debug_printf("DKIM: using existing bodyhash %s/%s/%ld\n",
2033       pdkim_hashes[hashtype].dkim_hashname, pdkim_canons[canon_method], bodylength);
2034     return b;
2035     }
2036
2037 DEBUG(D_receive) debug_printf("DKIM: new bodyhash %s/%s/%ld\n",
2038     pdkim_hashes[hashtype].dkim_hashname, pdkim_canons[canon_method], bodylength);
2039 b = store_get(sizeof(pdkim_bodyhash), GET_UNTAINTED);
2040 b->next = ctx->bodyhash;
2041 b->hashtype = hashtype;
2042 b->canon_method = canon_method;
2043 b->bodylength = bodylength;
2044 if (!exim_sha_init(&b->body_hash_ctx,           /*XXX hash method: extend for sha512 */
2045                   pdkim_hashes[hashtype].exim_hashmethod))
2046   {
2047   DEBUG(D_acl)
2048     debug_printf("DKIM: hash init error, possibly nonhandled hashtype\n");
2049   return NULL;
2050   }
2051 b->signed_body_bytes = 0;
2052 b->num_buffered_blanklines = 0;
2053 ctx->bodyhash = b;
2054 return b;
2055 }
2056
2057
2058 /* Set up a blob for calculating the bodyhash according to the
2059 needs of this signature.  Use an existing one if possible, or
2060 create a new one.
2061
2062 Return: hashblob pointer, or NULL on error (only used as a boolean).
2063 */
2064 pdkim_bodyhash *
2065 pdkim_set_sig_bodyhash(pdkim_ctx * ctx, pdkim_signature * sig)
2066 {
2067 pdkim_bodyhash * b = pdkim_set_bodyhash(ctx,
2068                         sig->hashtype, sig->canon_body, sig->bodylength);
2069 sig->calc_body_hash = b;
2070 return b;
2071 }
2072
2073
2074 /* -------------------------------------------------------------------------- */
2075
2076
2077 void
2078 pdkim_init_context(pdkim_ctx * ctx, BOOL dot_stuffed,
2079   uschar * (*dns_txt_callback)(const uschar *))
2080 {
2081 memset(ctx, 0, sizeof(pdkim_ctx));
2082 ctx->flags = dot_stuffed ? PDKIM_MODE_SIGN | PDKIM_DOT_TERM : PDKIM_MODE_SIGN;
2083 /* The line buffer is for message data, hence tainted */
2084 ctx->linebuf = store_get(PDKIM_MAX_BODY_LINE_LEN, GET_TAINTED);
2085 DEBUG(D_acl) ctx->dns_txt_callback = dns_txt_callback;
2086 }
2087
2088
2089 void
2090 pdkim_init(void)
2091 {
2092 exim_dkim_init();
2093 }
2094
2095
2096
2097 #endif  /*DISABLE_DKIM*/