projects / exim.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Keep options ordered alphabetical
[exim.git] / 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 # include <gnutls/abstract.h>
43 #endif
44
45 #ifdef SHA_GNUTLS
46 # include <gnutls/crypto.h>
47 #elif defined(SHA_POLARSSL)
48 # include "polarssl/sha1.h"
49 # include "polarssl/sha2.h"
50 #endif
51
52 #include "pdkim.h"
53
54 #define PDKIM_SIGNATURE_VERSION "1"
55 #define PDKIM_PUB_RECORD_VERSION "DKIM1"
56
57 #define PDKIM_MAX_HEADER_LEN 65536
58 #define PDKIM_MAX_HEADERS 512
59 #define PDKIM_MAX_BODY_LINE_LEN 16384
60 #define PDKIM_DNS_TXT_MAX_NAMELEN 1024
61 #define PDKIM_DEFAULT_SIGN_HEADERS "From:Sender:Reply-To:Subject:Date:"\
62 "Message-ID:To:Cc:MIME-Version:Content-Type:"\
63 "Content-Transfer-Encoding:Content-ID:"\
64 "Content-Description:Resent-Date:Resent-From:"\
65 "Resent-Sender:Resent-To:Resent-Cc:"\
66 "Resent-Message-ID:In-Reply-To:References:"\
67 "List-Id:List-Help:List-Unsubscribe:"\
68 "List-Subscribe:List-Post:List-Owner:List-Archive"
69
70 /* -------------------------------------------------------------------------- */
71 struct pdkim_stringlist {
72 char *value;
73 int tag;
74 void *next;
75 };
76
77 #define PDKIM_STR_ALLOC_FRAG 256
78 struct pdkim_str {
79 char *str;
80 unsigned int len;
81 unsigned int allocated;
82 };
83
84 /* -------------------------------------------------------------------------- */
85 /* A bunch of list constants */
86 const char *pdkim_querymethods[] = {
87 "dns/txt",
88 NULL
89 };
90 const char *pdkim_algos[] = {
91 "rsa-sha256",
92 "rsa-sha1",
93 NULL
94 };
95 const char *pdkim_canons[] = {
96 "simple",
97 "relaxed",
98 NULL
99 };
100 const char *pdkim_hashes[] = {
101 "sha256",
102 "sha1",
103 NULL
104 };
105 const char *pdkim_keytypes[] = {
106 "rsa",
107 NULL
108 };
109
110 typedef struct pdkim_combined_canon_entry {
111 const char *str;
112 int canon_headers;
113 int canon_body;
114 } pdkim_combined_canon_entry;
115
116 pdkim_combined_canon_entry pdkim_combined_canons[] = {
117 { "simple/simple", PDKIM_CANON_SIMPLE, PDKIM_CANON_SIMPLE },
118 { "simple/relaxed", PDKIM_CANON_SIMPLE, PDKIM_CANON_RELAXED },
119 { "relaxed/simple", PDKIM_CANON_RELAXED, PDKIM_CANON_SIMPLE },
120 { "relaxed/relaxed", PDKIM_CANON_RELAXED, PDKIM_CANON_RELAXED },
121 { "simple", PDKIM_CANON_SIMPLE, PDKIM_CANON_SIMPLE },
122 { "relaxed", PDKIM_CANON_RELAXED, PDKIM_CANON_SIMPLE },
123 { NULL, 0, 0 }
124 };
125
126
127 /* -------------------------------------------------------------------------- */
128
129 const char *
130 pdkim_verify_status_str(int status)
131 {
132 switch(status) {
133 case PDKIM_VERIFY_NONE: return "PDKIM_VERIFY_NONE";
134 case PDKIM_VERIFY_INVALID: return "PDKIM_VERIFY_INVALID";
135 case PDKIM_VERIFY_FAIL: return "PDKIM_VERIFY_FAIL";
136 case PDKIM_VERIFY_PASS: return "PDKIM_VERIFY_PASS";
137 default: return "PDKIM_VERIFY_UNKNOWN";
138 }
139 }
140
141 const char *
142 pdkim_verify_ext_status_str(int ext_status)
143 {
144 switch(ext_status) {
145 case PDKIM_VERIFY_FAIL_BODY: return "PDKIM_VERIFY_FAIL_BODY";
146 case PDKIM_VERIFY_FAIL_MESSAGE: return "PDKIM_VERIFY_FAIL_MESSAGE";
147 case PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE: return "PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE";
148 case PDKIM_VERIFY_INVALID_BUFFER_SIZE: return "PDKIM_VERIFY_INVALID_BUFFER_SIZE";
149 case PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD: return "PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD";
150 case PDKIM_VERIFY_INVALID_PUBKEY_IMPORT: return "PDKIM_VERIFY_INVALID_PUBKEY_IMPORT";
151 default: return "PDKIM_VERIFY_UNKNOWN";
152 }
153 }
154
155
156 /* -------------------------------------------------------------------------- */
157 /* Print debugging functions */
158 void
159 pdkim_quoteprint(const char *data, int len, int lf)
160 {
161 int i;
162 const unsigned char *p = (const unsigned char *)data;
163
164 for (i = 0; i < len; i++)
165 {
166 const int c = p[i];
167 switch (c)
168 {
169 case ' ' : debug_printf("{SP}"); break;
170 case '\t': debug_printf("{TB}"); break;
171 case '\r': debug_printf("{CR}"); break;
172 case '\n': debug_printf("{LF}"); break;
173 case '{' : debug_printf("{BO}"); break;
174 case '}' : debug_printf("{BC}"); break;
175 default:
176 if ( (c < 32) || (c > 127) )
177 debug_printf("{%02x}", c);
178 else
179 debug_printf("%c", c);
180 break;
181 }
182 }
183 if (lf)
184 debug_printf("\n");
185 }
186
187 void
188 pdkim_hexprint(const char *data, int len, int lf)
189 {
190 int i;
191 const unsigned char *p = (const unsigned char *)data;
192
193 for (i = 0 ; i < len; i++)
194 debug_printf("%02x", p[i]);
195 if (lf)
196 debug_printf("\n");
197 }
198
199
200
201 /* String package: should be replaced by Exim standard ones */
202
203 static pdkim_stringlist *
204 pdkim_prepend_stringlist(pdkim_stringlist *base, char *str)
205 {
206 pdkim_stringlist *new_entry = malloc(sizeof(pdkim_stringlist));
207
208 if (!new_entry) return NULL;
209 memset(new_entry, 0, sizeof(pdkim_stringlist));
210 if (!(new_entry->value = strdup(str))) return NULL;
211 if (base)
212 {
213 pdkim_stringlist *last = base;
214 while (last->next != NULL) { last = last->next; }
215 last->next = new_entry;
216 return base;
217 }
218 else
219 return new_entry;
220 }
221
222
223 /* -------------------------------------------------------------------------- */
224 /* A small "growing string" implementation to escape malloc/realloc hell */
225
226 static pdkim_str *
227 pdkim_strnew (const char *cstr)
228 {
229 unsigned int len = cstr ? strlen(cstr) : 0;
230 pdkim_str *p = malloc(sizeof(pdkim_str));
231
232 if (!p) return NULL;
233 memset(p, 0, sizeof(pdkim_str));
234 if (!(p->str = malloc(len+1)))
235 {
236 free(p);
237 return NULL;
238 }
239 p->allocated = len+1;
240 p->len = len;
241 if (cstr)
242 strcpy(p->str, cstr);
243 else
244 p->str[p->len] = '\0';
245 return p;
246 }
247
248 static char *
249 pdkim_strncat(pdkim_str *str, const char *data, int len)
250 {
251 if ((str->allocated - str->len) < (len+1))
252 {
253 /* Extend the buffer */
254 int num_frags = ((len+1)/PDKIM_STR_ALLOC_FRAG)+1;
255 char *n = realloc(str->str,
256 (str->allocated+(num_frags*PDKIM_STR_ALLOC_FRAG)));
257 if (n == NULL) return NULL;
258 str->str = n;
259 str->allocated += (num_frags*PDKIM_STR_ALLOC_FRAG);
260 }
261 strncpy(&(str->str[str->len]), data, len);
262 str->len += len;
263 str->str[str->len] = '\0';
264 return str->str;
265 }
266
267 static char *
268 pdkim_strcat(pdkim_str *str, const char *cstr)
269 {
270 return pdkim_strncat(str, cstr, strlen(cstr));
271 }
272
273 static char *
274 pdkim_strtrim(pdkim_str *str)
275 {
276 char *p = str->str;
277 char *q = str->str;
278 while ( (*p != '\0') && ((*p == '\t') || (*p == ' ')) ) p++;
279 while (*p != '\0') {*q = *p; q++; p++;}
280 *q = '\0';
281 while ( (q != str->str) && ( (*q == '\0') || (*q == '\t') || (*q == ' ') ) )
282 {
283 *q = '\0';
284 q--;
285 }
286 str->len = strlen(str->str);
287 return str->str;
288 }
289
290 static char *
291 pdkim_strclear(pdkim_str *str)
292 {
293 str->str[0] = '\0';
294 str->len = 0;
295 return str->str;
296 }
297
298 static void
299 pdkim_strfree(pdkim_str *str)
300 {
301 if (!str) return;
302 if (str->str) free(str->str);
303 free(str);
304 }
305
306
307
308 /* -------------------------------------------------------------------------- */
309
310 static void
311 pdkim_free_pubkey(pdkim_pubkey *pub)
312 {
313 if (pub)
314 {
315 if (pub->version ) free(pub->version);
316 if (pub->granularity) free(pub->granularity);
317 if (pub->hashes ) free(pub->hashes);
318 if (pub->keytype ) free(pub->keytype);
319 if (pub->srvtype ) free(pub->srvtype);
320 if (pub->notes ) free(pub->notes);
321 /* if (pub->key ) free(pub->key); */
322 free(pub);
323 }
324 }
325
326
327 /* -------------------------------------------------------------------------- */
328
329 static void
330 pdkim_free_sig(pdkim_signature *sig)
331 {
332 if (sig)
333 {
334 pdkim_signature *next = (pdkim_signature *)sig->next;
335
336 pdkim_stringlist *e = sig->headers;
337 while(e)
338 {
339 pdkim_stringlist *c = e;
340 if (e->value) free(e->value);
341 e = e->next;
342 free(c);
343 }
344
345 if (sig->selector ) free(sig->selector);
346 if (sig->domain ) free(sig->domain);
347 if (sig->identity ) free(sig->identity);
348 if (sig->headernames ) free(sig->headernames);
349 if (sig->copiedheaders ) free(sig->copiedheaders);
350 if (sig->rsa_privkey ) free(sig->rsa_privkey);
351 if (sig->sign_headers ) free(sig->sign_headers);
352 if (sig->signature_header) free(sig->signature_header);
353
354 if (sig->pubkey) pdkim_free_pubkey(sig->pubkey);
355
356 free(sig);
357 if (next) pdkim_free_sig(next);
358 }
359 }
360
361
362 /* -------------------------------------------------------------------------- */
363
364 DLLEXPORT void
365 pdkim_free_ctx(pdkim_ctx *ctx)
366 {
367 if (ctx)
368 {
369 pdkim_stringlist *e = ctx->headers;
370 while(e)
371 {
372 pdkim_stringlist *c = e;
373 if (e->value) free(e->value);
374 e = e->next;
375 free(c);
376 }
377 pdkim_free_sig(ctx->sig);
378 pdkim_strfree(ctx->cur_header);
379 free(ctx);
380 }
381 }
382
383
384 /* -------------------------------------------------------------------------- */
385 /* Matches the name of the passed raw "header" against
386 the passed colon-separated "list", starting at entry
387 "start". Returns the position of the header name in
388 the list. */
389
390 static int
391 header_name_match(const char *header,
392 char *tick,
393 int do_tick)
394 {
395 char *hname;
396 char *lcopy;
397 char *p;
398 char *q;
399 int rc = PDKIM_FAIL;
400
401 /* Get header name */
402 char *hcolon = strchr(header, ':');
403
404 if (!hcolon) return rc; /* This isn't a header */
405
406 if (!(hname = malloc((hcolon-header)+1)))
407 return PDKIM_ERR_OOM;
408 memset(hname, 0, (hcolon-header)+1);
409 strncpy(hname, header, (hcolon-header));
410
411 /* Copy tick-off list locally, so we can punch zeroes into it */
412 if (!(lcopy = strdup(tick)))
413 {
414 free(hname);
415 return PDKIM_ERR_OOM;
416 }
417 p = lcopy;
418 q = strchr(p, ':');
419 while (q)
420 {
421 *q = '\0';
422
423 if (strcasecmp(p, hname) == 0)
424 {
425 rc = PDKIM_OK;
426 /* Invalidate header name instance in tick-off list */
427 if (do_tick) tick[p-lcopy] = '_';
428 goto BAIL;
429 }
430
431 p = q+1;
432 q = strchr(p, ':');
433 }
434
435 if (strcasecmp(p, hname) == 0)
436 {
437 rc = PDKIM_OK;
438 /* Invalidate header name instance in tick-off list */
439 if (do_tick) tick[p-lcopy] = '_';
440 }
441
442 BAIL:
443 free(hname);
444 free(lcopy);
445 return rc;
446 }
447
448
449 /* -------------------------------------------------------------------------- */
450 /* Performs "relaxed" canonicalization of a header. The returned pointer needs
451 to be free()d. */
452
453 static char *
454 pdkim_relax_header (char *header, int crlf)
455 {
456 BOOL past_field_name = FALSE;
457 BOOL seen_wsp = FALSE;
458 char *p;
459 char *q;
460 char *relaxed = malloc(strlen(header)+3);
461
462 if (!relaxed) return NULL;
463
464 q = relaxed;
465 for (p = header; *p != '\0'; p++)
466 {
467 int c = *p;
468 /* Ignore CR & LF */
469 if (c == '\r' || c == '\n')
470 continue;
471 if (c == '\t' || c == ' ')
472 {
473 if (seen_wsp)
474 continue;
475 c = ' '; /* Turns WSP into SP */
476 seen_wsp = TRUE;
477 }
478 else
479 if (!past_field_name && c == ':')
480 {
481 if (seen_wsp) q--; /* This removes WSP before the colon */
482 seen_wsp = TRUE; /* This removes WSP after the colon */
483 past_field_name = TRUE;
484 }
485 else
486 seen_wsp = FALSE;
487
488 /* Lowercase header name */
489 if (!past_field_name) c = tolower(c);
490 *q++ = c;
491 }
492
493 if (q > relaxed && q[-1] == ' ') q--; /* Squash eventual trailing SP */
494 *q = '\0';
495
496 if (crlf) strcat(relaxed, "\r\n");
497 return relaxed;
498 }
499
500
501 /* -------------------------------------------------------------------------- */
502 #define PDKIM_QP_ERROR_DECODE -1
503
504 static char *
505 pdkim_decode_qp_char(char *qp_p, int *c)
506 {
507 char *initial_pos = qp_p;
508
509 /* Advance one char */
510 qp_p++;
511
512 /* Check for two hex digits and decode them */
513 if (isxdigit(*qp_p) && isxdigit(qp_p[1]))
514 {
515 /* Do hex conversion */
516 *c = (isdigit(*qp_p) ? *qp_p - '0' : toupper(*qp_p) - 'A' + 10) << 4;
517 *c |= isdigit(qp_p[1]) ? qp_p[1] - '0' : toupper(qp_p[1]) - 'A' + 10;
518 return qp_p + 2;
519 }
520
521 /* Illegal char here */
522 *c = PDKIM_QP_ERROR_DECODE;
523 return initial_pos;
524 }
525
526
527 /* -------------------------------------------------------------------------- */
528
529 static char *
530 pdkim_decode_qp(char *str)
531 {
532 int nchar = 0;
533 char *q;
534 char *p = str;
535 char *n = malloc(strlen(p)+1);
536
537 if (!n) return NULL;
538
539 *n = '\0';
540 q = n;
541 while (*p != '\0')
542 {
543 if (*p == '=')
544 {
545 p = pdkim_decode_qp_char(p, &nchar);
546 if (nchar >= 0)
547 {
548 *q++ = nchar;
549 continue;
550 }
551 }
552 else
553 *q++ = *p;
554 p++;
555 }
556 *q = '\0';
557 return n;
558 }
559
560
561 /* -------------------------------------------------------------------------- */
562
563 static char *
564 pdkim_decode_base64(char *str, int *num_decoded)
565 {
566 int dlen = 0;
567 char *res;
568 int old_pool = store_pool;
569
570 /* There is a store-reset between header & body reception
571 so cannot use the main pool */
572
573 store_pool = POOL_PERM;
574 dlen = b64decode(US str, USS &res);
575 store_pool = old_pool;
576
577 if (dlen < 0) return NULL;
578
579 if (num_decoded) *num_decoded = dlen;
580 return res;
581 }
582
583
584 /* -------------------------------------------------------------------------- */
585
586 static char *
587 pdkim_encode_base64(char *str, int num)
588 {
589 char * ret;
590 int old_pool = store_pool;
591
592 store_pool = POOL_PERM;
593 ret = CS b64encode(US str, num);
594 store_pool = old_pool;
595 return ret;
596 }
597
598
599 /* -------------------------------------------------------------------------- */
600 #define PDKIM_HDR_LIMBO 0
601 #define PDKIM_HDR_TAG 1
602 #define PDKIM_HDR_VALUE 2
603
604 static pdkim_signature *
605 pdkim_parse_sig_header(pdkim_ctx *ctx, char *raw_hdr)
606 {
607 pdkim_signature *sig ;
608 char *p, *q;
609 pdkim_str *cur_tag = NULL;
610 pdkim_str *cur_val = NULL;
611 BOOL past_hname = FALSE;
612 BOOL in_b_val = FALSE;
613 int where = PDKIM_HDR_LIMBO;
614 int i;
615
616 if (!(sig = malloc(sizeof(pdkim_signature)))) return NULL;
617 memset(sig, 0, sizeof(pdkim_signature));
618 sig->bodylength = -1;
619
620 if (!(sig->rawsig_no_b_val = malloc(strlen(raw_hdr)+1)))
621 {
622 free(sig);
623 return NULL;
624 }
625
626 q = sig->rawsig_no_b_val;
627
628 for (p = raw_hdr; ; p++)
629 {
630 char c = *p;
631
632 /* Ignore FWS */
633 if (c == '\r' || c == '\n')
634 goto NEXT_CHAR;
635
636 /* Fast-forward through header name */
637 if (!past_hname)
638 {
639 if (c == ':') past_hname = TRUE;
640 goto NEXT_CHAR;
641 }
642
643 if (where == PDKIM_HDR_LIMBO)
644 {
645 /* In limbo, just wait for a tag-char to appear */
646 if (!(c >= 'a' && c <= 'z'))
647 goto NEXT_CHAR;
648
649 where = PDKIM_HDR_TAG;
650 }
651
652 if (where == PDKIM_HDR_TAG)
653 {
654 if (!cur_tag)
655 cur_tag = pdkim_strnew(NULL);
656
657 if (c >= 'a' && c <= 'z')
658 pdkim_strncat(cur_tag, p, 1);
659
660 if (c == '=')
661 {
662 if (strcmp(cur_tag->str, "b") == 0)
663 {
664 *q = '='; q++;
665 in_b_val = TRUE;
666 }
667 where = PDKIM_HDR_VALUE;
668 goto NEXT_CHAR;
669 }
670 }
671
672 if (where == PDKIM_HDR_VALUE)
673 {
674 if (!cur_val)
675 cur_val = pdkim_strnew(NULL);
676
677 if (c == '\r' || c == '\n' || c == ' ' || c == '\t')
678 goto NEXT_CHAR;
679
680 if (c == ';' || c == '\0')
681 {
682 if (cur_tag->len > 0)
683 {
684 pdkim_strtrim(cur_val);
685
686 DEBUG(D_acl) debug_printf(" %s=%s\n", cur_tag->str, cur_val->str);
687
688 switch (cur_tag->str[0])
689 {
690 case 'b':
691 if (cur_tag->str[1] == 'h')
692 sig->bodyhash = pdkim_decode_base64(cur_val->str,
693 &sig->bodyhash_len);
694 else
695 sig->sigdata = pdkim_decode_base64(cur_val->str,
696 &sig->sigdata_len);
697 break;
698 case 'v':
699 /* We only support version 1, and that is currently the
700 only version there is. */
701 if (strcmp(cur_val->str, PDKIM_SIGNATURE_VERSION) == 0)
702 sig->version = 1;
703 break;
704 case 'a':
705 for (i = 0; pdkim_algos[i]; i++)
706 if (strcmp(cur_val->str, pdkim_algos[i]) == 0)
707 {
708 sig->algo = i;
709 break;
710 }
711 break;
712 case 'c':
713 for (i = 0; pdkim_combined_canons[i].str; i++)
714 if (strcmp(cur_val->str, pdkim_combined_canons[i].str) == 0)
715 {
716 sig->canon_headers = pdkim_combined_canons[i].canon_headers;
717 sig->canon_body = pdkim_combined_canons[i].canon_body;
718 break;
719 }
720 break;
721 case 'q':
722 for (i = 0; pdkim_querymethods[i]; i++)
723 if (strcmp(cur_val->str, pdkim_querymethods[i]) == 0)
724 {
725 sig->querymethod = i;
726 break;
727 }
728 break;
729 case 's':
730 sig->selector = strdup(cur_val->str); break;
731 case 'd':
732 sig->domain = strdup(cur_val->str); break;
733 case 'i':
734 sig->identity = pdkim_decode_qp(cur_val->str); break;
735 case 't':
736 sig->created = strtoul(cur_val->str, NULL, 10); break;
737 case 'x':
738 sig->expires = strtoul(cur_val->str, NULL, 10); break;
739 case 'l':
740 sig->bodylength = strtol(cur_val->str, NULL, 10); break;
741 case 'h':
742 sig->headernames = strdup(cur_val->str); break;
743 case 'z':
744 sig->copiedheaders = pdkim_decode_qp(cur_val->str); break;
745 default:
746 DEBUG(D_acl) debug_printf(" Unknown tag encountered\n");
747 break;
748 }
749 }
750 pdkim_strclear(cur_tag);
751 pdkim_strclear(cur_val);
752 in_b_val = FALSE;
753 where = PDKIM_HDR_LIMBO;
754 }
755 else
756 pdkim_strncat(cur_val, p, 1);
757 }
758
759 NEXT_CHAR:
760 if (c == '\0')
761 break;
762
763 if (!in_b_val)
764 *q++ = c;
765 }
766
767 /* Make sure the most important bits are there. */
768 if (!(sig->domain && (*(sig->domain) != '\0') &&
769 sig->selector && (*(sig->selector) != '\0') &&
770 sig->headernames && (*(sig->headernames) != '\0') &&
771 sig->bodyhash &&
772 sig->sigdata &&
773 sig->version))
774 {
775 pdkim_free_sig(sig);
776 return NULL;
777 }
778
779 *q = '\0';
780 /* Chomp raw header. The final newline must not be added to the signature. */
781 q--;
782 while (q > sig->rawsig_no_b_val && (*q == '\r' || *q == '\n'))
783 *q = '\0'; q--; /*XXX questionable code layout; possible bug */
784
785 DEBUG(D_acl)
786 {
787 debug_printf(
788 "PDKIM >> Raw signature w/o b= tag value >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
789 pdkim_quoteprint(sig->rawsig_no_b_val, strlen(sig->rawsig_no_b_val), 1);
790 debug_printf(
791 "PDKIM >> Sig size: %4d bits\n", sig->sigdata_len*8);
792 debug_printf(
793 "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
794 }
795
796 #ifdef SHA_OPENSSL
797
798 SHA1_Init (&sig->sha1_body);
799 SHA256_Init(&sig->sha2_body);
800
801 #elif defined(SHA_GNUTLS)
802
803 gnutls_hash_init(&sig->sha_body,
804 sig->algo == PDKIM_ALGO_RSA_SHA1 ? GNUTLS_DIG_SHA1 : GNUTLS_DIG_SHA256);
805
806 #elif defined(SHA_POLARSSL)
807
808 if ( !(sig->sha1_body = malloc(sizeof(sha1_context)))
809 || !(sig->sha2_body = malloc(sizeof(sha2_context)))
810 )
811 {
812 pdkim_free_sig(sig);
813 return NULL;
814 }
815
816 sha1_starts(sig->sha1_body);
817 sha2_starts(sig->sha2_body, 0);
818
819 #endif /* SHA impl */
820
821 return sig;
822 }
823
824
825 /* -------------------------------------------------------------------------- */
826
827 static pdkim_pubkey *
828 pdkim_parse_pubkey_record(pdkim_ctx *ctx, char *raw_record)
829 {
830 pdkim_pubkey *pub;
831 char *p;
832 pdkim_str *cur_tag = NULL;
833 pdkim_str *cur_val = NULL;
834 int where = PDKIM_HDR_LIMBO;
835
836 if (!(pub = malloc(sizeof(pdkim_pubkey)))) return NULL;
837 memset(pub, 0, sizeof(pdkim_pubkey));
838
839 for (p = raw_record; ; p++)
840 {
841 char c = *p;
842
843 /* Ignore FWS */
844 if (c == '\r' || c == '\n')
845 goto NEXT_CHAR;
846
847 if (where == PDKIM_HDR_LIMBO)
848 {
849 /* In limbo, just wait for a tag-char to appear */
850 if (!(c >= 'a' && c <= 'z'))
851 goto NEXT_CHAR;
852
853 where = PDKIM_HDR_TAG;
854 }
855
856 if (where == PDKIM_HDR_TAG)
857 {
858 if (!cur_tag)
859 cur_tag = pdkim_strnew(NULL);
860
861 if (c >= 'a' && c <= 'z')
862 pdkim_strncat(cur_tag, p, 1);
863
864 if (c == '=')
865 {
866 where = PDKIM_HDR_VALUE;
867 goto NEXT_CHAR;
868 }
869 }
870
871 if (where == PDKIM_HDR_VALUE)
872 {
873 if (!cur_val)
874 cur_val = pdkim_strnew(NULL);
875
876 if (c == '\r' || c == '\n')
877 goto NEXT_CHAR;
878
879 if (c == ';' || c == '\0')
880 {
881 if (cur_tag->len > 0)
882 {
883 pdkim_strtrim(cur_val);
884 DEBUG(D_acl) debug_printf(" %s=%s\n", cur_tag->str, cur_val->str);
885
886 switch (cur_tag->str[0])
887 {
888 case 'v':
889 /* This tag isn't evaluated because:
890 - We only support version DKIM1.
891 - Which is the default for this value (set below)
892 - Other versions are currently not specified. */
893 break;
894 case 'h':
895 pub->hashes = strdup(cur_val->str); break;
896 case 'g':
897 pub->granularity = strdup(cur_val->str); break;
898 case 'n':
899 pub->notes = pdkim_decode_qp(cur_val->str); break;
900 case 'p':
901 pub->key = pdkim_decode_base64(cur_val->str, &(pub->key_len)); break;
902 case 'k':
903 pub->hashes = strdup(cur_val->str); break;
904 case 's':
905 pub->srvtype = strdup(cur_val->str); break;
906 case 't':
907 if (strchr(cur_val->str, 'y') != NULL) pub->testing = 1;
908 if (strchr(cur_val->str, 's') != NULL) pub->no_subdomaining = 1;
909 break;
910 default:
911 DEBUG(D_acl) debug_printf(" Unknown tag encountered\n");
912 break;
913 }
914 }
915 pdkim_strclear(cur_tag);
916 pdkim_strclear(cur_val);
917 where = PDKIM_HDR_LIMBO;
918 }
919 else
920 pdkim_strncat(cur_val, p, 1);
921 }
922
923 NEXT_CHAR:
924 if (c == '\0') break;
925 }
926
927 /* Set fallback defaults */
928 if (!pub->version ) pub->version = strdup(PDKIM_PUB_RECORD_VERSION);
929 if (!pub->granularity) pub->granularity = strdup("*");
930 if (!pub->keytype ) pub->keytype = strdup("rsa");
931 if (!pub->srvtype ) pub->srvtype = strdup("*");
932
933 /* p= is required */
934 if (pub->key)
935 return pub;
936
937 pdkim_free_pubkey(pub);
938 return NULL;
939 }
940
941
942 /* -------------------------------------------------------------------------- */
943
944 static int
945 pdkim_update_bodyhash(pdkim_ctx *ctx, const char *data, int len)
946 {
947 pdkim_signature *sig = ctx->sig;
948 /* Cache relaxed version of data */
949 char *relaxed_data = NULL;
950 int relaxed_len = 0;
951
952 /* Traverse all signatures, updating their hashes. */
953 while (sig)
954 {
955 /* Defaults to simple canon (no further treatment necessary) */
956 const char *canon_data = data;
957 int canon_len = len;
958
959 if (sig->canon_body == PDKIM_CANON_RELAXED)
960 {
961 /* Relax the line if not done already */
962 if (!relaxed_data)
963 {
964 BOOL seen_wsp = FALSE;
965 const char *p;
966 int q = 0;
967
968 if (!(relaxed_data = malloc(len+1)))
969 return PDKIM_ERR_OOM;
970
971 for (p = data; *p; p++)
972 {
973 char c = *p;
974 if (c == '\r')
975 {
976 if (q > 0 && relaxed_data[q-1] == ' ')
977 q--;
978 }
979 else if (c == '\t' || c == ' ')
980 {
981 c = ' '; /* Turns WSP into SP */
982 if (seen_wsp)
983 continue;
984 seen_wsp = TRUE;
985 }
986 else
987 seen_wsp = FALSE;
988 relaxed_data[q++] = c;
989 }
990 relaxed_data[q] = '\0';
991 relaxed_len = q;
992 }
993 canon_data = relaxed_data;
994 canon_len = relaxed_len;
995 }
996
997 /* Make sure we don't exceed the to-be-signed body length */
998 if ( sig->bodylength >= 0
999 && sig->signed_body_bytes + (unsigned long)canon_len > sig->bodylength
1000 )
1001 canon_len = sig->bodylength - sig->signed_body_bytes;
1002
1003 if (canon_len > 0)
1004 {
1005 #ifdef SHA_GNUTLS
1006 gnutls_hash(sig->sha_body, canon_data, canon_len);
1007 #else
1008 if (sig->algo == PDKIM_ALGO_RSA_SHA1)
1009 # ifdef SHA_OPENSSL
1010 SHA1_Update (&sig->sha1_body, canon_data, canon_len);
1011 else
1012 SHA256_Update(&sig->sha2_body, canon_data, canon_len);
1013 # elif defined(SHA_POLARSSL)
1014 sha1_update(sig->sha1_body, US canon_data, canon_len);
1015 else
1016 sha2_update(sig->sha2_body, US canon_data, canon_len);
1017 # endif
1018 #endif
1019
1020 sig->signed_body_bytes += canon_len;
1021 DEBUG(D_acl) pdkim_quoteprint(canon_data, canon_len, 1);
1022 }
1023
1024 sig = sig->next;
1025 }
1026
1027 if (relaxed_data) free(relaxed_data);
1028 return PDKIM_OK;
1029 }
1030
1031
1032 /* -------------------------------------------------------------------------- */
1033
1034 static int
1035 pdkim_finish_bodyhash(pdkim_ctx *ctx)
1036 {
1037 pdkim_signature *sig;
1038
1039 /* Traverse all signatures */
1040 for (sig = ctx->sig; sig; sig = sig->next)
1041 { /* Finish hashes */
1042 uschar bh[32]; /* SHA-256 = 32 Bytes, SHA-1 = 20 Bytes */
1043
1044 #ifdef SHA_GNUTLS
1045 gnutls_hash_output(sig->sha_body, bh);
1046 #else
1047 if (sig->algo == PDKIM_ALGO_RSA_SHA1)
1048 # ifdef SHA_OPENSSL
1049 SHA1_Final (bh, &sig->sha1_body);
1050 else
1051 SHA256_Final(bh, &sig->sha2_body);
1052 # elif defined(SHA_POLARSSL)
1053 sha1_finish(sig->sha1_body, bh);
1054 else
1055 sha2_finish(sig->sha2_body, bh);
1056 # endif
1057 #endif
1058
1059 DEBUG(D_acl)
1060 {
1061 debug_printf("PDKIM [%s] Body bytes hashed: %lu\n"
1062 "PDKIM [%s] bh computed: ",
1063 sig->domain, sig->signed_body_bytes, sig->domain);
1064 pdkim_hexprint((char *)bh, sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20 : 32, 1);
1065 }
1066
1067 /* SIGNING -------------------------------------------------------------- */
1068 if (ctx->mode == PDKIM_MODE_SIGN)
1069 {
1070 sig->bodyhash_len = sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20:32;
1071 sig->bodyhash = CS string_copyn(US bh, sig->bodyhash_len);
1072
1073 /* If bodylength limit is set, and we have received less bytes
1074 than the requested amount, effectively remove the limit tag. */
1075 if (sig->signed_body_bytes < sig->bodylength)
1076 sig->bodylength = -1;
1077 }
1078
1079 /* VERIFICATION --------------------------------------------------------- */
1080 else
1081 {
1082 /* Compare bodyhash */
1083 if (memcmp(bh, sig->bodyhash,
1084 (sig->algo == PDKIM_ALGO_RSA_SHA1)?20:32) == 0)
1085 {
1086 DEBUG(D_acl) debug_printf("PDKIM [%s] Body hash verified OK\n", sig->domain);
1087 }
1088 else
1089 {
1090 DEBUG(D_acl)
1091 {
1092 debug_printf("PDKIM [%s] bh signature: ", sig->domain);
1093 pdkim_hexprint(sig->bodyhash,
1094 sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20 : 32, 1);
1095 debug_printf("PDKIM [%s] Body hash did NOT verify\n", sig->domain);
1096 }
1097 sig->verify_status = PDKIM_VERIFY_FAIL;
1098 sig->verify_ext_status = PDKIM_VERIFY_FAIL_BODY;
1099 }
1100 }
1101 }
1102
1103 return PDKIM_OK;
1104 }
1105
1106
1107
1108 /* -------------------------------------------------------------------------- */
1109 /* Callback from pdkim_feed below for processing complete body lines */
1110
1111 static int
1112 pdkim_bodyline_complete(pdkim_ctx *ctx)
1113 {
1114 char *p = ctx->linebuf;
1115 int n = ctx->linebuf_offset;
1116 pdkim_signature *sig = ctx->sig; /*XXX assumes only one sig */
1117
1118 /* Ignore extra data if we've seen the end-of-data marker */
1119 if (ctx->seen_eod) goto BAIL;
1120
1121 /* We've always got one extra byte to stuff a zero ... */
1122 ctx->linebuf[ctx->linebuf_offset] = '\0';
1123
1124 /* Terminate on EOD marker */
1125 if (memcmp(p, ".\r\n", 3) == 0)
1126 {
1127 /* In simple body mode, if any empty lines were buffered,
1128 replace with one. rfc 4871 3.4.3 */
1129 /*XXX checking the signed-body-bytes is a gross hack; I think
1130 it indicates that all linebreaks should be buffered, including
1131 the one terminating a text line */
1132 if ( sig && sig->canon_body == PDKIM_CANON_SIMPLE
1133 && sig->signed_body_bytes == 0
1134 && ctx->num_buffered_crlf > 0
1135 )
1136 pdkim_update_bodyhash(ctx, "\r\n", 2);
1137
1138 ctx->seen_eod = TRUE;
1139 goto BAIL;
1140 }
1141 /* Unstuff dots */
1142 if (memcmp(p, "..", 2) == 0)
1143 {
1144 p++;
1145 n--;
1146 }
1147
1148 /* Empty lines need to be buffered until we find a non-empty line */
1149 if (memcmp(p, "\r\n", 2) == 0)
1150 {
1151 ctx->num_buffered_crlf++;
1152 goto BAIL;
1153 }
1154
1155 if (sig && sig->canon_body == PDKIM_CANON_RELAXED)
1156 {
1157 /* Lines with just spaces need to be buffered too */
1158 char *check = p;
1159 while (memcmp(check, "\r\n", 2) != 0)
1160 {
1161 char c = *check;
1162
1163 if (c != '\t' && c != ' ')
1164 goto PROCESS;
1165 check++;
1166 }
1167
1168 ctx->num_buffered_crlf++;
1169 goto BAIL;
1170 }
1171
1172 PROCESS:
1173 /* At this point, we have a non-empty line, so release the buffered ones. */
1174 while (ctx->num_buffered_crlf)
1175 {
1176 pdkim_update_bodyhash(ctx, "\r\n", 2);
1177 ctx->num_buffered_crlf--;
1178 }
1179
1180 pdkim_update_bodyhash(ctx, p, n);
1181
1182 BAIL:
1183 ctx->linebuf_offset = 0;
1184 return PDKIM_OK;
1185 }
1186
1187
1188 /* -------------------------------------------------------------------------- */
1189 /* Callback from pdkim_feed below for processing complete headers */
1190 #define DKIM_SIGNATURE_HEADERNAME "DKIM-Signature:"
1191
1192 static int
1193 pdkim_header_complete(pdkim_ctx *ctx)
1194 {
1195 /* Special case: The last header can have an extra \r appended */
1196 if ( (ctx->cur_header->len > 1) &&
1197 (ctx->cur_header->str[(ctx->cur_header->len)-1] == '\r') )
1198 {
1199 ctx->cur_header->str[(ctx->cur_header->len)-1] = '\0';
1200 ctx->cur_header->len--;
1201 }
1202
1203 ctx->num_headers++;
1204 if (ctx->num_headers > PDKIM_MAX_HEADERS) goto BAIL;
1205
1206 /* SIGNING -------------------------------------------------------------- */
1207 if (ctx->mode == PDKIM_MODE_SIGN)
1208 {
1209 pdkim_signature *sig;
1210
1211 for (sig = ctx->sig; sig; sig = sig->next) /* Traverse all signatures */
1212 if (header_name_match(ctx->cur_header->str,
1213 sig->sign_headers?
1214 sig->sign_headers:
1215 PDKIM_DEFAULT_SIGN_HEADERS, 0) == PDKIM_OK)
1216 {
1217 pdkim_stringlist *list;
1218
1219 /* Add header to the signed headers list (in reverse order) */
1220 if (!(list = pdkim_prepend_stringlist(sig->headers,
1221 ctx->cur_header->str)))
1222 return PDKIM_ERR_OOM;
1223 sig->headers = list;
1224 }
1225 }
1226
1227 /* VERIFICATION ----------------------------------------------------------- */
1228 /* DKIM-Signature: headers are added to the verification list */
1229 if (ctx->mode == PDKIM_MODE_VERIFY)
1230 {
1231 if (strncasecmp(ctx->cur_header->str,
1232 DKIM_SIGNATURE_HEADERNAME,
1233 strlen(DKIM_SIGNATURE_HEADERNAME)) == 0)
1234 {
1235 pdkim_signature *new_sig;
1236
1237 /* Create and chain new signature block */
1238 DEBUG(D_acl) debug_printf(
1239 "PDKIM >> Found sig, trying to parse >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1240
1241 if ((new_sig = pdkim_parse_sig_header(ctx, ctx->cur_header->str)))
1242 {
1243 pdkim_signature *last_sig = ctx->sig;
1244 if (!last_sig)
1245 ctx->sig = new_sig;
1246 else
1247 {
1248 while (last_sig->next) last_sig = last_sig->next;
1249 last_sig->next = new_sig;
1250 }
1251 }
1252 else
1253 DEBUG(D_acl) debug_printf(
1254 "Error while parsing signature header\n"
1255 "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1256 }
1257
1258 /* every other header is stored for signature verification */
1259 else
1260 {
1261 pdkim_stringlist *list;
1262
1263 if (!(list = pdkim_prepend_stringlist(ctx->headers, ctx->cur_header->str)))
1264 return PDKIM_ERR_OOM;
1265 ctx->headers = list;
1266 }
1267 }
1268
1269 BAIL:
1270 pdkim_strclear(ctx->cur_header); /* Re-use existing pdkim_str */
1271 return PDKIM_OK;
1272 }
1273
1274
1275
1276 /* -------------------------------------------------------------------------- */
1277 #define HEADER_BUFFER_FRAG_SIZE 256
1278
1279 DLLEXPORT int
1280 pdkim_feed (pdkim_ctx *ctx, char *data, int len)
1281 {
1282 int p;
1283
1284 for (p = 0; p<len; p++)
1285 {
1286 char c = data[p];
1287
1288 if (ctx->past_headers)
1289 {
1290 /* Processing body byte */
1291 ctx->linebuf[ctx->linebuf_offset++] = c;
1292 if (c == '\n')
1293 {
1294 int rc = pdkim_bodyline_complete(ctx); /* End of line */
1295 if (rc != PDKIM_OK) return rc;
1296 }
1297 if (ctx->linebuf_offset == (PDKIM_MAX_BODY_LINE_LEN-1))
1298 return PDKIM_ERR_LONG_LINE;
1299 }
1300 else
1301 {
1302 /* Processing header byte */
1303 if (c != '\r')
1304 {
1305 if (c == '\n')
1306 {
1307 if (ctx->seen_lf)
1308 {
1309 int rc = pdkim_header_complete(ctx); /* Seen last header line */
1310 if (rc != PDKIM_OK) return rc;
1311
1312 ctx->past_headers = TRUE;
1313 ctx->seen_lf = 0;
1314 DEBUG(D_acl) debug_printf(
1315 "PDKIM >> Hashed body data, canonicalized >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1316 continue;
1317 }
1318 else
1319 ctx->seen_lf = TRUE;
1320 }
1321 else if (ctx->seen_lf)
1322 {
1323 if (!(c == '\t' || c == ' '))
1324 {
1325 int rc = pdkim_header_complete(ctx); /* End of header */
1326 if (rc != PDKIM_OK) return rc;
1327 }
1328 ctx->seen_lf = FALSE;
1329 }
1330 }
1331
1332 if (!ctx->cur_header)
1333 if (!(ctx->cur_header = pdkim_strnew(NULL)))
1334 return PDKIM_ERR_OOM;
1335
1336 if (ctx->cur_header->len < PDKIM_MAX_HEADER_LEN)
1337 if (!pdkim_strncat(ctx->cur_header, &data[p], 1))
1338 return PDKIM_ERR_OOM;
1339 }
1340 }
1341 return PDKIM_OK;
1342 }
1343
1344 /*
1345 * RFC 5322 specifies that header line length SHOULD be no more than 78
1346 * lets make it so!
1347 * pdkim_headcat
1348 * returns char*
1349 *
1350 * col: this int holds and receives column number (octets since last '\n')
1351 * str: partial string to append to
1352 * pad: padding, split line or space after before or after eg: ";"
1353 * intro: - must join to payload eg "h=", usually the tag name
1354 * payload: eg base64 data - long data can be split arbitrarily.
1355 *
1356 * this code doesn't fold the header in some of the places that RFC4871
1357 * allows: As per RFC5322(2.2.3) it only folds before or after tag-value
1358 * pairs and inside long values. it also always spaces or breaks after the
1359 * "pad"
1360 *
1361 * no guarantees are made for output given out-of range input. like tag
1362 * names longer than 78, or bogus col. Input is assumed to be free of line breaks.
1363 */
1364
1365 static char *
1366 pdkim_headcat(int *col, pdkim_str *str, const char * pad,
1367 const char *intro, const char *payload)
1368 {
1369 size_t l;
1370
1371 if (pad)
1372 {
1373 l = strlen(pad);
1374 if (*col + l > 78)
1375 {
1376 pdkim_strcat(str, "\r\n\t");
1377 *col = 1;
1378 }
1379 pdkim_strncat(str, pad, l);
1380 *col += l;
1381 }
1382
1383 l = (pad?1:0) + (intro?strlen(intro):0);
1384
1385 if (*col + l > 78)
1386 { /*can't fit intro - start a new line to make room.*/
1387 pdkim_strcat(str, "\r\n\t");
1388 *col = 1;
1389 l = intro?strlen(intro):0;
1390 }
1391
1392 l += payload ? strlen(payload):0 ;
1393
1394 while (l>77)
1395 { /* this fragment will not fit on a single line */
1396 if (pad)
1397 {
1398 pdkim_strcat(str, " ");
1399 *col += 1;
1400 pad = NULL; /* only want this once */
1401 l--;
1402 }
1403
1404 if (intro)
1405 {
1406 size_t sl = strlen(intro);
1407
1408 pdkim_strncat(str, intro, sl);
1409 *col += sl;
1410 l -= sl;
1411 intro = NULL; /* only want this once */
1412 }
1413
1414 if (payload)
1415 {
1416 size_t sl = strlen(payload);
1417 size_t chomp = *col+sl < 77 ? sl : 78-*col;
1418
1419 pdkim_strncat(str, payload, chomp);
1420 *col += chomp;
1421 payload += chomp;
1422 l -= chomp-1;
1423 }
1424
1425 /* the while precondition tells us it didn't fit. */
1426 pdkim_strcat(str, "\r\n\t");
1427 *col = 1;
1428 }
1429
1430 if (*col + l > 78)
1431 {
1432 pdkim_strcat(str, "\r\n\t");
1433 *col = 1;
1434 pad = NULL;
1435 }
1436
1437 if (pad)
1438 {
1439 pdkim_strcat(str, " ");
1440 *col += 1;
1441 pad = NULL;
1442 }
1443
1444 if (intro)
1445 {
1446 size_t sl = strlen(intro);
1447
1448 pdkim_strncat(str, intro, sl);
1449 *col += sl;
1450 l -= sl;
1451 intro = NULL;
1452 }
1453
1454 if (payload)
1455 {
1456 size_t sl = strlen(payload);
1457
1458 pdkim_strncat(str, payload, sl);
1459 *col += sl;
1460 }
1461
1462 return str->str;
1463 }
1464
1465
1466 /* -------------------------------------------------------------------------- */
1467
1468 static char *
1469 pdkim_create_header(pdkim_signature *sig, int final)
1470 {
1471 char *rc = NULL;
1472 char *base64_bh = NULL;
1473 char *base64_b = NULL;
1474 int col = 0;
1475 pdkim_str *hdr;
1476 pdkim_str *canon_all;
1477
1478 if (!(hdr = pdkim_strnew("DKIM-Signature: v="PDKIM_SIGNATURE_VERSION)))
1479 return NULL;
1480
1481 if (!(canon_all = pdkim_strnew(pdkim_canons[sig->canon_headers])))
1482 goto BAIL;
1483
1484 if (!(base64_bh = pdkim_encode_base64(sig->bodyhash, sig->bodyhash_len)))
1485 goto BAIL;
1486
1487 col = strlen(hdr->str);
1488
1489 /* Required and static bits */
1490 if ( pdkim_headcat(&col, hdr, ";", "a=", pdkim_algos[sig->algo])
1491 && pdkim_headcat(&col, hdr, ";", "q=", pdkim_querymethods[sig->querymethod])
1492 && pdkim_strcat(canon_all, "/")
1493 && pdkim_strcat(canon_all, pdkim_canons[sig->canon_body])
1494 && pdkim_headcat(&col, hdr, ";", "c=", canon_all->str)
1495 && pdkim_headcat(&col, hdr, ";", "d=", sig->domain)
1496 && pdkim_headcat(&col, hdr, ";", "s=", sig->selector)
1497 )
1498 {
1499 /* list of eader names can be split between items. */
1500 {
1501 char *n = strdup(sig->headernames);
1502 char *f = n;
1503 char *i = "h=";
1504 char *s = ";";
1505
1506 if (!n) goto BAIL;
1507 while (*n)
1508 {
1509 char *c = strchr(n, ':');
1510
1511 if (c) *c ='\0';
1512
1513 if (!i)
1514 if (!pdkim_headcat(&col, hdr, NULL, NULL, ":"))
1515 {
1516 free(f);
1517 goto BAIL;
1518 }
1519
1520 if (!pdkim_headcat(&col, hdr, s, i, n))
1521 {
1522 free(f);
1523 goto BAIL;
1524 }
1525
1526 if (!c)
1527 break;
1528
1529 n = c+1;
1530 s = NULL;
1531 i = NULL;
1532 }
1533 free(f);
1534 }
1535
1536 if(!pdkim_headcat(&col, hdr, ";", "bh=", base64_bh))
1537 goto BAIL;
1538
1539 /* Optional bits */
1540 if (sig->identity)
1541 if(!pdkim_headcat(&col, hdr, ";", "i=", sig->identity))
1542 goto BAIL;
1543
1544 if (sig->created > 0)
1545 {
1546 char minibuf[20];
1547
1548 snprintf(minibuf, 20, "%lu", sig->created);
1549 if(!pdkim_headcat(&col, hdr, ";", "t=", minibuf))
1550 goto BAIL;
1551 }
1552
1553 if (sig->expires > 0)
1554 {
1555 char minibuf[20];
1556
1557 snprintf(minibuf, 20, "%lu", sig->expires);
1558 if(!pdkim_headcat(&col, hdr, ";", "x=", minibuf))
1559 goto BAIL;
1560 }
1561
1562 if (sig->bodylength >= 0)
1563 {
1564 char minibuf[20];
1565
1566 snprintf(minibuf, 20, "%lu", sig->bodylength);
1567 if(!pdkim_headcat(&col, hdr, ";", "l=", minibuf))
1568 goto BAIL;
1569 }
1570
1571 /* Preliminary or final version? */
1572 if (final)
1573 {
1574 if (!(base64_b = pdkim_encode_base64(sig->sigdata, sig->sigdata_len)))
1575 goto BAIL;
1576 if (!pdkim_headcat(&col, hdr, ";", "b=", base64_b))
1577 goto BAIL;
1578 }
1579 else
1580 if(!pdkim_headcat(&col, hdr, ";", "b=", ""))
1581 goto BAIL;
1582
1583 /* add trailing semicolon: I'm not sure if this is actually needed */
1584 if (!pdkim_headcat(&col, hdr, NULL, ";", ""))
1585 goto BAIL;
1586 }
1587
1588 rc = strdup(hdr->str);
1589
1590 BAIL:
1591 pdkim_strfree(hdr);
1592 if (canon_all) pdkim_strfree(canon_all);
1593 return rc;
1594 }
1595
1596
1597 /* -------------------------------------------------------------------------- */
1598
1599 DLLEXPORT int
1600 pdkim_feed_finish(pdkim_ctx *ctx, pdkim_signature **return_signatures)
1601 {
1602 pdkim_signature *sig = ctx->sig;
1603 pdkim_str *headernames = NULL; /* Collected signed header names */
1604
1605 /* Check if we must still flush a (partial) header. If that is the
1606 case, the message has no body, and we must compute a body hash
1607 out of '<CR><LF>' */
1608 if (ctx->cur_header && ctx->cur_header->len)
1609 {
1610 int rc = pdkim_header_complete(ctx);
1611 if (rc != PDKIM_OK) return rc;
1612 pdkim_update_bodyhash(ctx, "\r\n", 2);
1613 }
1614 else
1615 DEBUG(D_acl) debug_printf(
1616 "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1617
1618 /* Build (and/or evaluate) body hash */
1619 if (pdkim_finish_bodyhash(ctx) != PDKIM_OK)
1620 return PDKIM_ERR_OOM;
1621
1622 /* SIGNING -------------------------------------------------------------- */
1623 if (ctx->mode == PDKIM_MODE_SIGN)
1624 if (!(headernames = pdkim_strnew(NULL)))
1625 return PDKIM_ERR_OOM;
1626 /* ---------------------------------------------------------------------- */
1627
1628 while (sig)
1629 {
1630 #ifdef SHA_OPENSSL
1631 SHA_CTX sha1_headers;
1632 SHA256_CTX sha2_headers;
1633 #elif defined(SHA_GNUTLS)
1634 gnutls_hash_hd_t sha_headers;
1635 #elif defined(SHA_POLARSSL)
1636 sha1_context sha1_headers;
1637 sha2_context sha2_headers;
1638 #endif
1639
1640 char *sig_hdr;
1641 char headerhash[32];
1642
1643 #ifdef RSA_GNUTLS
1644 uschar * hdata = NULL;
1645 int hdata_alloc = 0;
1646 int hdata_size = 0;
1647 #endif
1648
1649 #ifdef SHA_GNUTLS
1650 gnutls_hash_init(&sha_headers,
1651 sig->algo == PDKIM_ALGO_RSA_SHA1 ? GNUTLS_DIG_SHA1 : GNUTLS_DIG_SHA256);
1652 #else
1653 if (sig->algo == PDKIM_ALGO_RSA_SHA1)
1654 # ifdef SHA_OPENSSL
1655 SHA1_Init(&sha1_headers);
1656 else
1657 SHA256_Init(&sha2_headers);
1658 # elif defined(SHA_POLARSSL)
1659 sha1_starts(&sha1_headers);
1660 else
1661 sha2_starts(&sha2_headers, 0);
1662 # endif
1663 #endif
1664
1665 DEBUG(D_acl) debug_printf(
1666 "PDKIM >> Hashed header data, canonicalized, in sequence >>>>>>>>>>>>>>\n");
1667
1668 /* SIGNING ---------------------------------------------------------------- */
1669 /* When signing, walk through our header list and add them to the hash. As we
1670 go, construct a list of the header's names to use for the h= parameter. */
1671
1672 if (ctx->mode == PDKIM_MODE_SIGN)
1673 {
1674 pdkim_stringlist *p;
1675
1676 for (p = sig->headers; p; p = p->next)
1677 {
1678 char *rh = NULL;
1679 /* Collect header names (Note: colon presence is guaranteed here) */
1680 char *q = strchr(p->value, ':');
1681
1682 if (!(pdkim_strncat(headernames, p->value,
1683 (q-(p->value)) + (p->next ? 1 : 0))))
1684 return PDKIM_ERR_OOM;
1685
1686 rh = sig->canon_headers == PDKIM_CANON_RELAXED
1687 ? pdkim_relax_header(p->value, 1) /* cook header for relaxed canon */
1688 : strdup(p->value); /* just copy it for simple canon */
1689 if (!rh)
1690 return PDKIM_ERR_OOM;
1691
1692 /* Feed header to the hash algorithm */
1693 #ifdef SHA_GNUTLS
1694 gnutls_hash(sha_headers, rh, strlen(rh));
1695 #else
1696 if (sig->algo == PDKIM_ALGO_RSA_SHA1)
1697 # ifdef SHA_OPENSSL
1698 SHA1_Update (&sha1_headers, rh, strlen(rh));
1699 else
1700 SHA256_Update(&sha2_headers, rh, strlen(rh));
1701 # elif defined(SHA_POLARSSL)
1702 sha1_update(&sha1_headers, US rh, strlen(rh));
1703 else
1704 sha2_update(&sha2_headers, US rh, strlen(rh));
1705 # endif
1706 #endif
1707
1708 #ifdef RSA_GNUTLS
1709 /* Remember headers block for signing */
1710 hdata = string_append(hdata, &hdata_alloc, &hdata_size, 1, rh);
1711 #endif
1712
1713 DEBUG(D_acl) pdkim_quoteprint(rh, strlen(rh), 1);
1714 free(rh);
1715 }
1716 }
1717
1718 /* VERIFICATION ----------------------------------------------------------- */
1719 /* When verifying, walk through the header name list in the h= parameter and
1720 add the headers to the hash in that order. */
1721 else
1722 {
1723 char *b = strdup(sig->headernames);
1724 char *p = b;
1725 char *q = NULL;
1726 pdkim_stringlist *hdrs;
1727
1728 if (!b) return PDKIM_ERR_OOM;
1729
1730 /* clear tags */
1731 for (hdrs = ctx->headers; hdrs; hdrs = hdrs->next)
1732 hdrs->tag = 0;
1733
1734 while(1)
1735 {
1736 if ((q = strchr(p, ':')))
1737 *q = '\0';
1738
1739 for (hdrs = ctx->headers; hdrs; hdrs = hdrs->next)
1740 if ( hdrs->tag == 0
1741 && strncasecmp(hdrs->value, p, strlen(p)) == 0
1742 && (hdrs->value)[strlen(p)] == ':'
1743 )
1744 {
1745 char *rh;
1746
1747 rh = sig->canon_headers == PDKIM_CANON_RELAXED
1748 ? pdkim_relax_header(hdrs->value, 1) /* cook header for relaxed canon */
1749 : strdup(hdrs->value); /* just copy it for simple canon */
1750 if (!rh)
1751 return PDKIM_ERR_OOM;
1752
1753 /* Feed header to the hash algorithm */
1754 #ifdef SHA_GNUTLS
1755 gnutls_hash(sha_headers, rh, strlen(rh));
1756 #else
1757 if (sig->algo == PDKIM_ALGO_RSA_SHA1)
1758 # ifdef SHA_OPENSSL
1759 SHA1_Update (&sha1_headers, rh, strlen(rh));
1760 else
1761 SHA256_Update(&sha2_headers, rh, strlen(rh));
1762 # elif defined(SHA_POLARSSL)
1763 sha1_update(&sha1_headers, US rh, strlen(rh));
1764 else
1765 sha2_update(&sha2_headers, US rh, strlen(rh));
1766 # endif
1767 #endif
1768
1769 DEBUG(D_acl) pdkim_quoteprint(rh, strlen(rh), 1);
1770 free(rh);
1771 hdrs->tag = 1;
1772 break;
1773 }
1774
1775 if (!q) break;
1776 p = q+1;
1777 }
1778 free(b);
1779 }
1780
1781 DEBUG(D_acl) debug_printf(
1782 "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1783
1784 /* SIGNING ---------------------------------------------------------------- */
1785 if (ctx->mode == PDKIM_MODE_SIGN)
1786 {
1787 /* Copy headernames to signature struct */
1788 sig->headernames = strdup(headernames->str);
1789 pdkim_strfree(headernames);
1790
1791 /* Create signature header with b= omitted */
1792 sig_hdr = pdkim_create_header(ctx->sig, 0);
1793 }
1794
1795 /* VERIFICATION ----------------------------------------------------------- */
1796 else
1797 sig_hdr = strdup(sig->rawsig_no_b_val);
1798 /* ------------------------------------------------------------------------ */
1799
1800 if (!sig_hdr)
1801 return PDKIM_ERR_OOM;
1802
1803 /* Relax header if necessary */
1804 if (sig->canon_headers == PDKIM_CANON_RELAXED)
1805 {
1806 char *relaxed_hdr = pdkim_relax_header(sig_hdr, 0);
1807
1808 free(sig_hdr);
1809 if (!relaxed_hdr)
1810 return PDKIM_ERR_OOM;
1811 sig_hdr = relaxed_hdr;
1812 }
1813
1814 DEBUG(D_acl)
1815 {
1816 debug_printf(
1817 "PDKIM >> Signed DKIM-Signature header, canonicalized >>>>>>>>>>>>>>>>>\n");
1818 pdkim_quoteprint(sig_hdr, strlen(sig_hdr), 1);
1819 debug_printf(
1820 "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
1821 }
1822
1823 /* Finalize header hash */
1824 #ifdef SHA_GNUTLS
1825 gnutls_hash(sha_headers, sig_hdr, strlen(sig_hdr));
1826 gnutls_hash_output(sha_headers, headerhash);
1827 #else
1828 if (sig->algo == PDKIM_ALGO_RSA_SHA1)
1829 # ifdef SHA_OPENSSL
1830 {
1831 SHA1_Update(&sha1_headers, sig_hdr, strlen(sig_hdr));
1832 SHA1_Final(US headerhash, &sha1_headers);
1833 }
1834 else
1835 {
1836 SHA256_Update(&sha2_headers, sig_hdr, strlen(sig_hdr));
1837 SHA256_Final(US headerhash, &sha2_headers);
1838 }
1839 # elif defined(SHA_POLARSSL)
1840 {
1841 sha1_update(&sha1_headers, US sig_hdr, strlen(sig_hdr));
1842 sha1_finish(&sha1_headers, US headerhash);
1843 }
1844 else
1845 {
1846 sha2_update(&sha2_headers, US sig_hdr, strlen(sig_hdr));
1847 sha2_finish(&sha2_headers, US headerhash);
1848 }
1849 # endif
1850 #endif
1851
1852 DEBUG(D_acl)
1853 {
1854 debug_printf("PDKIM [%s] hh computed: ", sig->domain);
1855 pdkim_hexprint(headerhash, sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20:32, 1);
1856 }
1857
1858 #ifdef RSA_GNUTLS
1859 if (ctx->mode == PDKIM_MODE_SIGN)
1860 hdata = string_append(hdata, &hdata_alloc, &hdata_size, 1, sig_hdr);
1861 #endif
1862
1863 free(sig_hdr);
1864
1865 /* SIGNING ---------------------------------------------------------------- */
1866 if (ctx->mode == PDKIM_MODE_SIGN)
1867 {
1868 #ifdef RSA_OPENSSL
1869 RSA * rsa;
1870 uschar * p, * q;
1871 int len;
1872 #elif defined(RSA_GNUTLS)
1873 gnutls_x509_privkey_t rsa;
1874 gnutls_datum_t k;
1875 int rc;
1876 size_t sigsize;
1877 #endif
1878
1879 /* Import private key */
1880 #ifdef RSA_OPENSSL
1881
1882 if ( !(p = Ustrstr(sig->rsa_privkey, "-----BEGIN RSA PRIVATE KEY-----"))
1883 || !(q = Ustrstr(p+=31, "-----END RSA PRIVATE KEY-----"))
1884 )
1885 return PDKIM_SIGN_PRIVKEY_WRAP;
1886 *q = '\0';
1887 if ((len = b64decode(p, &p)) < 0)
1888 {
1889 DEBUG(D_acl) debug_printf("b64decode failed\n");
1890 return PDKIM_SIGN_PRIVKEY_B64D;
1891 }
1892 if (!(rsa = d2i_RSAPrivateKey(NULL, CUSS &p, len)))
1893 {
1894 DEBUG(D_acl)
1895 {
1896 char ssl_errstring[256];
1897 ERR_error_string(ERR_get_error(), ssl_errstring);
1898 debug_printf("d2i_RSAPrivateKey: %s\n", ssl_errstring);
1899 }
1900 return PDKIM_ERR_RSA_PRIVKEY;
1901 }
1902
1903 #elif defined(RSA_GNUTLS)
1904
1905 k.data = sig->rsa_privkey;
1906 k.size = strlen(sig->rsa_privkey);
1907 if ( (rc = gnutls_x509_privkey_init(&rsa)) != GNUTLS_E_SUCCESS
1908 || (rc = gnutls_x509_privkey_import2(rsa, &k,
1909 GNUTLS_X509_FMT_PEM, NULL, GNUTLS_PKCS_PLAIN)) != GNUTLS_E_SUCCESS
1910 )
1911 {
1912 DEBUG(D_acl) debug_printf("gnutls_x509_privkey_import2: %s\n",
1913 gnutls_strerror(rc));
1914 return PDKIM_ERR_RSA_PRIVKEY;
1915 }
1916
1917 #endif
1918
1919
1920 /* Allocate mem for signature */
1921 #ifdef RSA_OPENSSL
1922 sig->sigdata = store_get(RSA_size(rsa));
1923 #elif defined(RSA_GNUTLS)
1924 k.data = hdata;
1925 k.size = hdata_size;
1926 (void) gnutls_x509_privkey_sign_data(rsa,
1927 sig->algo == PDKIM_ALGO_RSA_SHA1 ? GNUTLS_DIG_SHA1 : GNUTLS_DIG_SHA256,
1928 0, &k, NULL, &sigsize);
1929 sig->sigdata = store_get(sig->sigdata_len = sigsize);
1930 #endif
1931
1932 /* Do signing */
1933 #ifdef RSA_OPENSSL
1934
1935 if (RSA_sign(sig->algo == PDKIM_ALGO_RSA_SHA1 ? NID_sha1 : NID_sha256,
1936 CUS headerhash, sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20 : 32,
1937 US sig->sigdata, (unsigned int *)&sig->sigdata_len,
1938 rsa) != 1)
1939 return PDKIM_ERR_RSA_SIGNING;
1940 RSA_free(rsa);
1941
1942 #elif defined(RSA_GNUTLS)
1943
1944 if ((rc = gnutls_x509_privkey_sign_data(rsa,
1945 sig->algo == PDKIM_ALGO_RSA_SHA1 ? GNUTLS_DIG_SHA1 : GNUTLS_DIG_SHA256,
1946 0, &k, sig->sigdata, &sigsize)) != GNUTLS_E_SUCCESS
1947 )
1948 {
1949 DEBUG(D_acl) debug_printf("gnutls_x509_privkey_sign_data: %s\n",
1950 gnutls_strerror(rc));
1951 return PDKIM_ERR_RSA_SIGNING;
1952 }
1953 gnutls_x509_privkey_deinit(rsa);
1954
1955 #endif
1956
1957
1958 DEBUG(D_acl)
1959 {
1960 debug_printf( "PDKIM [%s] b computed: ", sig->domain);
1961 pdkim_hexprint(sig->sigdata, sig->sigdata_len, 1);
1962 }
1963
1964 if (!(sig->signature_header = pdkim_create_header(ctx->sig, 1)))
1965 return PDKIM_ERR_OOM;
1966 }
1967
1968 /* VERIFICATION ----------------------------------------------------------- */
1969 else
1970 {
1971 #ifdef RSA_OPENSSL
1972 RSA * rsa;
1973 const unsigned char * p;
1974 #elif defined(RSA_GNUTLS)
1975 gnutls_pubkey_t rsa;
1976 gnutls_datum_t k, s;
1977 int rc;
1978 #endif
1979 char *dns_txt_name, *dns_txt_reply;
1980
1981 #ifdef RSA_GNUTLS
1982 gnutls_pubkey_init(&rsa);
1983 #endif
1984
1985 /* Fetch public key for signing domain, from DNS */
1986
1987 if (!(dns_txt_name = malloc(PDKIM_DNS_TXT_MAX_NAMELEN)))
1988 return PDKIM_ERR_OOM;
1989
1990 if (!(dns_txt_reply = malloc(PDKIM_DNS_TXT_MAX_RECLEN)))
1991 {
1992 free(dns_txt_name);
1993 return PDKIM_ERR_OOM;
1994 }
1995
1996 memset(dns_txt_reply, 0, PDKIM_DNS_TXT_MAX_RECLEN);
1997 memset(dns_txt_name , 0, PDKIM_DNS_TXT_MAX_NAMELEN);
1998
1999 if (snprintf(dns_txt_name, PDKIM_DNS_TXT_MAX_NAMELEN,
2000 "%s._domainkey.%s.",
2001 sig->selector, sig->domain) >= PDKIM_DNS_TXT_MAX_NAMELEN)
2002 {
2003 sig->verify_status = PDKIM_VERIFY_INVALID;
2004 sig->verify_ext_status = PDKIM_VERIFY_INVALID_BUFFER_SIZE;
2005 goto NEXT_VERIFY;
2006 }
2007
2008 if ( ctx->dns_txt_callback(dns_txt_name, dns_txt_reply) != PDKIM_OK
2009 || dns_txt_reply[0] == '\0')
2010 {
2011 sig->verify_status = PDKIM_VERIFY_INVALID;
2012 sig->verify_ext_status = PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE;
2013 goto NEXT_VERIFY;
2014 }
2015
2016 DEBUG(D_acl)
2017 {
2018 debug_printf(
2019 "PDKIM >> Parsing public key record >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"
2020 " Raw record: ");
2021 pdkim_quoteprint(dns_txt_reply, strlen(dns_txt_reply), 1);
2022 }
2023
2024 if (!(sig->pubkey = pdkim_parse_pubkey_record(ctx, dns_txt_reply)))
2025 {
2026 sig->verify_status = PDKIM_VERIFY_INVALID;
2027 sig->verify_ext_status = PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD;
2028
2029 DEBUG(D_acl) debug_printf(
2030 " Error while parsing public key record\n"
2031 "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
2032 goto NEXT_VERIFY;
2033 }
2034
2035 DEBUG(D_acl) debug_printf(
2036 "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
2037
2038 /* Import public key */
2039 #ifdef RSA_OPENSSL
2040
2041 p = CUS sig->pubkey->key;
2042 if (!(rsa = d2i_RSA_PUBKEY(NULL, &p, (long) sig->pubkey->key_len)))
2043
2044 #elif defined(RSA_GNUTLS)
2045
2046 k.data = sig->pubkey->key;
2047 k.size = sig->pubkey->key_len;
2048 if ((rc = gnutls_pubkey_import(rsa, &k, GNUTLS_X509_FMT_DER))
2049 != GNUTLS_E_SUCCESS)
2050
2051 #endif
2052 {
2053 DEBUG(D_acl)
2054 {
2055 #ifdef RSA_OPENSSL
2056 long e;
2057 ERR_load_crypto_strings(); /*XXX move to a startup routine */
2058 while ((e = ERR_get_error()))
2059 debug_printf("Az: %.120s\n", ERR_error_string(e, NULL));
2060 #elif defined(RSA_GNUTLS)
2061 debug_printf("gnutls_pubkey_import: %s\n", gnutls_strerror(rc));
2062 #endif
2063 }
2064
2065 sig->verify_status = PDKIM_VERIFY_INVALID;
2066 sig->verify_ext_status = PDKIM_VERIFY_INVALID_PUBKEY_IMPORT;
2067 goto NEXT_VERIFY;
2068 }
2069
2070 /* Check the signature */
2071 #ifdef RSA_OPENSSL
2072
2073 if (RSA_verify(sig->algo == PDKIM_ALGO_RSA_SHA1 ? NID_sha1 : NID_sha256,
2074 CUS headerhash, sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20 : 32,
2075 US sig->sigdata, (unsigned int)sig->sigdata_len,
2076 rsa) != 1)
2077
2078 #elif defined(RSA_GNUTLS)
2079
2080 k.data = headerhash;
2081 k.size = sig->algo == PDKIM_ALGO_RSA_SHA1 ? 20 : 32;
2082 s.data = sig->sigdata;
2083 s.size = sig->sigdata_len;
2084 if ((rc = gnutls_pubkey_verify_hash2(rsa,
2085 sig->algo == PDKIM_ALGO_RSA_SHA1
2086 ? GNUTLS_SIGN_RSA_SHA1 : GNUTLS_SIGN_RSA_SHA256,
2087 0, &k, &s)) < 0)
2088
2089 #endif
2090 {
2091 #if defined(RSA_GNUTLS)
2092 debug_printf("gnutls_pubkey_verify_hash2: %s\n", gnutls_strerror(rc));
2093 #endif
2094 sig->verify_status = PDKIM_VERIFY_FAIL;
2095 sig->verify_ext_status = PDKIM_VERIFY_FAIL_MESSAGE;
2096 goto NEXT_VERIFY;
2097 }
2098
2099 /* We have a winner! (if bodydhash was correct earlier) */
2100 if (sig->verify_status == PDKIM_VERIFY_NONE)
2101 sig->verify_status = PDKIM_VERIFY_PASS;
2102
2103 NEXT_VERIFY:
2104
2105 DEBUG(D_acl)
2106 {
2107 debug_printf("PDKIM [%s] signature status: %s",
2108 sig->domain, pdkim_verify_status_str(sig->verify_status));
2109 if (sig->verify_ext_status > 0)
2110 debug_printf(" (%s)\n",
2111 pdkim_verify_ext_status_str(sig->verify_ext_status));
2112 else
2113 debug_printf("\n");
2114 }
2115
2116 #ifdef RSA_GNUTLS
2117 gnutls_pubkey_deinit(rsa);
2118 #endif
2119 free(dns_txt_name);
2120 free(dns_txt_reply);
2121 }
2122
2123 sig = sig->next;
2124 }
2125
2126 /* If requested, set return pointer to signature(s) */
2127 if (return_signatures)
2128 *return_signatures = ctx->sig;
2129
2130 return PDKIM_OK;
2131 }
2132
2133
2134 /* -------------------------------------------------------------------------- */
2135
2136 DLLEXPORT pdkim_ctx *
2137 pdkim_init_verify(int(*dns_txt_callback)(char *, char *))
2138 {
2139 pdkim_ctx *ctx = malloc(sizeof(pdkim_ctx));
2140
2141 if (!ctx)
2142 return NULL;
2143 memset(ctx, 0, sizeof(pdkim_ctx));
2144
2145 if (!(ctx->linebuf = malloc(PDKIM_MAX_BODY_LINE_LEN)))
2146 {
2147 free(ctx);
2148 return NULL;
2149 }
2150
2151 ctx->mode = PDKIM_MODE_VERIFY;
2152 ctx->dns_txt_callback = dns_txt_callback;
2153
2154 return ctx;
2155 }
2156
2157
2158 /* -------------------------------------------------------------------------- */
2159
2160 DLLEXPORT pdkim_ctx *
2161 pdkim_init_sign(char *domain, char *selector, char *rsa_privkey, int algo)
2162 {
2163 pdkim_ctx *ctx;
2164 pdkim_signature *sig;
2165
2166 if (!domain || !selector || !rsa_privkey)
2167 return NULL;
2168
2169 if (!(ctx = malloc(sizeof(pdkim_ctx))))
2170 return NULL;
2171 memset(ctx, 0, sizeof(pdkim_ctx));
2172
2173 if (!(ctx->linebuf = malloc(PDKIM_MAX_BODY_LINE_LEN)))
2174 {
2175 free(ctx);
2176 return NULL;
2177 }
2178
2179 if (!(sig = malloc(sizeof(pdkim_signature))))
2180 {
2181 free(ctx->linebuf);
2182 free(ctx);
2183 return NULL;
2184 }
2185 memset(sig, 0, sizeof(pdkim_signature));
2186
2187 sig->bodylength = -1;
2188
2189 ctx->mode = PDKIM_MODE_SIGN;
2190 ctx->sig = sig;
2191
2192 ctx->sig->domain = strdup(domain);
2193 ctx->sig->selector = strdup(selector);
2194 ctx->sig->rsa_privkey = strdup(rsa_privkey);
2195 ctx->sig->algo = algo;
2196
2197 if (!ctx->sig->domain || !ctx->sig->selector || !ctx->sig->rsa_privkey)
2198 goto BAIL;
2199
2200 #ifdef SHA_OPENSSL
2201 SHA1_Init (&ctx->sig->sha1_body);
2202 SHA256_Init(&ctx->sig->sha2_body);
2203
2204 #elif defined(SHA_GNUTLS)
2205 gnutls_hash_init(&ctx->sig->sha_body,
2206 algo == PDKIM_ALGO_RSA_SHA1 ? GNUTLS_DIG_SHA1 : GNUTLS_DIG_SHA256);
2207
2208 #elif defined(SHA_POLARSSL)
2209 if (!(ctx->sig->sha1_body = malloc(sizeof(sha1_context))))
2210 goto BAIL;
2211 sha1_starts(ctx->sig->sha1_body);
2212
2213 if (!(ctx->sig->sha2_body = malloc(sizeof(sha2_context))))
2214 goto BAIL;
2215 sha2_starts(ctx->sig->sha2_body, 0);
2216
2217 #endif
2218
2219 return ctx;
2220
2221 BAIL:
2222 pdkim_free_ctx(ctx);
2223 return NULL;
2224 }
2225
2226
2227 /* -------------------------------------------------------------------------- */
2228
2229 DLLEXPORT int
2230 pdkim_set_optional(pdkim_ctx *ctx,
2231 char *sign_headers,
2232 char *identity,
2233 int canon_headers,
2234 int canon_body,
2235 long bodylength,
2236 unsigned long created,
2237 unsigned long expires)
2238 {
2239 if (identity)
2240 if (!(ctx->sig->identity = strdup(identity)))
2241 return PDKIM_ERR_OOM;
2242
2243 if (sign_headers)
2244 if (!(ctx->sig->sign_headers = strdup(sign_headers)))
2245 return PDKIM_ERR_OOM;
2246
2247 ctx->sig->canon_headers = canon_headers;
2248 ctx->sig->canon_body = canon_body;
2249 ctx->sig->bodylength = bodylength;
2250 ctx->sig->created = created;
2251 ctx->sig->expires = expires;
2252
2253 return PDKIM_OK;
2254 }
2255
2256
2257 #endif /*DISABLE_DKIM*/
Unnamed repository; edit this file 'description' to name the repository.