X-Git-Url: https://git.exim.org/exim.git/blobdiff_plain/cf1cce5e82df2da1875f51ef25fd4259d6e33e61..0ae2cff689a193dcab8f6b9fb73d7de1f847ad1b:/src/src/pdkim/pdkim.c diff --git a/src/src/pdkim/pdkim.c b/src/src/pdkim/pdkim.c index 365234f4e..457d83efc 100644 --- a/src/src/pdkim/pdkim.c +++ b/src/src/pdkim/pdkim.c @@ -2,7 +2,7 @@ * PDKIM - a RFC4871 (DKIM) implementation * * Copyright (C) 2009 - 2016 Tom Kistner - * Copyright (C) 2016 - 2017 Jeremy Harris + * Copyright (C) 2016 - 2018 Jeremy Harris * * http://duncanthrax.net/pdkim/ * @@ -71,24 +71,29 @@ const uschar * pdkim_canons[] = { NULL }; -typedef struct { - const uschar * dkim_hashname; - hashmethod exim_hashmethod; -} pdkim_hashtype; -static const pdkim_hashtype pdkim_hashes[] = { +const pdkim_hashtype pdkim_hashes[] = { { US"sha1", HASH_SHA1 }, { US"sha256", HASH_SHA2_256 }, { US"sha512", HASH_SHA2_512 } }; const uschar * pdkim_keytypes[] = { - US"rsa" + [KEYTYPE_RSA] = US"rsa", +#ifdef SIGN_HAVE_ED25519 + [KEYTYPE_ED25519] = US"ed25519", /* Works for 3.6.0 GnuTLS */ +#endif + +#ifdef notyet_EC_dkim_extensions /* https://tools.ietf.org/html/draft-srose-dkim-ecc-00 */ + US"eccp256", + US"eccp348", + US"ed448", +#endif }; typedef struct pdkim_combined_canon_entry { - const uschar * str; - int canon_headers; - int canon_body; + const uschar * str; + int canon_headers; + int canon_body; } pdkim_combined_canon_entry; pdkim_combined_canon_entry pdkim_combined_canons[] = { @@ -116,6 +121,34 @@ return string_sprintf("%s-%s", } +int +pdkim_hashname_to_hashtype(const uschar * s, unsigned len) +{ +int i; +if (!len) len = Ustrlen(s); +for (i = 0; i < nelem(pdkim_hashes); i++) + if (Ustrncmp(s, pdkim_hashes[i].dkim_hashname, len) == 0) + return i; +return -1; +} + +void +pdkim_cstring_to_canons(const uschar * s, unsigned len, + int * canon_head, int * canon_body) +{ +int i; +if (!len) len = Ustrlen(s); +for (i = 0; pdkim_combined_canons[i].str; i++) + if ( Ustrncmp(s, pdkim_combined_canons[i].str, len) == 0 + && len == Ustrlen(pdkim_combined_canons[i].str)) + { + *canon_head = pdkim_combined_canons[i].canon_headers; + *canon_body = pdkim_combined_canons[i].canon_body; + break; + } +} + + const char * pdkim_verify_status_str(int status) @@ -155,9 +188,9 @@ switch(status) { case PDKIM_OK: return US"OK"; case PDKIM_FAIL: return US"FAIL"; - case PDKIM_ERR_RSA_PRIVKEY: return US"RSA_PRIVKEY"; - case PDKIM_ERR_RSA_SIGNING: return US"RSA SIGNING"; - case PDKIM_ERR_LONG_LINE: return US"RSA_LONG_LINE"; + case PDKIM_ERR_RSA_PRIVKEY: return US"PRIVKEY"; + case PDKIM_ERR_RSA_SIGNING: return US"SIGNING"; + case PDKIM_ERR_LONG_LINE: return US"LONG_LINE"; case PDKIM_ERR_BUFFER_TOO_SMALL: return US"BUFFER_TOO_SMALL"; case PDKIM_SIGN_PRIVKEY_WRAP: return US"PRIVKEY_WRAP"; case PDKIM_SIGN_PRIVKEY_B64D: return US"PRIVKEY_B64D"; @@ -168,7 +201,7 @@ switch(status) /* -------------------------------------------------------------------------- */ /* Print debugging functions */ -static void +void pdkim_quoteprint(const uschar *data, int len) { int i; @@ -194,7 +227,7 @@ for (i = 0; i < len; i++) debug_printf("\n"); } -static void +void pdkim_hexprint(const uschar *data, int len) { int i; @@ -293,16 +326,16 @@ return PDKIM_FAIL; /* -------------------------------------------------------------------------- */ /* Performs "relaxed" canonicalization of a header. */ -static uschar * -pdkim_relax_header(const uschar * header, BOOL append_crlf) +uschar * +pdkim_relax_header_n(const uschar * header, int len, BOOL append_crlf) { BOOL past_field_name = FALSE; BOOL seen_wsp = FALSE; const uschar * p; -uschar * relaxed = store_get(Ustrlen(header)+3); +uschar * relaxed = store_get(len+3); uschar * q = relaxed; -for (p = header; *p; p++) +for (p = header; p - header < len; p++) { uschar c = *p; @@ -338,6 +371,13 @@ return relaxed; } +uschar * +pdkim_relax_header(const uschar * header, BOOL append_crlf) +{ +return pdkim_relax_header_n(header, Ustrlen(header), append_crlf); +} + + /* -------------------------------------------------------------------------- */ #define PDKIM_QP_ERROR_DECODE -1 @@ -398,16 +438,15 @@ return n; /* -------------------------------------------------------------------------- */ -static void +void pdkim_decode_base64(const uschar * str, blob * b) { -int dlen; -dlen = b64decode(str, &b->data); +int dlen = b64decode(str, &b->data); if (dlen < 0) b->data = NULL; b->len = dlen; } -static uschar * +uschar * pdkim_encode_base64(blob * b) { return b64encode(b->data, b->len); @@ -504,7 +543,7 @@ for (p = raw_hdr; ; p++) switch (*cur_tag->s) { - case 'b': + case 'b': /* sig-data or body-hash */ switch (cur_tag->s[1]) { case '\0': pdkim_decode_base64(cur_val->s, &sig->sighash); break; @@ -514,58 +553,58 @@ for (p = raw_hdr; ; p++) default: break; } break; - case 'v': + case 'v': /* version */ /* We only support version 1, and that is currently the only version there is. */ sig->version = Ustrcmp(cur_val->s, PDKIM_SIGNATURE_VERSION) == 0 ? 1 : -1; break; - case 'a': + case 'a': /* algorithm */ { uschar * s = Ustrchr(cur_val->s, '-'); for(i = 0; i < nelem(pdkim_keytypes); i++) if (Ustrncmp(cur_val->s, pdkim_keytypes[i], s - cur_val->s) == 0) { sig->keytype = i; break; } - for (++s, i = 0; i < nelem(pdkim_hashes); i++) - if (Ustrcmp(s, pdkim_hashes[i].dkim_hashname) == 0) - { sig->hashtype = i; break; } + if (sig->keytype < 0) + log_write(0, LOG_MAIN, + "DKIM: ignoring signature due to nonhandled keytype in a=%s", + cur_val->s); + + sig->hashtype = pdkim_hashname_to_hashtype(++s, 0); break; } - case 'c': - for (i = 0; pdkim_combined_canons[i].str; i++) - if (Ustrcmp(cur_val->s, pdkim_combined_canons[i].str) == 0) - { - sig->canon_headers = pdkim_combined_canons[i].canon_headers; - sig->canon_body = pdkim_combined_canons[i].canon_body; - break; - } + case 'c': /* canonicalization */ + pdkim_cstring_to_canons(cur_val->s, 0, + &sig->canon_headers, &sig->canon_body); break; - case 'q': + case 'q': /* Query method (for pubkey)*/ for (i = 0; pdkim_querymethods[i]; i++) if (Ustrcmp(cur_val->s, pdkim_querymethods[i]) == 0) { - sig->querymethod = i; + sig->querymethod = i; /* we never actually use this */ break; } break; - case 's': + case 's': /* Selector */ sig->selector = string_copyn(cur_val->s, cur_val->ptr); break; - case 'd': + case 'd': /* SDID */ sig->domain = string_copyn(cur_val->s, cur_val->ptr); break; - case 'i': + case 'i': /* AUID */ sig->identity = pdkim_decode_qp(cur_val->s); break; - case 't': + case 't': /* Timestamp */ sig->created = strtoul(CS cur_val->s, NULL, 10); break; - case 'x': + case 'x': /* Expiration */ sig->expires = strtoul(CS cur_val->s, NULL, 10); break; - case 'l': + case 'l': /* Body length count */ sig->bodylength = strtol(CS cur_val->s, NULL, 10); break; - case 'h': + case 'h': /* signed header fields */ sig->headernames = string_copyn(cur_val->s, cur_val->ptr); break; - case 'z': + case 'z': /* Copied headfields */ sig->copiedheaders = pdkim_decode_qp(cur_val->s); break; +/*XXX draft-ietf-dcrup-dkim-crypto-05 would need 'p' tag support +for rsafp signatures. But later discussion is dropping those. */ default: DEBUG(D_acl) debug_printf(" Unknown tag encountered\n"); break; @@ -587,6 +626,9 @@ NEXT_CHAR: *q++ = c; } +if (sig->keytype < 0 || sig->hashtype < 0) /* Cannot verify this signature */ + return NULL; + *q = '\0'; /* Chomp raw header. The final newline must not be added to the signature. */ while (--q > sig->rawsig_no_b_val && (*q == '\r' || *q == '\n')) @@ -603,7 +645,7 @@ DEBUG(D_acl) "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"); } -if (!pdkim_set_bodyhash(ctx, sig)) +if (!pdkim_set_sig_bodyhash(ctx, sig)) return NULL; return sig; @@ -612,8 +654,8 @@ return sig; /* -------------------------------------------------------------------------- */ -static pdkim_pubkey * -pdkim_parse_pubkey_record(pdkim_ctx *ctx, const uschar *raw_record) +pdkim_pubkey * +pdkim_parse_pubkey_record(const uschar *raw_record) { const uschar * ele; int sep = ';'; @@ -635,7 +677,7 @@ while ((ele = string_nextinlist(&raw_record, &sep, NULL, 0))) { case 'v': pub->version = val; break; case 'h': pub->hashes = val; break; - case 'k': break; + case 'k': pub->keytype = val; break; case 'g': pub->granularity = val; break; case 'n': pub->notes = pdkim_decode_qp(val); break; case 'p': pdkim_decode_base64(val, &pub->key); break; @@ -658,9 +700,7 @@ else if (Ustrcmp(pub->version, PDKIM_PUB_RECORD_VERSION) != 0) } if (!pub->granularity) pub->granularity = US"*"; -/* if (!pub->keytype ) pub->keytype = US"rsa"; -*/ if (!pub->srvtype ) pub->srvtype = US"*"; /* p= is required */ @@ -689,7 +729,7 @@ if (b->canon_method == PDKIM_CANON_RELAXED) if (!relaxed_data) { BOOL seen_wsp = FALSE; - const uschar * p; + const uschar * p, * r; int q = 0; /* We want to be able to free this else we allocate @@ -700,7 +740,7 @@ if (b->canon_method == PDKIM_CANON_RELAXED) relaxed_data = store_malloc(sizeof(blob) + orig_data->len+1); relaxed_data->data = US (relaxed_data+1); - for (p = orig_data->data; *p; p++) + for (p = orig_data->data, r = p + orig_data->len; p < r; p++) { char c = *p; if (c == '\r') @@ -751,7 +791,11 @@ pdkim_bodyhash * b; pdkim_signature * sig; for (b = ctx->bodyhash; b; b = b->next) /* Finish hashes */ + { + DEBUG(D_acl) debug_printf("PDKIM: finish bodyhash %d/%d/%d len %ld\n", + b->hashtype, b->canon_method, b->bodylength, b->signed_body_bytes); exim_sha_finish(&b->body_hash_ctx, &b->bh); + } /* Traverse all signatures */ for (sig = ctx->sig; sig; sig = sig->next) @@ -760,10 +804,10 @@ for (sig = ctx->sig; sig; sig = sig->next) DEBUG(D_acl) { - debug_printf("PDKIM [%s] Body bytes hashed: %lu\n" + debug_printf("PDKIM [%s] Body bytes (%s) hashed: %lu\n" "PDKIM [%s] Body %s computed: ", - sig->domain, b->signed_body_bytes, - sig->domain, pdkim_hashes[sig->hashtype].dkim_hashname); + sig->domain, pdkim_canons[b->canon_method], b->signed_body_bytes, + sig->domain, pdkim_hashes[b->hashtype].dkim_hashname); pdkim_hexprint(CUS b->bh.data, b->bh.len); } @@ -783,7 +827,7 @@ for (sig = ctx->sig; sig; sig = sig->next) if ( sig->bodyhash.data && memcmp(b->bh.data, sig->bodyhash.data, b->bh.len) == 0) { - DEBUG(D_acl) debug_printf("PDKIM [%s] Body hash verified OK\n", sig->domain); + DEBUG(D_acl) debug_printf("PDKIM [%s] Body hash compared OK\n", sig->domain); } else { @@ -827,6 +871,7 @@ ctx->linebuf_offset = 0; /* -------------------------------------------------------------------------- */ /* Call from pdkim_feed below for processing complete body lines */ +/* NOTE: the line is not NUL-terminated; but we have a count */ static void pdkim_bodyline_complete(pdkim_ctx * ctx) @@ -918,6 +963,11 @@ if ( (ctx->cur_header->ptr > 1) && --ctx->cur_header->ptr; (void) string_from_gstring(ctx->cur_header); +#ifdef EXPERIMENTAL_ARC +/* Feed the header line to ARC processing */ +(void) arc_header_feed(ctx->cur_header, !(ctx->flags & PDKIM_MODE_SIGN)); +#endif + if (++ctx->num_headers > PDKIM_MAX_HEADERS) goto BAIL; /* SIGNING -------------------------------------------------------------- */ @@ -1297,7 +1347,7 @@ pdkim_pubkey * p; dns_txt_name = string_sprintf("%s._domainkey.%s.", sig->selector, sig->domain); -if ( !(dns_txt_reply = ctx->dns_txt_callback(CS dns_txt_name)) +if ( !(dns_txt_reply = ctx->dns_txt_callback(dns_txt_name)) || dns_txt_reply[0] == '\0' ) { @@ -1316,7 +1366,7 @@ DEBUG(D_acl) pdkim_quoteprint(CUS dns_txt_reply, Ustrlen(dns_txt_reply)); } -if ( !(p = pdkim_parse_pubkey_record(ctx, CUS dns_txt_reply)) +if ( !(p = pdkim_parse_pubkey_record(CUS dns_txt_reply)) || (Ustrcmp(p->srvtype, "*") != 0 && Ustrcmp(p->srvtype, "email") != 0) ) { @@ -1339,7 +1389,10 @@ DEBUG(D_acl) debug_printf( "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"); /* Import public key */ -if ((*errstr = exim_dkim_verify_init(&p->key, vctx))) + +if ((*errstr = exim_dkim_verify_init(&p->key, + sig->keytype == KEYTYPE_ED25519 ? KEYFMT_ED25519_BARE : KEYFMT_DER, + vctx))) { DEBUG(D_acl) debug_printf("verify_init: %s\n", *errstr); sig->verify_status = PDKIM_VERIFY_INVALID; @@ -1347,6 +1400,7 @@ if ((*errstr = exim_dkim_verify_init(&p->key, vctx))) return NULL; } +vctx->keytype = sig->keytype; return p; } @@ -1359,6 +1413,7 @@ pdkim_feed_finish(pdkim_ctx * ctx, pdkim_signature ** return_signatures, { pdkim_bodyhash * b; pdkim_signature * sig; +BOOL verify_pass = FALSE; /* Check if we must still flush a (partial) header. If that is the case, the message has no body, and we must compute a body hash @@ -1379,20 +1434,59 @@ else DEBUG(D_acl) debug_printf( "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"); -/* Build (and/or evaluate) body hash */ +/* Build (and/or evaluate) body hash. Do this even if no DKIM sigs, in case we +have a hash to do for ARC. */ + pdkim_finish_bodyhash(ctx); +if (!ctx->sig) + { + DEBUG(D_acl) debug_printf("PDKIM: no signatures\n"); + *return_signatures = NULL; + return PDKIM_OK; + } + for (sig = ctx->sig; sig; sig = sig->next) { hctx hhash_ctx; uschar * sig_hdr = US""; blob hhash; gstring * hdata = NULL; + es_ctx sctx; - if (!exim_sha_init(&hhash_ctx, pdkim_hashes[sig->hashtype].exim_hashmethod)) + if ( !(ctx->flags & PDKIM_MODE_SIGN) + && sig->verify_status == PDKIM_VERIFY_FAIL) { DEBUG(D_acl) - debug_printf("PDKIM: hash setup error, possibly nonhandled hashtype\n"); + debug_printf("PDKIM: [%s] abandoning this signature\n", sig->domain); + continue; + } + + /*XXX The hash of the headers is needed for GCrypt (for which we can do RSA + suging only, as it happens) and for either GnuTLS and OpenSSL when we are + signing with EC (specifically, Ed25519). The former is because the GCrypt + signing operation is pure (does not do its own hash) so we must hash. The + latter is because we (stupidly, but this is what the IETF draft is saying) + must hash with the declared hash method, then pass the result to the library + hash-and-sign routine (because that's all the libraries are providing. And + we're stuck with whatever that hidden hash method is, too). We may as well + do this hash incrementally. + We don't need the hash we're calculating here for the GnuTLS and OpenSSL + cases of RSA signing, since those library routines can do hash-and-sign. + + Some time in the future we could easily avoid doing the hash here for those + cases (which will be common for a long while. We could also change from + the current copy-all-the-headers-into-one-block, then call the hash-and-sign + implementation - to a proper incremental one. Unfortunately, GnuTLS just + cannot do incremental - either signing or verification. Unsure about GCrypt. + */ + + /*XXX The header hash is also used (so far) by the verify operation */ + + if (!exim_sha_init(&hhash_ctx, pdkim_hashes[sig->hashtype].exim_hashmethod)) + { + log_write(0, LOG_MAIN|LOG_PANIC, + "PDKIM: hash setup error, possibly nonhandled hashtype"); break; } @@ -1403,7 +1497,8 @@ for (sig = ctx->sig; sig; sig = sig->next) sig->sign_headers); DEBUG(D_acl) debug_printf( - "PDKIM >> Header data for hash, canonicalized, in sequence >>>>>>>>>>>>\n"); + "PDKIM >> Header data for hash, canonicalized (%-7s), in sequence >>\n", + pdkim_canons[sig->canon_headers]); /* SIGNING ---------------------------------------------------------------- */ @@ -1420,9 +1515,19 @@ for (sig = ctx->sig; sig; sig = sig->next) uschar * s; int sep = 0; - sig->headernames = NULL; /* Collected signed header names */ + /* Import private key, including the keytype which we need for building + the signature header */ + +/*XXX extend for non-RSA algos */ + if ((*err = exim_dkim_signing_init(CUS sig->privkey, &sctx))) + { + log_write(0, LOG_MAIN|LOG_PANIC, "signing_init: %s", *err); + return PDKIM_ERR_RSA_PRIVKEY; + } + sig->keytype = sctx.keytype; - for (p = sig->headers; p; p = p->next) + for (sig->headernames = NULL, /* Collected signed header names */ + p = sig->headers; p; p = p->next) { uschar * rh = p->value; @@ -1438,6 +1543,7 @@ for (sig = ctx->sig; sig; sig = sig->next) exim_sha_update(&hhash_ctx, CUS rh, Ustrlen(rh)); /* Remember headers block for signing (when the library cannot do incremental) */ + /*XXX we could avoid doing this for all but the GnuTLS/RSA case */ hdata = exim_dkim_data_append(hdata, rh); DEBUG(D_acl) pdkim_quoteprint(rh, Ustrlen(rh)); @@ -1529,8 +1635,8 @@ for (sig = ctx->sig; sig; sig = sig->next) DEBUG(D_acl) { - debug_printf( - "PDKIM >> Signed DKIM-Signature header, canonicalized >>>>>>>>>>>>>>>>>\n"); + debug_printf("PDKIM >> Signed DKIM-Signature header, canonicalized (%-7s) >>>>>>>\n", + pdkim_canons[sig->canon_headers]); pdkim_quoteprint(CUS sig_hdr, Ustrlen(sig_hdr)); debug_printf( "PDKIM <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"); @@ -1555,31 +1661,25 @@ for (sig = ctx->sig; sig; sig = sig->next) /* SIGNING ---------------------------------------------------------------- */ if (ctx->flags & PDKIM_MODE_SIGN) { - es_ctx sctx; - - /* Import private key, including the keytype */ -/*XXX extend for non-RSA algos */ - if ((*err = exim_dkim_signing_init(US sig->privkey, &sctx))) - { - DEBUG(D_acl) debug_printf("signing_init: %s\n", *err); - return PDKIM_ERR_RSA_PRIVKEY; - } + hashmethod hm = sig->keytype == KEYTYPE_ED25519 + ? HASH_SHA2_512 : pdkim_hashes[sig->hashtype].exim_hashmethod; - /* Do signing. With OpenSSL we are signing the hash of headers just - calculated, with GnuTLS we have to sign an entire block of headers - (due to available interfaces) and it recalculates the hash internally. */ +#ifdef SIGN_HAVE_ED25519 + /* For GCrypt, and for EC, we pass the hash-of-headers to the signing + routine. For anything else we just pass the headers. */ -#if defined(SIGN_GNUTLS) - hhash.data = hdata->s; - hhash.len = hdata->ptr; + if (sig->keytype != KEYTYPE_ED25519) #endif + { + hhash.data = hdata->s; + hhash.len = hdata->ptr; + } /*XXX extend for non-RSA algos */ - if ((*err = exim_dkim_sign(&sctx, - pdkim_hashes[sig->hashtype].exim_hashmethod, - &hhash, &sig->sighash))) +/*- done for GnuTLS */ + if ((*err = exim_dkim_sign(&sctx, hm, &hhash, &sig->sighash))) { - DEBUG(D_acl) debug_printf("signing: %s\n", *err); + log_write(0, LOG_MAIN|LOG_PANIC, "signing: %s", *err); return PDKIM_ERR_RSA_SIGNING; } @@ -1636,7 +1736,12 @@ for (sig = ctx->sig; sig; sig = sig->next) } if (!(sig->pubkey = pdkim_key_from_dns(ctx, sig, &vctx, err))) + { + log_write(0, LOG_MAIN, "PDKIM: %s%s %s%s [failed key import]", + sig->domain ? "d=" : "", sig->domain ? sig->domain : US"", + sig->selector ? "s=" : "", sig->selector ? sig->selector : US""); goto NEXT_VERIFY; + } /* If the pubkey limits to a list of specific hashes, ignore sigs that do not have the hash part of the sig algorithm matching */ @@ -1660,10 +1765,11 @@ for (sig = ctx->sig; sig; sig = sig->next) } /* Check the signature */ -/*XXX needs extension for non-RSA */ +/*XXX extend for non-RSA algos */ +/*- done for GnuTLS */ if ((*err = exim_dkim_verify(&vctx, - pdkim_hashes[sig->hashtype].exim_hashmethod, - &hhash, &sig->sighash))) + pdkim_hashes[sig->hashtype].exim_hashmethod, + &hhash, &sig->sighash))) { DEBUG(D_acl) debug_printf("headers verify: %s\n", *err); sig->verify_status = PDKIM_VERIFY_FAIL; @@ -1674,14 +1780,18 @@ for (sig = ctx->sig; sig; sig = sig->next) /* We have a winner! (if bodyhash was correct earlier) */ if (sig->verify_status == PDKIM_VERIFY_NONE) + { sig->verify_status = PDKIM_VERIFY_PASS; + verify_pass = TRUE; + } NEXT_VERIFY: DEBUG(D_acl) { - debug_printf("PDKIM [%s] signature status: %s", - sig->domain, pdkim_verify_status_str(sig->verify_status)); + debug_printf("PDKIM [%s] %s signature status: %s", + sig->domain, dkim_sig_to_a_tag(sig), + pdkim_verify_status_str(sig->verify_status)); if (sig->verify_ext_status > 0) debug_printf(" (%s)\n", pdkim_verify_ext_status_str(sig->verify_ext_status)); @@ -1695,14 +1805,15 @@ NEXT_VERIFY: if (return_signatures) *return_signatures = ctx->sig; -return PDKIM_OK; +return ctx->flags & PDKIM_MODE_SIGN || verify_pass + ? PDKIM_OK : PDKIM_FAIL; } /* -------------------------------------------------------------------------- */ DLLEXPORT pdkim_ctx * -pdkim_init_verify(uschar * (*dns_txt_callback)(char *), BOOL dot_stuffing) +pdkim_init_verify(uschar * (*dns_txt_callback)(uschar *), BOOL dot_stuffing) { pdkim_ctx * ctx; @@ -1719,8 +1830,6 @@ return ctx; /* -------------------------------------------------------------------------- */ -/*XXX ? needs extension to cover non-RSA algo? */ - DLLEXPORT pdkim_signature * pdkim_init_sign(pdkim_ctx * ctx, uschar * domain, uschar * selector, uschar * privkey, @@ -1742,15 +1851,15 @@ sig->bodylength = -1; sig->domain = string_copy(US domain); sig->selector = string_copy(US selector); sig->privkey = string_copy(US privkey); -/*XXX no keytype yet; comes from privkey */ +sig->keytype = -1; for (hashtype = 0; hashtype < nelem(pdkim_hashes); hashtype++) if (Ustrcmp(hashname, pdkim_hashes[hashtype].dkim_hashname) == 0) { sig->hashtype = hashtype; break; } if (hashtype >= nelem(pdkim_hashes)) { - DEBUG(D_acl) - debug_printf("PDKIM: unrecognised hashname '%s'\n", hashname); + log_write(0, LOG_MAIN|LOG_PANIC, + "PDKIM: unrecognised hashname '%s'", hashname); return NULL; } @@ -1798,29 +1907,35 @@ return; /* Set up a blob for calculating the bodyhash according to the -needs of this signature. Use an existing one if possible, or -create a new one. +given needs. Use an existing one if possible, or create a new one. -Return: hashblob pointer, or NULL on error (only used as a boolean). +Return: hashblob pointer, or NULL on error */ pdkim_bodyhash * -pdkim_set_bodyhash(pdkim_ctx * ctx, pdkim_signature * sig) +pdkim_set_bodyhash(pdkim_ctx * ctx, int hashtype, int canon_method, + long bodylength) { pdkim_bodyhash * b; for (b = ctx->bodyhash; b; b = b->next) - if ( sig->hashtype == b->hashtype - && sig->canon_body == b->canon_method - && sig->bodylength == b->bodylength) - goto old; + if ( hashtype == b->hashtype + && canon_method == b->canon_method + && bodylength == b->bodylength) + { + DEBUG(D_receive) debug_printf("PDKIM: using existing bodyhash %d/%d/%ld\n", + hashtype, canon_method, bodylength); + return b; + } +DEBUG(D_receive) debug_printf("PDKIM: new bodyhash %d/%d/%ld\n", + hashtype, canon_method, bodylength); b = store_get(sizeof(pdkim_bodyhash)); b->next = ctx->bodyhash; -b->hashtype = sig->hashtype; -b->canon_method = sig->canon_body; -b->bodylength = sig->bodylength; +b->hashtype = hashtype; +b->canon_method = canon_method; +b->bodylength = bodylength; if (!exim_sha_init(&b->body_hash_ctx, /*XXX hash method: extend for sha512 */ - pdkim_hashes[sig->hashtype].exim_hashmethod)) + pdkim_hashes[hashtype].exim_hashmethod)) { DEBUG(D_acl) debug_printf("PDKIM: hash init error, possibly nonhandled hashtype\n"); @@ -1829,8 +1944,21 @@ if (!exim_sha_init(&b->body_hash_ctx, /*XXX hash method: extend for sha512 */ b->signed_body_bytes = 0; b->num_buffered_blanklines = 0; ctx->bodyhash = b; +return b; +} + + +/* Set up a blob for calculating the bodyhash according to the +needs of this signature. Use an existing one if possible, or +create a new one. -old: +Return: hashblob pointer, or NULL on error (only used as a boolean). +*/ +pdkim_bodyhash * +pdkim_set_sig_bodyhash(pdkim_ctx * ctx, pdkim_signature * sig) +{ +pdkim_bodyhash * b = pdkim_set_bodyhash(ctx, + sig->hashtype, sig->canon_body, sig->bodylength); sig->calc_body_hash = b; return b; } @@ -1841,7 +1969,7 @@ return b; void pdkim_init_context(pdkim_ctx * ctx, BOOL dot_stuffed, - uschar * (*dns_txt_callback)(char *)) + uschar * (*dns_txt_callback)(uschar *)) { memset(ctx, 0, sizeof(pdkim_ctx)); ctx->flags = dot_stuffed ? PDKIM_MODE_SIGN | PDKIM_DOT_TERM : PDKIM_MODE_SIGN;