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