src/src/pdkim/pdkim.c

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