Update upstream source from tag 'upstream/6.0.0'master

Update to upstream version '6.0.0'
with Debian dir 5604a80ec1c96ca76f25f40d78e6ef855abec322

3 files changed, 9 insertions, 146 deletions

diff --git a/src/mongo/crypto/SConscript b/src/mongo/crypto/SConscript
index 82385f5238c..d6e291f712f 100644
--- a/src/mongo/crypto/SConscript
+++ b/src/mongo/crypto/SConscript
@@ -98,7 +98,6 @@ env.Library(
     ],
     LIBDEPS=[
         '$BUILD_DIR/mongo/base/secure_allocator',
-        '$BUILD_DIR/mongo/bson/bson_validate',
         '$BUILD_DIR/mongo/db/common',
         '$BUILD_DIR/mongo/idl/idl_parser',
     ],
diff --git a/src/mongo/crypto/sha_block_openssl.cpp b/src/mongo/crypto/sha_block_openssl.cpp
index 1e6b0c86d6b..80a752fbafa 100644
--- a/src/mongo/crypto/sha_block_openssl.cpp
+++ b/src/mongo/crypto/sha_block_openssl.cpp
@@ -87,66 +87,6 @@ namespace mongo {
 
 namespace {
 
-
-/**
- * Class to load singleton instances of each SHA algorithm.
- */
-#if OPENSSL_VERSION_NUMBER > 0x30000000L
-class OpenSSLHashLoader {
-public:
-    OpenSSLHashLoader() {
-        _algoSHA1 = EVP_MD_fetch(NULL, "SHA1", NULL);
-        _algoSHA256 = EVP_MD_fetch(NULL, "SHA2-256", NULL);
-        _algoSHA512 = EVP_MD_fetch(NULL, "SHA2-512", NULL);
-    }
-
-    ~OpenSSLHashLoader() {
-        EVP_MD_free(_algoSHA1);
-        EVP_MD_free(_algoSHA256);
-        EVP_MD_free(_algoSHA512);
-    }
-
-    const EVP_MD* getSHA512() {
-        return _algoSHA512;
-    }
-
-    const EVP_MD* getSHA256() {
-        return _algoSHA256;
-    }
-
-    const EVP_MD* getSHA1() {
-        return _algoSHA1;
-    }
-
-private:
-    EVP_MD* _algoSHA512;
-    EVP_MD* _algoSHA256;
-    EVP_MD* _algoSHA1;
-};
-#else
-
-class OpenSSLHashLoader {
-public:
-    const EVP_MD* getSHA512() {
-        return EVP_sha512();
-    }
-
-    const EVP_MD* getSHA256() {
-        return EVP_sha256();
-    }
-
-    const EVP_MD* getSHA1() {
-        return EVP_sha1();
-    }
-};
-#endif
-
-static OpenSSLHashLoader& getOpenSSLHashLoader() {
-    static OpenSSLHashLoader* loader = new OpenSSLHashLoader();
-    return *loader;
-}
-
-
 /*
  * Computes a SHA hash of 'input'.
  */
@@ -191,41 +131,38 @@ void computeHmacImpl(const EVP_MD* md,
 
 void SHA1BlockTraits::computeHash(std::initializer_list<ConstDataRange> input,
                                   HashType* const output) {
-    computeHashImpl<SHA1BlockTraits::HashType>(getOpenSSLHashLoader().getSHA1(), input, output);
+    computeHashImpl<SHA1BlockTraits::HashType>(EVP_sha1(), input, output);
 }
 
 void SHA256BlockTraits::computeHash(std::initializer_list<ConstDataRange> input,
                                     HashType* const output) {
-    computeHashImpl<SHA256BlockTraits::HashType>(getOpenSSLHashLoader().getSHA256(), input, output);
+    computeHashImpl<SHA256BlockTraits::HashType>(EVP_sha256(), input, output);
 }
 
 void SHA512BlockTraits::computeHash(std::initializer_list<ConstDataRange> input,
                                     HashType* const output) {
-    computeHashImpl<SHA512BlockTraits::HashType>(getOpenSSLHashLoader().getSHA512(), input, output);
+    computeHashImpl<SHA512BlockTraits::HashType>(EVP_sha512(), input, output);
 }
 
 void SHA1BlockTraits::computeHmac(const uint8_t* key,
                                   size_t keyLen,
                                   std::initializer_list<ConstDataRange> input,
                                   SHA1BlockTraits::HashType* const output) {
-    return computeHmacImpl<SHA1BlockTraits::HashType>(
-        getOpenSSLHashLoader().getSHA1(), key, keyLen, input, output);
+    return computeHmacImpl<SHA1BlockTraits::HashType>(EVP_sha1(), key, keyLen, input, output);
 }
 
 void SHA256BlockTraits::computeHmac(const uint8_t* key,
                                     size_t keyLen,
                                     std::initializer_list<ConstDataRange> input,
                                     SHA256BlockTraits::HashType* const output) {
-    return computeHmacImpl<SHA256BlockTraits::HashType>(
-        getOpenSSLHashLoader().getSHA256(), key, keyLen, input, output);
+    return computeHmacImpl<SHA256BlockTraits::HashType>(EVP_sha256(), key, keyLen, input, output);
 }
 
 void SHA512BlockTraits::computeHmac(const uint8_t* key,
                                     size_t keyLen,
                                     std::initializer_list<ConstDataRange> input,
                                     SHA512BlockTraits::HashType* const output) {
-    return computeHmacImpl<SHA512BlockTraits::HashType>(
-        getOpenSSLHashLoader().getSHA512(), key, keyLen, input, output);
+    return computeHmacImpl<SHA512BlockTraits::HashType>(EVP_sha512(), key, keyLen, input, output);
 }
 
 }  // namespace mongo
diff --git a/src/mongo/crypto/symmetric_crypto_openssl.cpp b/src/mongo/crypto/symmetric_crypto_openssl.cpp
index 62d69b02284..d0e843dd7d9 100644
--- a/src/mongo/crypto/symmetric_crypto_openssl.cpp
+++ b/src/mongo/crypto/symmetric_crypto_openssl.cpp
@@ -48,79 +48,6 @@
 namespace mongo {
 namespace crypto {
 
-
-/**
- * Class to load singleton instances of each Encryption Cipher algorithm.
- */
-#if OPENSSL_VERSION_NUMBER > 0x30000000L
-
-class OpenSSLCipherLoader {
-public:
-    OpenSSLCipherLoader() {
-        _algoAES256CBC = EVP_CIPHER_fetch(NULL, "AES-256-CBC", NULL);
-        _algoAES256GCM = EVP_CIPHER_fetch(NULL, "AES-256-GCM", NULL);
-        _algoAES256CTR = EVP_CIPHER_fetch(NULL, "AES-256-CTR", NULL);
-    }
-
-    ~OpenSSLCipherLoader() {
-        EVP_CIPHER_free(_algoAES256CBC);
-        EVP_CIPHER_free(_algoAES256GCM);
-        EVP_CIPHER_free(_algoAES256CTR);
-    }
-
-    const EVP_CIPHER* getAES256CTR() {
-        return _algoAES256CTR;
-    }
-
-    const EVP_CIPHER* getAES256GCM() {
-        return _algoAES256GCM;
-    }
-
-    const EVP_CIPHER* getAES256CBC() {
-        return _algoAES256CBC;
-    }
-
-private:
-    EVP_CIPHER* _algoAES256CTR;
-    EVP_CIPHER* _algoAES256GCM;
-    EVP_CIPHER* _algoAES256CBC;
-};
-#else
-
-class OpenSSLCipherLoader {
-public:
-    OpenSSLCipherLoader() {
-        _algoAES256CBC = EVP_get_cipherbyname("aes-256-cbc");
-        _algoAES256GCM = EVP_get_cipherbyname("aes-256-gcm");
-        _algoAES256CTR = EVP_get_cipherbyname("aes-256-ctr");
-    }
-
-    const EVP_CIPHER* getAES256CTR() {
-        return _algoAES256CTR;
-    }
-
-    const EVP_CIPHER* getAES256GCM() {
-        return _algoAES256GCM;
-    }
-
-    const EVP_CIPHER* getAES256CBC() {
-        return _algoAES256CBC;
-    }
-
-private:
-    const EVP_CIPHER* _algoAES256CTR;
-    const EVP_CIPHER* _algoAES256GCM;
-    const EVP_CIPHER* _algoAES256CBC;
-};
-
-#endif
-
-static OpenSSLCipherLoader& getOpenSSLCipherLoader() {
-    static OpenSSLCipherLoader* loader = new OpenSSLCipherLoader();
-    return *loader;
-}
-
-
 namespace {
 template <typename Init>
 void initCipherContext(
@@ -129,11 +56,11 @@ void initCipherContext(
     const EVP_CIPHER* cipher = nullptr;
     if (keySize == sym256KeySize) {
         if (mode == crypto::aesMode::cbc) {
-            cipher = getOpenSSLCipherLoader().getAES256CBC();
+            cipher = EVP_get_cipherbyname("aes-256-cbc");
         } else if (mode == crypto::aesMode::gcm) {
-            cipher = getOpenSSLCipherLoader().getAES256GCM();
+            cipher = EVP_get_cipherbyname("aes-256-gcm");
         } else if (mode == crypto::aesMode::ctr) {
-            cipher = getOpenSSLCipherLoader().getAES256CTR();
+            cipher = EVP_get_cipherbyname("aes-256-ctr");
         }
     }
     uassert(ErrorCodes::BadValue,