OpenSSL 3.x: fixes to support Conan 2.0

recipes/openssl/3.x.x/conandata.yml

@@ -1,4 +1,8 @@
 sources:
+  3.1.0:
+    url:
+      - "https://www.openssl.org/source/openssl-3.1.0.tar.gz"
+    sha256: aaa925ad9828745c4cad9d9efeb273deca820f2cdcf2c3ac7d7c1212b7c497b4
   3.0.8:
     url:
       - "https://www.openssl.org/source/openssl-3.0.8.tar.gz"

recipes/openssl/3.x.x/test_package/CMakeLists.txt

@@ -1,44 +1,44 @@
-cmake_minimum_required(VERSION 3.1)
-project(test_package C)
+cmake_minimum_required(VERSION 3.15)
+project(test_package LANGUAGES C)
 
-include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-conan_basic_setup(TARGETS)
-
-option(OPENSSL_WITH_ZLIB "OpenSSL with zlib support" ON)
 option(OPENSSL_WITH_LEGACY "OpenSSL with support for the legacy provider" ON)
 option(OPENSSL_WITH_MD4 "OpenSSL with MD4 support (needs legacy provider)" ON)
 option(OPENSSL_WITH_RIPEMD160 "OpenSSL with RIPEMD16 support (needs legacy provider)" ON)
 
 set(OpenSSL_DEBUG 1)
 find_package(OpenSSL REQUIRED)
 
-message("OPENSSL_FOUND: ${OPENSSL_FOUND}")
-message("OPENSSL_INCLUDE_DIR: ${OPENSSL_INCLUDE_DIR}")
-message("OPENSSL_CRYPTO_LIBRARY: ${OPENSSL_CRYPTO_LIBRARY}")
-message("OPENSSL_CRYPTO_LIBRARIES: ${OPENSSL_CRYPTO_LIBRARIES}")
-message("OPENSSL_SSL_LIBRARY: ${OPENSSL_SSL_LIBRARY}")
-message("OPENSSL_SSL_LIBRARIES: ${OPENSSL_SSL_LIBRARIES}")
-message("OPENSSL_LIBRARIES: ${OPENSSL_LIBRARIES}")
-message("OPENSSL_VERSION: ${OPENSSL_VERSION}")
+# Test whether variables from https://cmake.org/cmake/help/latest/module/FindOpenSSL.html
+# are properly defined in conan generators
+set(_custom_vars
+    OPENSSL_FOUND
+    OPENSSL_INCLUDE_DIR
+    OPENSSL_CRYPTO_LIBRARY
+    OPENSSL_CRYPTO_LIBRARIES
+    OPENSSL_SSL_LIBRARY
+    OPENSSL_SSL_LIBRARIES
+    OPENSSL_LIBRARIES
+    OPENSSL_VERSION
+)
+foreach(_custom_var ${_custom_vars})
+    if(DEFINED ${_custom_var})
+        message(STATUS "${_custom_var}: ${${_custom_var}}")
+    else()
+        message(FATAL_ERROR "${_custom_var} not defined")
+    endif()
+endforeach()
 
-add_executable(digest digest.c)
-if(OPENSSL_WITH_ZLIB)
-    target_compile_definitions(digest PRIVATE WITH_ZLIB)
-endif()
-target_link_libraries(digest OpenSSL::Crypto)
+add_executable(test_package test_package.c digest.c)
+target_link_libraries(test_package PRIVATE OpenSSL::SSL OpenSSL::Crypto)
 
 if(OPENSSL_WITH_LEGACY)
-    add_executable(digest_legacy digest_legacy.c)
+    target_sources(test_package PRIVATE digest_legacy.c)
     # do now show deperecation warnings
-    target_compile_definitions(digest_legacy PRIVATE OPENSSL_SUPPRESS_DEPRECATED)
+    target_compile_definitions(test_package PRIVATE OPENSSL_SUPPRESS_DEPRECATED TEST_OPENSSL_LEGACY)
     if(OPENSSL_WITH_MD4)
-      target_compile_definitions(digest_legacy PRIVATE OPENSSL_WITH_MD4)
+      target_compile_definitions(test_package PRIVATE OPENSSL_WITH_MD4)
     endif()
     if(OPENSSL_WITH_RIPEMD160)
-      target_compile_definitions(digest_legacy PRIVATE OPENSSL_WITH_RIPEMD160)
-    endif()
-    if(OPENSSL_WITH_ZLIB)
-        target_compile_definitions(digest_legacy PRIVATE WITH_ZLIB)
+      target_compile_definitions(test_package PRIVATE OPENSSL_WITH_RIPEMD160)
     endif()
-    target_link_libraries(digest_legacy OpenSSL::Crypto)
 endif()

recipes/openssl/3.x.x/test_package/conanfile.py

@@ -1,40 +1,38 @@
-from conans import CMake, tools, ConanFile
-from conan.tools.build import cross_building
+from conan import ConanFile
+from conan.tools.build import can_run
+from conan.tools.cmake import cmake_layout, CMake, CMakeToolchain
 import os
 
 
 class TestPackageConan(ConanFile):
-    settings = "os", "compiler", "arch", "build_type"
-    generators = "cmake", "cmake_find_package", "pkg_config"
+    settings = "os", "arch", "compiler", "build_type"
+    generators = "CMakeDeps", "VirtualRunEnv"
+    test_type = "explicit"
+
+    def layout(self):
+        cmake_layout(self)
+
+    def requirements(self):
+        self.requires(self.tested_reference_str)
 
     def _with_legacy(self):
-        return (not self.options["openssl"].no_legacy and
-            ((not self.options["openssl"].no_md4) or
-              (not self.options["openssl"].no_rmd160)))
+        return (not self.dependencies["openssl"].options.no_legacy and
+            ((not self.dependencies["openssl"].options.no_md4) or
+              (not self.dependencies["openssl"].options.no_rmd160)))
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.cache_variables["OPENSSL_WITH_LEGACY"] = self._with_legacy()
+        tc.cache_variables["OPENSSL_WITH_MD4"] = not self.dependencies["openssl"].options.no_md4
+        tc.cache_variables["OPENSSL_WITH_RIPEMD160"] = not self.dependencies["openssl"].options.no_rmd160
+        tc.generate()
 
     def build(self):
         cmake = CMake(self)
-        cmake.definitions["OPENSSL_WITH_ZLIB"] = not self.options["openssl"].no_zlib
-        cmake.definitions["OPENSSL_WITH_LEGACY"] = self._with_legacy()
-        cmake.definitions["OPENSSL_WITH_MD4"] = not self.options["openssl"].no_md4
-        cmake.definitions["OPENSSL_WITH_RIPEMD160"] = not self.options["openssl"].no_rmd160
-        if self.settings.os == "Android":
-            cmake.definitions["CONAN_LIBCXX"] = ""
         cmake.configure()
         cmake.build()
 
     def test(self):
-        if not cross_building(self):
-            bin_path = os.path.join("bin", "digest")
-            self.run(bin_path, run_environment=True)
-
-            if not self.options["openssl"].no_legacy:
-                bin_legacy_path = os.path.join("bin", "digest_legacy")
-                self.run(bin_legacy_path, run_environment=True)
-
-            if not self.options["openssl"].no_stdio:
-                self.run("openssl version", run_environment=True)
-        assert os.path.exists(os.path.join(self.deps_cpp_info["openssl"].rootpath, "licenses", "LICENSE.txt"))
-
-        for fn in ("libcrypto.pc", "libssl.pc", "openssl.pc",):
-            assert os.path.isfile(os.path.join(self.build_folder, fn))
+        if can_run(self):
+            bin_path = os.path.join(self.cpp.build.bindirs[0], "test_package")
+            self.run(bin_path, env="conanrun")

recipes/openssl/3.x.x/test_package/digest.c

@@ -2,9 +2,6 @@
 #include <openssl/sha.h>
 #include <openssl/crypto.h>
 #include <openssl/ssl.h>
-#if defined(WITH_ZLIB)
-#include <zlib.h>
-#endif
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -32,7 +29,7 @@ void SHA3_hash(const EVP_MD *type, const unsigned char *message, size_t message_
     EVP_MD_CTX_destroy(mdctx);
 }
 
-int main()
+void digest()
 {
     unsigned int digest_len;
     unsigned char sha256_digest[SHA256_DIGEST_LENGTH],
@@ -64,10 +61,5 @@ int main()
     printf("sha512 digest: %s\n", sha512_string);
     printf("sha3 256 digest: %s\n", sha3_256_string);
     printf("sha3 512 digest: %s\n", sha3_512_string);
-    printf("OpenSSL version: %s\n", OpenSSL_version(OPENSSL_VERSION));
-#if defined(WITH_ZLIB)
-    printf("ZLIB version: %s\n", ZLIB_VERSION);
-#endif
 
-    return 0;
 }

recipes/openssl/3.x.x/test_package/digest_legacy.c

@@ -10,9 +10,6 @@
 #include <openssl/err.h>
 #include <openssl/crypto.h>
 #include <openssl/ssl.h>
-#if defined(WITH_ZLIB)
-#include <zlib.h>
-#endif
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -53,7 +50,7 @@ int MDx_hash(const EVP_MD *type, const unsigned char *message, size_t message_le
     return 0;
 }
 
-int main()
+int digest_legacy()
 {
     unsigned int digest_len;
     unsigned char md5_digest[MD5_DIGEST_LENGTH];
@@ -139,10 +136,6 @@ int main()
     printf("RIPEMD160 digest: %s\n", ripemd160_string);
     printf("RIPEMD160 digest (variant 2): %s\n", ripemd160_string2);
 #endif
-    printf("OpenSSL version: %s\n", OpenSSL_version(OPENSSL_VERSION));
-#if defined(WITH_ZLIB)
-    printf("ZLIB version: %s\n", ZLIB_VERSION);
-#endif
 
     return 0;
 }

recipes/openssl/3.x.x/test_package/test_package.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <openssl/ssl.h>
+
+void digest();
+int digest_legacy();
+
+int main()
+{
+	int legacy_result = 0;
+	OPENSSL_init_ssl(0, NULL);
+	printf("OpenSSL version: %s\n", OpenSSL_version(OPENSSL_VERSION));
+
+	digest();
+
+#if defined(TEST_OPENSSL_LEGACY)
+	legacy_result = digest_legacy();
+	if (legacy_result != 0) {
+		printf("Error testing the digest_legacy() function\n");
+		return 1;
+	}
+#endif
+
+	return 0;
+}

recipes/openssl/3.x.x/test_v1_package/CMakeLists.txt

@@ -0,0 +1,44 @@
+cmake_minimum_required(VERSION 3.1)
+project(test_package C)
+
+include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
+conan_basic_setup(TARGETS)
+
+option(OPENSSL_WITH_ZLIB "OpenSSL with zlib support" ON)
+option(OPENSSL_WITH_LEGACY "OpenSSL with support for the legacy provider" ON)
+option(OPENSSL_WITH_MD4 "OpenSSL with MD4 support (needs legacy provider)" ON)
+option(OPENSSL_WITH_RIPEMD160 "OpenSSL with RIPEMD16 support (needs legacy provider)" ON)
+
+set(OpenSSL_DEBUG 1)
+find_package(OpenSSL REQUIRED)
+
+message("OPENSSL_FOUND: ${OPENSSL_FOUND}")
+message("OPENSSL_INCLUDE_DIR: ${OPENSSL_INCLUDE_DIR}")
+message("OPENSSL_CRYPTO_LIBRARY: ${OPENSSL_CRYPTO_LIBRARY}")
+message("OPENSSL_CRYPTO_LIBRARIES: ${OPENSSL_CRYPTO_LIBRARIES}")
+message("OPENSSL_SSL_LIBRARY: ${OPENSSL_SSL_LIBRARY}")
+message("OPENSSL_SSL_LIBRARIES: ${OPENSSL_SSL_LIBRARIES}")
+message("OPENSSL_LIBRARIES: ${OPENSSL_LIBRARIES}")
+message("OPENSSL_VERSION: ${OPENSSL_VERSION}")
+
+add_executable(digest digest.c)
+if(OPENSSL_WITH_ZLIB)
+    target_compile_definitions(digest PRIVATE WITH_ZLIB)
+endif()
+target_link_libraries(digest OpenSSL::Crypto)
+
+if(OPENSSL_WITH_LEGACY)
+    add_executable(digest_legacy digest_legacy.c)
+    # do now show deperecation warnings
+    target_compile_definitions(digest_legacy PRIVATE OPENSSL_SUPPRESS_DEPRECATED)
+    if(OPENSSL_WITH_MD4)
+      target_compile_definitions(digest_legacy PRIVATE OPENSSL_WITH_MD4)
+    endif()
+    if(OPENSSL_WITH_RIPEMD160)
+      target_compile_definitions(digest_legacy PRIVATE OPENSSL_WITH_RIPEMD160)
+    endif()
+    if(OPENSSL_WITH_ZLIB)
+        target_compile_definitions(digest_legacy PRIVATE WITH_ZLIB)
+    endif()
+    target_link_libraries(digest_legacy OpenSSL::Crypto)
+endif()

recipes/openssl/3.x.x/test_v1_package/conanfile.py

@@ -0,0 +1,40 @@
+from conans import CMake, tools, ConanFile
+from conan.tools.build import cross_building
+import os
+
+
+class TestPackageConan(ConanFile):
+    settings = "os", "compiler", "arch", "build_type"
+    generators = "cmake", "cmake_find_package", "pkg_config"
+
+    def _with_legacy(self):
+        return (not self.options["openssl"].no_legacy and
+            ((not self.options["openssl"].no_md4) or
+              (not self.options["openssl"].no_rmd160)))
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.definitions["OPENSSL_WITH_ZLIB"] = not self.options["openssl"].no_zlib
+        cmake.definitions["OPENSSL_WITH_LEGACY"] = self._with_legacy()
+        cmake.definitions["OPENSSL_WITH_MD4"] = not self.options["openssl"].no_md4
+        cmake.definitions["OPENSSL_WITH_RIPEMD160"] = not self.options["openssl"].no_rmd160
+        if self.settings.os == "Android":
+            cmake.definitions["CONAN_LIBCXX"] = ""
+        cmake.configure()
+        cmake.build()
+
+    def test(self):
+        if not cross_building(self):
+            bin_path = os.path.join("bin", "digest")
+            self.run(bin_path, run_environment=True)
+
+            if not self.options["openssl"].no_legacy:
+                bin_legacy_path = os.path.join("bin", "digest_legacy")
+                self.run(bin_legacy_path, run_environment=True)
+
+            if not self.options["openssl"].no_stdio:
+                self.run("openssl version", run_environment=True)
+        assert os.path.exists(os.path.join(self.deps_cpp_info["openssl"].rootpath, "licenses", "LICENSE.txt"))
+
+        for fn in ("libcrypto.pc", "libssl.pc", "openssl.pc",):
+            assert os.path.isfile(os.path.join(self.build_folder, fn))

recipes/openssl/3.x.x/test_v1_package/digest.c

@@ -0,0 +1,73 @@
+#include <openssl/evp.h>
+#include <openssl/sha.h>
+#include <openssl/crypto.h>
+#include <openssl/ssl.h>
+#if defined(WITH_ZLIB)
+#include <zlib.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#define snprintf _snprintf
+#endif
+
+void SHA3_hash(const EVP_MD *type, const unsigned char *message, size_t message_len, unsigned char *digest, unsigned int *digest_len) {
+    EVP_MD_CTX *mdctx;
+
+    if((mdctx = EVP_MD_CTX_create()) == NULL)
+        printf("EVP_MD_CTX_create error!\n");
+
+    if(EVP_DigestInit_ex(mdctx, type, NULL) != 1)
+        printf("EVP_DigestInit_ex error!\n");
+
+    if(EVP_DigestUpdate(mdctx, message, message_len) != 1)
+        printf("EVP_DigestUpdate error!\n");
+
+    if(EVP_DigestFinal_ex(mdctx, digest, digest_len) != 1)
+        printf("EVP_DigestFinal_ex error!\n");
+
+    EVP_MD_CTX_destroy(mdctx);
+}
+
+int main()
+{
+    unsigned int digest_len;
+    unsigned char sha256_digest[SHA256_DIGEST_LENGTH],
+        sha512_digest[SHA512_DIGEST_LENGTH],
+        sha3_256_digest[SHA256_DIGEST_LENGTH],
+        sha3_512_digest[SHA512_DIGEST_LENGTH];
+    char sha256_string[SHA256_DIGEST_LENGTH*2+1] = {0},
+        sha512_string[SHA512_DIGEST_LENGTH*2+1] = {0},
+        sha3_256_string[SHA256_DIGEST_LENGTH*2+1] = {0},
+        sha3_512_string[SHA512_DIGEST_LENGTH*2+1] = {0};
+    char string[] = "happy";
+
+    SHA256((unsigned char*)&string, strlen(string), (unsigned char*)&sha256_digest);
+    SHA512((unsigned char*)&string, strlen(string), (unsigned char*)&sha512_digest);
+    SHA3_hash(EVP_sha3_256(), (unsigned char*)&string, strlen(string), (unsigned char*)&sha3_256_digest, &digest_len);
+    SHA3_hash(EVP_sha3_512(), (unsigned char*)&string, strlen(string), (unsigned char*)&sha3_512_digest, &digest_len);
+
+    for(int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+        snprintf(&sha256_string[i*2], sizeof(sha256_string)-i*2, "%02x", (unsigned int)sha256_digest[i]);
+        snprintf(&sha3_256_string[i*2], sizeof(sha3_256_string)-i*2, "%02x", (unsigned int)sha3_256_digest[i]);
+    }
+
+    for(int i = 0; i < SHA512_DIGEST_LENGTH; i++) {
+        snprintf(&sha512_string[i*2], sizeof(sha512_string)-i*2, "%02x", (unsigned int)sha512_digest[i]);
+        snprintf(&sha3_512_string[i*2], sizeof(sha3_512_string)-i*2, "%02x", (unsigned int)sha3_512_digest[i]);
+    }
+
+    printf("sha256 digest: %s\n", sha256_string);
+    printf("sha512 digest: %s\n", sha512_string);
+    printf("sha3 256 digest: %s\n", sha3_256_string);
+    printf("sha3 512 digest: %s\n", sha3_512_string);
+    printf("OpenSSL version: %s\n", OpenSSL_version(OPENSSL_VERSION));
+#if defined(WITH_ZLIB)
+    printf("ZLIB version: %s\n", ZLIB_VERSION);
+#endif
+
+    return 0;
+}