src/ssl/support.cc

   1 /*
   2  * Copyright (C) 1996-2021 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 /* DEBUG: section 83    SSL accelerator support */
  10
  11 #include "squid.h"
  12
  13 /* MS Visual Studio Projects are monolithic, so we need the following
  14  * #if to exclude the SSL code from compile process when not needed.
  15  */
  16 #if USE_OPENSSL
  17
  18 #include "acl/FilledChecklist.h"
  19 #include "anyp/PortCfg.h"
  20 #include "anyp/Uri.h"
  21 #include "fatal.h"
  22 #include "fd.h"
  23 #include "fde.h"
  24 #include "globals.h"
  25 #include "ipc/MemMap.h"
  26 #include "security/CertError.h"
  27 #include "security/ErrorDetail.h"
  28 #include "security/Session.h"
  29 #include "SquidConfig.h"
  30 #include "SquidTime.h"
  31 #include "ssl/bio.h"
  32 #include "ssl/Config.h"
  33 #include "ssl/ErrorDetail.h"
  34 #include "ssl/gadgets.h"
  35 #include "ssl/support.h"
  36
  37 #include <cerrno>
  38
  39 // TODO: Move ssl_ex_index_* global variables from global.cc here.
  40 static int ssl_ex_index_verify_callback_parameters = -1;
  41
  42 static Ssl::CertsIndexedList SquidUntrustedCerts;
  43
  44 const EVP_MD *Ssl::DefaultSignHash = NULL;
  45
  46 std::vector<const char *> Ssl::BumpModeStr = {
  47     "none",
  48     "client-first",
  49     "server-first",
  50     "peek",
  51     "stare",
  52     "bump",
  53     "splice",
  54     "terminate"
  55     /*,"err"*/
  56 };
  57
  58 /**
  59  \defgroup ServerProtocolSSLInternal Server-Side SSL Internals
  60  \ingroup ServerProtocolSSLAPI
  61  */
  62
  63 int
  64 Ssl::AskPasswordCb(char *buf, int size, int rwflag, void *userdata)
  65 {
  66     FILE *in;
  67     int len = 0;
  68     char cmdline[1024];
  69
  70     snprintf(cmdline, sizeof(cmdline), "\"%s\" \"%s\"", ::Config.Program.ssl_password, (const char *)userdata);
  71     in = popen(cmdline, "r");
  72
  73     if (fgets(buf, size, in))
  74
  75         len = strlen(buf);
  76
  77     while (len > 0 && (buf[len - 1] == '\n' || buf[len - 1] == '\r'))
  78         --len;
  79
  80     buf[len] = '\0';
  81
  82     pclose(in);
  83
  84     return len;
  85 }
  86
  87 /// \ingroup ServerProtocolSSLInternal
  88 static void
  89 ssl_ask_password(SSL_CTX * context, const char * prompt)
  90 {
  91     if (Config.Program.ssl_password) {
  92         SSL_CTX_set_default_passwd_cb(context, Ssl::AskPasswordCb);
  93         SSL_CTX_set_default_passwd_cb_userdata(context, (void *)prompt);
  94     }
  95 }
  96
  97 #if HAVE_LIBSSL_SSL_CTX_SET_TMP_RSA_CALLBACK
  98 static RSA *
  99 ssl_temp_rsa_cb(SSL * ssl, int anInt, int keylen)
 100 {
 101     static RSA *rsa_512 = nullptr;
 102     static RSA *rsa_1024 = nullptr;
 103     static BIGNUM *e = nullptr;
 104     RSA *rsa = nullptr;
 105     int newkey = 0;
 106
 107     if (!e) {
 108         e = BN_new();
 109         if (!e || !BN_set_word(e, RSA_F4)) {
 110             debugs(83, DBG_IMPORTANT, "ssl_temp_rsa_cb: Failed to set exponent for key " << keylen);
 111             BN_free(e);
 112             e = nullptr;
 113             return nullptr;
 114         }
 115     }
 116
 117     switch (keylen) {
 118
 119     case 512:
 120
 121         if (!rsa_512) {
 122             rsa_512 = RSA_new();
 123             if (rsa_512 && RSA_generate_key_ex(rsa_512, 512, e, nullptr)) {
 124                 newkey = 1;
 125             } else {
 126                 RSA_free(rsa_512);
 127                 rsa_512 = nullptr;
 128             }
 129         }
 130
 131         rsa = rsa_512;
 132         break;
 133
 134     case 1024:
 135
 136         if (!rsa_1024) {
 137             rsa_1024 = RSA_new();
 138             if (rsa_1024 && RSA_generate_key_ex(rsa_1024, 1024, e, nullptr)) {
 139                 newkey = 1;
 140             } else {
 141                 RSA_free(rsa_1024);
 142                 rsa_1024 = nullptr;
 143             }
 144         }
 145
 146         rsa = rsa_1024;
 147         break;
 148
 149     default:
 150         debugs(83, DBG_IMPORTANT, "ssl_temp_rsa_cb: Unexpected key length " << keylen);
 151         return NULL;
 152     }
 153
 154     if (rsa == NULL) {
 155         debugs(83, DBG_IMPORTANT, "ssl_temp_rsa_cb: Failed to generate key " << keylen);
 156         return NULL;
 157     }
 158
 159     if (newkey) {
 160         if (Debug::Enabled(83, 5))
 161             PEM_write_RSAPrivateKey(debug_log, rsa, NULL, NULL, 0, NULL, NULL);
 162
 163         debugs(83, DBG_IMPORTANT, "Generated ephemeral RSA key of length " << keylen);
 164     }
 165
 166     return rsa;
 167 }
 168 #endif
 169
 170 void
 171 Ssl::MaybeSetupRsaCallback(Security::ContextPointer &ctx)
 172 {
 173 #if HAVE_LIBSSL_SSL_CTX_SET_TMP_RSA_CALLBACK
 174     debugs(83, 9, "Setting RSA key generation callback.");
 175     SSL_CTX_set_tmp_rsa_callback(ctx.get(), ssl_temp_rsa_cb);
 176 #endif
 177 }
 178
 179 int Ssl::asn1timeToString(ASN1_TIME *tm, char *buf, int len)
 180 {
 181     BIO *bio;
 182     int write = 0;
 183     bio = BIO_new(BIO_s_mem());
 184     if (bio) {
 185         if (ASN1_TIME_print(bio, tm))
 186             write = BIO_read(bio, buf, len-1);
 187         BIO_free(bio);
 188     }
 189     buf[write]='\0';
 190     return write;
 191 }
 192
 193 int Ssl::matchX509CommonNames(X509 *peer_cert, void *check_data, int (*check_func)(void *check_data,  ASN1_STRING *cn_data))
 194 {
 195     assert(peer_cert);
 196
 197     X509_NAME *name = X509_get_subject_name(peer_cert);
 198
 199     for (int i = X509_NAME_get_index_by_NID(name, NID_commonName, -1); i >= 0; i = X509_NAME_get_index_by_NID(name, NID_commonName, i)) {
 200
 201         ASN1_STRING *cn_data = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(name, i));
 202
 203         if ( (*check_func)(check_data, cn_data) == 0)
 204             return 1;
 205     }
 206
 207     STACK_OF(GENERAL_NAME) * altnames;
 208     altnames = (STACK_OF(GENERAL_NAME)*)X509_get_ext_d2i(peer_cert, NID_subject_alt_name, NULL, NULL);
 209
 210     if (altnames) {
 211         int numalts = sk_GENERAL_NAME_num(altnames);
 212         for (int i = 0; i < numalts; ++i) {
 213             const GENERAL_NAME *check = sk_GENERAL_NAME_value(altnames, i);
 214             if (check->type != GEN_DNS) {
 215                 continue;
 216             }
 217             ASN1_STRING *cn_data = check->d.dNSName;
 218
 219             if ( (*check_func)(check_data, cn_data) == 0) {
 220                 sk_GENERAL_NAME_pop_free(altnames, GENERAL_NAME_free);
 221                 return 1;
 222             }
 223         }
 224         sk_GENERAL_NAME_pop_free(altnames, GENERAL_NAME_free);
 225     }
 226     return 0;
 227 }
 228
 229 static int check_domain( void *check_data, ASN1_STRING *cn_data)
 230 {
 231     char cn[1024];
 232     const char *server = (const char *)check_data;
 233
 234     if (cn_data->length == 0)
 235         return 1; // zero length cn, ignore
 236
 237     if (cn_data->length > (int)sizeof(cn) - 1)
 238         return 1; //if does not fit our buffer just ignore
 239
 240     char *s = reinterpret_cast<char*>(cn_data->data);
 241     char *d = cn;
 242     for (int i = 0; i < cn_data->length; ++i, ++d, ++s) {
 243         if (*s == '\0')
 244             return 1; // always a domain mismatch. contains 0x00
 245         *d = *s;
 246     }
 247     cn[cn_data->length] = '\0';
 248     debugs(83, 4, "Verifying server domain " << server << " to certificate name/subjectAltName " << cn);
 249     return matchDomainName(server, (cn[0] == '*' ? cn + 1 : cn), mdnRejectSubsubDomains);
 250 }
 251
 252 bool Ssl::checkX509ServerValidity(X509 *cert, const char *server)
 253 {
 254     return matchX509CommonNames(cert, (void *)server, check_domain);
 255 }
 256
 257 /// adjusts OpenSSL validation results for each verified certificate in ctx
 258 /// OpenSSL "verify_callback function" (\ref OpenSSL_vcb_disambiguation)
 259 static int
 260 ssl_verify_cb(int ok, X509_STORE_CTX * ctx)
 261 {
 262     // preserve original ctx->error before SSL_ calls can overwrite it
 263     Security::ErrorCode error_no = ok ? SSL_ERROR_NONE : X509_STORE_CTX_get_error(ctx);
 264
 265     char buffer[256] = "";
 266     SSL *ssl = (SSL *)X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
 267     SSL_CTX *sslctx = SSL_get_SSL_CTX(ssl);
 268     SBuf *server = (SBuf *)SSL_get_ex_data(ssl, ssl_ex_index_server);
 269     void *dont_verify_domain = SSL_CTX_get_ex_data(sslctx, ssl_ctx_ex_index_dont_verify_domain);
 270     ACLChecklist *check = (ACLChecklist*)SSL_get_ex_data(ssl, ssl_ex_index_cert_error_check);
 271     X509 *peeked_cert = (X509 *)SSL_get_ex_data(ssl, ssl_ex_index_ssl_peeked_cert);
 272     Security::CertPointer peer_cert;
 273     peer_cert.resetAndLock(X509_STORE_CTX_get0_cert(ctx));
 274
 275     X509_NAME_oneline(X509_get_subject_name(peer_cert.get()), buffer, sizeof(buffer));
 276
 277     // detect infinite loops
 278     uint32_t *validationCounter = static_cast<uint32_t *>(SSL_get_ex_data(ssl, ssl_ex_index_ssl_validation_counter));
 279     if (!validationCounter) {
 280         validationCounter = new uint32_t(1);
 281         SSL_set_ex_data(ssl, ssl_ex_index_ssl_validation_counter, validationCounter);
 282     } else {
 283         // overflows allowed if SQUID_CERT_VALIDATION_ITERATION_MAX >= UINT32_MAX
 284         (*validationCounter)++;
 285     }
 286
 287     if ((*validationCounter) >= SQUID_CERT_VALIDATION_ITERATION_MAX) {
 288         ok = 0; // or the validation loop will never stop
 289         error_no = SQUID_X509_V_ERR_INFINITE_VALIDATION;
 290         debugs(83, 2, "SQUID_X509_V_ERR_INFINITE_VALIDATION: " <<
 291                *validationCounter << " iterations while checking " << buffer);
 292     }
 293
 294     if (ok) {
 295         debugs(83, 5, "SSL Certificate signature OK: " << buffer);
 296
 297         // Check for domain mismatch only if the current certificate is the peer certificate.
 298         if (!dont_verify_domain && server && peer_cert.get() == X509_STORE_CTX_get_current_cert(ctx)) {
 299             if (!Ssl::checkX509ServerValidity(peer_cert.get(), server->c_str())) {
 300                 debugs(83, 2, "SQUID_X509_V_ERR_DOMAIN_MISMATCH: Certificate " << buffer << " does not match domainname " << server);
 301                 ok = 0;
 302                 error_no = SQUID_X509_V_ERR_DOMAIN_MISMATCH;
 303             }
 304         }
 305     }
 306
 307     if (ok && peeked_cert) {
 308         // Check whether the already peeked certificate matches the new one.
 309         if (X509_cmp(peer_cert.get(), peeked_cert) != 0) {
 310             debugs(83, 2, "SQUID_X509_V_ERR_CERT_CHANGE: Certificate " << buffer << " does not match peeked certificate");
 311             ok = 0;
 312             error_no =  SQUID_X509_V_ERR_CERT_CHANGE;
 313         }
 314     }
 315
 316     if (!ok && error_no == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY) {
 317         if (const auto params = Ssl::VerifyCallbackParameters::Find(*ssl)) {
 318             if (params->callerHandlesMissingCertificates) {
 319                 debugs(83, 3, "hiding X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY");
 320                 params->hidMissingIssuer = true;
 321                 ok = 1;
 322             }
 323         }
 324     }
 325
 326     if (!ok) {
 327         Security::CertPointer broken_cert;
 328         broken_cert.resetAndLock(X509_STORE_CTX_get_current_cert(ctx));
 329         if (!broken_cert)
 330             broken_cert = peer_cert;
 331
 332         Security::CertErrors *errs = static_cast<Security::CertErrors *>(SSL_get_ex_data(ssl, ssl_ex_index_ssl_errors));
 333         const int depth = X509_STORE_CTX_get_error_depth(ctx);
 334         if (!errs) {
 335             errs = new Security::CertErrors(Security::CertError(error_no, broken_cert, depth));
 336             if (!SSL_set_ex_data(ssl, ssl_ex_index_ssl_errors,  (void *)errs)) {
 337                 debugs(83, 2, "Failed to set ssl error_no in ssl_verify_cb: Certificate " << buffer);
 338                 delete errs;
 339                 errs = NULL;
 340             }
 341         } else // remember another error number
 342             errs->push_back_unique(Security::CertError(error_no, broken_cert, depth));
 343
 344         if (const char *err_descr = Ssl::GetErrorDescr(error_no))
 345             debugs(83, 5, err_descr << ": " << buffer);
 346         else
 347             debugs(83, DBG_IMPORTANT, "SSL unknown certificate error " << error_no << " in " << buffer);
 348
 349         // Check if the certificate error can be bypassed.
 350         // Infinity validation loop errors can not bypassed.
 351         if (error_no != SQUID_X509_V_ERR_INFINITE_VALIDATION) {
 352             if (check) {
 353                 ACLFilledChecklist *filledCheck = Filled(check);
 354                 assert(!filledCheck->sslErrors);
 355                 filledCheck->sslErrors = new Security::CertErrors(Security::CertError(error_no, broken_cert));
 356                 filledCheck->serverCert = peer_cert;
 357                 if (check->fastCheck().allowed()) {
 358                     debugs(83, 3, "bypassing SSL error " << error_no << " in " << buffer);
 359                     ok = 1;
 360                 } else {
 361                     debugs(83, 5, "confirming SSL error " << error_no);
 362                 }
 363                 delete filledCheck->sslErrors;
 364                 filledCheck->sslErrors = NULL;
 365                 filledCheck->serverCert.reset();
 366             }
 367             // If the certificate validator is used then we need to allow all errors and
 368             // pass them to certificate validator for more processing
 369             else if (Ssl::TheConfig.ssl_crt_validator) {
 370                 ok = 1;
 371             }
 372         }
 373     }
 374
 375     if (Ssl::TheConfig.ssl_crt_validator) {
 376         // Check if we have stored certificates chain. Store if not.
 377         if (!SSL_get_ex_data(ssl, ssl_ex_index_ssl_cert_chain)) {
 378             STACK_OF(X509) *certStack = X509_STORE_CTX_get1_chain(ctx);
 379             if (certStack && !SSL_set_ex_data(ssl, ssl_ex_index_ssl_cert_chain, certStack))
 380                 sk_X509_pop_free(certStack, X509_free);
 381         }
 382     }
 383
 384     if (!ok && !SSL_get_ex_data(ssl, ssl_ex_index_ssl_error_detail) ) {
 385
 386         // Find the broken certificate. It may be intermediate.
 387         Security::CertPointer broken_cert(peer_cert); // reasonable default if search fails
 388         // Our SQUID_X509_V_ERR_DOMAIN_MISMATCH implies peer_cert is at fault.
 389         if (error_no != SQUID_X509_V_ERR_DOMAIN_MISMATCH) {
 390             if (auto *last_used_cert = X509_STORE_CTX_get_current_cert(ctx))
 391                 broken_cert.resetAndLock(last_used_cert);
 392         }
 393
 394         std::unique_ptr<Security::ErrorDetail::Pointer> edp(new Security::ErrorDetail::Pointer(
 395                     new Security::ErrorDetail(error_no, peer_cert, broken_cert)));
 396         if (SSL_set_ex_data(ssl, ssl_ex_index_ssl_error_detail, edp.get()))
 397             edp.release();
 398         else
 399             debugs(83, 2, "failed to store a " << buffer << " error detail: " << *edp);
 400     }
 401
 402     return ok;
 403 }
 404
 405 void
 406 Ssl::ConfigurePeerVerification(Security::ContextPointer &ctx, const Security::ParsedPortFlags flags)
 407 {
 408     int mode;
 409
 410     // assume each flag is exclusive; flags creator must check this assumption
 411     if (flags & SSL_FLAG_DONT_VERIFY_PEER) {
 412         debugs(83, DBG_IMPORTANT, "SECURITY WARNING: Peer certificates are not verified for validity!");
 413         debugs(83, DBG_IMPORTANT, "UPGRADE NOTICE: The DONT_VERIFY_PEER flag is deprecated. Remove the clientca= option to disable client certificates.");
 414         mode = SSL_VERIFY_NONE;
 415     }
 416     else if (flags & SSL_FLAG_DELAYED_AUTH) {
 417         debugs(83, DBG_PARSE_NOTE(3), "not requesting client certificates until ACL processing requires one");
 418         mode = SSL_VERIFY_NONE;
 419     }
 420     else if (flags & SSL_FLAG_CONDITIONAL_AUTH) {
 421         debugs(83, DBG_PARSE_NOTE(3), "will request the client certificate but ignore its absence");
 422         mode = SSL_VERIFY_PEER;
 423     }
 424     else {
 425         debugs(83, DBG_PARSE_NOTE(3), "Requiring client certificates.");
 426         mode = SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
 427     }
 428
 429     SSL_CTX_set_verify(ctx.get(), mode, (mode != SSL_VERIFY_NONE) ? ssl_verify_cb : nullptr);
 430 }
 431
 432 void
 433 Ssl::DisablePeerVerification(Security::ContextPointer &ctx)
 434 {
 435     debugs(83, DBG_PARSE_NOTE(3), "Not requiring any client certificates");
 436     SSL_CTX_set_verify(ctx.get(),SSL_VERIFY_NONE,nullptr);
 437 }
 438
 439 static int VerifyCtxCertificates(X509_STORE_CTX *ctx, STACK_OF(X509) *extraCerts);
 440
 441 bool
 442 Ssl::VerifyConnCertificates(Security::Connection &sconn, const Ssl::X509_STACK_Pointer &extraCerts)
 443 {
 444     const auto peerCertificatesChain = SSL_get_peer_cert_chain(&sconn);
 445
 446     // TODO: Replace debugs/return false with returning ErrorDetail::Pointer.
 447     // Using Security::ErrorDetail terminology, errors in _this_ function are
 448     // "non-validation errors", but VerifyCtxCertificates() errors may be
 449     // "certificate validation errors". Callers detail SQUID_TLS_ERR_CONNECT.
 450     // Some details should be created right here. Others extracted from OpenSSL.
 451     // Why not throw? Most of the reasons detailed in the following commit apply
 452     // here as well: https://github.com/measurement-factory/squid/commit/e862d33
 453
 454     if (!peerCertificatesChain || sk_X509_num(peerCertificatesChain) == 0) {
 455         debugs(83, 2, "no server certificates");
 456         return false;
 457     }
 458
 459     const auto verificationStore = SSL_CTX_get_cert_store(SSL_get_SSL_CTX(&sconn));
 460     if (!verificationStore) {
 461         debugs(83, 2, "no certificate store");
 462         return false;
 463     }
 464
 465     const X509_STORE_CTX_Pointer storeCtx(X509_STORE_CTX_new());
 466     if (!storeCtx) {
 467         debugs(83, 2, "cannot create X509_STORE_CTX; likely OOM");
 468         return false;
 469     }
 470
 471     const auto peerCert = sk_X509_value(peerCertificatesChain, 0);
 472     if (!X509_STORE_CTX_init(storeCtx.get(), verificationStore, peerCert, peerCertificatesChain)) {
 473         debugs(83, 2, "cannot initialize X509_STORE_CTX");
 474         return false;
 475     }
 476
 477 #if defined(SSL_CERT_FLAG_SUITEB_128_LOS)
 478     // overwrite context Suite B (RFC 5759) flags with connection non-defaults
 479     // SSL_set_cert_flags() return type is long, but its implementation actually
 480     // returns an unsigned long flags value expected by X509_STORE_CTX_set_flags
 481     const unsigned long certFlags = SSL_set_cert_flags(&sconn, 0);
 482     if (const auto suiteBflags = certFlags & SSL_CERT_FLAG_SUITEB_128_LOS)
 483         X509_STORE_CTX_set_flags(storeCtx.get(), suiteBflags);
 484 #endif
 485
 486     if (!X509_STORE_CTX_set_ex_data(storeCtx.get(), SSL_get_ex_data_X509_STORE_CTX_idx(), &sconn)) {
 487         debugs(83, 2, "cannot attach SSL object to X509_STORE_CTX");
 488         return false;
 489     }
 490
 491     // If we ever add DANE support to Squid, we will supply DANE details here:
 492     // X509_STORE_CTX_set0_dane(storeCtx.get(), SSL_get0_dane(&sconn));
 493
 494     // tell OpenSSL we are verifying a server certificate
 495     if (!X509_STORE_CTX_set_default(storeCtx.get(), "ssl_server")) {
 496         debugs(83, 2, "cannot set default verification method to ssl_server");
 497         return false;
 498     }
 499
 500     // overwrite context "verification parameters" with connection non-defaults
 501     const auto param = X509_STORE_CTX_get0_param(storeCtx.get());
 502     if (!param) {
 503         debugs(83, 2, "no context verification parameters");
 504         return false;
 505     }
 506 #if defined(HAVE_X509_VERIFY_PARAM_SET_AUTH_LEVEL)
 507     X509_VERIFY_PARAM_set_auth_level(param, SSL_get_security_level(&sconn));
 508 #endif
 509     if (!X509_VERIFY_PARAM_set1(param, SSL_get0_param(&sconn))) {
 510         debugs(83, 2, "cannot overwrite context verification parameters");
 511         return false;
 512     }
 513
 514     // copy any connection "verify_callback function" to the validation context
 515     // (\ref OpenSSL_vcb_disambiguation)
 516     if (const auto cb = SSL_get_verify_callback(&sconn))
 517         X509_STORE_CTX_set_verify_cb(storeCtx.get(), cb);
 518
 519     // verify the server certificate chain in the prepared validation context
 520     if (VerifyCtxCertificates(storeCtx.get(), extraCerts.get()) <= 0) {
 521         // see also: ssl_verify_cb() details errors via ssl_ex_index_ssl_errors
 522         const auto verifyResult = X509_STORE_CTX_get_error(storeCtx.get());
 523         debugs(83, 3, "verification failure: " << verifyResult << ' ' << X509_verify_cert_error_string(verifyResult));
 524         return false;
 525     }
 526
 527     debugs(83, 7, "success");
 528     return true;
 529 }
 530
 531 /* Ssl::VerifyCallbackParameters */
 532
 533 Ssl::VerifyCallbackParameters *
 534 Ssl::VerifyCallbackParameters::Find(Security::Connection &sconn)
 535 {
 536     return static_cast<VerifyCallbackParameters*>(SSL_get_ex_data(&sconn, ssl_ex_index_verify_callback_parameters));
 537 }
 538
 539 Ssl::VerifyCallbackParameters *
 540 Ssl::VerifyCallbackParameters::New(Security::Connection &sconn)
 541 {
 542     Must(!Find(sconn));
 543     const auto parameters = new VerifyCallbackParameters();
 544     if (!SSL_set_ex_data(&sconn, ssl_ex_index_verify_callback_parameters, parameters)) {
 545         delete parameters;
 546         throw TextException("SSL_set_ex_data() failed; likely OOM", Here());
 547     }
 548     return parameters;
 549 }
 550
 551 Ssl::VerifyCallbackParameters &
 552 Ssl::VerifyCallbackParameters::At(Security::Connection &sconn)
 553 {
 554     const auto parameters = Find(sconn);
 555     Must(parameters);
 556     return *parameters;
 557 }
 558
 559 // "dup" function for SSL_get_ex_new_index("cert_err_check")
 560 #if SQUID_USE_CONST_CRYPTO_EX_DATA_DUP
 561 static int
 562 ssl_dupAclChecklist(CRYPTO_EX_DATA *, const CRYPTO_EX_DATA *, void *,
 563                     int, long, void *)
 564 #else
 565 static int
 566 ssl_dupAclChecklist(CRYPTO_EX_DATA *, CRYPTO_EX_DATA *, void *,
 567                     int, long, void *)
 568 #endif
 569 {
 570     // We do not support duplication of ACLCheckLists.
 571     // If duplication is needed, we can count copies with cbdata.
 572     assert(false);
 573     return 0;
 574 }
 575
 576 // "free" function for SSL_get_ex_new_index("cert_err_check")
 577 static void
 578 ssl_freeAclChecklist(void *, void *ptr, CRYPTO_EX_DATA *,
 579                      int, long, void *)
 580 {
 581     delete static_cast<ACLChecklist *>(ptr); // may be NULL
 582 }
 583
 584 // "free" function for SSL_get_ex_new_index("ssl_error_detail")
 585 static void
 586 ssl_free_ErrorDetail(void *, void *ptr, CRYPTO_EX_DATA *,
 587                      int, long, void *)
 588 {
 589     const auto errDetail = static_cast<Security::ErrorDetail::Pointer*>(ptr);
 590     delete errDetail;
 591 }
 592
 593 static void
 594 ssl_free_SslErrors(void *, void *ptr, CRYPTO_EX_DATA *,
 595                    int, long, void *)
 596 {
 597     Security::CertErrors *errs = static_cast <Security::CertErrors*>(ptr);
 598     delete errs;
 599 }
 600
 601 // "free" function for SSL_get_ex_new_index("ssl_ex_index_ssl_validation_counter")
 602 static void
 603 ssl_free_int(void *, void *ptr, CRYPTO_EX_DATA *,
 604              int, long, void *)
 605 {
 606     uint32_t *counter = static_cast <uint32_t *>(ptr);
 607     delete counter;
 608 }
 609
 610 /// \ingroup ServerProtocolSSLInternal
 611 /// Callback handler function to release STACK_OF(X509) "ex" data stored
 612 /// in an SSL object.
 613 static void
 614 ssl_free_CertChain(void *, void *ptr, CRYPTO_EX_DATA *,
 615                    int, long, void *)
 616 {
 617     STACK_OF(X509) *certsChain = static_cast <STACK_OF(X509) *>(ptr);
 618     sk_X509_pop_free(certsChain,X509_free);
 619 }
 620
 621 // "free" function for X509 certificates
 622 static void
 623 ssl_free_X509(void *, void *ptr, CRYPTO_EX_DATA *,
 624               int, long, void *)
 625 {
 626     X509  *cert = static_cast <X509 *>(ptr);
 627     X509_free(cert);
 628 }
 629
 630 // "free" function for SBuf
 631 static void
 632 ssl_free_SBuf(void *, void *ptr, CRYPTO_EX_DATA *,
 633               int, long, void *)
 634 {
 635     SBuf  *buf = static_cast <SBuf *>(ptr);
 636     delete buf;
 637 }
 638
 639 /// "free" function for the ssl_ex_index_verify_callback_parameters entry
 640 static void
 641 ssl_free_VerifyCallbackParameters(void *, void *ptr, CRYPTO_EX_DATA *,
 642                                   int, long, void *)
 643 {
 644     delete static_cast<Ssl::VerifyCallbackParameters*>(ptr);
 645 }
 646
 647 void
 648 Ssl::Initialize(void)
 649 {
 650     static bool initialized = false;
 651     if (initialized)
 652         return;
 653     initialized = true;
 654
 655     SQUID_OPENSSL_init_ssl();
 656
 657 #if !defined(OPENSSL_NO_ENGINE)
 658     if (::Config.SSL.ssl_engine) {
 659         ENGINE_load_builtin_engines();
 660         ENGINE *e;
 661         if (!(e = ENGINE_by_id(::Config.SSL.ssl_engine)))
 662             fatalf("Unable to find SSL engine '%s'\n", ::Config.SSL.ssl_engine);
 663
 664         if (!ENGINE_set_default(e, ENGINE_METHOD_ALL)) {
 665             const auto ssl_error = ERR_get_error();
 666             fatalf("Failed to initialise SSL engine: %s\n", Security::ErrorString(ssl_error));
 667         }
 668     }
 669 #else
 670     if (::Config.SSL.ssl_engine)
 671         fatalf("Your OpenSSL has no SSL engine support\n");
 672 #endif
 673
 674     const char *defName = ::Config.SSL.certSignHash ? ::Config.SSL.certSignHash : SQUID_SSL_SIGN_HASH_IF_NONE;
 675     Ssl::DefaultSignHash = EVP_get_digestbyname(defName);
 676     if (!Ssl::DefaultSignHash)
 677         fatalf("Sign hash '%s' is not supported\n", defName);
 678
 679     ssl_ex_index_server = SSL_get_ex_new_index(0, (void *) "server", NULL, NULL, ssl_free_SBuf);
 680     ssl_ctx_ex_index_dont_verify_domain = SSL_CTX_get_ex_new_index(0, (void *) "dont_verify_domain", NULL, NULL, NULL);
 681     ssl_ex_index_cert_error_check = SSL_get_ex_new_index(0, (void *) "cert_error_check", NULL, &ssl_dupAclChecklist, &ssl_freeAclChecklist);
 682     ssl_ex_index_ssl_error_detail = SSL_get_ex_new_index(0, (void *) "ssl_error_detail", NULL, NULL, &ssl_free_ErrorDetail);
 683     ssl_ex_index_ssl_peeked_cert  = SSL_get_ex_new_index(0, (void *) "ssl_peeked_cert", NULL, NULL, &ssl_free_X509);
 684     ssl_ex_index_ssl_errors =  SSL_get_ex_new_index(0, (void *) "ssl_errors", NULL, NULL, &ssl_free_SslErrors);
 685     ssl_ex_index_ssl_cert_chain = SSL_get_ex_new_index(0, (void *) "ssl_cert_chain", NULL, NULL, &ssl_free_CertChain);
 686     ssl_ex_index_ssl_validation_counter = SSL_get_ex_new_index(0, (void *) "ssl_validation_counter", NULL, NULL, &ssl_free_int);
 687     ssl_ex_index_verify_callback_parameters = SSL_get_ex_new_index(0, (void *) "verify_callback_parameters", nullptr, nullptr, &ssl_free_VerifyCallbackParameters);
 688 }
 689
 690 bool
 691 Ssl::InitServerContext(Security::ContextPointer &ctx, AnyP::PortCfg &port)
 692 {
 693     if (!ctx)
 694         return false;
 695
 696     return true;
 697 }
 698
 699 bool
 700 Ssl::InitClientContext(Security::ContextPointer &ctx, Security::PeerOptions &peer, Security::ParsedPortFlags fl)
 701 {
 702     if (!ctx)
 703         return false;
 704
 705     if (!peer.sslCipher.isEmpty()) {
 706         debugs(83, 5, "Using chiper suite " << peer.sslCipher << ".");
 707
 708         const char *cipher = peer.sslCipher.c_str();
 709         if (!SSL_CTX_set_cipher_list(ctx.get(), cipher)) {
 710             const auto ssl_error = ERR_get_error();
 711             fatalf("Failed to set SSL cipher suite '%s': %s\n",
 712                    cipher, Security::ErrorString(ssl_error));
 713         }
 714     }
 715
 716     if (!peer.certs.empty()) {
 717         // TODO: support loading multiple cert/key pairs
 718         auto &keys = peer.certs.front();
 719         if (!keys.certFile.isEmpty()) {
 720             debugs(83, DBG_IMPORTANT, "Using certificate in " << keys.certFile);
 721
 722             const char *certfile = keys.certFile.c_str();
 723             if (!SSL_CTX_use_certificate_chain_file(ctx.get(), certfile)) {
 724                 const auto ssl_error = ERR_get_error();
 725                 fatalf("Failed to acquire SSL certificate '%s': %s\n",
 726                        certfile, Security::ErrorString(ssl_error));
 727             }
 728
 729             debugs(83, DBG_IMPORTANT, "Using private key in " << keys.privateKeyFile);
 730             const char *keyfile = keys.privateKeyFile.c_str();
 731             ssl_ask_password(ctx.get(), keyfile);
 732
 733             if (!SSL_CTX_use_PrivateKey_file(ctx.get(), keyfile, SSL_FILETYPE_PEM)) {
 734                 const auto ssl_error = ERR_get_error();
 735                 fatalf("Failed to acquire SSL private key '%s': %s\n",
 736                        keyfile, Security::ErrorString(ssl_error));
 737             }
 738
 739             debugs(83, 5, "Comparing private and public SSL keys.");
 740
 741             if (!SSL_CTX_check_private_key(ctx.get())) {
 742                 const auto ssl_error = ERR_get_error();
 743                 fatalf("SSL private key '%s' does not match public key '%s': %s\n",
 744                        certfile, keyfile, Security::ErrorString(ssl_error));
 745             }
 746         }
 747     }
 748
 749     MaybeSetupRsaCallback(ctx);
 750
 751     Ssl::ConfigurePeerVerification(ctx, fl);
 752
 753     return true;
 754 }
 755
 756 /// \ingroup ServerProtocolSSLInternal
 757 static const char *
 758 ssl_get_attribute(X509_NAME * name, const char *attribute_name)
 759 {
 760     static char buffer[1024];
 761     buffer[0] = '\0';
 762
 763     if (strcmp(attribute_name, "DN") == 0) {
 764         X509_NAME_oneline(name, buffer, sizeof(buffer));
 765     } else {
 766         int nid = OBJ_txt2nid(const_cast<char *>(attribute_name));
 767         if (nid == 0) {
 768             debugs(83, DBG_IMPORTANT, "WARNING: Unknown SSL attribute name '" << attribute_name << "'");
 769             return nullptr;
 770         }
 771         X509_NAME_get_text_by_NID(name, nid, buffer, sizeof(buffer));
 772     }
 773
 774     return *buffer ? buffer : nullptr;
 775 }
 776
 777 /// \ingroup ServerProtocolSSLInternal
 778 const char *
 779 Ssl::GetX509UserAttribute(X509 * cert, const char *attribute_name)
 780 {
 781     X509_NAME *name;
 782     const char *ret;
 783
 784     if (!cert)
 785         return NULL;
 786
 787     name = X509_get_subject_name(cert);
 788
 789     ret = ssl_get_attribute(name, attribute_name);
 790
 791     return ret;
 792 }
 793
 794 const char *
 795 Ssl::GetX509Fingerprint(X509 * cert, const char *)
 796 {
 797     static char buf[1024];
 798     if (!cert)
 799         return NULL;
 800
 801     unsigned int n;
 802     unsigned char md[EVP_MAX_MD_SIZE];
 803     if (!X509_digest(cert, EVP_sha1(), md, &n))
 804         return NULL;
 805
 806     assert(3 * n + 1 < sizeof(buf));
 807
 808     char *s = buf;
 809     for (unsigned int i=0; i < n; ++i, s += 3) {
 810         const char term = (i + 1 < n) ? ':' : '\0';
 811         snprintf(s, 4, "%02X%c", md[i], term);
 812     }
 813
 814     return buf;
 815 }
 816
 817 SBuf
 818 Ssl::GetX509PEM(X509 * cert)
 819 {
 820     assert(cert);
 821
 822     Ssl::BIO_Pointer bio(BIO_new(BIO_s_mem()));
 823     PEM_write_bio_X509(bio.get(), cert);
 824
 825     char *ptr;
 826     const auto len = BIO_get_mem_data(bio.get(), &ptr);
 827     return SBuf(ptr, len);
 828 }
 829
 830 /// \ingroup ServerProtocolSSLInternal
 831 const char *
 832 Ssl::GetX509CAAttribute(X509 * cert, const char *attribute_name)
 833 {
 834
 835     X509_NAME *name;
 836     const char *ret;
 837
 838     if (!cert)
 839         return NULL;
 840
 841     name = X509_get_issuer_name(cert);
 842
 843     ret = ssl_get_attribute(name, attribute_name);
 844
 845     return ret;
 846 }
 847
 848 const char *sslGetUserAttribute(SSL *ssl, const char *attribute_name)
 849 {
 850     if (!ssl)
 851         return NULL;
 852
 853     X509 *cert = SSL_get_peer_certificate(ssl);
 854
 855     const char *attr = Ssl::GetX509UserAttribute(cert, attribute_name);
 856
 857     X509_free(cert);
 858     return attr;
 859 }
 860
 861 const char *sslGetCAAttribute(SSL *ssl, const char *attribute_name)
 862 {
 863     if (!ssl)
 864         return NULL;
 865
 866     X509 *cert = SSL_get_peer_certificate(ssl);
 867
 868     const char *attr = Ssl::GetX509CAAttribute(cert, attribute_name);
 869
 870     X509_free(cert);
 871     return attr;
 872 }
 873
 874 const char *
 875 sslGetUserEmail(SSL * ssl)
 876 {
 877     return sslGetUserAttribute(ssl, "emailAddress");
 878 }
 879
 880 SBuf
 881 sslGetUserCertificatePEM(SSL *ssl)
 882 {
 883     assert(ssl);
 884
 885     if (const auto cert = SSL_get_peer_certificate(ssl))
 886         return Ssl::GetX509PEM(cert);
 887
 888     return SBuf();
 889 }
 890
 891 SBuf
 892 sslGetUserCertificateChainPEM(SSL *ssl)
 893 {
 894     assert(ssl);
 895
 896     auto chain = SSL_get_peer_cert_chain(ssl);
 897
 898     if (!chain)
 899         return sslGetUserCertificatePEM(ssl);
 900
 901     Ssl::BIO_Pointer bio(BIO_new(BIO_s_mem()));
 902
 903     for (int i = 0; i < sk_X509_num(chain); ++i) {
 904         X509 *cert = sk_X509_value(chain, i);
 905         PEM_write_bio_X509(bio.get(), cert);
 906     }
 907
 908     char *ptr;
 909     const auto len = BIO_get_mem_data(bio.get(), &ptr);
 910     return SBuf(ptr, len);
 911 }
 912
 913 /// Create SSL context and apply ssl certificate and private key to it.
 914 Security::ContextPointer
 915 Ssl::createSSLContext(Security::CertPointer & x509, Security::PrivateKeyPointer & pkey, Security::ServerOptions &options)
 916 {
 917     Security::ContextPointer ctx(options.createBlankContext());
 918
 919     if (!SSL_CTX_use_certificate(ctx.get(), x509.get()))
 920         return Security::ContextPointer();
 921
 922     if (!SSL_CTX_use_PrivateKey(ctx.get(), pkey.get()))
 923         return Security::ContextPointer();
 924
 925     if (!options.updateContextConfig(ctx))
 926         return Security::ContextPointer();
 927
 928     return ctx;
 929 }
 930
 931 Security::ContextPointer
 932 Ssl::GenerateSslContextUsingPkeyAndCertFromMemory(const char * data, Security::ServerOptions &options, bool trusted)
 933 {
 934     Security::CertPointer cert;
 935     Security::PrivateKeyPointer pkey;
 936     if (!readCertAndPrivateKeyFromMemory(cert, pkey, data) || !cert || !pkey)
 937         return Security::ContextPointer();
 938
 939     Security::ContextPointer ctx(createSSLContext(cert, pkey, options));
 940     if (ctx && trusted)
 941         Ssl::chainCertificatesToSSLContext(ctx, options);
 942     return ctx;
 943 }
 944
 945 Security::ContextPointer
 946 Ssl::GenerateSslContext(CertificateProperties const &properties, Security::ServerOptions &options, bool trusted)
 947 {
 948     Security::CertPointer cert;
 949     Security::PrivateKeyPointer pkey;
 950     if (!generateSslCertificate(cert, pkey, properties) || !cert || !pkey)
 951         return Security::ContextPointer();
 952
 953     Security::ContextPointer ctx(createSSLContext(cert, pkey, options));
 954     if (ctx && trusted)
 955         Ssl::chainCertificatesToSSLContext(ctx, options);
 956     return ctx;
 957 }
 958
 959 void
 960 Ssl::chainCertificatesToSSLContext(Security::ContextPointer &ctx, Security::ServerOptions &options)
 961 {
 962     assert(ctx);
 963     // Add signing certificate to the certificates chain
 964     X509 *signingCert = options.signingCa.cert.get();
 965     if (SSL_CTX_add_extra_chain_cert(ctx.get(), signingCert)) {
 966         // increase the certificate lock
 967         X509_up_ref(signingCert);
 968     } else {
 969         const auto ssl_error = ERR_get_error();
 970         debugs(33, DBG_IMPORTANT, "WARNING: can not add signing certificate to SSL context chain: " << Security::ErrorString(ssl_error));
 971     }
 972
 973     for (auto cert : options.signingCa.chain) {
 974         if (SSL_CTX_add_extra_chain_cert(ctx.get(), cert.get())) {
 975             // increase the certificate lock
 976             X509_up_ref(cert.get());
 977         } else {
 978             const auto error = ERR_get_error();
 979             debugs(83, DBG_IMPORTANT, "WARNING: can not add certificate to SSL dynamic context chain: " << Security::ErrorString(error));
 980         }
 981     }
 982 }
 983
 984 void
 985 Ssl::configureUnconfiguredSslContext(Security::ContextPointer &ctx, Ssl::CertSignAlgorithm signAlgorithm,AnyP::PortCfg &port)
 986 {
 987     if (ctx && signAlgorithm == Ssl::algSignTrusted)
 988         Ssl::chainCertificatesToSSLContext(ctx, port.secure);
 989 }
 990
 991 bool
 992 Ssl::configureSSL(SSL *ssl, CertificateProperties const &properties, AnyP::PortCfg &port)
 993 {
 994     Security::CertPointer cert;
 995     Security::PrivateKeyPointer pkey;
 996     if (!generateSslCertificate(cert, pkey, properties))
 997         return false;
 998
 999     if (!cert)
1000         return false;
1001
1002     if (!pkey)
1003         return false;
1004
1005     if (!SSL_use_certificate(ssl, cert.get()))
1006         return false;
1007
1008     if (!SSL_use_PrivateKey(ssl, pkey.get()))
1009         return false;
1010
1011     return true;
1012 }
1013
1014 bool
1015 Ssl::configureSSLUsingPkeyAndCertFromMemory(SSL *ssl, const char *data, AnyP::PortCfg &port)
1016 {
1017     Security::CertPointer cert;
1018     Security::PrivateKeyPointer pkey;
1019     if (!readCertAndPrivateKeyFromMemory(cert, pkey, data))
1020         return false;
1021
1022     if (!cert || !pkey)
1023         return false;
1024
1025     if (!SSL_use_certificate(ssl, cert.get()))
1026         return false;
1027
1028     if (!SSL_use_PrivateKey(ssl, pkey.get()))
1029         return false;
1030
1031     return true;
1032 }
1033
1034 bool
1035 Ssl::verifySslCertificate(const Security::ContextPointer &ctx, CertificateProperties const &properties)
1036 {
1037 #if HAVE_SSL_CTX_GET0_CERTIFICATE
1038     X509 * cert = SSL_CTX_get0_certificate(ctx.get());
1039 #elif SQUID_USE_SSLGETCERTIFICATE_HACK
1040     // SSL_get_certificate is buggy in openssl versions 1.0.1d and 1.0.1e
1041     // Try to retrieve certificate directly from Security::ContextPointer object
1042     X509 ***pCert = (X509 ***)ctx->cert;
1043     X509 * cert = pCert && *pCert ? **pCert : NULL;
1044 #elif SQUID_SSLGETCERTIFICATE_BUGGY
1045     X509 * cert = NULL;
1046     assert(0);
1047 #else
1048     // Temporary ssl for getting X509 certificate from SSL_CTX.
1049     Security::SessionPointer ssl(Security::NewSessionObject(ctx));
1050     X509 * cert = SSL_get_certificate(ssl.get());
1051 #endif
1052     if (!cert)
1053         return false;
1054     const auto time_notBefore = X509_getm_notBefore(cert);
1055     const auto time_notAfter = X509_getm_notAfter(cert);
1056     return (X509_cmp_current_time(time_notBefore) < 0 && X509_cmp_current_time(time_notAfter) > 0);
1057 }
1058
1059 void
1060 Ssl::setClientSNI(SSL *ssl, const char *fqdn)
1061 {
1062     const Ip::Address test(fqdn);
1063     if (!test.isAnyAddr())
1064         return; // raw IP is inappropriate for SNI
1065
1066     //The SSL_CTRL_SET_TLSEXT_HOSTNAME is a openssl macro which indicates
1067     // if the TLS servername extension (SNI) is enabled in openssl library.
1068 #if defined(SSL_CTRL_SET_TLSEXT_HOSTNAME)
1069     if (!SSL_set_tlsext_host_name(ssl, fqdn)) {
1070         const auto ssl_error = ERR_get_error();
1071         debugs(83, 3,  "WARNING: unable to set TLS servername extension (SNI): " <<
1072                Security::ErrorString(ssl_error) << "\n");
1073     }
1074 #else
1075     debugs(83, 7,  "no support for TLS servername extension (SNI)");
1076 #endif
1077 }
1078
1079 const char *
1080 Ssl::findIssuerUri(X509 *cert)
1081 {
1082     AUTHORITY_INFO_ACCESS *info;
1083     if (!cert)
1084         return nullptr;
1085     info = static_cast<AUTHORITY_INFO_ACCESS *>(X509_get_ext_d2i(cert, NID_info_access, NULL, NULL));
1086     if (!info)
1087         return nullptr;
1088
1089     static char uri[MAX_URL];
1090     uri[0] = '\0';
1091
1092     for (int i = 0; i < sk_ACCESS_DESCRIPTION_num(info); i++) {
1093         ACCESS_DESCRIPTION *ad = sk_ACCESS_DESCRIPTION_value(info, i);
1094         if (OBJ_obj2nid(ad->method) == NID_ad_ca_issuers) {
1095             if (ad->location->type == GEN_URI) {
1096                 xstrncpy(uri,
1097                          reinterpret_cast<const char *>(
1098                              ASN1_STRING_get0_data(ad->location->d.uniformResourceIdentifier)
1099                          ),
1100                          sizeof(uri));
1101             }
1102             break;
1103         }
1104     }
1105     AUTHORITY_INFO_ACCESS_free(info);
1106     return uri[0] != '\0' ? uri : nullptr;
1107 }
1108
1109 bool
1110 Ssl::loadCerts(const char *certsFile, Ssl::CertsIndexedList &list)
1111 {
1112     BIO *in = BIO_new_file(certsFile, "r");
1113     if (!in) {
1114         debugs(83, DBG_IMPORTANT, "Failed to open '" << certsFile << "' to load certificates");
1115         return false;
1116     }
1117
1118     X509 *aCert;
1119     while((aCert = PEM_read_bio_X509(in, NULL, NULL, NULL))) {
1120         static char buffer[2048];
1121         X509_NAME_oneline(X509_get_subject_name(aCert), buffer, sizeof(buffer));
1122         list.insert(std::pair<SBuf, X509 *>(SBuf(buffer), aCert));
1123     }
1124     debugs(83, 4, "Loaded " << list.size() << " certificates from file: '" << certsFile << "'");
1125     BIO_free(in);
1126     return true;
1127 }
1128
1129 /// quickly find the issuer certificate of a certificate cert in the
1130 /// Ssl::CertsIndexedList list
1131 static X509 *
1132 findCertIssuerFast(Ssl::CertsIndexedList &list, X509 *cert)
1133 {
1134     static char buffer[2048];
1135
1136     if (X509_NAME *issuerName = X509_get_issuer_name(cert))
1137         X509_NAME_oneline(issuerName, buffer, sizeof(buffer));
1138     else
1139         return NULL;
1140
1141     const auto ret = list.equal_range(SBuf(buffer));
1142     for (Ssl::CertsIndexedList::iterator it = ret.first; it != ret.second; ++it) {
1143         X509 *issuer = it->second;
1144         if (X509_check_issued(issuer, cert) == X509_V_OK) {
1145             return issuer;
1146         }
1147     }
1148     return NULL;
1149 }
1150
1151 /// slowly find the issuer certificate of a given cert using linear search
1152 static X509 *
1153 sk_x509_findIssuer(const STACK_OF(X509) *sk, X509 *cert)
1154 {
1155     if (!sk)
1156         return nullptr;
1157
1158     const auto certCount = sk_X509_num(sk);
1159     for (int i = 0; i < certCount; ++i) {
1160         const auto issuer = sk_X509_value(sk, i);
1161         if (X509_check_issued(issuer, cert) == X509_V_OK)
1162             return issuer;
1163     }
1164     return nullptr;
1165 }
1166
1167 /// finds issuer of a given certificate in CA store of the given connContext
1168 /// \returns the cert issuer (after increasing its reference count) or nil
1169 static X509 *
1170 findIssuerInCaDb(X509 *cert, const Security::ContextPointer &connContext)
1171 {
1172     if (!connContext)
1173         return nullptr;
1174
1175     X509_STORE_CTX *storeCtx = X509_STORE_CTX_new();
1176     if (!storeCtx) {
1177         debugs(83, DBG_IMPORTANT, "Failed to allocate STORE_CTX object");
1178         return nullptr;
1179     }
1180
1181     X509 *issuer = nullptr;
1182     X509_STORE *store = SSL_CTX_get_cert_store(connContext.get());
1183     if (X509_STORE_CTX_init(storeCtx, store, nullptr, nullptr)) {
1184         const auto ret = X509_STORE_CTX_get1_issuer(&issuer, storeCtx, cert);
1185         if (ret > 0) {
1186             assert(issuer);
1187             char buffer[256];
1188             debugs(83, 5, "found " << X509_NAME_oneline(X509_get_subject_name(issuer), buffer, sizeof(buffer)));
1189         } else {
1190             debugs(83, ret < 0 ? 2 : 3, "not found or failure: " << ret);
1191             assert(!issuer);
1192         }
1193     } else {
1194         const auto ssl_error = ERR_get_error();
1195         debugs(83, DBG_IMPORTANT, "Failed to initialize STORE_CTX object: " << Security::ErrorString(ssl_error));
1196     }
1197
1198     X509_STORE_CTX_free(storeCtx);
1199
1200     return issuer;
1201 }
1202
1203 Security::CertPointer
1204 Ssl::findIssuerCertificate(X509 *cert, const STACK_OF(X509) *serverCertificates, const Security::ContextPointer &context)
1205 {
1206     Must(cert);
1207
1208     // check certificate chain, if any
1209     if (const auto issuer = serverCertificates ? sk_x509_findIssuer(serverCertificates, cert) : nullptr) {
1210         X509_up_ref(issuer);
1211         return Security::CertPointer(issuer);
1212     }
1213
1214     // check untrusted certificates
1215     if (const auto issuer = findCertIssuerFast(SquidUntrustedCerts, cert)) {
1216         X509_up_ref(issuer);
1217         return Security::CertPointer(issuer);
1218     }
1219
1220     // check trusted CA certificates
1221     if (const auto issuer = findIssuerInCaDb(cert, context)) {
1222         // no X509_up_ref(issuer) because findIssuerInCaDb() ups reference count
1223         return Security::CertPointer(issuer);
1224     }
1225
1226     return Security::CertPointer(nullptr);
1227 }
1228
1229 bool
1230 Ssl::missingChainCertificatesUrls(std::queue<SBuf> &URIs, const STACK_OF(X509) &serverCertificates, const Security::ContextPointer &context)
1231 {
1232     for (int i = 0; i < sk_X509_num(&serverCertificates); ++i) {
1233         const auto cert = sk_X509_value(&serverCertificates, i);
1234
1235         if (findIssuerCertificate(cert, &serverCertificates, context))
1236             continue;
1237
1238         if (const auto issuerUri = findIssuerUri(cert)) {
1239             URIs.push(SBuf(issuerUri));
1240         } else {
1241             static char name[2048];
1242             debugs(83, 3, "Issuer certificate for " <<
1243                    X509_NAME_oneline(X509_get_subject_name(cert), name, sizeof(name)) <<
1244                    " is missing and its URI is not provided");
1245         }
1246     }
1247
1248     debugs(83, (URIs.empty() ? 3 : 5), "found: " << URIs.size());
1249     return !URIs.empty();
1250 }
1251
1252 /// add missing issuer certificates to untrustedCerts
1253 static void
1254 completeIssuers(X509_STORE_CTX *ctx, STACK_OF(X509) &untrustedCerts)
1255 {
1256     debugs(83, 2,  "completing " << sk_X509_num(&untrustedCerts) <<
1257            " OpenSSL untrusted certs using " << SquidUntrustedCerts.size() <<
1258            " configured untrusted certificates");
1259
1260     const X509_VERIFY_PARAM *param = X509_STORE_CTX_get0_param(ctx);
1261     int depth = X509_VERIFY_PARAM_get_depth(param);
1262     Security::CertPointer current;
1263     current.resetAndLock(X509_STORE_CTX_get0_cert(ctx));
1264     int i = 0;
1265     for (i = 0; current && (i < depth); ++i) {
1266         if (X509_check_issued(current.get(), current.get()) == X509_V_OK) {
1267             // either ctx->cert is itself self-signed or untrustedCerts
1268             // already contain the self-signed current certificate
1269             break;
1270         }
1271
1272         // untrustedCerts is short, not worth indexing
1273         const Security::ContextPointer nullCtx;
1274         auto issuer = Ssl::findIssuerCertificate(current.get(), &untrustedCerts, nullCtx);
1275         current = issuer;
1276         if (issuer)
1277             sk_X509_push(&untrustedCerts, issuer.release());
1278     }
1279
1280     if (i >= depth)
1281         debugs(83, 2,  "exceeded the maximum certificate chain length: " << depth);
1282 }
1283
1284 /// Validates certificates while consulting sslproxy_foreign_intermediate_certs
1285 /// and, optionally, the given extra certificates.
1286 /// \returns whatever OpenSSL X509_verify_cert() returns
1287 static int
1288 VerifyCtxCertificates(X509_STORE_CTX *ctx, STACK_OF(X509) *extraCerts)
1289 {
1290     // OpenSSL already maintains ctx->untrusted but we cannot modify
1291     // internal OpenSSL list directly. We have to give OpenSSL our own
1292     // list, but it must include certificates on the OpenSSL ctx->untrusted
1293     STACK_OF(X509) *oldUntrusted = X509_STORE_CTX_get0_untrusted(ctx);
1294     // X509_chain_up_ref() increments cert references _and_ dupes the stack
1295     Ssl::X509_STACK_Pointer untrustedCerts(oldUntrusted ? X509_chain_up_ref(oldUntrusted) : sk_X509_new_null());
1296
1297     if (extraCerts) {
1298         for (int i = 0; i < sk_X509_num(extraCerts); ++i) {
1299             const auto cert = sk_X509_value(extraCerts, i);
1300             X509_up_ref(cert);
1301             sk_X509_push(untrustedCerts.get(), cert);
1302         }
1303     }
1304
1305     // If the local untrusted certificates internal database is used
1306     // run completeIssuers to add missing certificates if possible.
1307     if (SquidUntrustedCerts.size() > 0)
1308         completeIssuers(ctx, *untrustedCerts);
1309
1310     X509_STORE_CTX_set0_untrusted(ctx, untrustedCerts.get()); // No locking/unlocking, just sets ctx->untrusted
1311     int ret = X509_verify_cert(ctx);
1312     X509_STORE_CTX_set0_untrusted(ctx, oldUntrusted); // Set back the old untrusted list
1313     return ret;
1314 }
1315
1316 /// \interface OpenSSL_vcb_disambiguation
1317 ///
1318 /// OpenSSL has two very different concepts with nearly identical names:
1319 ///
1320 /// a) A (replaceable) certificate verification function -- X509_verify_cert():
1321 ///    This function drives the entire certificate verification algorithm.
1322 ///    It can be called directly, but is usually called during SSL_connect().
1323 ///    OpenSSL calls this function a "verification callback function".
1324 ///    SSL_CTX_set_cert_verify_callback(3) replaces X509_verify_cert() default.
1325 ///
1326 /// b) An (optional) certificate verification adjustment callback:
1327 ///    This function, if set, is called at the end of (a) to adjust (a) results.
1328 ///    It is never called directly, only from (a).
1329 ///    OpenSSL calls this function a "verify_callback function".
1330 ///    The SSL_CTX_set_verify(3) family of functions sets this function.
1331
1332 /// Validates certificates while consulting sslproxy_foreign_intermediate_certs
1333 /// but without using any dynamically downloaded intermediate certificates.
1334 /// OpenSSL "verification callback function" (\ref OpenSSL_vcb_disambiguation)
1335 static int
1336 untrustedToStoreCtx_cb(X509_STORE_CTX *ctx, void *)
1337 {
1338     debugs(83, 4, "Try to use pre-downloaded intermediate certificates");
1339     return VerifyCtxCertificates(ctx, nullptr);
1340 }
1341
1342 void
1343 Ssl::useSquidUntrusted(SSL_CTX *sslContext)
1344 {
1345     SSL_CTX_set_cert_verify_callback(sslContext, untrustedToStoreCtx_cb, NULL);
1346 }
1347
1348 bool
1349 Ssl::loadSquidUntrusted(const char *path)
1350 {
1351     return Ssl::loadCerts(path, SquidUntrustedCerts);
1352 }
1353
1354 void
1355 Ssl::unloadSquidUntrusted()
1356 {
1357     if (SquidUntrustedCerts.size()) {
1358         for (Ssl::CertsIndexedList::iterator it = SquidUntrustedCerts.begin(); it != SquidUntrustedCerts.end(); ++it) {
1359             X509_free(it->second);
1360         }
1361         SquidUntrustedCerts.clear();
1362     }
1363 }
1364
1365 bool Ssl::generateUntrustedCert(Security::CertPointer &untrustedCert, Security::PrivateKeyPointer &untrustedPkey, Security::CertPointer const  &cert, Security::PrivateKeyPointer const & pkey)
1366 {
1367     // Generate the self-signed certificate, using a hard-coded subject prefix
1368     Ssl::CertificateProperties certProperties;
1369     if (const char *cn = CommonHostName(cert.get())) {
1370         certProperties.commonName = "Not trusted by \"";
1371         certProperties.commonName += cn;
1372         certProperties.commonName += "\"";
1373     } else if (const char *org = getOrganization(cert.get())) {
1374         certProperties.commonName =  "Not trusted by \"";
1375         certProperties.commonName += org;
1376         certProperties.commonName += "\"";
1377     } else
1378         certProperties.commonName =  "Not trusted";
1379     certProperties.setCommonName = true;
1380     // O, OU, and other CA subject fields will be mimicked
1381     // Expiration date and other common properties will be mimicked
1382     certProperties.signAlgorithm = Ssl::algSignSelf;
1383     certProperties.signWithPkey.resetAndLock(pkey.get());
1384     certProperties.mimicCert.resetAndLock(cert.get());
1385     return Ssl::generateSslCertificate(untrustedCert, untrustedPkey, certProperties);
1386 }
1387
1388 void Ssl::InRamCertificateDbKey(const Ssl::CertificateProperties &certProperties, SBuf &key)
1389 {
1390     bool origSignatureAsKey = false;
1391     if (certProperties.mimicCert) {
1392         if (auto *sig = Ssl::X509_get_signature(certProperties.mimicCert)) {
1393             origSignatureAsKey = true;
1394             key.append((const char *)sig->data, sig->length);
1395         }
1396     }
1397
1398     if (!origSignatureAsKey || certProperties.setCommonName) {
1399         // Use common name instead
1400         key.append(certProperties.commonName.c_str());
1401     }
1402     key.append(certProperties.setCommonName ? '1' : '0');
1403     key.append(certProperties.setValidAfter ? '1' : '0');
1404     key.append(certProperties.setValidBefore ? '1' : '0');
1405     key.append(certProperties.signAlgorithm != Ssl:: algSignEnd ? certSignAlgorithm(certProperties.signAlgorithm) : "-");
1406     key.append(certProperties.signHash ? EVP_MD_name(certProperties.signHash) : "-");
1407
1408     if (certProperties.mimicCert) {
1409         Ssl::BIO_Pointer bio(BIO_new_SBuf(&key));
1410         ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509), bio.get(), (ASN1_VALUE *)certProperties.mimicCert.get());
1411     }
1412 }
1413
1414 static int
1415 bio_sbuf_create(BIO* bio)
1416 {
1417     BIO_set_init(bio, 0);
1418     BIO_set_data(bio, NULL);
1419     return 1;
1420 }
1421
1422 static int
1423 bio_sbuf_destroy(BIO* bio)
1424 {
1425     if (!bio)
1426         return 0;
1427     return 1;
1428 }
1429
1430 int
1431 bio_sbuf_write(BIO* bio, const char* data, int len)
1432 {
1433     SBuf *buf = static_cast<SBuf *>(BIO_get_data(bio));
1434     // TODO: Convert exceptions into BIO errors
1435     buf->append(data, len);
1436     return len;
1437 }
1438
1439 int
1440 bio_sbuf_puts(BIO* bio, const char* data)
1441 {
1442     // TODO: use bio_sbuf_write() instead
1443     SBuf *buf = static_cast<SBuf *>(BIO_get_data(bio));
1444     size_t oldLen = buf->length();
1445     buf->append(data);
1446     return buf->length() - oldLen;
1447 }
1448
1449 long
1450 bio_sbuf_ctrl(BIO* bio, int cmd, long num, void* ptr) {
1451     SBuf *buf = static_cast<SBuf *>(BIO_get_data(bio));
1452     switch (cmd) {
1453     case BIO_CTRL_RESET:
1454         // TODO: Convert exceptions into BIO errors
1455         buf->clear();
1456         return 1;
1457     case BIO_CTRL_FLUSH:
1458         return 1;
1459     default:
1460         return 0;
1461     }
1462 }
1463
1464 BIO *Ssl::BIO_new_SBuf(SBuf *buf)
1465 {
1466 #if HAVE_LIBCRYPTO_BIO_METH_NEW
1467     static BIO_METHOD *BioSBufMethods = nullptr;
1468     if (!BioSBufMethods) {
1469         BioSBufMethods = BIO_meth_new(BIO_TYPE_MEM, "Squid-SBuf");
1470         BIO_meth_set_write(BioSBufMethods, bio_sbuf_write);
1471         BIO_meth_set_read(BioSBufMethods, nullptr);
1472         BIO_meth_set_puts(BioSBufMethods, bio_sbuf_puts);
1473         BIO_meth_set_gets(BioSBufMethods, nullptr);
1474         BIO_meth_set_ctrl(BioSBufMethods, bio_sbuf_ctrl);
1475         BIO_meth_set_create(BioSBufMethods, bio_sbuf_create);
1476         BIO_meth_set_destroy(BioSBufMethods, bio_sbuf_destroy);
1477     }
1478 #else
1479     static BIO_METHOD *BioSBufMethods = new BIO_METHOD({
1480         BIO_TYPE_MEM,
1481         "Squid SBuf",
1482         bio_sbuf_write,
1483         nullptr,
1484         bio_sbuf_puts,
1485         nullptr,
1486         bio_sbuf_ctrl,
1487         bio_sbuf_create,
1488         bio_sbuf_destroy,
1489         NULL
1490     });
1491 #endif
1492     BIO *bio = BIO_new(BioSBufMethods);
1493     Must(bio);
1494     BIO_set_data(bio, buf);
1495     BIO_set_init(bio, 1);
1496     return bio;
1497 }
1498
1499 #endif /* USE_OPENSSL */
1500