1 #pragma once 2 3 #include "logging.hpp" 4 #include "random.hpp" 5 6 extern "C" 7 { 8 #include <nghttp2/nghttp2.h> 9 } 10 #include <openssl/bio.h> 11 #include <openssl/dh.h> 12 #include <openssl/dsa.h> 13 #include <openssl/err.h> 14 #include <openssl/evp.h> 15 #include <openssl/pem.h> 16 #include <openssl/rand.h> 17 #include <openssl/rsa.h> 18 #include <openssl/ssl.h> 19 20 #include <boost/asio/ssl/context.hpp> 21 22 #include <optional> 23 #include <random> 24 #include <string> 25 26 namespace ensuressl 27 { 28 constexpr const char* trustStorePath = "/etc/ssl/certs/authority"; 29 constexpr const char* x509Comment = "Generated from OpenBMC service"; 30 static void initOpenssl(); 31 static EVP_PKEY* createEcKey(); 32 33 // Trust chain related errors.` 34 inline bool isTrustChainError(int errnum) 35 { 36 return (errnum == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) || 37 (errnum == X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN) || 38 (errnum == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY) || 39 (errnum == X509_V_ERR_CERT_UNTRUSTED) || 40 (errnum == X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE); 41 } 42 43 inline bool validateCertificate(X509* const cert) 44 { 45 // Create an empty X509_STORE structure for certificate validation. 46 X509_STORE* x509Store = X509_STORE_new(); 47 if (x509Store == nullptr) 48 { 49 BMCWEB_LOG_ERROR << "Error occurred during X509_STORE_new call"; 50 return false; 51 } 52 53 // Load Certificate file into the X509 structure. 54 X509_STORE_CTX* storeCtx = X509_STORE_CTX_new(); 55 if (storeCtx == nullptr) 56 { 57 BMCWEB_LOG_ERROR << "Error occurred during X509_STORE_CTX_new call"; 58 X509_STORE_free(x509Store); 59 return false; 60 } 61 62 int errCode = X509_STORE_CTX_init(storeCtx, x509Store, cert, nullptr); 63 if (errCode != 1) 64 { 65 BMCWEB_LOG_ERROR << "Error occurred during X509_STORE_CTX_init call"; 66 X509_STORE_CTX_free(storeCtx); 67 X509_STORE_free(x509Store); 68 return false; 69 } 70 71 errCode = X509_verify_cert(storeCtx); 72 if (errCode == 1) 73 { 74 BMCWEB_LOG_INFO << "Certificate verification is success"; 75 X509_STORE_CTX_free(storeCtx); 76 X509_STORE_free(x509Store); 77 return true; 78 } 79 if (errCode == 0) 80 { 81 errCode = X509_STORE_CTX_get_error(storeCtx); 82 X509_STORE_CTX_free(storeCtx); 83 X509_STORE_free(x509Store); 84 if (isTrustChainError(errCode)) 85 { 86 BMCWEB_LOG_DEBUG << "Ignoring Trust Chain error. Reason: " 87 << X509_verify_cert_error_string(errCode); 88 return true; 89 } 90 BMCWEB_LOG_ERROR << "Certificate verification failed. Reason: " 91 << X509_verify_cert_error_string(errCode); 92 return false; 93 } 94 95 BMCWEB_LOG_ERROR 96 << "Error occurred during X509_verify_cert call. ErrorCode: " 97 << errCode; 98 X509_STORE_CTX_free(storeCtx); 99 X509_STORE_free(x509Store); 100 return false; 101 } 102 103 inline bool verifyOpensslKeyCert(const std::string& filepath) 104 { 105 bool privateKeyValid = false; 106 bool certValid = false; 107 108 std::cout << "Checking certs in file " << filepath << "\n"; 109 110 FILE* file = fopen(filepath.c_str(), "r"); 111 if (file != nullptr) 112 { 113 EVP_PKEY* pkey = PEM_read_PrivateKey(file, nullptr, nullptr, nullptr); 114 if (pkey != nullptr) 115 { 116 #if (OPENSSL_VERSION_NUMBER < 0x30000000L) 117 RSA* rsa = EVP_PKEY_get1_RSA(pkey); 118 if (rsa != nullptr) 119 { 120 std::cout << "Found an RSA key\n"; 121 if (RSA_check_key(rsa) == 1) 122 { 123 privateKeyValid = true; 124 } 125 else 126 { 127 std::cerr << "Key not valid error number " 128 << ERR_get_error() << "\n"; 129 } 130 RSA_free(rsa); 131 } 132 else 133 { 134 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(pkey); 135 if (ec != nullptr) 136 { 137 std::cout << "Found an EC key\n"; 138 if (EC_KEY_check_key(ec) == 1) 139 { 140 privateKeyValid = true; 141 } 142 else 143 { 144 std::cerr << "Key not valid error number " 145 << ERR_get_error() << "\n"; 146 } 147 EC_KEY_free(ec); 148 } 149 } 150 #else 151 EVP_PKEY_CTX* pkeyCtx = EVP_PKEY_CTX_new_from_pkey(nullptr, pkey, 152 nullptr); 153 154 if (pkeyCtx == nullptr) 155 { 156 std::cerr << "Unable to allocate pkeyCtx " << ERR_get_error() 157 << "\n"; 158 } 159 else if (EVP_PKEY_check(pkeyCtx) == 1) 160 { 161 privateKeyValid = true; 162 } 163 else 164 { 165 std::cerr << "Key not valid error number " << ERR_get_error() 166 << "\n"; 167 } 168 #endif 169 170 if (privateKeyValid) 171 { 172 // If the order is certificate followed by key in input file 173 // then, certificate read will fail. So, setting the file 174 // pointer to point beginning of file to avoid certificate and 175 // key order issue. 176 fseek(file, 0, SEEK_SET); 177 178 X509* x509 = PEM_read_X509(file, nullptr, nullptr, nullptr); 179 if (x509 == nullptr) 180 { 181 std::cout << "error getting x509 cert " << ERR_get_error() 182 << "\n"; 183 } 184 else 185 { 186 certValid = validateCertificate(x509); 187 X509_free(x509); 188 } 189 } 190 191 #if (OPENSSL_VERSION_NUMBER > 0x30000000L) 192 EVP_PKEY_CTX_free(pkeyCtx); 193 #endif 194 EVP_PKEY_free(pkey); 195 } 196 fclose(file); 197 } 198 return certValid; 199 } 200 201 inline X509* loadCert(const std::string& filePath) 202 { 203 BIO* certFileBio = BIO_new_file(filePath.c_str(), "rb"); 204 if (certFileBio == nullptr) 205 { 206 BMCWEB_LOG_ERROR << "Error occured during BIO_new_file call, " 207 << "FILE= " << filePath; 208 return nullptr; 209 } 210 211 X509* cert = X509_new(); 212 if (cert == nullptr) 213 { 214 BMCWEB_LOG_ERROR << "Error occured during X509_new call, " 215 << ERR_get_error(); 216 BIO_free(certFileBio); 217 return nullptr; 218 } 219 220 if (PEM_read_bio_X509(certFileBio, &cert, nullptr, nullptr) == nullptr) 221 { 222 BMCWEB_LOG_ERROR << "Error occured during PEM_read_bio_X509 call, " 223 << "FILE= " << filePath; 224 225 BIO_free(certFileBio); 226 X509_free(cert); 227 return nullptr; 228 } 229 BIO_free(certFileBio); 230 return cert; 231 } 232 233 inline int addExt(X509* cert, int nid, const char* value) 234 { 235 X509_EXTENSION* ex = nullptr; 236 X509V3_CTX ctx{}; 237 X509V3_set_ctx(&ctx, cert, cert, nullptr, nullptr, 0); 238 239 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) 240 ex = X509V3_EXT_conf_nid(nullptr, &ctx, nid, const_cast<char*>(value)); 241 if (ex == nullptr) 242 { 243 BMCWEB_LOG_ERROR << "Error: In X509V3_EXT_conf_nidn: " << value; 244 return -1; 245 } 246 X509_add_ext(cert, ex, -1); 247 X509_EXTENSION_free(ex); 248 return 0; 249 } 250 251 inline void generateSslCertificate(const std::string& filepath, 252 const std::string& cn) 253 { 254 FILE* pFile = nullptr; 255 std::cout << "Generating new keys\n"; 256 initOpenssl(); 257 258 std::cerr << "Generating EC key\n"; 259 EVP_PKEY* pPrivKey = createEcKey(); 260 if (pPrivKey != nullptr) 261 { 262 std::cerr << "Generating x509 Certificate\n"; 263 // Use this code to directly generate a certificate 264 X509* x509 = X509_new(); 265 if (x509 != nullptr) 266 { 267 // get a random number from the RNG for the certificate serial 268 // number If this is not random, regenerating certs throws broswer 269 // errors 270 bmcweb::OpenSSLGenerator gen; 271 std::uniform_int_distribution<int> dis( 272 1, std::numeric_limits<int>::max()); 273 int serial = dis(gen); 274 275 ASN1_INTEGER_set(X509_get_serialNumber(x509), serial); 276 277 // not before this moment 278 X509_gmtime_adj(X509_get_notBefore(x509), 0); 279 // Cert is valid for 10 years 280 X509_gmtime_adj(X509_get_notAfter(x509), 281 60L * 60L * 24L * 365L * 10L); 282 283 // set the public key to the key we just generated 284 X509_set_pubkey(x509, pPrivKey); 285 286 // get the subject name 287 X509_NAME* name = X509_get_subject_name(x509); 288 289 using x509String = const unsigned char; 290 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 291 x509String* country = reinterpret_cast<x509String*>("US"); 292 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 293 x509String* company = reinterpret_cast<x509String*>("OpenBMC"); 294 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 295 x509String* cnStr = reinterpret_cast<x509String*>(cn.c_str()); 296 297 X509_NAME_add_entry_by_txt(name, "C", MBSTRING_ASC, country, -1, -1, 298 0); 299 X509_NAME_add_entry_by_txt(name, "O", MBSTRING_ASC, company, -1, -1, 300 0); 301 X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, cnStr, -1, -1, 302 0); 303 // set the CSR options 304 X509_set_issuer_name(x509, name); 305 306 X509_set_version(x509, 2); 307 addExt(x509, NID_basic_constraints, ("critical,CA:TRUE")); 308 addExt(x509, NID_subject_alt_name, ("DNS:" + cn).c_str()); 309 addExt(x509, NID_subject_key_identifier, ("hash")); 310 addExt(x509, NID_authority_key_identifier, ("keyid")); 311 addExt(x509, NID_key_usage, ("digitalSignature, keyEncipherment")); 312 addExt(x509, NID_ext_key_usage, ("serverAuth")); 313 addExt(x509, NID_netscape_comment, (x509Comment)); 314 315 // Sign the certificate with our private key 316 X509_sign(x509, pPrivKey, EVP_sha256()); 317 318 pFile = fopen(filepath.c_str(), "wt"); 319 320 if (pFile != nullptr) 321 { 322 PEM_write_PrivateKey(pFile, pPrivKey, nullptr, nullptr, 0, 323 nullptr, nullptr); 324 325 PEM_write_X509(pFile, x509); 326 fclose(pFile); 327 pFile = nullptr; 328 } 329 330 X509_free(x509); 331 } 332 333 EVP_PKEY_free(pPrivKey); 334 pPrivKey = nullptr; 335 } 336 337 // cleanup_openssl(); 338 } 339 340 EVP_PKEY* createEcKey() 341 { 342 EVP_PKEY* pKey = nullptr; 343 344 #if (OPENSSL_VERSION_NUMBER < 0x30000000L) 345 int eccgrp = 0; 346 eccgrp = OBJ_txt2nid("secp384r1"); 347 348 EC_KEY* myecc = EC_KEY_new_by_curve_name(eccgrp); 349 if (myecc != nullptr) 350 { 351 EC_KEY_set_asn1_flag(myecc, OPENSSL_EC_NAMED_CURVE); 352 EC_KEY_generate_key(myecc); 353 pKey = EVP_PKEY_new(); 354 if (pKey != nullptr) 355 { 356 if (EVP_PKEY_assign(pKey, EVP_PKEY_EC, myecc) != 0) 357 { 358 /* pKey owns myecc from now */ 359 if (EC_KEY_check_key(myecc) <= 0) 360 { 361 std::cerr << "EC_check_key failed.\n"; 362 } 363 } 364 } 365 } 366 #else 367 // Create context for curve parameter generation. 368 std::unique_ptr<EVP_PKEY_CTX, decltype(&::EVP_PKEY_CTX_free)> ctx{ 369 EVP_PKEY_CTX_new_id(EVP_PKEY_EC, nullptr), &::EVP_PKEY_CTX_free}; 370 if (!ctx) 371 { 372 return nullptr; 373 } 374 375 // Set up curve parameters. 376 EVP_PKEY* params = nullptr; 377 if ((EVP_PKEY_paramgen_init(ctx.get()) <= 0) || 378 (EVP_PKEY_CTX_set_ec_param_enc(ctx.get(), OPENSSL_EC_NAMED_CURVE) <= 379 0) || 380 (EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx.get(), NID_secp384r1) <= 381 0) || 382 (EVP_PKEY_paramgen(ctx.get(), ¶ms) <= 0)) 383 { 384 return nullptr; 385 } 386 387 // Set up RAII holder for params. 388 std::unique_ptr<EVP_PKEY, decltype(&::EVP_PKEY_free)> pparams{ 389 params, &::EVP_PKEY_free}; 390 391 // Set new context for key generation, using curve parameters. 392 ctx.reset(EVP_PKEY_CTX_new_from_pkey(nullptr, params, nullptr)); 393 if (!ctx || (EVP_PKEY_keygen_init(ctx.get()) <= 0)) 394 { 395 return nullptr; 396 } 397 398 // Generate key. 399 if (EVP_PKEY_keygen(ctx.get(), &pKey) <= 0) 400 { 401 return nullptr; 402 } 403 #endif 404 405 return pKey; 406 } 407 408 void initOpenssl() 409 { 410 #if OPENSSL_VERSION_NUMBER < 0x10100000L 411 SSL_load_error_strings(); 412 OpenSSL_add_all_algorithms(); 413 RAND_load_file("/dev/urandom", 1024); 414 #endif 415 } 416 417 inline void ensureOpensslKeyPresentAndValid(const std::string& filepath) 418 { 419 bool pemFileValid = false; 420 421 pemFileValid = verifyOpensslKeyCert(filepath); 422 423 if (!pemFileValid) 424 { 425 std::cerr << "Error in verifying signature, regenerating\n"; 426 generateSslCertificate(filepath, "testhost"); 427 } 428 } 429 430 inline int nextProtoCallback(SSL* /*unused*/, const unsigned char** data, 431 unsigned int* len, void* /*unused*/) 432 { 433 // First byte is the length. 434 constexpr std::string_view h2 = "\x02h2"; 435 *data = std::bit_cast<const unsigned char*>(h2.data()); 436 *len = static_cast<unsigned int>(h2.size()); 437 return SSL_TLSEXT_ERR_OK; 438 } 439 440 inline int alpnSelectProtoCallback(SSL* /*unused*/, const unsigned char** out, 441 unsigned char* outlen, 442 const unsigned char* in, unsigned int inlen, 443 void* /*unused*/) 444 { 445 // There's a mismatch in constness for nghttp2_select_next_protocol. The 446 // examples in nghttp2 don't show this problem. Unclear what the right fix 447 // is here. 448 449 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) 450 unsigned char** outNew = const_cast<unsigned char**>(out); 451 int rv = nghttp2_select_next_protocol(outNew, outlen, in, inlen); 452 if (rv != 1) 453 { 454 return SSL_TLSEXT_ERR_NOACK; 455 } 456 457 return SSL_TLSEXT_ERR_OK; 458 } 459 460 inline std::shared_ptr<boost::asio::ssl::context> 461 getSslContext(const std::string& sslPemFile) 462 { 463 std::shared_ptr<boost::asio::ssl::context> mSslContext = 464 std::make_shared<boost::asio::ssl::context>( 465 boost::asio::ssl::context::tls_server); 466 mSslContext->set_options(boost::asio::ssl::context::default_workarounds | 467 boost::asio::ssl::context::no_sslv2 | 468 boost::asio::ssl::context::no_sslv3 | 469 boost::asio::ssl::context::single_dh_use | 470 boost::asio::ssl::context::no_tlsv1 | 471 boost::asio::ssl::context::no_tlsv1_1); 472 473 // BIG WARNING: This needs to stay disabled, as there will always be 474 // unauthenticated endpoints 475 // mSslContext->set_verify_mode(boost::asio::ssl::verify_peer); 476 477 SSL_CTX_set_options(mSslContext->native_handle(), SSL_OP_NO_RENEGOTIATION); 478 479 BMCWEB_LOG_DEBUG << "Using default TrustStore location: " << trustStorePath; 480 mSslContext->add_verify_path(trustStorePath); 481 482 mSslContext->use_certificate_file(sslPemFile, 483 boost::asio::ssl::context::pem); 484 mSslContext->use_private_key_file(sslPemFile, 485 boost::asio::ssl::context::pem); 486 487 if constexpr (bmcwebEnableHTTP2) 488 { 489 SSL_CTX_set_next_protos_advertised_cb(mSslContext->native_handle(), 490 nextProtoCallback, nullptr); 491 492 SSL_CTX_set_alpn_select_cb(mSslContext->native_handle(), 493 alpnSelectProtoCallback, nullptr); 494 } 495 // Set up EC curves to auto (boost asio doesn't have a method for this) 496 // There is a pull request to add this. Once this is included in an asio 497 // drop, use the right way 498 // http://stackoverflow.com/questions/18929049/boost-asio-with-ecdsa-certificate-issue 499 if (SSL_CTX_set_ecdh_auto(mSslContext->native_handle(), 1) != 1) 500 { 501 BMCWEB_LOG_ERROR << "Error setting tmp ecdh list\n"; 502 } 503 504 // Mozilla intermediate cipher suites v5.7 505 // Sourced from: https://ssl-config.mozilla.org/guidelines/5.7.json 506 const char* mozillaIntermediate = "ECDHE-ECDSA-AES128-GCM-SHA256:" 507 "ECDHE-RSA-AES128-GCM-SHA256:" 508 "ECDHE-ECDSA-AES256-GCM-SHA384:" 509 "ECDHE-RSA-AES256-GCM-SHA384:" 510 "ECDHE-ECDSA-CHACHA20-POLY1305:" 511 "ECDHE-RSA-CHACHA20-POLY1305:" 512 "DHE-RSA-AES128-GCM-SHA256:" 513 "DHE-RSA-AES256-GCM-SHA384:" 514 "DHE-RSA-CHACHA20-POLY1305"; 515 516 if (SSL_CTX_set_cipher_list(mSslContext->native_handle(), 517 mozillaIntermediate) != 1) 518 { 519 BMCWEB_LOG_ERROR << "Error setting cipher list\n"; 520 } 521 return mSslContext; 522 } 523 524 inline std::optional<boost::asio::ssl::context> getSSLClientContext() 525 { 526 boost::asio::ssl::context sslCtx(boost::asio::ssl::context::tls_client); 527 528 boost::system::error_code ec; 529 530 // Support only TLS v1.2 & v1.3 531 sslCtx.set_options(boost::asio::ssl::context::default_workarounds | 532 boost::asio::ssl::context::no_sslv2 | 533 boost::asio::ssl::context::no_sslv3 | 534 boost::asio::ssl::context::single_dh_use | 535 boost::asio::ssl::context::no_tlsv1 | 536 boost::asio::ssl::context::no_tlsv1_1, 537 ec); 538 if (ec) 539 { 540 BMCWEB_LOG_ERROR << "SSL context set_options failed"; 541 return std::nullopt; 542 } 543 544 // Add a directory containing certificate authority files to be used 545 // for performing verification. 546 sslCtx.set_default_verify_paths(ec); 547 if (ec) 548 { 549 BMCWEB_LOG_ERROR << "SSL context set_default_verify failed"; 550 return std::nullopt; 551 } 552 553 // Verify the remote server's certificate 554 sslCtx.set_verify_mode(boost::asio::ssl::verify_peer, ec); 555 if (ec) 556 { 557 BMCWEB_LOG_ERROR << "SSL context set_verify_mode failed"; 558 return std::nullopt; 559 } 560 561 // All cipher suites are set as per OWASP datasheet. 562 // https://cheatsheetseries.owasp.org/cheatsheets/TLS_Cipher_String_Cheat_Sheet.html 563 constexpr const char* sslCiphers = "ECDHE-ECDSA-AES128-GCM-SHA256:" 564 "ECDHE-RSA-AES128-GCM-SHA256:" 565 "ECDHE-ECDSA-AES256-GCM-SHA384:" 566 "ECDHE-RSA-AES256-GCM-SHA384:" 567 "ECDHE-ECDSA-CHACHA20-POLY1305:" 568 "ECDHE-RSA-CHACHA20-POLY1305:" 569 "DHE-RSA-AES128-GCM-SHA256:" 570 "DHE-RSA-AES256-GCM-SHA384" 571 "TLS_AES_128_GCM_SHA256:" 572 "TLS_AES_256_GCM_SHA384:" 573 "TLS_CHACHA20_POLY1305_SHA256"; 574 575 if (SSL_CTX_set_cipher_list(sslCtx.native_handle(), sslCiphers) != 1) 576 { 577 BMCWEB_LOG_ERROR << "SSL_CTX_set_cipher_list failed"; 578 return std::nullopt; 579 } 580 581 return sslCtx; 582 } 583 584 } // namespace ensuressl 585