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