src/src/pdkim/pdkim.c

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