X-Git-Url: https://git.exim.org/exim.git/blobdiff_plain/cb2243935be366d4605e94a1e55c1dcc933b66cd..37f3dc43fb3a9e1513f8a31c49401b121c1adeb5:/src/src/pdkim/pdkim.c

diff --git a/src/src/pdkim/pdkim.c b/src/src/pdkim/pdkim.c
index 3840c0514..fb2742c18 100644
--- a/src/src/pdkim/pdkim.c
+++ b/src/src/pdkim/pdkim.c
@@ -39,17 +39,10 @@
 #elif defined(RSA_GNUTLS)
 # include <gnutls/gnutls.h>
 # include <gnutls/x509.h>
-# include <gnutls/abstract.h>
-#endif
-
-#ifdef SHA_GNUTLS
-# include <gnutls/crypto.h>
-#elif defined(SHA_POLARSSL)
-# include "polarssl/sha1.h"
-# include "polarssl/sha2.h"
 #endif
 
 #include "pdkim.h"
+#include "rsa.h"
 
 #define PDKIM_SIGNATURE_VERSION     "1"
 #define PDKIM_PUB_RECORD_VERSION    "DKIM1"
@@ -146,7 +139,8 @@ pdkim_verify_ext_status_str(int ext_status)
     case PDKIM_VERIFY_FAIL_MESSAGE: return "PDKIM_VERIFY_FAIL_MESSAGE";
     case PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE: return "PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE";
     case PDKIM_VERIFY_INVALID_BUFFER_SIZE: return "PDKIM_VERIFY_INVALID_BUFFER_SIZE";
-    case PDKIM_VERIFY_INVALID_PUBKEY_PARSING: return "PDKIM_VERIFY_INVALID_PUBKEY_PARSING";
+    case PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD: return "PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD";
+    case PDKIM_VERIFY_INVALID_PUBKEY_IMPORT: return "PDKIM_VERIFY_INVALID_PUBKEY_IMPORT";
     default: return "PDKIM_VERIFY_UNKNOWN";
   }
 }
@@ -154,15 +148,13 @@ pdkim_verify_ext_status_str(int ext_status)
 
 /* -------------------------------------------------------------------------- */
 /* Print debugging functions */
-void
-pdkim_quoteprint(const char *data, int len, int lf)
+static void
+pdkim_quoteprint(const uschar *data, int len)
 {
 int i;
-const unsigned char *p = (const unsigned char *)data;
-
 for (i = 0; i < len; i++)
   {
-  const int c = p[i];
+  const int c = data[i];
   switch (c)
     {
     case ' ' : debug_printf("{SP}"); break;
@@ -179,25 +171,20 @@ for (i = 0; i < len; i++)
       break;
     }
   }
-if (lf)
-  debug_printf("\n");
+debug_printf("\n");
 }
 
-void
-pdkim_hexprint(const char *data, int len, int lf)
+static void
+pdkim_hexprint(const uschar *data, int len)
 {
 int i;
-const unsigned char *p = (const unsigned char *)data;
-
-for (i = 0 ; i < len; i++)
-  debug_printf("%02x", p[i]);
-if (lf)
-  debug_printf("\n");
+for (i = 0 ; i < len; i++) debug_printf("%02x", data[i]);
+debug_printf("\n");
 }
 
 
 
-/* String package: should be replaced by Exim standard ones */
+/* SSS probably want to keep the "stringlist" notion */
 
 static pdkim_stringlist *
 pdkim_prepend_stringlist(pdkim_stringlist *base, char *str)
@@ -207,20 +194,15 @@ pdkim_stringlist *new_entry = malloc(sizeof(pdkim_stringlist));
 if (!new_entry) return NULL;
 memset(new_entry, 0, sizeof(pdkim_stringlist));
 if (!(new_entry->value = strdup(str))) return NULL;
-if (base)
-  {
-  pdkim_stringlist *last = base;
-  while (last->next != NULL) { last = last->next; }
-  last->next = new_entry;
-  return base;
-  }
-else
-  return new_entry;
+if (base) new_entry->next = base;
+return new_entry;
 }
 
 
 /* -------------------------------------------------------------------------- */
 /* A small "growing string" implementation to escape malloc/realloc hell */
+/* String package: should be replaced by Exim standard ones */
+/* SSS Ustrcpy */
 
 static pdkim_str *
 pdkim_strnew (const char *cstr)
@@ -244,6 +226,9 @@ else
 return p;
 }
 
+
+/*SSS Ustrncat */
+
 static char *
 pdkim_strncat(pdkim_str *str, const char *data, int len)
 {
@@ -263,22 +248,29 @@ str->str[str->len] = '\0';
 return str->str;
 }
 
+
+/* SSS Ustrcat */
+
 static char *
 pdkim_strcat(pdkim_str *str, const char *cstr)
 {
 return pdkim_strncat(str, cstr, strlen(cstr));
 }
 
+
+
+/* Trim whitespace fore & aft */
+
 static char *
 pdkim_strtrim(pdkim_str *str)
 {
 char *p = str->str;
 char *q = str->str;
-while ( (*p != '\0') && ((*p == '\t') || (*p == ' ')) ) p++;
-while (*p != '\0') {*q = *p; q++; p++;}
+while (*p == '\t' || *p == ' ') p++;		/* skip whitespace */
+while (*p) {*q = *p; q++; p++;}			/* dump the leading whitespace */
 *q = '\0';
-while ( (q != str->str) && ( (*q == '\0') || (*q == '\t') || (*q == ' ') ) )
-  {
+while (q != str->str && ( (*q == '\0') || (*q == '\t') || (*q == ' ') ) )
+  {						/* dump trailing whitespace */
   *q = '\0';
   q--;
   }
@@ -286,6 +278,8 @@ str->len = strlen(str->str);
 return str->str;
 }
 
+
+
 static char *
 pdkim_strclear(pdkim_str *str)
 {
@@ -294,6 +288,8 @@ str->len = 0;
 return str->str;
 }
 
+
+
 static void
 pdkim_strfree(pdkim_str *str)
 {
@@ -303,6 +299,19 @@ free(str);
 }
 
 
+static void
+pdkim_stringlist_free(pdkim_stringlist * e)
+{
+while(e)
+  {
+  pdkim_stringlist * c = e;
+  if (e->value) free(e->value);
+  e = e->next;
+  free(c);
+  }
+}
+
+
 
 /* -------------------------------------------------------------------------- */
 
@@ -317,7 +326,6 @@ if (pub)
   if (pub->keytype    ) free(pub->keytype);
   if (pub->srvtype    ) free(pub->srvtype);
   if (pub->notes      ) free(pub->notes);
-/*  if (pub->key        ) free(pub->key); */
   free(pub);
   }
 }
@@ -332,19 +340,10 @@ if (sig)
   {
   pdkim_signature *next = (pdkim_signature *)sig->next;
 
-  pdkim_stringlist *e = sig->headers;
-  while(e)
-    {
-    pdkim_stringlist *c = e;
-    if (e->value) free(e->value);
-    e = e->next;
-    free(c);
-    }
-
+  pdkim_stringlist_free(sig->headers);
   if (sig->selector        ) free(sig->selector);
   if (sig->domain          ) free(sig->domain);
   if (sig->identity        ) free(sig->identity);
-  if (sig->headernames     ) free(sig->headernames);
   if (sig->copiedheaders   ) free(sig->copiedheaders);
   if (sig->rsa_privkey     ) free(sig->rsa_privkey);
   if (sig->sign_headers    ) free(sig->sign_headers);
@@ -365,14 +364,7 @@ pdkim_free_ctx(pdkim_ctx *ctx)
 {
 if (ctx)
   {
-  pdkim_stringlist *e = ctx->headers;
-  while(e)
-    {
-    pdkim_stringlist *c = e;
-    if (e->value) free(e->value);
-    e = e->next;
-    free(c);
-    }
+  pdkim_stringlist_free(ctx->headers);
   pdkim_free_sig(ctx->sig);
   pdkim_strfree(ctx->cur_header);
   free(ctx);
@@ -382,14 +374,12 @@ if (ctx)
 
 /* -------------------------------------------------------------------------- */
 /* Matches the name of the passed raw "header" against
-   the passed colon-separated "list", starting at entry
-   "start". Returns the position of the header name in
-   the list. */
+   the passed colon-separated "tick", and invalidates
+   the entry in tick. Returns OK or fail-code */
+/*XXX might be safer done using a pdkim_stringlist for "tick" */
 
 static int
-header_name_match(const char *header,
-                      char       *tick,
-                      int         do_tick)
+header_name_match(const char * header, char * tick)
 {
 char *hname;
 char *lcopy;
@@ -423,7 +413,7 @@ while (q)
     {
     rc = PDKIM_OK;
     /* Invalidate header name instance in tick-off list */
-    if (do_tick) tick[p-lcopy] = '_';
+    tick[p-lcopy] = '_';
     goto BAIL;
     }
 
@@ -435,7 +425,7 @@ if (strcasecmp(p, hname) == 0)
   {
   rc = PDKIM_OK;
   /* Invalidate header name instance in tick-off list */
-  if (do_tick) tick[p-lcopy] = '_';
+  tick[p-lcopy] = '_';
   }
 
 BAIL:
@@ -559,37 +549,25 @@ return n;
 
 /* -------------------------------------------------------------------------- */
 
-static char *
-pdkim_decode_base64(char *str, int *num_decoded)
+static void
+pdkim_decode_base64(uschar *str, blob * b)
 {
-int dlen = 0;
-char *res;
-int old_pool = store_pool;
-
-/* There is a store-reset between header & body reception
-so cannot use the main pool */
-
-store_pool = POOL_PERM;
-dlen = b64decode(US str, USS &res);
-store_pool = old_pool;
-
-if (dlen < 0) return NULL;
-
-if (num_decoded) *num_decoded = dlen;
-return res;
+int dlen;
+dlen = b64decode(str, &b->data);
+if (dlen < 0) b->data = NULL;
+b->len = dlen;
 }
 
-
 /* -------------------------------------------------------------------------- */
 
 static char *
-pdkim_encode_base64(char *str, int num)
+pdkim_encode_base64(blob * b)
 {
 char * ret;
 int old_pool = store_pool;
 
 store_pool = POOL_PERM;
-ret = CS b64encode(US str, num);
+ret = CS b64encode(b->data, b->len);
 store_pool = old_pool;
 return ret;
 }
@@ -611,6 +589,13 @@ BOOL past_hname = FALSE;
 BOOL in_b_val = FALSE;
 int where = PDKIM_HDR_LIMBO;
 int i;
+int old_pool = store_pool;
+
+/* There is a store-reset between header & body reception
+so cannot use the main pool. Any allocs done by Exim
+memory-handling must use the perm pool. */
+
+store_pool = POOL_PERM;
 
 if (!(sig = malloc(sizeof(pdkim_signature)))) return NULL;
 memset(sig, 0, sizeof(pdkim_signature));
@@ -688,11 +673,9 @@ for (p = raw_hdr; ; p++)
 	  {
 	  case 'b':
 	    if (cur_tag->str[1] == 'h')
-	      sig->bodyhash = pdkim_decode_base64(cur_val->str,
-		  &sig->bodyhash_len);
+	      pdkim_decode_base64(US cur_val->str, &sig->bodyhash);
 	    else
-	      sig->sigdata = pdkim_decode_base64(cur_val->str,
-		  &sig->sigdata_len);
+	      pdkim_decode_base64(US cur_val->str, &sig->sigdata);
 	    break;
 	  case 'v':
 	      /* We only support version 1, and that is currently the
@@ -738,7 +721,7 @@ for (p = raw_hdr; ; p++)
 	  case 'l':
 	    sig->bodylength = strtol(cur_val->str, NULL, 10); break;
 	  case 'h':
-	    sig->headernames = strdup(cur_val->str); break;
+	    sig->headernames = string_copy(US cur_val->str); break;
 	  case 'z':
 	    sig->copiedheaders = pdkim_decode_qp(cur_val->str); break;
 	  default:
@@ -763,12 +746,12 @@ NEXT_CHAR:
     *q++ = c;
   }
 
+store_pool = old_pool;
+
 /* Make sure the most important bits are there. */
 if (!(sig->domain      && (*(sig->domain)      != '\0') &&
       sig->selector    && (*(sig->selector)    != '\0') &&
       sig->headernames && (*(sig->headernames) != '\0') &&
-      sig->bodyhash    &&
-      sig->sigdata     &&
       sig->version))
   {
   pdkim_free_sig(sig);
@@ -777,46 +760,21 @@ if (!(sig->domain      && (*(sig->domain)      != '\0') &&
 
 *q = '\0';
 /* Chomp raw header. The final newline must not be added to the signature. */
-q--;
-while (q > sig->rawsig_no_b_val  && (*q == '\r' || *q == '\n'))
-  *q = '\0'; q--;	/*XXX questionable code layout; possible bug */
+while (--q > sig->rawsig_no_b_val  && (*q == '\r' || *q == '\n'))
+  *q = '\0';
 
 DEBUG(D_acl)
   {
   debug_printf(
 	  "PDKIM >> Raw signature w/o b= tag value >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
-  pdkim_quoteprint(sig->rawsig_no_b_val, strlen(sig->rawsig_no_b_val), 1);
+  pdkim_quoteprint(US sig->rawsig_no_b_val, strlen(sig->rawsig_no_b_val));
   debug_printf(
-	  "PDKIM >> Sig size: %4d bits\n", sig->sigdata_len*8);
+	  "PDKIM >> Sig size: %4u bits\n", (unsigned) sig->sigdata.len*8);
   debug_printf(
 	  "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
   }
 
-#ifdef SHA_OPENSSL
-
-SHA1_Init  (&sig->sha1_body);
-SHA256_Init(&sig->sha2_body);
-
-#elif defined(SHA_GNUTLS)
-
-gnutls_hash_init(&sig->sha_body,
-  sig->algo == PDKIM_ALGO_RSA_SHA1 ? GNUTLS_DIG_SHA1 : GNUTLS_DIG_SHA256);
-
-#elif defined(SHA_POLARSSL)
-
-if (  !(sig->sha1_body = malloc(sizeof(sha1_context)))
-   || !(sig->sha2_body = malloc(sizeof(sha2_context)))
-   )
-  {
-  pdkim_free_sig(sig);
-  return NULL;
-  }
-
-sha1_starts(sig->sha1_body);
-sha2_starts(sig->sha2_body, 0);
-
-#endif	/* SHA impl */
-
+exim_sha_init(&sig->body_hash, sig->algo == PDKIM_ALGO_RSA_SHA1);
 return sig;
 }
 
@@ -872,9 +830,6 @@ for (p = raw_record; ; p++)
     if (!cur_val)
       cur_val = pdkim_strnew(NULL);
 
-    if (c == '\r' || c == '\n')
-      goto NEXT_CHAR;
-
     if (c == ';' || c == '\0')
       {
       if (cur_tag->len > 0)
@@ -897,7 +852,8 @@ for (p = raw_record; ; p++)
 	  case 'n':
 	    pub->notes = pdkim_decode_qp(cur_val->str); break;
 	  case 'p':
-	    pub->key = pdkim_decode_base64(cur_val->str, &(pub->key_len)); break;
+	    pdkim_decode_base64(US cur_val->str, &pub->key);
+            break;
 	  case 'k':
 	    pub->hashes = strdup(cur_val->str); break;
 	  case 's':
@@ -930,7 +886,7 @@ if (!pub->keytype    ) pub->keytype     = strdup("rsa");
 if (!pub->srvtype    ) pub->srvtype     = strdup("*");
 
 /* p= is required */
-if (pub->key)
+if (pub->key.data)
   return pub;
 
 pdkim_free_pubkey(pub);
@@ -945,15 +901,15 @@ pdkim_update_bodyhash(pdkim_ctx *ctx, const char *data, int len)
 {
 pdkim_signature *sig = ctx->sig;
 /* Cache relaxed version of data */
-char *relaxed_data = NULL;
-int   relaxed_len  = 0;
+uschar *relaxed_data = NULL;
+int     relaxed_len  = 0;
 
 /* Traverse all signatures, updating their hashes. */
 while (sig)
   {
   /* Defaults to simple canon (no further treatment necessary) */
-  const char *canon_data = data;
-  int         canon_len = len;
+  const uschar *canon_data = CUS data;
+  int           canon_len = len;
 
   if (sig->canon_body == PDKIM_CANON_RELAXED)
     {
@@ -1001,23 +957,9 @@ while (sig)
 
   if (canon_len > 0)
     {
-#ifdef SHA_GNUTLS
-    gnutls_hash(sig->sha_body, canon_data, canon_len);
-#else
-    if (sig->algo == PDKIM_ALGO_RSA_SHA1)
-# ifdef SHA_OPENSSL
-      SHA1_Update  (&sig->sha1_body, canon_data, canon_len);
-    else
-      SHA256_Update(&sig->sha2_body, canon_data, canon_len);
-# elif defined(SHA_POLARSSL)
-      sha1_update(sig->sha1_body, US canon_data, canon_len);
-    else
-      sha2_update(sig->sha2_body, US canon_data, canon_len);
-# endif
-#endif
-
+    exim_sha_update(&sig->body_hash, CCS canon_data, canon_len);
     sig->signed_body_bytes += canon_len;
-    DEBUG(D_acl) pdkim_quoteprint(canon_data, canon_len, 1);
+    DEBUG(D_acl) pdkim_quoteprint(canon_data, canon_len);
     }
 
   sig = sig->next;
@@ -1038,36 +980,22 @@ pdkim_signature *sig;
 /* Traverse all signatures */
 for (sig = ctx->sig; sig; sig = sig->next)
   {					/* Finish hashes */
-  uschar bh[32]; /* SHA-256 = 32 Bytes,  SHA-1 = 20 Bytes */
-
-#ifdef SHA_GNUTLS
-  gnutls_hash_output(sig->sha_body, bh);
-#else
-  if (sig->algo == PDKIM_ALGO_RSA_SHA1)
-# ifdef SHA_OPENSSL
-    SHA1_Final  (bh, &sig->sha1_body);
-  else
-    SHA256_Final(bh, &sig->sha2_body);
-# elif defined(SHA_POLARSSL)
-    sha1_finish(sig->sha1_body, bh);
-  else
-    sha2_finish(sig->sha2_body, bh);
-# endif
-#endif
+  blob bh;
+
+  exim_sha_finish(&sig->body_hash, &bh);
 
   DEBUG(D_acl)
     {
     debug_printf("PDKIM [%s] Body bytes hashed: %lu\n"
 		 "PDKIM [%s] bh  computed: ",
 		sig->domain, sig->signed_body_bytes, sig->domain);
-    pdkim_hexprint((char *)bh, sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20 : 32, 1);
+    pdkim_hexprint(CUS bh.data, bh.len);
     }
 
   /* SIGNING -------------------------------------------------------------- */
   if (ctx->mode == PDKIM_MODE_SIGN)
     {
-    sig->bodyhash_len = sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20:32;
-    sig->bodyhash = string_copyn(US bh, sig->bodyhash_len);
+    sig->bodyhash = bh;
 
     /* If bodylength limit is set, and we have received less bytes
        than the requested amount, effectively remove the limit tag. */
@@ -1079,8 +1007,7 @@ for (sig = ctx->sig; sig; sig = sig->next)
   else
     {
     /* Compare bodyhash */
-    if (memcmp(bh, sig->bodyhash,
-	       (sig->algo == PDKIM_ALGO_RSA_SHA1)?20:32) == 0)
+    if (memcmp(bh.data, sig->bodyhash.data, bh.len) == 0)
       {
       DEBUG(D_acl) debug_printf("PDKIM [%s] Body hash verified OK\n", sig->domain);
       }
@@ -1089,8 +1016,8 @@ for (sig = ctx->sig; sig; sig = sig->next)
       DEBUG(D_acl)
         {
 	debug_printf("PDKIM [%s] bh signature: ", sig->domain);
-	pdkim_hexprint(sig->bodyhash,
-			 sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20 : 32, 1);
+	pdkim_hexprint(sig->bodyhash.data,
+			 exim_sha_hashlen(&sig->body_hash));
 	debug_printf("PDKIM [%s] Body hash did NOT verify\n", sig->domain);
 	}
       sig->verify_status     = PDKIM_VERIFY_FAIL;
@@ -1208,19 +1135,15 @@ if (ctx->mode == PDKIM_MODE_SIGN)
   pdkim_signature *sig;
 
   for (sig = ctx->sig; sig; sig = sig->next)			/* Traverse all signatures */
-    if (header_name_match(ctx->cur_header->str,
-			  sig->sign_headers?
-			    sig->sign_headers:
-			    PDKIM_DEFAULT_SIGN_HEADERS, 0) == PDKIM_OK)
-      {
-      pdkim_stringlist *list;
+    {
+    pdkim_stringlist *list;
 
-      /* Add header to the signed headers list (in reverse order) */
-      if (!(list = pdkim_prepend_stringlist(sig->headers,
-				    ctx->cur_header->str)))
-	return PDKIM_ERR_OOM;
-      sig->headers = list;
-      }
+    /* Add header to the signed headers list (in reverse order) */
+    if (!(list = pdkim_prepend_stringlist(sig->headers,
+				  ctx->cur_header->str)))
+      return PDKIM_ERR_OOM;
+    sig->headers = list;
+    }
   }
 
 /* VERIFICATION ----------------------------------------------------------- */
@@ -1311,7 +1234,7 @@ for (p = 0; p<len; p++)
 	  ctx->past_headers = TRUE;
 	  ctx->seen_lf = 0;
 	  DEBUG(D_acl) debug_printf(
-	      "PDKIM >> Hashed body data, canonicalized >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+	      "PDKIM >> Body data for hash, canonicalized >>>>>>>>>>>>>>>>>>>>>>\n");
 	  continue;
 	  }
 	else
@@ -1465,7 +1388,7 @@ return str->str;
 /* -------------------------------------------------------------------------- */
 
 static char *
-pdkim_create_header(pdkim_signature *sig, int final)
+pdkim_create_header(pdkim_signature *sig, BOOL final)
 {
 char *rc = NULL;
 char *base64_bh = NULL;
@@ -1480,7 +1403,7 @@ if (!(hdr = pdkim_strnew("DKIM-Signature: v="PDKIM_SIGNATURE_VERSION)))
 if (!(canon_all = pdkim_strnew(pdkim_canons[sig->canon_headers])))
   goto BAIL;
 
-if (!(base64_bh = pdkim_encode_base64(sig->bodyhash, sig->bodyhash_len)))
+if (!(base64_bh = pdkim_encode_base64(&sig->bodyhash)))
   goto BAIL;
 
 col = strlen(hdr->str);
@@ -1495,10 +1418,9 @@ if (  pdkim_headcat(&col, hdr, ";", "a=", pdkim_algos[sig->algo])
    && pdkim_headcat(&col, hdr, ";", "s=", sig->selector)
    )
   {
-  /* list of eader names can be split between items. */
+  /* list of header names can be split between items. */
     {
-    char *n = strdup(sig->headernames);
-    char *f = n;
+    char *n = CS string_copy(sig->headernames);
     char *i = "h=";
     char *s = ";";
 
@@ -1512,13 +1434,11 @@ if (  pdkim_headcat(&col, hdr, ";", "a=", pdkim_algos[sig->algo])
       if (!i)
 	if (!pdkim_headcat(&col, hdr, NULL, NULL, ":"))
 	  {
-	  free(f);
 	  goto BAIL;
 	  }
 
       if (!pdkim_headcat(&col, hdr, s, i, n))
 	{
-	free(f);
 	goto BAIL;
 	}
 
@@ -1529,7 +1449,6 @@ if (  pdkim_headcat(&col, hdr, ";", "a=", pdkim_algos[sig->algo])
       s = NULL;
       i = NULL;
       }
-    free(f);
     }
 
   if(!pdkim_headcat(&col, hdr, ";", "bh=", base64_bh))
@@ -1570,7 +1489,7 @@ if (  pdkim_headcat(&col, hdr, ";", "a=", pdkim_algos[sig->algo])
   /* Preliminary or final version? */
   if (final)
     {
-    if (!(base64_b = pdkim_encode_base64(sig->sigdata, sig->sigdata_len)))
+    if (!(base64_b = pdkim_encode_base64(&sig->sigdata)))
       goto BAIL;
     if (!pdkim_headcat(&col, hdr, ";", "b=", base64_b))
       goto BAIL;
@@ -1626,92 +1545,70 @@ if (ctx->mode == PDKIM_MODE_SIGN)
 
 while (sig)
   {
-#ifdef SHA_OPENSSL
-  SHA_CTX    sha1_headers;
-  SHA256_CTX sha2_headers;
-#elif defined(SHA_GNUTLS)
-  gnutls_hash_hd_t sha_headers;
-#elif defined(SHA_POLARSSL)
-  sha1_context sha1_headers;
-  sha2_context sha2_headers;
-#endif
-
-  char *sig_hdr;
-  char headerhash[32];
-
-#ifdef RSA_GNUTLS
-  uschar * hdata = NULL;
+  BOOL is_sha1 = sig->algo == PDKIM_ALGO_RSA_SHA1;
+  hctx hhash_ctx;
+  char * sig_hdr;
+  blob hhash;
+  blob hdata;
   int hdata_alloc = 0;
-  int hdata_size = 0;
-#endif
 
-#ifdef SHA_GNUTLS
-  gnutls_hash_init(&sha_headers,
-    sig->algo == PDKIM_ALGO_RSA_SHA1 ? GNUTLS_DIG_SHA1 : GNUTLS_DIG_SHA256);
-#else
-  if (sig->algo == PDKIM_ALGO_RSA_SHA1)
-# ifdef SHA_OPENSSL
-    SHA1_Init(&sha1_headers);
-  else
-    SHA256_Init(&sha2_headers);
-# elif defined(SHA_POLARSSL)
-    sha1_starts(&sha1_headers);
-  else
-    sha2_starts(&sha2_headers, 0);
-# endif
-#endif
+  hdata.data = NULL;
+  hdata.len = 0;
+
+  exim_sha_init(&hhash_ctx, is_sha1);
 
   DEBUG(D_acl) debug_printf(
       "PDKIM >> Hashed header data, canonicalized, in sequence >>>>>>>>>>>>>>\n");
 
   /* SIGNING ---------------------------------------------------------------- */
   /* When signing, walk through our header list and add them to the hash. As we
-     go, construct a list of the header's names to use for the h= parameter. */
+     go, construct a list of the header's names to use for the h= parameter.
+     Then append to that list any remaining header names for which there was no
+     header to sign. */
 
   if (ctx->mode == PDKIM_MODE_SIGN)
     {
     pdkim_stringlist *p;
+    const uschar * l;
+    uschar * s;
+    int sep = 0;
 
     for (p = sig->headers; p; p = p->next)
-      {
-      char *rh = NULL;
-      /* Collect header names (Note: colon presence is guaranteed here) */
-      char *q = strchr(p->value, ':');
+      if (header_name_match(p->value, sig->sign_headers) == PDKIM_OK)
+	{
+	uschar * rh;
+	/* Collect header names (Note: colon presence is guaranteed here) */
+	uschar * q = Ustrchr(p->value, ':');
 
-      if (!(pdkim_strncat(headernames, p->value,
-			(q-(p->value)) + (p->next ? 1 : 0))))
-	return PDKIM_ERR_OOM;
+	if (!(pdkim_strncat(headernames, p->value,
+			  (q - US p->value) + (p->next ? 1 : 0))))
+	  return PDKIM_ERR_OOM;
 
-      rh = sig->canon_headers == PDKIM_CANON_RELAXED
-	? pdkim_relax_header(p->value, 1) /* cook header for relaxed canon */
-	: strdup(p->value);              /* just copy it for simple canon */
-      if (!rh)
-	return PDKIM_ERR_OOM;
+	rh = sig->canon_headers == PDKIM_CANON_RELAXED
+	  ? US pdkim_relax_header(p->value, 1) /* cook header for relaxed canon */
+	  : string_copy(CUS p->value);         /* just copy it for simple canon */
+	if (!rh)
+	  return PDKIM_ERR_OOM;
 
-      /* Feed header to the hash algorithm */
-#ifdef SHA_GNUTLS
-      gnutls_hash(sha_headers, rh, strlen(rh));
-#else
-      if (sig->algo == PDKIM_ALGO_RSA_SHA1)
-# ifdef SHA_OPENSSL
-	SHA1_Update  (&sha1_headers, rh, strlen(rh));
-      else
-	SHA256_Update(&sha2_headers, rh, strlen(rh));
-# elif defined(SHA_POLARSSL)
-	sha1_update(&sha1_headers, US rh, strlen(rh));
-      else
-	sha2_update(&sha2_headers, US rh, strlen(rh));
-# endif
-#endif
+	/* Feed header to the hash algorithm */
+	exim_sha_update(&hhash_ctx, CCS rh, Ustrlen(rh));
 
-#ifdef RSA_GNUTLS
-      /* Remember headers block for signing */
-      hdata = string_append(hdata, &hdata_alloc, &hdata_size, 1, rh);
-#endif
+	/* Remember headers block for signing (when the library cannot do incremental)  */
+	(void) exim_rsa_data_append(&hdata, &hdata_alloc, rh);
 
-      DEBUG(D_acl) pdkim_quoteprint(rh, strlen(rh), 1);
-      free(rh);
-      }
+	DEBUG(D_acl) pdkim_quoteprint(rh, Ustrlen(rh));
+	}
+
+    l = US sig->sign_headers;
+    while((s = string_nextinlist(&l, &sep, NULL, 0)))
+      if (*s != '_')
+	{			/*SSS string_append_listele() */
+	if (headernames->len > 0 && headernames->str[headernames->len-1] != ':')
+	  if (!(pdkim_strncat(headernames, ":", 1)))
+	    return PDKIM_ERR_OOM;
+	if (!(pdkim_strncat(headernames, CS s, Ustrlen(s))))
+	  return PDKIM_ERR_OOM;
+	}
     }
 
   /* VERIFICATION ----------------------------------------------------------- */
@@ -1719,10 +1616,10 @@ while (sig)
      add the headers to the hash in that order. */
   else
     {
-    char *b = strdup(sig->headernames);
-    char *p = b;
-    char *q = NULL;
-    pdkim_stringlist *hdrs;
+    uschar * b = string_copy(sig->headernames);
+    uschar * p = b;
+    uschar * q;
+    pdkim_stringlist * hdrs;
 
     if (!b) return PDKIM_ERR_OOM;
 
@@ -1732,41 +1629,26 @@ while (sig)
 
     while(1)
       {
-      if ((q = strchr(p, ':')))
+      if ((q = Ustrchr(p, ':')))
 	*q = '\0';
 
+/*XXX walk the list of headers in same order as received. */
       for (hdrs = ctx->headers; hdrs; hdrs = hdrs->next)
 	if (  hdrs->tag == 0
-	   && strncasecmp(hdrs->value, p, strlen(p)) == 0
-	   && (hdrs->value)[strlen(p)] == ':'
+	   && strncasecmp(hdrs->value, CS p, Ustrlen(p)) == 0
+	   && (hdrs->value)[Ustrlen(p)] == ':'
 	   )
 	  {
-	  char *rh;
-
-	  rh = sig->canon_headers == PDKIM_CANON_RELAXED
-	    ? pdkim_relax_header(hdrs->value, 1) /* cook header for relaxed canon */
-	    : strdup(hdrs->value);               /* just copy it for simple canon */
+	  uschar * rh = sig->canon_headers == PDKIM_CANON_RELAXED
+	    ? US pdkim_relax_header(hdrs->value, 1) /* cook header for relaxed canon */
+	    : string_copy(CUS hdrs->value);         /* just copy it for simple canon */
 	  if (!rh)
 	    return PDKIM_ERR_OOM;
 
 	  /* Feed header to the hash algorithm */
-#ifdef SHA_GNUTLS
-	  gnutls_hash(sha_headers, rh, strlen(rh));
-#else
-	  if (sig->algo == PDKIM_ALGO_RSA_SHA1)
-# ifdef SHA_OPENSSL
-	    SHA1_Update  (&sha1_headers, rh, strlen(rh));
-	  else
-	    SHA256_Update(&sha2_headers, rh, strlen(rh));
-# elif defined(SHA_POLARSSL)
-	    sha1_update(&sha1_headers, US rh, strlen(rh));
-	  else
-	    sha2_update(&sha2_headers, US rh, strlen(rh));
-# endif
-#endif
+	  exim_sha_update(&hhash_ctx, CCS rh, Ustrlen(rh));
 
-	  DEBUG(D_acl) pdkim_quoteprint(rh, strlen(rh), 1);
-	  free(rh);
+	  DEBUG(D_acl) pdkim_quoteprint(rh, Ustrlen(rh));
 	  hdrs->tag = 1;
 	  break;
 	  }
@@ -1774,7 +1656,6 @@ while (sig)
       if (!q) break;
       p = q+1;
       }
-    free(b);
     }
 
   DEBUG(D_acl) debug_printf(
@@ -1784,11 +1665,11 @@ while (sig)
   if (ctx->mode == PDKIM_MODE_SIGN)
     {
     /* Copy headernames to signature struct */
-    sig->headernames = strdup(headernames->str);
+    sig->headernames = string_copy(US headernames->str);
     pdkim_strfree(headernames);
 
     /* Create signature header with b= omitted */
-    sig_hdr = pdkim_create_header(ctx->sig, 0);
+    sig_hdr = pdkim_create_header(sig, FALSE);
     }
 
   /* VERIFICATION ----------------------------------------------------------- */
@@ -1814,162 +1695,78 @@ while (sig)
     {
     debug_printf(
 	    "PDKIM >> Signed DKIM-Signature header, canonicalized >>>>>>>>>>>>>>>>>\n");
-    pdkim_quoteprint(sig_hdr, strlen(sig_hdr), 1);
+    pdkim_quoteprint(CUS sig_hdr, strlen(sig_hdr));
     debug_printf(
 	    "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
     }
 
   /* Finalize header hash */
-#ifdef SHA_GNUTLS
-  gnutls_hash(sha_headers, sig_hdr, strlen(sig_hdr));
-  gnutls_hash_output(sha_headers, headerhash);
-#else
-  if (sig->algo == PDKIM_ALGO_RSA_SHA1)
-# ifdef SHA_OPENSSL
-    {
-    SHA1_Update(&sha1_headers, sig_hdr, strlen(sig_hdr));
-    SHA1_Final(US headerhash, &sha1_headers);
-    }
-  else
-    {
-    SHA256_Update(&sha2_headers, sig_hdr, strlen(sig_hdr));
-    SHA256_Final(US headerhash, &sha2_headers);
-    }
-# elif defined(SHA_POLARSSL)
-    {
-    sha1_update(&sha1_headers, US sig_hdr, strlen(sig_hdr));
-    sha1_finish(&sha1_headers, US headerhash);
-    }
-  else
-    {
-    sha2_update(&sha2_headers, US sig_hdr, strlen(sig_hdr));
-    sha2_finish(&sha2_headers, US headerhash);
-    }
-# endif
-#endif
+  exim_sha_update(&hhash_ctx, sig_hdr, strlen(sig_hdr));
+  exim_sha_finish(&hhash_ctx, &hhash);
 
   DEBUG(D_acl)
     {
     debug_printf("PDKIM [%s] hh computed: ", sig->domain);
-    pdkim_hexprint(headerhash, sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20:32, 1);
+    pdkim_hexprint(hhash.data, hhash.len);
     }
 
-#ifdef RSA_GNUTLS
+  /* Remember headers block for signing (when the library cannot do incremental)  */
   if (ctx->mode == PDKIM_MODE_SIGN)
-    hdata = string_append(hdata, &hdata_alloc, &hdata_size, 1, sig_hdr);
-#endif
+    (void) exim_rsa_data_append(&hdata, &hdata_alloc, US sig_hdr);
 
   free(sig_hdr);
 
   /* SIGNING ---------------------------------------------------------------- */
   if (ctx->mode == PDKIM_MODE_SIGN)
     {
-#ifdef RSA_OPENSSL
-    RSA * rsa;
-    uschar * p, * q;
-    int len;
-#elif defined(RSA_GNUTLS)
-    gnutls_x509_privkey_t rsa;
-    gnutls_datum_t k;
-    int rc;
-    size_t sigsize;
-#endif
+    es_ctx sctx;
+    const uschar * errstr;
 
     /* Import private key */
-#ifdef RSA_OPENSSL
-
-    if (  !(p = Ustrstr(sig->rsa_privkey, "-----BEGIN RSA PRIVATE KEY-----"))
-       || !(q = Ustrstr(p+=31, "-----END RSA PRIVATE KEY-----"))
-       )
-      return PDKIM_ERR_RSA_PRIVKEY;
-    *q = '\0';
-    if (  (len = b64decode(p, &p)) < 0
-       || !(rsa = d2i_RSAPrivateKey(NULL, CUSS &p, len))
-       )
-      /*XXX todo: get errstring from library */
-      return PDKIM_ERR_RSA_PRIVKEY;
-
-#elif defined(RSA_GNUTLS)
-
-    k.data = sig->rsa_privkey;
-    k.size = strlen(sig->rsa_privkey);
-    if (  (rc = gnutls_x509_privkey_init(&rsa)) != GNUTLS_E_SUCCESS
-       || (rc = gnutls_x509_privkey_import2(rsa, &k,
-	      GNUTLS_X509_FMT_PEM, NULL, GNUTLS_PKCS_PLAIN)) != GNUTLS_E_SUCCESS
-       )
+    if ((errstr = exim_rsa_signing_init(US sig->rsa_privkey, &sctx)))
       {
-      DEBUG(D_acl) debug_printf("gnutls_x509_privkey_import2: %s\n",
-	gnutls_strerror(rc));
+      DEBUG(D_acl) debug_printf("signing_init: %s\n", errstr);
       return PDKIM_ERR_RSA_PRIVKEY;
       }
 
-#endif
-
+    /* Do signing.  With OpenSSL we are signing the hash of headers just
+    calculated, with GnuTLS we have to sign an entire block of headers
+    (due to available interfaces) and it recalculates the hash internally. */
 
-    /* Allocate mem for signature */
-#ifdef RSA_OPENSSL
-    sig->sigdata = store_get(RSA_size(rsa));
-#elif defined(RSA_GNUTLS)
-    k.data = hdata;
-    k.size = hdata_size;
-    (void) gnutls_x509_privkey_sign_data(rsa,
-      sig->algo == PDKIM_ALGO_RSA_SHA1 ? GNUTLS_DIG_SHA1 : GNUTLS_DIG_SHA256,
-      0, &k, NULL, &sigsize);
-    sig->sigdata = store_get(sig->sigdata_len = sigsize);
+#if defined(RSA_OPENSSL) || defined(RSA_GCRYPT)
+    hdata = hhash;
 #endif
 
-    /* Do signing */
-#ifdef RSA_OPENSSL
-
-    if (RSA_sign(sig->algo == PDKIM_ALGO_RSA_SHA1 ? NID_sha1 : NID_sha256,
-	  CUS headerhash, sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20 : 32,
-	  US sig->sigdata, (unsigned int *)&sig->sigdata_len,
-	  rsa) != 1)
-      return PDKIM_ERR_RSA_SIGNING;
-    RSA_free(rsa);
-
-#elif defined(RSA_GNUTLS)
-
-    if ((rc = gnutls_x509_privkey_sign_data(rsa,
-	  sig->algo == PDKIM_ALGO_RSA_SHA1 ? GNUTLS_DIG_SHA1 : GNUTLS_DIG_SHA256,
-	  0, &k, sig->sigdata, &sigsize)) != GNUTLS_E_SUCCESS
-       )
+    if ((errstr = exim_rsa_sign(&sctx, is_sha1, &hdata, &sig->sigdata)))
       {
-      DEBUG(D_acl) debug_printf("gnutls_x509_privkey_sign_data: %s\n",
-	gnutls_strerror(rc));
+      DEBUG(D_acl) debug_printf("signing: %s\n", errstr);
       return PDKIM_ERR_RSA_SIGNING;
       }
-    gnutls_x509_privkey_deinit(rsa);
-
-#endif
-
 
     DEBUG(D_acl)
       {
       debug_printf( "PDKIM [%s] b computed: ", sig->domain);
-      pdkim_hexprint(sig->sigdata, sig->sigdata_len, 1);
+      pdkim_hexprint(sig->sigdata.data, sig->sigdata.len);
       }
 
-    if (!(sig->signature_header = pdkim_create_header(ctx->sig, 1)))
+    if (!(sig->signature_header = pdkim_create_header(sig, TRUE)))
       return PDKIM_ERR_OOM;
+
+    /* We only ever sign with one sig, and we free'd "headernames"
+    above.  So to keep static-analysers happy, exit the loop explicitly.
+    Perhaps the code would be more clear if signing and verification
+    loops were separated? */
+
+    break;
     }
 
   /* VERIFICATION ----------------------------------------------------------- */
   else
     {
-#ifdef RSA_OPENSSL
-    RSA * rsa;
-    const unsigned char * p;
-#elif defined(RSA_GNUTLS)
-    gnutls_pubkey_t rsa;
-    gnutls_datum_t k, s;
-    int rc;
-#endif
-    char *dns_txt_name, *dns_txt_reply;
+    ev_ctx vctx;
+    const uschar * errstr;
 
-#ifdef RSA_GNUTLS
-    gnutls_pubkey_init(&rsa);
-#endif
+    char *dns_txt_name, *dns_txt_reply;
 
     /* Fetch public key for signing domain, from DNS */
 
@@ -2005,15 +1802,15 @@ while (sig)
     DEBUG(D_acl)
       {
       debug_printf(
-	      "PDKIM >> Parsing public key record >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"
-	      " Raw record: ");
-      pdkim_quoteprint(dns_txt_reply, strlen(dns_txt_reply), 1);
+          "PDKIM >> Parsing public key record >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"
+          " Raw record: ");
+      pdkim_quoteprint(CUS dns_txt_reply, strlen(dns_txt_reply));
       }
 
     if (!(sig->pubkey = pdkim_parse_pubkey_record(ctx, dns_txt_reply)))
       {
       sig->verify_status =      PDKIM_VERIFY_INVALID;
-      sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_PARSING;
+      sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD;
 
       DEBUG(D_acl) debug_printf(
 	  " Error while parsing public key record\n"
@@ -2022,69 +1819,27 @@ while (sig)
       }
 
     DEBUG(D_acl) debug_printf(
-	"PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
+	  "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
 
     /* Import public key */
-#ifdef RSA_OPENSSL
-
-    p = CUS sig->pubkey->key;
-    if (!(rsa = d2i_RSA_PUBKEY(NULL, &p, (long) sig->pubkey->key_len)))
-
-#elif defined(RSA_GNUTLS)
-
-    k.data = sig->pubkey->key;
-    k.size = sig->pubkey->key_len;
-    if ((rc = gnutls_pubkey_import(rsa, &k, GNUTLS_X509_FMT_DER))
-       != GNUTLS_E_SUCCESS)
-
-#endif
+    if ((errstr = exim_rsa_verify_init(&sig->pubkey->key, &vctx)))
       {
-      DEBUG(D_acl)
-	{
-#ifdef RSA_OPENSSL
-	long e;
-	ERR_load_crypto_strings();	/*XXX move to a startup routine */
-	while ((e = ERR_get_error()))
-	  debug_printf("Az: %.120s\n", ERR_error_string(e, NULL));
-#elif defined(RSA_GNUTLS)
-	debug_printf("gnutls_pubkey_import: %s\n", gnutls_strerror(rc));
-#endif
-	}
-
+      DEBUG(D_acl) debug_printf("verify_init: %s\n", errstr);
       sig->verify_status =      PDKIM_VERIFY_INVALID;
-      sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_PARSING;
+      sig->verify_ext_status =  PDKIM_VERIFY_INVALID_PUBKEY_IMPORT;
       goto NEXT_VERIFY;
       }
 
     /* Check the signature */
-#ifdef RSA_OPENSSL
-
-    if (RSA_verify(sig->algo == PDKIM_ALGO_RSA_SHA1 ? NID_sha1 : NID_sha256,
-	  CUS headerhash, sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20 : 32,
-	  US sig->sigdata, (unsigned int)sig->sigdata_len,
-	  rsa) != 1)
-
-#elif defined(RSA_GNUTLS)
-
-    k.data = headerhash;
-    k.size = sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20 : 32;
-    s.data = sig->sigdata;
-    s.size = sig->sigdata_len;
-    if ((rc = gnutls_pubkey_verify_hash2(rsa,
-		sig->algo == PDKIM_ALGO_RSA_SHA1
-		  ? GNUTLS_SIGN_RSA_SHA1 : GNUTLS_SIGN_RSA_SHA256,
-		0, &k, &s)) < 0)
-
-#endif
+    if ((errstr = exim_rsa_verify(&vctx, is_sha1, &hhash, &sig->sigdata)))
       {
-#if defined(RSA_GNUTLS)
-      debug_printf("gnutls_pubkey_verify_hash2: %s\n", gnutls_strerror(rc));
-#endif
+      DEBUG(D_acl) debug_printf("headers verify: %s\n", errstr);
       sig->verify_status =      PDKIM_VERIFY_FAIL;
       sig->verify_ext_status =  PDKIM_VERIFY_FAIL_MESSAGE;
       goto NEXT_VERIFY;
       }
 
+
     /* We have a winner! (if bodydhash was correct earlier) */
     if (sig->verify_status == PDKIM_VERIFY_NONE)
       sig->verify_status = PDKIM_VERIFY_PASS;
@@ -2102,9 +1857,6 @@ NEXT_VERIFY:
 	debug_printf("\n");
       }
 
-#ifdef RSA_GNUTLS
-    gnutls_pubkey_deinit(rsa);
-#endif
     free(dns_txt_name);
     free(dns_txt_reply);
     }
@@ -2178,33 +1930,15 @@ sig->bodylength = -1;
 ctx->mode = PDKIM_MODE_SIGN;
 ctx->sig = sig;
 
-ctx->sig->domain = strdup(domain);
-ctx->sig->selector = strdup(selector);
-ctx->sig->rsa_privkey = strdup(rsa_privkey);
-ctx->sig->algo = algo;
-
-if (!ctx->sig->domain || !ctx->sig->selector || !ctx->sig->rsa_privkey)
-  goto BAIL;
-
-#ifdef SHA_OPENSSL
-SHA1_Init  (&ctx->sig->sha1_body);
-SHA256_Init(&ctx->sig->sha2_body);
-
-#elif defined(SHA_GNUTLS)
-gnutls_hash_init(&ctx->sig->sha_body,
-    algo == PDKIM_ALGO_RSA_SHA1 ? GNUTLS_DIG_SHA1 : GNUTLS_DIG_SHA256);
-
-#elif defined(SHA_POLARSSL)
-if (!(ctx->sig->sha1_body = malloc(sizeof(sha1_context))))
-  goto BAIL;
-sha1_starts(ctx->sig->sha1_body);
+sig->domain = strdup(domain);
+sig->selector = strdup(selector);
+sig->rsa_privkey = strdup(rsa_privkey);
+sig->algo = algo;
 
-if (!(ctx->sig->sha2_body = malloc(sizeof(sha2_context))))
+if (!sig->domain || !sig->selector || !sig->rsa_privkey)
   goto BAIL;
-sha2_starts(ctx->sig->sha2_body, 0);
-
-#endif
 
+exim_sha_init(&sig->body_hash, algo == PDKIM_ALGO_RSA_SHA1);
 return ctx;
 
 BAIL:
@@ -2225,22 +1959,32 @@ pdkim_set_optional(pdkim_ctx *ctx,
                        unsigned long created,
                        unsigned long expires)
 {
+pdkim_signature * sig = ctx->sig;
+
 if (identity)
-  if (!(ctx->sig->identity = strdup(identity)))
+  if (!(sig->identity = strdup(identity)))
     return PDKIM_ERR_OOM;
 
-if (sign_headers)
-  if (!(ctx->sig->sign_headers = strdup(sign_headers)))
-    return PDKIM_ERR_OOM;
+if (!(sig->sign_headers = strdup(sign_headers
+	? sign_headers : PDKIM_DEFAULT_SIGN_HEADERS)))
+  return PDKIM_ERR_OOM;
 
-ctx->sig->canon_headers = canon_headers;
-ctx->sig->canon_body = canon_body;
-ctx->sig->bodylength = bodylength;
-ctx->sig->created = created;
-ctx->sig->expires = expires;
+sig->canon_headers = canon_headers;
+sig->canon_body = canon_body;
+sig->bodylength = bodylength;
+sig->created = created;
+sig->expires = expires;
 
 return PDKIM_OK;
 }
 
 
+void
+pdkim_init(void)
+{
+exim_rsa_init();
+}
+
+
+
 #endif	/*DISABLE_DKIM*/