src/src/miscmods/pdkim/pdkim.c

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