avoid functions deprecated in OpenSSL 3+
cover avoid functions deprecated in OpenSSL 3+
OpenSSL appears to be getting rid of the SHA1* and SHA256* functions in favor of the more generic EVP_* APIs. The EVP_* APIs unfortunately require more attention to be paid to memory management and require specialized copy functions (like gcrypt), so I'm only using them with OpenSSL 3.x (I've tested 1.1.1n, too).
I'm in favor of keeping OpenSSL support since its development headers/libraries are more likely to be already-installed on developers' systems than nettle or gcrypt.
On Debian systems participating in popularity-contest:
libssl-dev is in 21.95% of systems, while nettle-dev and libgcrypt20-dev is are only in 4.08% and 2.94%, respectively:
https://qa.debian.org/popcon.php?package=openssl
https://qa.debian.org/popcon.php?package=nettle
https://qa.debian.org/popcon.php?package=libgcrypt20
Eric Wong (2):
sha256: avoid functions deprecated in OpenSSL 3+ avoid SHA-1 functions deprecated in OpenSSL 3+
Makefile | 6 ++++++ hash-ll.h | 18 ++++++++++++++++-- sha1/openssl.h | 49 ++++++++++++++++++++++++++++++++++++++++++++++++ sha256/openssl.h | 49 ++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 120 insertions(+), 2 deletions(-) create mode 100644 sha1/openssl.h create mode 100644 sha256/openssl.h
PATCH 1/2 sha256: avoid functions deprecated in OpenSSL 3+
OpenSSL 3+ deprecates the SHA256_Init, SHA256_Update, and SHA256_Final functions, leading to errors when building with `DEVELOPER=1'.
Use the newer EVP_* API with OpenSSL 3+ despite being more error-prone and less efficient due to heap allocations.
--- Makefile | 3 +++ hash-ll.h | 6 +++++- sha256/openssl.h | 49 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 57 insertions(+), 1 deletion(-) create mode 100644 sha256/openssl.h
Makefile +3 -0
@@ -3216,6 +3216,9 @@ $(SP_OBJ): %.sp: %.c %.o sparse: $(SP_OBJ) EXCEPT_HDRS := $(GENERATED_H) unicode-width.h compat/% xdiff/% +ifndef OPENSSL_SHA256 + EXCEPT_HDRS += sha256/openssl.h +endif ifndef NETTLE_SHA256 EXCEPT_HDRS += sha256/nettle.h endif
hash-ll.h +5 -1
@@ -17,7 +17,11 @@#define SHA256_NEEDS_CLONE_HELPER #include "sha256/gcrypt.h" #elif defined(SHA256_OPENSSL ) -#include <openssl/sha.h> +# include <openssl/sha.h> +# if defined(OPENSSL_API_LEVEL ) &&OPENSSL_API_LEVEL >=3 +# define SHA256_NEEDS_CLONE_HELPER +# include "sha256/openssl.h" +# endif #else #include "sha256/block/sha256.h" #endif
sha256/openssl.h new file +49 -0
49 lines not on this page · raw message
PATCH 2/2 avoid SHA-1 functions deprecated in OpenSSL 3+
In reply to Eric WongOpenSSL 3+ deprecates the SHA1_Init, SHA1_Update, and SHA1_Final functions, leading to errors when building with `DEVELOPER=1'.
Use the newer EVP_* API with OpenSSL 3+ (only) despite being more error-prone and less efficient due to heap allocations.
--- Makefile | 3 +++ hash-ll.h | 12 +++++++++++- sha1/openssl.h | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 63 insertions(+), 1 deletion(-) create mode 100644 sha1/openssl.h
Makefile +3 -0
@@ -3216,6 +3216,9 @@ $(SP_OBJ): %.sp: %.c %.o sparse: $(SP_OBJ) EXCEPT_HDRS := $(GENERATED_H) unicode-width.h compat/% xdiff/% +ifndef OPENSSL_SHA1 + EXCEPT_HDRS += sha1/openssl.h +endif ifndef OPENSSL_SHA256 EXCEPT_HDRS += sha256/openssl.h endif
hash-ll.h +11 -1
@@ -4,7 +4,11 @@#if defined(SHA1_APPLE )#include <CommonCrypto/CommonDigest.h> #elif defined(SHA1_OPENSSL ) -#include <openssl/sha.h> +# include <openssl/sha.h> +# if defined(OPENSSL_API_LEVEL ) &&OPENSSL_API_LEVEL >=3 +# define SHA1_NEEDS_CLONE_HELPER +# include "sha1/openssl.h" +# endif #elif defined(SHA1_DC )#include "sha1dc_git.h" #else /* SHA1_BLK */
@@ -45,6 +49,10 @@#define git_SHA1_Update platform_SHA1_Update#define git_SHA1_Final platform_SHA1_Final +#ifdef platform_SHA1_Clone +#define git_SHA1_Clone platform_SHA1_Clone +#endif +#ifndef platform_SHA256_CTX#define platform_SHA256_CTX SHA256_CTX#define platform_SHA256_Init SHA256_Init
@@ -67,10 +75,12 @@#define git_SHA1_Update git_SHA1_Update_Chunked#endif +#ifndef SHA1_NEEDS_CLONE_HELPER static inline void git_SHA1_Clone (git_SHA_CTX *dst,const git_SHA_CTX *src) {memcpy (dst, src,sizeof (*dst)); } +#endif #ifndef SHA256_NEEDS_CLONE_HELPER static inline void git_SHA256_Clone (git_SHA256_CTX *dst,const git_SHA256_CTX *src)
sha1/openssl.h new file +49 -0
49 lines not on this page · raw message
Re: [PATCH 2/2] avoid SHA-1 functions deprecated in OpenSSL 3+
Quoted 9 lines · Eric Wong
hash-ll.h +1
-0@@ -45,6 +49,10 @@#define git_SHA1_Update platform_SHA1_Update#define git_SHA1_Final platform_SHA1_Final +#ifdef platform_SHA1_Clone
hash-ll.h
Quoted 10 lines
hash-ll.h +5
-0+#define git_SHA1_Clone platform_SHA1_Clone +#endif + +#ifndef SHA1_NEEDS_CLONE_HELPER static inline void git_SHA1_Clone (git_SHA_CTX *dst,const git_SHA_CTX *src) {memcpy (dst, src,sizeof (*dst)); } +#endif
This smelled a bit strange in that all the other platform_* stuff is "if a platform sha-1 header implements platform_SHA1_*, we will use it to define git_SHA1_* (which is the symbol we use in the code)" plus its inverse "if there is no specific platform_SHA1_*, we assume OpenSSL compatible ones and use them as platform_SHA1_* (which in turn will be used as git_SHA1-*)".
And that is why "#ifndef platform_SHA1_CTX" block gave us default values for them. And from that point of view, the first hunk (i.e. "if SHA1_CLONE is defined for the platform, we use it") is entirely sensible.
But I did not get why we guard the other hunk with a different CPP macro. If we have platform_SHA1_Clone already defined, and then NEEDS_CLONE_HELPER not defined, we end up creating an static inline platform_SHA1_CLONE here, and I was not sure if that is what we wanted to do.
The answer to the above puzzle (at least it was a puzzle to me) is that the new header "sha1/openssl.h" added by this series does have platform_SHA1_Clone defined, and the code that includes it define NEEDS_CLONE_HELPER to avoid this "static inline", so the CPP macro SHA1_NEEDS_CLONE_HELPER means "we need more than just a straight bitwise copy to clone the SHA context, which is provided elsewhere in the form of platform_SHA1_Clone".
So everything evens out. If we are with newer OpenSSL, we will include sha1/openssl.h and get both platform_SHA1_Clone and SHA1_NEEDS_CLONE_HELPER defined. If we are with older OpenSSL or non-OpenSSL, we do not get platform_SHA1_Clone (because the "#ifndef platform_SHA1_CTX" block does not have a fallback default defined) and we do not get SHA1_NEEDS_CLONE_HELPER either. We either use the memcpy() fallback only when we are not working with newer OpenSSL or whatever defines its own platform_SHA1_Clone. So the patch smelled a bit strange, but there isn't anything incorrect per-se.
But then is this making folks unnecessary work when they add non-OpenSSL support that needs more than just memcpy() to clone the context? What breaks if we turn these two hunks into
#ifdef platform_SHA1_Clone
#define git_SHA1_Clone platform_SHA1_Clone
#else
static inline void git_SHA1_Clone(git_SHA_CTX *dst, git_SHA_CTX *src)
{
memcpy(dst, src, sizeof(*dst));
}
#endifand drop the requirement that they must define SHA1_NEEDS_CLONE_HELPER if they want to define their own platform_SHA1_Clone()?
Thanks. Everything else in the patch made sense (even though I am not familiar with the EVP API) to me.
Re: [PATCH 2/2] avoid SHA-1 functions deprecated in OpenSSL 3+
Quoted 71 lines · Junio C Hamano
Quoted 9 lines · Eric Wong
hash-ll.h +1
-0@@ -45,6 +49,10 @@#define git_SHA1_Update platform_SHA1_Update#define git_SHA1_Final platform_SHA1_Final +#ifdef platform_SHA1_Clonehash-ll.h
Quoted 10 lines
hash-ll.h +5
-0+#define git_SHA1_Clone platform_SHA1_Clone +#endif + +#ifndef SHA1_NEEDS_CLONE_HELPER static inline void git_SHA1_Clone (git_SHA_CTX *dst,const git_SHA_CTX *src) {memcpy (dst, src,sizeof (*dst)); } +#endif This smelled a bit strange in that all the other platform_* stuff is "if a platform sha-1 header implements platform_SHA1_*, we will use it to define git_SHA1_* (which is the symbol we use in the code)" plus its inverse "if there is no specific platform_SHA1_*, we assume OpenSSL compatible ones and use them as platform_SHA1_* (which in turn will be used as git_SHA1-*)".
And that is why "#ifndef
platform_SHA1_CTX" block gave us default values for them. And from that point of view, the first hunk (i.e. "ifSHA1_CLONEis defined for the platform, we use it") is entirely sensible.But I did not get why we guard the other hunk with a different CPP macro. If we have
platform_SHA1_Clonealready defined, and thenNEEDS_CLONE_HELPERnot defined, we end up creating an static inlineplatform_SHA1_CLONEhere, and I was not sure if that is what we wanted to do.The answer to the above puzzle (at least it was a puzzle to me) is that the new header "
sha1/openssl.h" added by this series does haveplatform_SHA1_Clonedefined, and the code that includes it defineNEEDS_CLONE_HELPERto avoid this "static inline", so the CPP macroSHA1_NEEDS_CLONE_HELPERmeans "we need more than just a straight bitwise copy to clone the SHA context, which is provided elsewhere in the form ofplatform_SHA1_Clone".So everything evens out. If we are with newer OpenSSL, we will include
sha1/openssl.hand get bothplatform_SHA1_CloneandSHA1_NEEDS_CLONE_HELPERdefined. If we are with older OpenSSL or non-OpenSSL, we do not getplatform_SHA1_Clone(because the "#ifndefplatform_SHA1_CTX" block does not have a fallback default defined) and we do not getSHA1_NEEDS_CLONE_HELPEReither. We either use thememcpy()fallback only when we are not working with newer OpenSSL or whatever defines its ownplatform_SHA1_Clone. So the patch smelled a bit strange, but there isn't anything incorrect per-se.But then is this making folks unnecessary work when they add non-OpenSSL support that needs more than just
memcpy()to clone the context? What breaks if we turn these two hunks into#ifdef platform_SHA1_Clone #define git_SHA1_Clone platform_SHA1_Clone #else static inline void git_SHA1_Clone(git_SHA_CTX *dst, git_SHA_CTX *src) { memcpy(dst, src, sizeof(*dst)); } #endif
Quoted 2 lines
and drop the requirement that they must define
SHA1_NEEDS_CLONE_HELPERif they want to define their ownplatform_SHA1_Clone()?
I just copied the existing SHA256 stuff and mostly did a s/SHA256/SHA1/ in patch 2/2. I'm not sure why SHA256_NEEDS_CLONE_HELPER was needed, either, but I decided to keep the SHA1 and SHA256 code as similar as possible for consistency.
We could probably drop both *_NEEDS_CLONE_HELPER macros, but that's a separate patch.
Re: [PATCH 2/2] avoid SHA-1 functions deprecated in OpenSSL 3+
Quoted 8 lines · Eric Wong
I just copied the existing SHA256 stuff and mostly did a s/SHA256/SHA1/ in patch 2/2. I'm not sure why
SHA256_NEEDS_CLONE_HELPERwas needed, either, but I decided to keep the SHA1 and SHA256 code as similar as possible for consistency.We could probably drop both
*_NEEDS_CLONE_HELPERmacros, but that's a separate patch.
Fair enough. Thanks.