Core/Crypto: Transitional Cryptography update for OpenSSL 1.1

Support for both OpenSSL 1.0 LTS and OpenSSL 1.1 versions.

Many Linux distributions are still on 1.0 and will stay on LTS for quite
some time.

Port of CMaNGOS commit: cmangos/mangos-wotlk@e1b0048

src/common/Cryptography/ARC4.cpp

@@ -7,34 +7,34 @@
 #include "ARC4.h"
 #include <openssl/sha.h>
 
-ARC4::ARC4(uint8 len) : m_ctx()
+ARC4::ARC4(uint32 len) : m_ctx(EVP_CIPHER_CTX_new())
 {
-    EVP_CIPHER_CTX_init(&m_ctx);
+    EVP_CIPHER_CTX_init(m_ctx);
-    EVP_EncryptInit_ex(&m_ctx, EVP_rc4(), NULL, NULL, NULL);
+    EVP_EncryptInit_ex(m_ctx, EVP_rc4(), nullptr, nullptr, nullptr);
-    EVP_CIPHER_CTX_set_key_length(&m_ctx, len);
+    EVP_CIPHER_CTX_set_key_length(m_ctx, len);
 }
 
-ARC4::ARC4(uint8 *seed, uint8 len) : m_ctx()
+ARC4::ARC4(uint8* seed, uint32 len) : m_ctx(EVP_CIPHER_CTX_new())
 {
-    EVP_CIPHER_CTX_init(&m_ctx);
+    EVP_CIPHER_CTX_init(m_ctx);
-    EVP_EncryptInit_ex(&m_ctx, EVP_rc4(), NULL, NULL, NULL);
+    EVP_EncryptInit_ex(m_ctx, EVP_rc4(), nullptr, nullptr, nullptr);
-    EVP_CIPHER_CTX_set_key_length(&m_ctx, len);
+    EVP_CIPHER_CTX_set_key_length(m_ctx, len);
-    EVP_EncryptInit_ex(&m_ctx, NULL, NULL, seed, NULL);
+    EVP_EncryptInit_ex(m_ctx, nullptr, nullptr, seed, nullptr);
 }
 
 ARC4::~ARC4()
 {
-    EVP_CIPHER_CTX_cleanup(&m_ctx);
+    EVP_CIPHER_CTX_free(m_ctx);
 }
 
-void ARC4::Init(uint8 *seed)
+void ARC4::Init(uint8* seed)
 {
-    EVP_EncryptInit_ex(&m_ctx, NULL, NULL, seed, NULL);
+    EVP_EncryptInit_ex(m_ctx, nullptr, nullptr, seed, nullptr);
 }
 
-void ARC4::UpdateData(int len, uint8 *data)
+void ARC4::UpdateData(int len, uint8* data)
 {
     int outlen = 0;
-    EVP_EncryptUpdate(&m_ctx, data, &outlen, data, len);
+    EVP_EncryptUpdate(m_ctx, data, &outlen, data, len);
-    EVP_EncryptFinal_ex(&m_ctx, data, &outlen);
+    EVP_EncryptFinal_ex(m_ctx, data, &outlen);
 }

src/common/Cryptography/ARC4.h

@@ -13,13 +13,13 @@
 class ARC4
 {
     public:
-        ARC4(uint8 len);
+        ARC4(uint32 len);
-        ARC4(uint8 *seed, uint8 len);
+        ARC4(uint8* seed, uint32 len);
         ~ARC4();
-        void Init(uint8 *seed);
+        void Init(uint8* seed);
-        void UpdateData(int len, uint8 *data);
+        void UpdateData(int len, uint8* data);
     private:
-        EVP_CIPHER_CTX m_ctx;
+        EVP_CIPHER_CTX* m_ctx;
 };
 
 #endif

src/common/Cryptography/HMACSHA1.cpp

@@ -8,38 +8,54 @@
 #include "BigNumber.h"
 #include "Common.h"
 
+#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x10100000L
+HMAC_CTX* HMAC_CTX_new()
+{
+    HMAC_CTX *ctx = new HMAC_CTX();
+    HMAC_CTX_init(ctx);
+    return ctx;
+}
+
+void HMAC_CTX_free(HMAC_CTX* ctx)
+{
+    HMAC_CTX_cleanup(ctx);
+    delete ctx;
+}
+#endif
+
+
 HmacHash::HmacHash(uint32 len, uint8 *seed)
 {
-    HMAC_CTX_init(&m_ctx);
+    m_ctx = HMAC_CTX_new();
-    HMAC_Init_ex(&m_ctx, seed, len, EVP_sha1(), NULL);
+    HMAC_Init_ex(m_ctx, seed, len, EVP_sha1(), nullptr);
     memset(m_digest, 0, sizeof(m_digest));
 }
 
 HmacHash::~HmacHash()
 {
-    HMAC_CTX_cleanup(&m_ctx);
+    HMAC_CTX_free(m_ctx);
 }
 
 void HmacHash::UpdateData(const std::string &str)
 {
-    HMAC_Update(&m_ctx, (uint8 const*)str.c_str(), str.length());
+    HMAC_Update(m_ctx, reinterpret_cast<uint8 const*>(str.c_str()), str.length());
 }
 
 void HmacHash::UpdateData(const uint8* data, size_t len)
 {
-    HMAC_Update(&m_ctx, data, len);
+   HMAC_Update(m_ctx, data, len);
 }
 
 void HmacHash::Finalize()
 {
     uint32 length = 0;
-    HMAC_Final(&m_ctx, (uint8*)m_digest, &length);
+    HMAC_Final(m_ctx, m_digest, &length);
     ASSERT(length == SHA_DIGEST_LENGTH);
 }
 
-uint8 *HmacHash::ComputeHash(BigNumber* bn)
+uint8* HmacHash::ComputeHash(BigNumber* bn)
 {
-    HMAC_Update(&m_ctx, bn->AsByteArray().get(), bn->GetNumBytes());
+    HMAC_Update(m_ctx, bn->AsByteArray().get(), bn->GetNumBytes());
     Finalize();
-    return (uint8*)m_digest;
+    return m_digest;
 }

src/common/Cryptography/HMACSHA1.h

@@ -24,11 +24,11 @@ class HmacHash
         void UpdateData(const std::string &str);
         void UpdateData(const uint8* data, size_t len);
         void Finalize();
-        uint8 *ComputeHash(BigNumber* bn);
+        uint8* ComputeHash(BigNumber* bn);
-        uint8 *GetDigest() { return (uint8*)m_digest; }
+        uint8* GetDigest() { return m_digest; }
         int GetLength() const { return SHA_DIGEST_LENGTH; }
     private:
-        HMAC_CTX m_ctx;
+        HMAC_CTX* m_ctx;
         uint8 m_digest[SHA_DIGEST_LENGTH];
 };
 #endif