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