src/src/pdkim/signing.c

   1 /*
   2  *  PDKIM - a RFC4871 (DKIM) implementation
   3  *  Copyright (c) The Exim Maintainers 1995 - 2022
   4  *
   5  *  signing/verification interface
   6  */
   7
   8 #include "../exim.h"
   9 #include "crypt_ver.h"
  10 #include "signing.h"
  11
  12
  13 #ifdef MACRO_PREDEF
  14 # include "../macro_predef.h"
  15
  16 void
  17 features_crypto(void)
  18 {
  19 # ifdef SIGN_HAVE_ED25519
  20   builtin_macro_create(US"_CRYPTO_SIGN_ED25519");
  21 # endif
  22 # ifdef EXIM_HAVE_SHA3
  23   builtin_macro_create(US"_CRYPTO_HASH_SHA3");
  24 # endif
  25 }
  26 #else
  27
  28 #ifndef DISABLE_DKIM    /* rest of file */
  29
  30 #ifdef DISABLE_TLS
  31 # error Must no DISABLE_TLS, for DKIM
  32 #endif
  33
  34
  35 /******************************************************************************/
  36 #ifdef SIGN_GNUTLS
  37 # define EXIM_GNUTLS_LIBRARY_LOG_LEVEL 3
  38
  39 # ifndef GNUTLS_VERIFY_ALLOW_BROKEN
  40 #  define GNUTLS_VERIFY_ALLOW_BROKEN 0
  41 # endif
  42
  43
  44 /* Logging function which can be registered with
  45  *   gnutls_global_set_log_function()
  46  *   gnutls_global_set_log_level() 0..9
  47  */
  48 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
  49 static void
  50 exim_gnutls_logger_cb(int level, const char *message)
  51 {
  52 size_t len = strlen(message);
  53 if (len < 1)
  54   {
  55   DEBUG(D_tls) debug_printf("GnuTLS<%d> empty debug message\n", level);
  56   return;
  57   }
  58 DEBUG(D_tls) debug_printf("GnuTLS<%d>: %s%s", level, message,
  59     message[len-1] == '\n' ? "" : "\n");
  60 }
  61 #endif
  62
  63
  64
  65 void
  66 exim_dkim_init(void)
  67 {
  68 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
  69 DEBUG(D_tls)
  70   {
  71   gnutls_global_set_log_function(exim_gnutls_logger_cb);
  72   /* arbitrarily chosen level; bump upto 9 for more */
  73   gnutls_global_set_log_level(EXIM_GNUTLS_LIBRARY_LOG_LEVEL);
  74   }
  75 #endif
  76 }
  77
  78
  79 /* accumulate data (gnutls-only).  String to be appended must be nul-terminated. */
  80 gstring *
  81 exim_dkim_data_append(gstring * g, uschar * s)
  82 {
  83 return string_cat(g, s);
  84 }
  85
  86
  87
  88 /* import private key from PEM string in memory.
  89 Return: NULL for success, or an error string */
  90
  91 const uschar *
  92 exim_dkim_signing_init(const uschar * privkey_pem, es_ctx * sign_ctx)
  93 {
  94 gnutls_datum_t k = { .data = (void *)privkey_pem, .size = Ustrlen(privkey_pem) };
  95 gnutls_x509_privkey_t x509_key;
  96 const uschar * where;
  97 int rc;
  98
  99 if (  (where = US"internal init", rc = gnutls_x509_privkey_init(&x509_key))
 100    || (rc = gnutls_privkey_init(&sign_ctx->key))
 101    || (where = US"privkey PEM-block import",
 102        rc = gnutls_x509_privkey_import(x509_key, &k, GNUTLS_X509_FMT_PEM))
 103    || (where = US"internal privkey transfer",
 104        rc = gnutls_privkey_import_x509(sign_ctx->key, x509_key, 0))
 105    )
 106   return string_sprintf("%s: %s", where, gnutls_strerror(rc));
 107
 108 switch (rc = gnutls_privkey_get_pk_algorithm(sign_ctx->key, NULL))
 109   {
 110   case GNUTLS_PK_RSA:           sign_ctx->keytype = KEYTYPE_RSA;     break;
 111 #ifdef SIGN_HAVE_ED25519
 112   case GNUTLS_PK_EDDSA_ED25519: sign_ctx->keytype = KEYTYPE_ED25519; break;
 113 #endif
 114   default: return rc < 0
 115     ? CUS gnutls_strerror(rc)
 116     : string_sprintf("Unhandled key type: %d '%s'", rc, gnutls_pk_get_name(rc));
 117   }
 118
 119 return NULL;
 120 }
 121
 122
 123
 124 /* allocate mem for signature (when signing) */
 125 /* hash & sign data.   No way to do incremental.
 126
 127 Return: NULL for success, or an error string */
 128
 129 const uschar *
 130 exim_dkim_sign(es_ctx * sign_ctx, hashmethod hash, blob * data, blob * sig)
 131 {
 132 gnutls_datum_t k_data = { .data = data->data, .size = data->len };
 133 gnutls_digest_algorithm_t dig;
 134 gnutls_datum_t k_sig;
 135 int rc;
 136
 137 switch (hash)
 138   {
 139   case HASH_SHA1:       dig = GNUTLS_DIG_SHA1; break;
 140   case HASH_SHA2_256:   dig = GNUTLS_DIG_SHA256; break;
 141   case HASH_SHA2_512:   dig = GNUTLS_DIG_SHA512; break;
 142   default:              return US"nonhandled hash type";
 143   }
 144
 145 if ((rc = gnutls_privkey_sign_data(sign_ctx->key, dig, 0, &k_data, &k_sig)))
 146   return CUS gnutls_strerror(rc);
 147
 148 /* Don't care about deinit for the key; shortlived process */
 149
 150 sig->data = k_sig.data;
 151 sig->len = k_sig.size;
 152 return NULL;
 153 }
 154
 155
 156
 157 /* import public key (from blob in memory)
 158 Return: NULL for success, or an error string */
 159
 160 const uschar *
 161 exim_dkim_verify_init(blob * pubkey, keyformat fmt, ev_ctx * verify_ctx,
 162   unsigned * bits)
 163 {
 164 gnutls_datum_t k;
 165 int rc;
 166 const uschar * ret = NULL;
 167
 168 gnutls_pubkey_init(&verify_ctx->key);
 169 k.data = pubkey->data;
 170 k.size = pubkey->len;
 171
 172 switch(fmt)
 173   {
 174   case KEYFMT_DER:
 175     if ((rc = gnutls_pubkey_import(verify_ctx->key, &k, GNUTLS_X509_FMT_DER)))
 176       ret = US gnutls_strerror(rc);
 177     break;
 178 #ifdef SIGN_HAVE_ED25519
 179   case KEYFMT_ED25519_BARE:
 180     if ((rc = gnutls_pubkey_import_ecc_raw(verify_ctx->key,
 181                                           GNUTLS_ECC_CURVE_ED25519, &k, NULL)))
 182       ret = US gnutls_strerror(rc);
 183     break;
 184 #endif
 185   default:
 186     ret = US"pubkey format not handled";
 187     break;
 188   }
 189 if (!ret && bits) gnutls_pubkey_get_pk_algorithm(verify_ctx->key, bits);
 190 return ret;
 191 }
 192
 193
 194 /* verify signature (of hash if RSA sig, of data if EC sig.  No way to do incremental)
 195 (given pubkey & alleged sig)
 196 Return: NULL for success, or an error string */
 197
 198 const uschar *
 199 exim_dkim_verify(ev_ctx * verify_ctx, hashmethod hash, blob * data_hash, blob * sig)
 200 {
 201 gnutls_datum_t k = { .data = data_hash->data, .size = data_hash->len };
 202 gnutls_datum_t s = { .data = sig->data,       .size = sig->len };
 203 int rc;
 204 const uschar * ret = NULL;
 205
 206 #ifdef SIGN_HAVE_ED25519
 207 if (verify_ctx->keytype == KEYTYPE_ED25519)
 208   {
 209   if ((rc = gnutls_pubkey_verify_data2(verify_ctx->key,
 210                                       GNUTLS_SIGN_EDDSA_ED25519, 0, &k, &s)) < 0)
 211     ret = US gnutls_strerror(rc);
 212   }
 213 else
 214 #endif
 215   {
 216   gnutls_sign_algorithm_t algo;
 217   switch (hash)
 218     {
 219     case HASH_SHA1:     algo = GNUTLS_SIGN_RSA_SHA1;   break;
 220     case HASH_SHA2_256: algo = GNUTLS_SIGN_RSA_SHA256; break;
 221     case HASH_SHA2_512: algo = GNUTLS_SIGN_RSA_SHA512; break;
 222     default:            return US"nonhandled hash type";
 223     }
 224
 225   if ((rc = gnutls_pubkey_verify_hash2(verify_ctx->key, algo,
 226               GNUTLS_VERIFY_ALLOW_BROKEN, &k, &s)) < 0)
 227     ret = US gnutls_strerror(rc);
 228   }
 229
 230 gnutls_pubkey_deinit(verify_ctx->key);
 231 return ret;
 232 }
 233
 234
 235
 236
 237 #elif defined(SIGN_GCRYPT)
 238 /******************************************************************************/
 239 /* This variant is used under pre-3.0.0 GnuTLS.  Only rsa-sha1 and rsa-sha256 */
 240
 241
 242 /* Internal service routine:
 243 Read and move past an asn.1 header, checking class & tag,
 244 optionally returning the data-length */
 245
 246 static int
 247 as_tag(blob * der, uschar req_cls, long req_tag, long * alen)
 248 {
 249 int rc;
 250 uschar tag_class;
 251 int taglen;
 252 long tag, len;
 253
 254 debug_printf_indent("as_tag: %02x %02x %02x %02x\n",
 255         der->data[0], der->data[1], der->data[2], der->data[3]);
 256
 257 if ((rc = asn1_get_tag_der(der->data++, der->len--, &tag_class, &taglen, &tag))
 258     != ASN1_SUCCESS)
 259   return rc;
 260
 261 if (tag_class != req_cls || tag != req_tag) return ASN1_ELEMENT_NOT_FOUND;
 262
 263 if ((len = asn1_get_length_der(der->data, der->len, &taglen)) < 0)
 264   return ASN1_DER_ERROR;
 265 if (alen) *alen = len;
 266
 267 /* debug_printf_indent("as_tag:  tlen %d dlen %d\n", taglen, (int)len); */
 268
 269 der->data += taglen;
 270 der->len -= taglen;
 271 return rc;
 272 }
 273
 274 /* Internal service routine:
 275 Read and move over an asn.1 integer, setting an MPI to the value
 276 */
 277
 278 static uschar *
 279 as_mpi(blob * der, gcry_mpi_t * mpi)
 280 {
 281 long alen;
 282 int rc;
 283 gcry_error_t gerr;
 284
 285 debug_printf_indent("%s\n", __FUNCTION__);
 286
 287 /* integer; move past the header */
 288 if ((rc = as_tag(der, 0, ASN1_TAG_INTEGER, &alen)) != ASN1_SUCCESS)
 289   return US asn1_strerror(rc);
 290
 291 /* read to an MPI */
 292 if ((gerr = gcry_mpi_scan(mpi, GCRYMPI_FMT_STD, der->data, alen, NULL)))
 293   return US gcry_strerror(gerr);
 294
 295 /* move over the data */
 296 der->data += alen; der->len -= alen;
 297 return NULL;
 298 }
 299
 300
 301
 302 void
 303 exim_dkim_init(void)
 304 {
 305 /* Version check should be the very first call because it
 306 makes sure that important subsystems are initialized. */
 307 if (!gcry_check_version (GCRYPT_VERSION))
 308   {
 309   fputs ("libgcrypt version mismatch\n", stderr);
 310   exit (2);
 311   }
 312
 313 /* We don't want to see any warnings, e.g. because we have not yet
 314 parsed program options which might be used to suppress such
 315 warnings. */
 316 gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
 317
 318 /* ... If required, other initialization goes here.  Note that the
 319 process might still be running with increased privileges and that
 320 the secure memory has not been initialized.  */
 321
 322 /* Allocate a pool of 16k secure memory.  This make the secure memory
 323 available and also drops privileges where needed.  */
 324 gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
 325
 326 /* It is now okay to let Libgcrypt complain when there was/is
 327 a problem with the secure memory. */
 328 gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
 329
 330 /* ... If required, other initialization goes here.  */
 331
 332 /* Tell Libgcrypt that initialization has completed. */
 333 gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
 334
 335 return;
 336 }
 337
 338
 339
 340
 341 /* Accumulate data (gnutls-only).
 342 String to be appended must be nul-terminated. */
 343
 344 gstring *
 345 exim_dkim_data_append(gstring * g, uschar * s)
 346 {
 347 return g;       /*dummy*/
 348 }
 349
 350
 351
 352 /* import private key from PEM string in memory.
 353 Only handles RSA keys.
 354 Return: NULL for success, or an error string */
 355
 356 const uschar *
 357 exim_dkim_signing_init(const uschar * privkey_pem, es_ctx * sign_ctx)
 358 {
 359 uschar * s1, * s2;
 360 blob der;
 361 long alen;
 362 int rc;
 363
 364 /*XXX will need extension to _spot_ as well as handle a
 365 non-RSA key?  I think...
 366 So... this is not a PrivateKeyInfo - which would have a field
 367 identifying the keytype - PrivateKeyAlgorithmIdentifier -
 368 but a plain RSAPrivateKey (wrapped in PEM-headers.  Can we
 369 use those as a type tag?  What forms are there?  "BEGIN EC PRIVATE KEY" (cf. ec(1ssl))
 370
 371 How does OpenSSL PEM_read_bio_PrivateKey() deal with it?
 372 gnutls_x509_privkey_import() ?
 373 */
 374
 375 /*
 376  *  RSAPrivateKey ::= SEQUENCE
 377  *      version           Version,
 378  *      modulus           INTEGER,  -- n
 379  *      publicExponent    INTEGER,  -- e
 380  *      privateExponent   INTEGER,  -- d
 381  *      prime1            INTEGER,  -- p
 382  *      prime2            INTEGER,  -- q
 383  *      exponent1         INTEGER,  -- d mod (p-1)
 384  *      exponent2         INTEGER,  -- d mod (q-1)
 385  *      coefficient       INTEGER,  -- (inverse of q) mod p
 386  *      otherPrimeInfos   OtherPrimeInfos OPTIONAL
 387
 388  * ECPrivateKey ::= SEQUENCE {
 389  *     version        INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),
 390  *     privateKey     OCTET STRING,
 391  *     parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,
 392  *     publicKey  [1] BIT STRING OPTIONAL
 393  *   }
 394  * Hmm, only 1 useful item, and not even an integer?  Wonder how we might use it...
 395
 396 - actually, gnutls_x509_privkey_import() appears to require a curve name parameter
 397         value for that is an OID? a local-only integer (it's an enum in GnuTLS)?
 398
 399
 400 Useful cmds:
 401   ssh-keygen -t ecdsa -f foo.privkey
 402   ssh-keygen -t ecdsa -b384 -f foo.privkey
 403   ssh-keygen -t ecdsa -b521 -f foo.privkey
 404   ssh-keygen -t ed25519 -f foo.privkey
 405
 406   < foo openssl pkcs8 -in /dev/stdin -inform PEM -nocrypt -topk8 -outform DER | od -x
 407
 408   openssl asn1parse -in foo -inform PEM -dump
 409   openssl asn1parse -in foo -inform PEM -dump -stroffset 24    (??)
 410 (not good for ed25519)
 411
 412  */
 413
 414 if (  !(s1 = Ustrstr(CS privkey_pem, "-----BEGIN RSA PRIVATE KEY-----"))
 415    || !(s2 = Ustrstr(CS (s1+=31),    "-----END RSA PRIVATE KEY-----" ))
 416    )
 417   return US"Bad PEM wrapper";
 418
 419 *s2 = '\0';
 420
 421 if ((rc = b64decode(s1, &der.data) < 0))
 422   return US"Bad PEM-DER b64 decode";
 423 der.len = rc;
 424
 425 /* untangle asn.1 */
 426
 427 /* sequence; just move past the header */
 428 if ((rc = as_tag(&der, ASN1_CLASS_STRUCTURED, ASN1_TAG_SEQUENCE, NULL))
 429    != ASN1_SUCCESS) goto asn_err;
 430
 431 /* integer version; move past the header, check is zero */
 432 if ((rc = as_tag(&der, 0, ASN1_TAG_INTEGER, &alen)) != ASN1_SUCCESS)
 433   goto asn_err;
 434 if (alen != 1 || *der.data != 0)
 435   return US"Bad version number";
 436 der.data++; der.len--;
 437
 438 if (  (s1 = as_mpi(&der, &sign_ctx->n))
 439    || (s1 = as_mpi(&der, &sign_ctx->e))
 440    || (s1 = as_mpi(&der, &sign_ctx->d))
 441    || (s1 = as_mpi(&der, &sign_ctx->p))
 442    || (s1 = as_mpi(&der, &sign_ctx->q))
 443    || (s1 = as_mpi(&der, &sign_ctx->dp))
 444    || (s1 = as_mpi(&der, &sign_ctx->dq))
 445    || (s1 = as_mpi(&der, &sign_ctx->qp))
 446    )
 447   return s1;
 448
 449 #ifdef extreme_debug
 450 DEBUG(D_acl) debug_printf_indent("rsa_signing_init:\n");
 451   {
 452   uschar * s;
 453   gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, sign_ctx->n);
 454   debug_printf_indent(" N : %s\n", s);
 455   gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, sign_ctx->e);
 456   debug_printf_indent(" E : %s\n", s);
 457   gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, sign_ctx->d);
 458   debug_printf_indent(" D : %s\n", s);
 459   gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, sign_ctx->p);
 460   debug_printf_indent(" P : %s\n", s);
 461   gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, sign_ctx->q);
 462   debug_printf_indent(" Q : %s\n", s);
 463   gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, sign_ctx->dp);
 464   debug_printf_indent(" DP: %s\n", s);
 465   gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, sign_ctx->dq);
 466   debug_printf_indent(" DQ: %s\n", s);
 467   gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, sign_ctx->qp);
 468   debug_printf_indent(" QP: %s\n", s);
 469   }
 470 #endif
 471
 472 sign_ctx->keytype = KEYTYPE_RSA;
 473 return NULL;
 474
 475 asn_err: return US asn1_strerror(rc);
 476 }
 477
 478
 479
 480 /* allocate mem for signature (when signing) */
 481 /* sign already-hashed data.
 482
 483 Return: NULL for success, or an error string */
 484
 485 const uschar *
 486 exim_dkim_sign(es_ctx * sign_ctx, hashmethod hash, blob * data, blob * sig)
 487 {
 488 char * sexp_hash;
 489 gcry_sexp_t s_hash = NULL, s_key = NULL, s_sig = NULL;
 490 gcry_mpi_t m_sig;
 491 uschar * errstr;
 492 gcry_error_t gerr;
 493
 494 /*XXX will need extension for hash types (though, possibly, should
 495 be re-specced to not rehash but take an already-hashed value? Actually
 496 current impl looks WRONG - it _is_ given a hash so should not be
 497 re-hashing.  Has this been tested?
 498
 499 Will need extension for non-RSA sugning algos. */
 500
 501 switch (hash)
 502   {
 503   case HASH_SHA1:       sexp_hash = "(data(flags pkcs1)(hash sha1 %b))"; break;
 504   case HASH_SHA2_256:   sexp_hash = "(data(flags pkcs1)(hash sha256 %b))"; break;
 505   default:              return US"nonhandled hash type";
 506   }
 507
 508 #define SIGSPACE 128
 509 sig->data = store_get(SIGSPACE, GET_UNTAINTED);
 510
 511 if (gcry_mpi_cmp (sign_ctx->p, sign_ctx->q) > 0)
 512   {
 513   gcry_mpi_swap (sign_ctx->p, sign_ctx->q);
 514   gcry_mpi_invm (sign_ctx->qp, sign_ctx->p, sign_ctx->q);
 515   }
 516
 517 if (  (gerr = gcry_sexp_build (&s_key, NULL,
 518                 "(private-key (rsa (n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
 519                 sign_ctx->n, sign_ctx->e,
 520                 sign_ctx->d, sign_ctx->p,
 521                 sign_ctx->q, sign_ctx->qp))
 522    || (gerr = gcry_sexp_build (&s_hash, NULL, sexp_hash,
 523                 (int) data->len, CS data->data))
 524    ||  (gerr = gcry_pk_sign (&s_sig, s_hash, s_key))
 525    )
 526   return US gcry_strerror(gerr);
 527
 528 /* gcry_sexp_dump(s_sig); */
 529
 530 if (  !(s_sig = gcry_sexp_find_token(s_sig, "s", 0))
 531    )
 532   return US"no sig result";
 533
 534 m_sig = gcry_sexp_nth_mpi(s_sig, 1, GCRYMPI_FMT_USG);
 535
 536 #ifdef extreme_debug
 537 DEBUG(D_acl)
 538   {
 539   uschar * s;
 540   gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, m_sig);
 541   debug_printf_indent(" SG: %s\n", s);
 542   }
 543 #endif
 544
 545 gerr = gcry_mpi_print(GCRYMPI_FMT_USG, sig->data, SIGSPACE, &sig->len, m_sig);
 546 if (gerr)
 547   {
 548   debug_printf_indent("signature conversion from MPI to buffer failed\n");
 549   return US gcry_strerror(gerr);
 550   }
 551 #undef SIGSPACE
 552
 553 return NULL;
 554 }
 555
 556
 557 /* import public key (from blob in memory)
 558 Return: NULL for success, or an error string */
 559
 560 const uschar *
 561 exim_dkim_verify_init(blob * pubkey, keyformat fmt, ev_ctx * verify_ctx,
 562   unsigned * bits)
 563 {
 564 /*
 565 in code sequence per b81207d2bfa92 rsa_parse_public_key() and asn1_get_mpi()
 566 */
 567 uschar tag_class;
 568 int taglen;
 569 long alen;
 570 unsigned nbits;
 571 int rc;
 572 uschar * errstr;
 573 gcry_error_t gerr;
 574 uschar * stage = US"S1";
 575
 576 if (fmt != KEYFMT_DER) return US"pubkey format not handled";
 577
 578 /*
 579 sequence
 580  sequence
 581   OBJECT:rsaEncryption
 582   NULL
 583  BIT STRING:RSAPublicKey
 584   sequence
 585    INTEGER:Public modulus
 586    INTEGER:Public exponent
 587
 588 openssl rsa -in aux-fixed/dkim/dkim.private -pubout -outform DER | od -t x1 | head;
 589 openssl rsa -in aux-fixed/dkim/dkim.private -pubout | openssl asn1parse -dump;
 590 openssl rsa -in aux-fixed/dkim/dkim.private -pubout | openssl asn1parse -dump -offset 22;
 591 */
 592
 593 /* sequence; just move past the header */
 594 if ((rc = as_tag(pubkey, ASN1_CLASS_STRUCTURED, ASN1_TAG_SEQUENCE, NULL))
 595    != ASN1_SUCCESS) goto asn_err;
 596
 597 /* sequence; skip the entire thing */
 598 DEBUG(D_acl) stage = US"S2";
 599 if ((rc = as_tag(pubkey, ASN1_CLASS_STRUCTURED, ASN1_TAG_SEQUENCE, &alen))
 600    != ASN1_SUCCESS) goto asn_err;
 601 pubkey->data += alen; pubkey->len -= alen;
 602
 603
 604 /* bitstring: limit range to size of bitstring;
 605 move over header + content wrapper */
 606 DEBUG(D_acl) stage = US"BS";
 607 if ((rc = as_tag(pubkey, 0, ASN1_TAG_BIT_STRING, &alen)) != ASN1_SUCCESS)
 608   goto asn_err;
 609 pubkey->len = alen;
 610 pubkey->data++; pubkey->len--;
 611
 612 /* sequence; just move past the header */
 613 DEBUG(D_acl) stage = US"S3";
 614 if ((rc = as_tag(pubkey, ASN1_CLASS_STRUCTURED, ASN1_TAG_SEQUENCE, NULL))
 615    != ASN1_SUCCESS) goto asn_err;
 616
 617 /* read two integers */
 618 DEBUG(D_acl) stage = US"MPI";
 619 nbits = pubkey->len;
 620 if ((errstr = as_mpi(pubkey, &verify_ctx->n))) return errstr;
 621 nbits = (nbits - pubkey->len) * 8;
 622 if ((errstr = as_mpi(pubkey, &verify_ctx->e))) return errstr;
 623
 624 #ifdef extreme_debug
 625 DEBUG(D_acl) debug_printf_indent("rsa_verify_init:\n");
 626         {
 627         uschar * s;
 628         gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, verify_ctx->n);
 629         debug_printf_indent(" N : %s\n", s);
 630         gcry_mpi_aprint (GCRYMPI_FMT_HEX, &s, NULL, verify_ctx->e);
 631         debug_printf_indent(" E : %s\n", s);
 632         }
 633
 634 #endif
 635 if (bits) *bits = nbits;
 636 return NULL;
 637
 638 asn_err:
 639 DEBUG(D_acl) return string_sprintf("%s: %s", stage, asn1_strerror(rc));
 640              return US asn1_strerror(rc);
 641 }
 642
 643
 644 /* verify signature (of hash)
 645 XXX though we appear to be doing a hash, too!
 646 (given pubkey & alleged sig)
 647 Return: NULL for success, or an error string */
 648
 649 const uschar *
 650 exim_dkim_verify(ev_ctx * verify_ctx, hashmethod hash, blob * data_hash, blob * sig)
 651 {
 652 /*
 653 cf. libgnutls 2.8.5 _wrap_gcry_pk_verify()
 654 */
 655 char * sexp_hash;
 656 gcry_mpi_t m_sig;
 657 gcry_sexp_t s_sig = NULL, s_hash = NULL, s_pkey = NULL;
 658 gcry_error_t gerr;
 659 uschar * stage;
 660
 661 /*XXX needs extension for SHA512 */
 662 switch (hash)
 663   {
 664   case HASH_SHA1:     sexp_hash = "(data(flags pkcs1)(hash sha1 %b))"; break;
 665   case HASH_SHA2_256: sexp_hash = "(data(flags pkcs1)(hash sha256 %b))"; break;
 666   default:            return US"nonhandled hash type";
 667   }
 668
 669 if (  (stage = US"pkey sexp build",
 670        gerr = gcry_sexp_build (&s_pkey, NULL, "(public-key(rsa(n%m)(e%m)))",
 671                         verify_ctx->n, verify_ctx->e))
 672    || (stage = US"data sexp build",
 673        gerr = gcry_sexp_build (&s_hash, NULL, sexp_hash,
 674                 (int) data_hash->len, CS data_hash->data))
 675    || (stage = US"sig mpi scan",
 676        gerr = gcry_mpi_scan(&m_sig, GCRYMPI_FMT_USG, sig->data, sig->len, NULL))
 677    || (stage = US"sig sexp build",
 678        gerr = gcry_sexp_build (&s_sig, NULL, "(sig-val(rsa(s%m)))", m_sig))
 679    || (stage = US"verify",
 680        gerr = gcry_pk_verify (s_sig, s_hash, s_pkey))
 681    )
 682   {
 683   DEBUG(D_acl) debug_printf_indent("verify: error in stage '%s'\n", stage);
 684   return US gcry_strerror(gerr);
 685   }
 686
 687 if (s_sig) gcry_sexp_release (s_sig);
 688 if (s_hash) gcry_sexp_release (s_hash);
 689 if (s_pkey) gcry_sexp_release (s_pkey);
 690 gcry_mpi_release (m_sig);
 691 gcry_mpi_release (verify_ctx->n);
 692 gcry_mpi_release (verify_ctx->e);
 693
 694 return NULL;
 695 }
 696
 697
 698
 699
 700 #elif defined(SIGN_OPENSSL)
 701 /******************************************************************************/
 702
 703 void
 704 exim_dkim_init(void)
 705 {
 706 ERR_load_crypto_strings();
 707 }
 708
 709
 710 /* accumulate data (was gnutls-only but now needed for OpenSSL non-EC too
 711 because now using hash-and-sign interface) */
 712 gstring *
 713 exim_dkim_data_append(gstring * g, uschar * s)
 714 {
 715 return string_cat(g, s);
 716 }
 717
 718
 719 /* import private key from PEM string in memory.
 720 Return: NULL for success, or an error string */
 721
 722 const uschar *
 723 exim_dkim_signing_init(const uschar * privkey_pem, es_ctx * sign_ctx)
 724 {
 725 BIO * bp = BIO_new_mem_buf((void *)privkey_pem, -1);
 726
 727 if (!(sign_ctx->key = PEM_read_bio_PrivateKey(bp, NULL, NULL, NULL)))
 728   return string_sprintf("privkey PEM-block import: %s",
 729                         ERR_error_string(ERR_get_error(), NULL));
 730
 731 sign_ctx->keytype =
 732 #ifdef SIGN_HAVE_ED25519
 733         EVP_PKEY_type(EVP_PKEY_id(sign_ctx->key)) == EVP_PKEY_ED25519
 734           ? KEYTYPE_ED25519 : KEYTYPE_RSA;
 735 #else
 736         KEYTYPE_RSA;
 737 #endif
 738 return NULL;
 739 }
 740
 741
 742
 743 /* allocate mem for signature (when signing) */
 744 /* hash & sign data.  Incremental not supported.
 745
 746 Return: NULL for success with the signaature in the sig blob, or an error string */
 747
 748 const uschar *
 749 exim_dkim_sign(es_ctx * sign_ctx, hashmethod hash, blob * data, blob * sig)
 750 {
 751 const EVP_MD * md;
 752 EVP_MD_CTX * ctx;
 753 size_t siglen;
 754
 755 switch (hash)
 756   {
 757   case HASH_NULL:       md = NULL;         break;       /* Ed25519 signing */
 758   case HASH_SHA1:       md = EVP_sha1();   break;
 759   case HASH_SHA2_256:   md = EVP_sha256(); break;
 760   case HASH_SHA2_512:   md = EVP_sha512(); break;
 761   default:              return US"nonhandled hash type";
 762   }
 763
 764 #ifdef SIGN_HAVE_ED25519
 765 if (  (ctx = EVP_MD_CTX_new())
 766    && EVP_DigestSignInit(ctx, NULL, md, NULL, sign_ctx->key) > 0
 767    && EVP_DigestSign(ctx, NULL, &siglen, NULL, 0) > 0
 768    && (sig->data = store_get(siglen, GET_UNTAINTED))
 769
 770    /* Obtain the signature (slen could change here!) */
 771    && EVP_DigestSign(ctx, sig->data, &siglen, data->data, data->len) > 0
 772    )
 773   {
 774   EVP_MD_CTX_destroy(ctx);
 775   sig->len = siglen;
 776   return NULL;
 777   }
 778 #else
 779 /*XXX renamed to EVP_MD_CTX_new() in 1.1.0 */
 780 if (  (ctx = EVP_MD_CTX_create())
 781    && EVP_DigestSignInit(ctx, NULL, md, NULL, sign_ctx->key) > 0
 782    && EVP_DigestSignUpdate(ctx, data->data, data->len) > 0
 783    && EVP_DigestSignFinal(ctx, NULL, &siglen) > 0
 784    && (sig->data = store_get(siglen, GET_UNTAINTED))
 785
 786    /* Obtain the signature (slen could change here!) */
 787    && EVP_DigestSignFinal(ctx, sig->data, &siglen) > 0
 788    )
 789   {
 790   EVP_MD_CTX_destroy(ctx);
 791   sig->len = siglen;
 792   return NULL;
 793   }
 794 #endif
 795
 796 if (ctx) EVP_MD_CTX_destroy(ctx);
 797 return US ERR_error_string(ERR_get_error(), NULL);
 798 }
 799
 800
 801
 802 /* import public key (from blob in memory)
 803 Return: NULL for success, or an error string */
 804
 805 const uschar *
 806 exim_dkim_verify_init(blob * pubkey, keyformat fmt, ev_ctx * verify_ctx,
 807   unsigned * bits)
 808 {
 809 const uschar * s = pubkey->data;
 810 uschar * ret = NULL;
 811
 812 switch(fmt)
 813   {
 814   case KEYFMT_DER:
 815     /*XXX hmm, we never free this */
 816     if (!(verify_ctx->key = d2i_PUBKEY(NULL, &s, pubkey->len)))
 817       ret = US ERR_error_string(ERR_get_error(), NULL);
 818     break;
 819 #ifdef SIGN_HAVE_ED25519
 820   case KEYFMT_ED25519_BARE:
 821     if (!(verify_ctx->key = EVP_PKEY_new_raw_public_key(EVP_PKEY_ED25519, NULL,
 822                                                         s, pubkey->len)))
 823       ret = US ERR_error_string(ERR_get_error(), NULL);
 824     break;
 825 #endif
 826   default:
 827     ret = US"pubkey format not handled";
 828     break;
 829   }
 830
 831 if (!ret && bits) *bits = EVP_PKEY_bits(verify_ctx->key);
 832 return ret;
 833 }
 834
 835
 836
 837
 838 /* verify signature (of hash, except Ed25519 where of-data)
 839 (given pubkey & alleged sig)
 840 Return: NULL for success, or an error string */
 841
 842 const uschar *
 843 exim_dkim_verify(ev_ctx * verify_ctx, hashmethod hash, blob * data, blob * sig)
 844 {
 845 const EVP_MD * md;
 846
 847 switch (hash)
 848   {
 849   case HASH_NULL:       md = NULL;         break;
 850   case HASH_SHA1:       md = EVP_sha1();   break;
 851   case HASH_SHA2_256:   md = EVP_sha256(); break;
 852   case HASH_SHA2_512:   md = EVP_sha512(); break;
 853   default:              return US"nonhandled hash type";
 854   }
 855
 856 #ifdef SIGN_HAVE_ED25519
 857 if (!md)
 858   {
 859   EVP_MD_CTX * ctx;
 860
 861   if ((ctx = EVP_MD_CTX_new()))
 862     {
 863     if (  EVP_DigestVerifyInit(ctx, NULL, md, NULL, verify_ctx->key) > 0
 864        && EVP_DigestVerify(ctx, sig->data, sig->len, data->data, data->len) > 0
 865        )
 866       { EVP_MD_CTX_free(ctx); return NULL; }
 867     EVP_MD_CTX_free(ctx);
 868     }
 869   }
 870 else
 871 #endif
 872   {
 873   EVP_PKEY_CTX * ctx;
 874
 875   if ((ctx = EVP_PKEY_CTX_new(verify_ctx->key, NULL)))
 876     {
 877     if (  EVP_PKEY_verify_init(ctx) > 0
 878        && EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) > 0
 879        && EVP_PKEY_CTX_set_signature_md(ctx, md) > 0
 880        && EVP_PKEY_verify(ctx, sig->data, sig->len,
 881                                       data->data, data->len) == 1
 882        )
 883       { EVP_PKEY_CTX_free(ctx); return NULL; }
 884     EVP_PKEY_CTX_free(ctx);
 885
 886     DEBUG(D_tls)
 887       if (Ustrcmp(ERR_reason_error_string(ERR_peek_error()), "wrong signature length") == 0)
 888         debug_printf("sig len (from msg hdr): %d, expected (from dns pubkey) %d\n",
 889          (int) sig->len, EVP_PKEY_size(verify_ctx->key));
 890     }
 891   }
 892
 893 return US ERR_error_string(ERR_get_error(), NULL);
 894 }
 895
 896
 897
 898 #endif
 899 /******************************************************************************/
 900
 901 #endif  /*DISABLE_DKIM*/
 902 #endif  /*MACRO_PREDEF*/
 903 /* End of File */