undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

sha256: add support for Nettle

Browse Source 
For SHA-256, we currently have support for OpenSSL and libgcrypt because
these two libraries contain optimized implementations that can take
advantage of native processor instructions.  However, OpenSSL is not
suitable for linking against for Linux distros due to licensing
incompatibilities with the GPLv2, and libgcrypt has been less favored by
cryptographers due to some security-related implementation issues,
which, while not affecting our use of hash algorithms, has affected its
reputation.

Let's add another option that's compatible with the GPLv2, which is
Nettle.  This is an option which is generally better than libgcrypt
because on many distros GnuTLS (which uses Nettle) is used for HTTPS and
therefore as a practical matter it will be available on most systems.
As a result, prefer it over libgcrypt and our built-in implementation.

Nettle also has recently gained support for Intel's SHA-NI instructions,
which compare very favorably to other implementations, as well as
assembly implementations for when SHA-NI is not available.

A git gc on git.git sees a 12% performance improvement with Nettle over
our block SHA-256 implementation due to general assembly improvements.
With SHA-NI, the performance of raw SHA-256 on a 2 GiB file goes from
7.296 seconds with block SHA-256 to 1.523 seconds with Nettle.

Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
brian m. carlson 2022-07-10 13:29:07 +00:00 committed by Junio C Hamano
parent e4a4b31577
commit e555735836
3 changed files with 44 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Makefile
View File

@ -182,6 +182,8 @@ include shared.mak
# #
# Define BLK_SHA256 to use the built-in SHA-256 routines. # Define BLK_SHA256 to use the built-in SHA-256 routines.
# #
# Define NETTLE_SHA256 to use the SHA-256 routines in libnettle.
#
# Define GCRYPT_SHA256 to use the SHA-256 routines in libgcrypt. # Define GCRYPT_SHA256 to use the SHA-256 routines in libgcrypt.
# #
# Define OPENSSL_SHA256 to use the SHA-256 routines in OpenSSL. # Define OPENSSL_SHA256 to use the SHA-256 routines in OpenSSL.
@ -1842,6 +1844,10 @@ ifdef OPENSSL_SHA256
EXTLIBS += $(LIB_4_CRYPTO) EXTLIBS += $(LIB_4_CRYPTO)
BASIC_CFLAGS += -DSHA256_OPENSSL BASIC_CFLAGS += -DSHA256_OPENSSL
else else
ifdef NETTLE_SHA256
BASIC_CFLAGS += -DSHA256_NETTLE
EXTLIBS += -lnettle
else
ifdef GCRYPT_SHA256 ifdef GCRYPT_SHA256
BASIC_CFLAGS += -DSHA256_GCRYPT BASIC_CFLAGS += -DSHA256_GCRYPT
EXTLIBS += -lgcrypt EXTLIBS += -lgcrypt
@ -1850,6 +1856,7 @@ else
BASIC_CFLAGS += -DSHA256_BLK BASIC_CFLAGS += -DSHA256_BLK
endif endif
endif endif
endif
ifdef SHA1_MAX_BLOCK_SIZE ifdef SHA1_MAX_BLOCK_SIZE
LIB_OBJS += compat/sha1-chunked.o LIB_OBJS += compat/sha1-chunked.o
@ -3091,6 +3098,9 @@ $(SP_OBJ): %.sp: %.c %.o
sparse: $(SP_OBJ) sparse: $(SP_OBJ)
EXCEPT_HDRS := $(GENERATED_H) unicode-width.h compat/% xdiff/% EXCEPT_HDRS := $(GENERATED_H) unicode-width.h compat/% xdiff/%
ifndef NETTLE_SHA256
EXCEPT_HDRS += sha256/nettle.h
endif
ifndef GCRYPT_SHA256 ifndef GCRYPT_SHA256
EXCEPT_HDRS += sha256/gcrypt.h EXCEPT_HDRS += sha256/gcrypt.h
endif endif

4
hash.h
View File

@ -16,7 +16,9 @@
#include "block-sha1/sha1.h" #include "block-sha1/sha1.h"
#endif #endif
#if defined(SHA256_GCRYPT) #if defined(SHA256_NETTLE)
#include "sha256/nettle.h"
#elif defined(SHA256_GCRYPT)
#define SHA256_NEEDS_CLONE_HELPER #define SHA256_NEEDS_CLONE_HELPER
#include "sha256/gcrypt.h" #include "sha256/gcrypt.h"
#elif defined(SHA256_OPENSSL) #elif defined(SHA256_OPENSSL)

31
sha256/nettle.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef SHA256_NETTLE_H
#define SHA256_NETTLE_H
#include <nettle/sha2.h>
typedef struct sha256_ctx nettle_SHA256_CTX;
static inline void nettle_SHA256_Init(nettle_SHA256_CTX *ctx)
{
sha256_init(ctx);
}
static inline void nettle_SHA256_Update(nettle_SHA256_CTX *ctx,
const void *data,
size_t len)
{
sha256_update(ctx, len, data);
}
static inline void nettle_SHA256_Final(unsigned char *digest,
nettle_SHA256_CTX *ctx)
{
sha256_digest(ctx, SHA256_DIGEST_SIZE, digest);
}
#define platform_SHA256_CTX nettle_SHA256_CTX
#define platform_SHA256_Init nettle_SHA256_Init
#define platform_SHA256_Update nettle_SHA256_Update
#define platform_SHA256_Final nettle_SHA256_Final
#endif