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