X-Git-Url: https://vcs.fsf.org/?p=exim.git;a=blobdiff_plain;f=src%2Fsrc%2Fpdkim%2Fpdkim.c;h=4f0da3f7120eac1711de68c0bca745c44a1ff293;hp=de54c4a48f54e3e6ce9c32f594dde660fb5859a9;hb=a3c1395faebdb088bcef9cdb55bb42a791433ccd;hpb=67932e542eb65f681779f5d49974afe8369a9b9a

diff --git a/src/src/pdkim/pdkim.c b/src/src/pdkim/pdkim.c
index de54c4a48..4f0da3f71 100644
--- a/src/src/pdkim/pdkim.c
+++ b/src/src/pdkim/pdkim.c
@@ -1,7 +1,7 @@
 /*
  *  PDKIM - a RFC4871 (DKIM) implementation
  *
- *  Copyright (C) 2009  Tom Kistner <tom@duncanthrax.net>
+ *  Copyright (C) 2009 - 2012  Tom Kistner <tom@duncanthrax.net>
  *
  *  http://duncanthrax.net/pdkim/
  *
@@ -20,8 +20,6 @@
  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-/* $Cambridge: exim/src/src/pdkim/pdkim.c,v 1.12 2009/12/07 13:05:07 tom Exp $ */
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -53,6 +51,7 @@
 /* -------------------------------------------------------------------------- */
 struct pdkim_stringlist {
   char *value;
+  int  tag;
   void *next;
 };
 
@@ -65,32 +64,32 @@ struct pdkim_str {
 
 /* -------------------------------------------------------------------------- */
 /* A bunch of list constants */
-char *pdkim_querymethods[] = {
+const char *pdkim_querymethods[] = {
   "dns/txt",
   NULL
 };
-char *pdkim_algos[] = {
+const char *pdkim_algos[] = {
   "rsa-sha256",
   "rsa-sha1",
   NULL
 };
-char *pdkim_canons[] = {
+const char *pdkim_canons[] = {
   "simple",
   "relaxed",
   NULL
 };
-char *pdkim_hashes[] = {
+const char *pdkim_hashes[] = {
   "sha256",
   "sha1",
   NULL
 };
-char *pdkim_keytypes[] = {
+const char *pdkim_keytypes[] = {
   "rsa",
   NULL
 };
 
 typedef struct pdkim_combined_canon_entry {
-  char *str;
+  const char *str;
   int canon_headers;
   int canon_body;
 } pdkim_combined_canon_entry;
@@ -105,7 +104,7 @@ pdkim_combined_canon_entry pdkim_combined_canons[] = {
 };
 
 
-char *pdkim_verify_status_str(int status) {
+const char *pdkim_verify_status_str(int status) {
   switch(status) {
     case PDKIM_VERIFY_NONE:    return "PDKIM_VERIFY_NONE";
     case PDKIM_VERIFY_INVALID: return "PDKIM_VERIFY_INVALID";
@@ -114,7 +113,7 @@ char *pdkim_verify_status_str(int status) {
     default:                   return "PDKIM_VERIFY_UNKNOWN";
   }
 }
-char *pdkim_verify_ext_status_str(int ext_status) {
+const char *pdkim_verify_ext_status_str(int ext_status) {
   switch(ext_status) {
     case PDKIM_VERIFY_FAIL_BODY: return "PDKIM_VERIFY_FAIL_BODY";
     case PDKIM_VERIFY_FAIL_MESSAGE: return "PDKIM_VERIFY_FAIL_MESSAGE";
@@ -129,12 +128,12 @@ char *pdkim_verify_ext_status_str(int ext_status) {
 /* -------------------------------------------------------------------------- */
 /* Print debugging functions */
 #ifdef PDKIM_DEBUG
-void pdkim_quoteprint(FILE *stream, char *data, int len, int lf) {
+void pdkim_quoteprint(FILE *stream, const char *data, int len, int lf) {
   int i;
-  unsigned char *p = (unsigned char *)data;
+  const unsigned char *p = (const unsigned char *)data;
 
   for (i=0;i<len;i++) {
-    int c = p[i];
+    const int c = p[i];
     switch (c) {
       case ' ' : fprintf(stream,"{SP}"); break;
       case '\t': fprintf(stream,"{TB}"); break;
@@ -153,12 +152,12 @@ void pdkim_quoteprint(FILE *stream, char *data, int len, int lf) {
   if (lf)
     fputc('\n',stream);
 }
-void pdkim_hexprint(FILE *stream, char *data, int len, int lf) {
+void pdkim_hexprint(FILE *stream, const char *data, int len, int lf) {
   int i;
-  unsigned char *p = (unsigned char *)data;
+  const unsigned char *p = (const unsigned char *)data;
 
   for (i=0;i<len;i++) {
-    int c = p[i];
+    const int c = p[i];
     fprintf(stream,"%02x",c);
   }
   if (lf)
@@ -198,7 +197,7 @@ pdkim_stringlist *pdkim_prepend_stringlist(pdkim_stringlist *base, char *str) {
 
 /* -------------------------------------------------------------------------- */
 /* A small "growing string" implementation to escape malloc/realloc hell */
-pdkim_str *pdkim_strnew (char *cstr) {
+pdkim_str *pdkim_strnew (const char *cstr) {
   unsigned int len = cstr?strlen(cstr):0;
   pdkim_str *p = malloc(sizeof(pdkim_str));
   if (p == NULL) return NULL;
@@ -211,9 +210,10 @@ pdkim_str *pdkim_strnew (char *cstr) {
   p->allocated=(len+1);
   p->len=len;
   if (cstr) strcpy(p->str,cstr);
+  else p->str[p->len] = '\0';
   return p;
 }
-char *pdkim_strncat(pdkim_str *str, char *data, int len) {
+char *pdkim_strncat(pdkim_str *str, const char *data, int len) {
   if ((str->allocated - str->len) < (len+1)) {
     /* Extend the buffer */
     int num_frags = ((len+1)/PDKIM_STR_ALLOC_FRAG)+1;
@@ -228,7 +228,7 @@ char *pdkim_strncat(pdkim_str *str, char *data, int len) {
   str->str[str->len] = '\0';
   return str->str;
 }
-char *pdkim_strcat(pdkim_str *str, char *cstr) {
+char *pdkim_strcat(pdkim_str *str, const char *cstr) {
   return pdkim_strncat(str, cstr, strlen(cstr));
 }
 char *pdkim_numcat(pdkim_str *str, unsigned long num) {
@@ -302,7 +302,6 @@ void pdkim_free_sig(pdkim_signature *sig) {
     if (sig->signature_header != NULL) free(sig->signature_header);
     if (sig->sha1_body        != NULL) free(sig->sha1_body);
     if (sig->sha2_body        != NULL) free(sig->sha2_body);
-    if (sig->hnames_check     != NULL) free(sig->hnames_check);
 
     if (sig->pubkey != NULL) pdkim_free_pubkey(sig->pubkey);
 
@@ -315,6 +314,13 @@ void pdkim_free_sig(pdkim_signature *sig) {
 /* -------------------------------------------------------------------------- */
 DLLEXPORT void pdkim_free_ctx(pdkim_ctx *ctx) {
   if (ctx) {
+    pdkim_stringlist *e = ctx->headers;
+    while(e != NULL) {
+      pdkim_stringlist *c = e;
+      if (e->value != NULL) free(e->value);
+      e = e->next;
+      free(c);
+    }
     pdkim_free_sig(ctx->sig);
     pdkim_strfree(ctx->cur_header);
     free(ctx);
@@ -327,9 +333,9 @@ DLLEXPORT void pdkim_free_ctx(pdkim_ctx *ctx) {
    the passed colon-separated "list", starting at entry
    "start". Returns the position of the header name in
    the list. */
-int header_name_match(char *header,
-                      char *tick,
-                      int   do_tick) {
+int header_name_match(const char *header,
+                      char       *tick,
+                      int         do_tick) {
   char *hname;
   char *lcopy;
   char *p;
@@ -419,6 +425,7 @@ char *pdkim_relax_header (char *header, int crlf) {
     p++;
     q++;
   }
+  if ((q>relaxed) && (*(q-1) == ' ')) q--; /* Squash eventual trailing SP */
   *q = '\0';
   if (crlf) strcat(relaxed,"\r\n");
   return relaxed;
@@ -701,9 +708,6 @@ pdkim_signature *pdkim_parse_sig_header(pdkim_ctx *ctx, char *raw_hdr) {
     return NULL;
   }
 
-  /* Copy header list to 'tick-off' header list */
-  sig->hnames_check = strdup(sig->headernames);
-
   *q = '\0';
   /* Chomp raw header. The final newline must not be added to the signature. */
   q--;
@@ -863,7 +867,7 @@ pdkim_pubkey *pdkim_parse_pubkey_record(pdkim_ctx *ctx, char *raw_record) {
 
 
 /* -------------------------------------------------------------------------- */
-int pdkim_update_bodyhash(pdkim_ctx *ctx, char *data, int len) {
+int 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;
@@ -872,14 +876,14 @@ int pdkim_update_bodyhash(pdkim_ctx *ctx, char *data, int len) {
   /* Traverse all signatures, updating their hashes. */
   while (sig != NULL) {
     /* Defaults to simple canon (no further treatment necessary) */
-    char *canon_data = data;
-    int   canon_len = len;
+    const char *canon_data = data;
+    int         canon_len = len;
 
     if (sig->canon_body == PDKIM_CANON_RELAXED) {
       /* Relax the line if not done already */
       if (relaxed_data == NULL) {
         int seen_wsp = 0;
-        char *p = data;
+        const char *p = data;
         int q = 0;
         relaxed_data = malloc(len+1);
         if (relaxed_data == NULL) return PDKIM_ERR_OOM;
@@ -1062,65 +1066,69 @@ int pdkim_header_complete(pdkim_ctx *ctx) {
   ctx->num_headers++;
   if (ctx->num_headers > PDKIM_MAX_HEADERS) goto BAIL;
 
-  /* Traverse all signatures */
-  while (sig != NULL) {
-    pdkim_stringlist *list;
+  /* SIGNING -------------------------------------------------------------- */
+  if (ctx->mode == PDKIM_MODE_SIGN) {
+    /* Traverse all signatures */
+    while (sig != NULL) {
+      pdkim_stringlist *list;
 
-    /* SIGNING -------------------------------------------------------------- */
-    if (ctx->mode == PDKIM_MODE_SIGN) {
       if (header_name_match(ctx->cur_header->str,
                             sig->sign_headers?
                               sig->sign_headers:
                               PDKIM_DEFAULT_SIGN_HEADERS, 0) != PDKIM_OK) goto NEXT_SIG;
-    }
-    /* VERIFICATION --------------------------------------------------------- */
-    else {
-      /* Header is not included or all instances were already 'ticked off' */
-      if (header_name_match(ctx->cur_header->str,
-                            sig->hnames_check, 1) != PDKIM_OK) goto NEXT_SIG;
-    }
-
-    /* Add header to the signed headers list (in reverse order) */
-    list = pdkim_prepend_stringlist(sig->headers,
-                                    ctx->cur_header->str);
-    if (list == NULL) return PDKIM_ERR_OOM;
-    sig->headers = list;
 
-    NEXT_SIG:
-    sig = sig->next;
+      /* Add header to the signed headers list (in reverse order) */
+      list = pdkim_prepend_stringlist(sig->headers,
+                                      ctx->cur_header->str);
+      if (list == NULL) return PDKIM_ERR_OOM;
+      sig->headers = list;
+  
+      NEXT_SIG:
+      sig = sig->next;
+    }
   }
 
   /* DKIM-Signature: headers are added to the verification list */
-  if ( (ctx->mode == PDKIM_MODE_VERIFY) &&
-       (strncasecmp(ctx->cur_header->str,
+  if (ctx->mode == PDKIM_MODE_VERIFY) {
+    if (strncasecmp(ctx->cur_header->str,
                     DKIM_SIGNATURE_HEADERNAME,
-                    strlen(DKIM_SIGNATURE_HEADERNAME)) == 0) ) {
-     pdkim_signature *new_sig;
-    /* Create and chain new signature block */
-    #ifdef PDKIM_DEBUG
-    if (ctx->debug_stream)
-      fprintf(ctx->debug_stream,
-        "PDKIM >> Found sig, trying to parse >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
-    #endif
-    new_sig = pdkim_parse_sig_header(ctx, ctx->cur_header->str);
-    if (new_sig != NULL) {
-      pdkim_signature *last_sig = ctx->sig;
-      if (last_sig == NULL) {
-        ctx->sig = new_sig;
+                    strlen(DKIM_SIGNATURE_HEADERNAME)) == 0) {
+      pdkim_signature *new_sig;
+      /* Create and chain new signature block */
+      #ifdef PDKIM_DEBUG
+      if (ctx->debug_stream)
+        fprintf(ctx->debug_stream,
+          "PDKIM >> Found sig, trying to parse >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+      #endif
+      new_sig = pdkim_parse_sig_header(ctx, ctx->cur_header->str);
+      if (new_sig != NULL) {
+        pdkim_signature *last_sig = ctx->sig;
+        if (last_sig == NULL) {
+          ctx->sig = new_sig;
+        }
+        else {
+          while (last_sig->next != NULL) { last_sig = last_sig->next; }
+          last_sig->next = new_sig;
+        }
       }
       else {
-        while (last_sig->next != NULL) { last_sig = last_sig->next; }
-        last_sig->next = new_sig;
+        #ifdef PDKIM_DEBUG
+        if (ctx->debug_stream) {
+          fprintf(ctx->debug_stream,"Error while parsing signature header\n");
+          fprintf(ctx->debug_stream,
+            "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
+        }
+        #endif
       }
     }
+    /* every other header is stored for signature verification */
     else {
-      #ifdef PDKIM_DEBUG
-      if (ctx->debug_stream) {
-        fprintf(ctx->debug_stream,"Error while parsing signature header\n");
-        fprintf(ctx->debug_stream,
-          "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
-      }
-      #endif
+      pdkim_stringlist *list;
+
+      list = pdkim_prepend_stringlist(ctx->headers,
+                                      ctx->cur_header->str);
+      if (list == NULL) return PDKIM_ERR_OOM;
+      ctx->headers = list;
     }
   }
 
@@ -1304,7 +1312,7 @@ DLLEXPORT int pdkim_feed_finish(pdkim_ctx *ctx, pdkim_signature **return_signatu
     #ifdef PDKIM_DEBUG
     if (ctx->debug_stream)
       fprintf(ctx->debug_stream,
-        "\nPDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
+        "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
     #endif
   }
 
@@ -1375,14 +1383,23 @@ DLLEXPORT int pdkim_feed_finish(pdkim_ctx *ctx, pdkim_signature **return_signatu
       char *b = strdup(sig->headernames);
       char *p = b;
       char *q = NULL;
+      pdkim_stringlist *hdrs = ctx->headers;
+
       if (b == NULL) return PDKIM_ERR_OOM;
 
+      /* clear tags */
+      while (hdrs != NULL) {
+        hdrs->tag = 0;
+        hdrs = hdrs->next;
+      }
+
       while(1) {
-        pdkim_stringlist *hdrs = sig->headers;
+        hdrs = ctx->headers;
         q = strchr(p,':');
         if (q != NULL) *q = '\0';
         while (hdrs != NULL) {
-          if ( (strncasecmp(hdrs->value,p,strlen(p)) == 0) &&
+          if ( (hdrs->tag == 0) &&
+               (strncasecmp(hdrs->value,p,strlen(p)) == 0) &&
                ((hdrs->value)[strlen(p)] == ':') ) {
             char *rh = NULL;
             if (sig->canon_headers == PDKIM_CANON_RELAXED)
@@ -1400,7 +1417,7 @@ DLLEXPORT int pdkim_feed_finish(pdkim_ctx *ctx, pdkim_signature **return_signatu
               pdkim_quoteprint(ctx->debug_stream, rh, strlen(rh), 1);
             #endif
             free(rh);
-            (hdrs->value)[0] = '_';
+            hdrs->tag = 1;
             break;
           }
           hdrs = hdrs->next;
@@ -1480,7 +1497,7 @@ DLLEXPORT int pdkim_feed_finish(pdkim_ctx *ctx, pdkim_signature **return_signatu
     if (ctx->mode == PDKIM_MODE_SIGN) {
       rsa_context rsa;
 
-      rsa_init(&rsa,RSA_PKCS_V15,0,NULL,NULL);
+      rsa_init(&rsa,RSA_PKCS_V15,0);
 
       /* Perform private key operation */
       if (rsa_parse_key(&rsa, (unsigned char *)sig->rsa_privkey,
@@ -1519,7 +1536,7 @@ DLLEXPORT int pdkim_feed_finish(pdkim_ctx *ctx, pdkim_signature **return_signatu
       rsa_context rsa;
       char *dns_txt_name, *dns_txt_reply;
 
-      rsa_init(&rsa,RSA_PKCS_V15,0,NULL,NULL);
+      rsa_init(&rsa,RSA_PKCS_V15,0);
 
       dns_txt_name  = malloc(PDKIM_DNS_TXT_MAX_NAMELEN);
       if (dns_txt_name == NULL) return PDKIM_ERR_OOM;