Implement crypto support with the Nettle crypto library.

SVN-Revision: 3656

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 60f6b063cab301461a79001e1658228e94662856..7b01b4ba96a2cf811ff1f17b2c92d3f2dc3a0187 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -66,6 +66,7 @@ ELSE(WIN32 AND NOT CYGWIN)
   SET(ICONV_DEFAULT ON)
 ENDIF(WIN32 AND NOT CYGWIN)
 
+OPTION(ENABLE_NETTLE "Enable use of Nettle" ON)
 OPTION(ENABLE_OPENSSL "Enable use of OpenSSL" ON)
 OPTION(ENABLE_TAR "Enable tar building" ${TAR_DEFAULT})
 OPTION(ENABLE_TAR_SHARED "Enable dynamic build of tar" ${TAR_SHARED_DEFAULT})
@@ -301,6 +302,20 @@ CHECK_C_SOURCE_COMPILES(
    int main() { return 0;}"
  SAFE_TO_DEFINE_EXTENSIONS)
 
+#
+# Find Nettle
+#
+IF(ENABLE_NETTLE)
+  CHECK_LIBRARY_EXISTS(nettle "nettle_sha1_digest" "" NETTLE_FOUND)
+  IF(NETTLE_FOUND)
+    SET(CMAKE_REQUIRED_LIBRARIES "nettle")
+    FIND_LIBRARY(NETTLE_LIBRARY NAMES nettle)
+    LIST(APPEND ADDITIONAL_LIBS ${NETTLE_LIBRARY})
+  ELSE(NETTLE_FOUND)
+    SET(ENABLE_NETTLE OFF)
+  ENDIF(NETTLE_FOUND)
+ENDIF(ENABLE_NETTLE)
+
 #
 # Find OpenSSL
 #
@@ -327,7 +342,9 @@ MACRO(CHECK_CRYPTO CRYPTO IMPLEMENTATIONS)
     FOREACH(IMPLEMENTATION ${IMPLEMENTATIONS})
       IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND)
         SET(ARCHIVE_CRYPTO_${CRYPTO}_${IMPLEMENTATION} FALSE)
-      ENDIF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND)
+      ELSEIF("${IMPLEMENTATION}" MATCHES "^NETTLE$" AND NOT NETTLE_FOUND)
+        SET(ARCHIVE_CRYPTO_${CRYPTO}_${IMPLEMENTATION} FALSE)
+      ENDIF("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND)
       IF(NOT DEFINED ARCHIVE_CRYPTO_${CRYPTO}_${IMPLEMENTATION})
         # Probe the local implementation for whether this
        # crypto implementation is available on this platform.
@@ -339,7 +356,10 @@ MACRO(CHECK_CRYPTO CRYPTO IMPLEMENTATIONS)
              "${TRY_CRYPTO_REQUIRED_INCLUDES};${OPENSSL_INCLUDE_DIR}")
            SET(TRY_CRYPTO_REQUIRED_LIBS
                "-DLINK_LIBRARIES:STRING=${OPENSSL_LIBRARIES}")
-       ENDIF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)
+       ELSEIF("${IMPLEMENTATION}" MATCHES "^NETTLE$" AND NETTLE_FOUND)
+           SET(TRY_CRYPTO_REQUIRED_LIBS
+               "-DLINK_LIBRARIES:STRING=${NETTLE_LIBRARY}")
+       ENDIF("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)
 
        FILE(READ "${CMAKE_CURRENT_SOURCE_DIR}/libarchive/archive_crypto.c"
             ARCHIVE_CRYPTO_C)
@@ -1034,12 +1054,12 @@ ENDIF(ENABLE_ACL)
 # Check MD5/RMD160/SHA support
 # NOTE: Crypto checks must be run last before generating config.h
 #
-CHECK_CRYPTO(MD5 "LIBC;LIBSYSTEM;OPENSSL")
-CHECK_CRYPTO(RMD160 "LIBC;OPENSSL")
-CHECK_CRYPTO(SHA1 "LIBC;LIBSYSTEM;OPENSSL")
-CHECK_CRYPTO(SHA256 "LIBC;LIBC2;LIBC3;LIBSYSTEM;OPENSSL")
-CHECK_CRYPTO(SHA384 "LIBC;LIBC2;LIBC3;LIBSYSTEM;OPENSSL")
-CHECK_CRYPTO(SHA512 "LIBC;LIBC2;LIBC3;LIBSYSTEM;OPENSSL")
+CHECK_CRYPTO(MD5 "LIBC;LIBSYSTEM;NETTLE;OPENSSL")
+CHECK_CRYPTO(RMD160 "LIBC;NETTLE;OPENSSL")
+CHECK_CRYPTO(SHA1 "LIBC;LIBSYSTEM;NETTLE;OPENSSL")
+CHECK_CRYPTO(SHA256 "LIBC;LIBC2;LIBC3;LIBSYSTEM;NETTLE;OPENSSL")
+CHECK_CRYPTO(SHA384 "LIBC;LIBC2;LIBC3;LIBSYSTEM;NETTLE;OPENSSL")
+CHECK_CRYPTO(SHA512 "LIBC;LIBC2;LIBC3;LIBSYSTEM;NETTLE;OPENSSL")
 CHECK_CRYPTO_WIN("MD5;SHA1;SHA256;SHA384;SHA512")
 
 # Generate "config.h" from "build/cmake/config.h.in"

diff --git a/build/cmake/config.h.in b/build/cmake/config.h.in
index cdebd0587c2b5e21436b12744918b54af846df18..61984c2856ea5a4b64cf39a3bbc28266c540623d 100644 (file)
--- a/build/cmake/config.h.in
+++ b/build/cmake/config.h.in
@@ -184,6 +184,9 @@ typedef uint64_t uintmax_t;
 /* MD5 via ARCHIVE_CRYPTO_MD5_LIBSYSTEM supported. */
 #cmakedefine ARCHIVE_CRYPTO_MD5_LIBSYSTEM 1
 
+/* MD5 via ARCHIVE_CRYPTO_MD5_NETTLE supported. */
+#cmakedefine ARCHIVE_CRYPTO_MD5_NETTLE 1
+
 /* MD5 via ARCHIVE_CRYPTO_MD5_OPENSSL supported. */
 #cmakedefine ARCHIVE_CRYPTO_MD5_OPENSSL 1
 
@@ -193,6 +196,9 @@ typedef uint64_t uintmax_t;
 /* RMD160 via ARCHIVE_CRYPTO_RMD160_LIBC supported. */
 #cmakedefine ARCHIVE_CRYPTO_RMD160_LIBC 1
 
+/* RMD160 via ARCHIVE_CRYPTO_RMD160_NETTLE supported. */
+#cmakedefine ARCHIVE_CRYPTO_RMD160_NETTLE 1
+
 /* RMD160 via ARCHIVE_CRYPTO_RMD160_OPENSSL supported. */
 #cmakedefine ARCHIVE_CRYPTO_RMD160_OPENSSL 1
 
@@ -202,6 +208,9 @@ typedef uint64_t uintmax_t;
 /* SHA1 via ARCHIVE_CRYPTO_SHA1_LIBSYSTEM supported. */
 #cmakedefine ARCHIVE_CRYPTO_SHA1_LIBSYSTEM 1
 
+/* SHA1 via ARCHIVE_CRYPTO_SHA1_NETTLE supported. */
+#cmakedefine ARCHIVE_CRYPTO_SHA1_NETTLE 1
+
 /* SHA1 via ARCHIVE_CRYPTO_SHA1_OPENSSL supported. */
 #cmakedefine ARCHIVE_CRYPTO_SHA1_OPENSSL 1
 
@@ -220,6 +229,9 @@ typedef uint64_t uintmax_t;
 /* SHA256 via ARCHIVE_CRYPTO_SHA256_LIBSYSTEM supported. */
 #cmakedefine ARCHIVE_CRYPTO_SHA256_LIBSYSTEM 1
 
+/* SHA256 via ARCHIVE_CRYPTO_SHA256_NETTLE supported. */
+#cmakedefine ARCHIVE_CRYPTO_SHA256_NETTLE 1
+
 /* SHA256 via ARCHIVE_CRYPTO_SHA256_OPENSSL supported. */
 #cmakedefine ARCHIVE_CRYPTO_SHA256_OPENSSL 1
 
@@ -238,6 +250,9 @@ typedef uint64_t uintmax_t;
 /* SHA384 via ARCHIVE_CRYPTO_SHA384_LIBSYSTEM supported. */
 #cmakedefine ARCHIVE_CRYPTO_SHA384_LIBSYSTEM 1
 
+/* SHA384 via ARCHIVE_CRYPTO_SHA384_NETTLE supported. */
+#cmakedefine ARCHIVE_CRYPTO_SHA384_NETTLE 1
+
 /* SHA384 via ARCHIVE_CRYPTO_SHA384_OPENSSL supported. */
 #cmakedefine ARCHIVE_CRYPTO_SHA384_OPENSSL 1
 
@@ -256,6 +271,9 @@ typedef uint64_t uintmax_t;
 /* SHA512 via ARCHIVE_CRYPTO_SHA512_LIBSYSTEM supported. */
 #cmakedefine ARCHIVE_CRYPTO_SHA512_LIBSYSTEM 1
 
+/* SHA512 via ARCHIVE_CRYPTO_SHA512_NETTLE supported. */
+#cmakedefine ARCHIVE_CRYPTO_SHA512_NETTLE 1
+
 /* SHA512 via ARCHIVE_CRYPTO_SHA512_OPENSSL supported. */
 #cmakedefine ARCHIVE_CRYPTO_SHA512_OPENSSL 1
 

diff --git a/configure.ac b/configure.ac
index a0bb45fc261520eb4fd2078a6a7dc1808ab75e74..824a01e1ad787969c09a7c8edd1365d7c05bc158 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -266,6 +266,8 @@ if test "x$with_lzma" != "xno"; then
   AC_CHECK_LIB(lzma,lzma_stream_decoder)
 fi
 
+AC_ARG_WITH([nettle],
+  AS_HELP_STRING([--without-nettle], [Don't build with crypto support from Nettle]))
 AC_ARG_WITH([openssl],
   AS_HELP_STRING([--without-openssl], [Don't build support for mtree and xar hashes through openssl]))
 
@@ -566,6 +568,14 @@ CRYPTO_CHECK(SHA512, LIBC2, sha512)
 CRYPTO_CHECK(SHA512, LIBC3, sha512)
 CRYPTO_CHECK(SHA512, LIBSYSTEM, sha512)
 
+if test "x$with_nettle" != "xno"; then
+    CRYPTO_CHECK(MD5, NETTLE, md5, -lnettle)
+    CRYPTO_CHECK(RMD160, NETTLE, rmd160, -lnettle)
+    CRYPTO_CHECK(SHA1, NETTLE, sha1, -lnettle)
+    CRYPTO_CHECK(SHA256, NETTLE, sha256, -lnettle)
+    CRYPTO_CHECK(SHA384, NETTLE, sha384, -lnettle)
+    CRYPTO_CHECK(SHA512, NETTLE, sha512, -lnettle)
+fi
 if test "x$with_openssl" != "xno"; then
     CRYPTO_CHECK(MD5, OPENSSL, md5, -lcrypto)
     CRYPTO_CHECK(RMD160, OPENSSL, rmd160, -lcrypto)

diff --git a/libarchive/archive_crypto.c b/libarchive/archive_crypto.c
index fd091764552e2b0d51fa82e0b33561b0462328c5..dcca1512ecec3815317f481e22b05eb8ff571d76 100644 (file)
--- a/libarchive/archive_crypto.c
+++ b/libarchive/archive_crypto.c
@@ -78,6 +78,30 @@ __archive_libsystem_md5final(archive_md5_ctx *ctx, void *md)
   return (ARCHIVE_OK);
 }
 
+#elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
+
+static int
+__archive_nettle_md5init(archive_md5_ctx *ctx)
+{
+  md5_init(ctx);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_md5update(archive_md5_ctx *ctx, const void *indata,
+    size_t insize)
+{
+  md5_update(ctx, insize, indata);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_md5final(archive_md5_ctx *ctx, void *md)
+{
+  md5_digest(ctx, MD5_DIGEST_SIZE, md);
+  return (ARCHIVE_OK);
+}
+
 #elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
 
 static int
@@ -158,6 +182,30 @@ __archive_libc_ripemd160final(archive_rmd160_ctx *ctx, void *md)
   return (ARCHIVE_OK);
 }
 
+#elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
+
+static int
+__archive_nettle_ripemd160init(archive_rmd160_ctx *ctx)
+{
+  rmd160_init(ctx);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
+    size_t insize)
+{
+  rmd160_update(ctx, insize, indata);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_ripemd160final(archive_rmd160_ctx *ctx, void *md)
+{
+  rmd160_digest(ctx, RMD160_DIGEST_SIZE, md);
+  return (ARCHIVE_OK);
+}
+
 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
 
 static int
@@ -233,6 +281,30 @@ __archive_libsystem_sha1final(archive_sha1_ctx *ctx, void *md)
   return (ARCHIVE_OK);
 }
 
+#elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
+
+static int
+__archive_nettle_sha1init(archive_sha1_ctx *ctx)
+{
+  sha1_init(ctx);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_sha1update(archive_sha1_ctx *ctx, const void *indata,
+    size_t insize)
+{
+  sha1_update(ctx, insize, indata);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_sha1final(archive_sha1_ctx *ctx, void *md)
+{
+  sha1_digest(ctx, SHA1_DIGEST_SIZE, md);
+  return (ARCHIVE_OK);
+}
+
 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
 
 static int
@@ -385,6 +457,30 @@ __archive_libsystem_sha256final(archive_sha256_ctx *ctx, void *md)
   return (ARCHIVE_OK);
 }
 
+#elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
+
+static int
+__archive_nettle_sha256init(archive_sha256_ctx *ctx)
+{
+  sha256_init(ctx);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_sha256update(archive_sha256_ctx *ctx, const void *indata,
+    size_t insize)
+{
+  sha256_update(ctx, insize, indata);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_sha256final(archive_sha256_ctx *ctx, void *md)
+{
+  sha256_digest(ctx, SHA256_DIGEST_SIZE, md);
+  return (ARCHIVE_OK);
+}
+
 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
 
 static int
@@ -532,6 +628,30 @@ __archive_libsystem_sha384final(archive_sha384_ctx *ctx, void *md)
   return (ARCHIVE_OK);
 }
 
+#elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
+
+static int
+__archive_nettle_sha384init(archive_sha384_ctx *ctx)
+{
+  sha384_init(ctx);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_sha384update(archive_sha384_ctx *ctx, const void *indata,
+    size_t insize)
+{
+  sha384_update(ctx, insize, indata);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_sha384final(archive_sha384_ctx *ctx, void *md)
+{
+  sha384_digest(ctx, SHA384_DIGEST_SIZE, md);
+  return (ARCHIVE_OK);
+}
+
 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
 
 static int
@@ -679,6 +799,30 @@ __archive_libsystem_sha512final(archive_sha512_ctx *ctx, void *md)
   return (ARCHIVE_OK);
 }
 
+#elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
+
+static int
+__archive_nettle_sha512init(archive_sha512_ctx *ctx)
+{
+  sha512_init(ctx);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_sha512update(archive_sha512_ctx *ctx, const void *indata,
+    size_t insize)
+{
+  sha512_update(ctx, insize, indata);
+  return (ARCHIVE_OK);
+}
+
+static int
+__archive_nettle_sha512final(archive_sha512_ctx *ctx, void *md)
+{
+  sha512_digest(ctx, SHA512_DIGEST_SIZE, md);
+  return (ARCHIVE_OK);
+}
+
 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
 
 static int
@@ -749,6 +893,10 @@ const struct archive_crypto __archive_crypto =
   &__archive_libsystem_md5init,
   &__archive_libsystem_md5update,
   &__archive_libsystem_md5final,
+#elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
+  &__archive_nettle_md5init,
+  &__archive_nettle_md5update,
+  &__archive_nettle_md5final,
 #elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
   &__archive_openssl_md5init,
   &__archive_openssl_md5update,
@@ -768,6 +916,10 @@ const struct archive_crypto __archive_crypto =
   &__archive_libc_ripemd160init,
   &__archive_libc_ripemd160update,
   &__archive_libc_ripemd160final,
+#elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
+  &__archive_nettle_ripemd160init,
+  &__archive_nettle_ripemd160update,
+  &__archive_nettle_ripemd160final,
 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
   &__archive_openssl_ripemd160init,
   &__archive_openssl_ripemd160update,
@@ -787,6 +939,10 @@ const struct archive_crypto __archive_crypto =
   &__archive_libsystem_sha1init,
   &__archive_libsystem_sha1update,
   &__archive_libsystem_sha1final,
+#elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
+  &__archive_nettle_sha1init,
+  &__archive_nettle_sha1update,
+  &__archive_nettle_sha1final,
 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
   &__archive_openssl_sha1init,
   &__archive_openssl_sha1update,
@@ -818,6 +974,10 @@ const struct archive_crypto __archive_crypto =
   &__archive_libsystem_sha256init,
   &__archive_libsystem_sha256update,
   &__archive_libsystem_sha256final,
+#elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
+  &__archive_nettle_sha256init,
+  &__archive_nettle_sha256update,
+  &__archive_nettle_sha256final,
 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
   &__archive_openssl_sha256init,
   &__archive_openssl_sha256update,
@@ -849,6 +1009,10 @@ const struct archive_crypto __archive_crypto =
   &__archive_libsystem_sha384init,
   &__archive_libsystem_sha384update,
   &__archive_libsystem_sha384final,
+#elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
+  &__archive_nettle_sha384init,
+  &__archive_nettle_sha384update,
+  &__archive_nettle_sha384final,
 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
   &__archive_openssl_sha384init,
   &__archive_openssl_sha384update,
@@ -880,6 +1044,10 @@ const struct archive_crypto __archive_crypto =
   &__archive_libsystem_sha512init,
   &__archive_libsystem_sha512update,
   &__archive_libsystem_sha512final
+#elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
+  &__archive_nettle_sha512init,
+  &__archive_nettle_sha512update,
+  &__archive_nettle_sha512final,
 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
   &__archive_openssl_sha512init,
   &__archive_openssl_sha512update,

diff --git a/libarchive/archive_crypto_private.h b/libarchive/archive_crypto_private.h
index aca1e26e403c28314e64ecccea5681c1274bf8cd..8feb5cf9dbb2d0428ce562c97e281fec3370c08c 100644 (file)
--- a/libarchive/archive_crypto_private.h
+++ b/libarchive/archive_crypto_private.h
@@ -88,6 +88,20 @@
 #include <CommonCrypto/CommonDigest.h>
 #endif
 
+/* Nettle crypto headers */
+#if defined(ARCHIVE_CRYPTO_MD5_NETTLE)
+#include <nettle/md5.h>
+#endif
+#if defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
+#include <nettle/rmd.h>
+#endif
+#if defined(ARCHIVE_CRYPTO_SHA1_NETTLE) ||\
+  defined(ARCHIVE_CRYPTO_SHA256_NETTLE) ||\
+  defined(ARCHIVE_CRYPTO_SHA384_NETTLE) ||\
+  defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
+#include <nettle/sha.h>
+#endif
+
 /* OpenSSL crypto headers */
 #if defined(ARCHIVE_CRYPTO_MD5_OPENSSL) ||\
   defined(ARCHIVE_CRYPTO_RMD160_OPENSSL) ||\
@@ -118,6 +132,8 @@ extern void __la_hash_Update(Digest_CTX *, const unsigned char *, size_t);
 typedef MD5_CTX archive_md5_ctx;
 #elif defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM)
 typedef CC_MD5_CTX archive_md5_ctx;
+#elif defined(ARCHIVE_CRYPTO_MD5_NETTLE)
+typedef struct md5_ctx archive_md5_ctx;
 #elif defined(ARCHIVE_CRYPTO_MD5_OPENSSL)
 typedef EVP_MD_CTX archive_md5_ctx;
 #elif defined(ARCHIVE_CRYPTO_MD5_WIN)
@@ -128,6 +144,8 @@ typedef unsigned char archive_md5_ctx;
 
 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC)
 typedef RMD160_CTX archive_rmd160_ctx;
+#elif defined(ARCHIVE_CRYPTO_RMD160_NETTLE)
+typedef struct rmd160_ctx archive_rmd160_ctx;
 #elif defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
 typedef EVP_MD_CTX archive_rmd160_ctx;
 #else
@@ -138,6 +156,8 @@ typedef unsigned char archive_rmd160_ctx;
 typedef SHA1_CTX archive_sha1_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM)
 typedef CC_SHA1_CTX archive_sha1_ctx;
+#elif defined(ARCHIVE_CRYPTO_SHA1_NETTLE)
+typedef struct sha1_ctx archive_sha1_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA1_OPENSSL)
 typedef EVP_MD_CTX archive_sha1_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA1_WIN)
@@ -154,6 +174,8 @@ typedef SHA256_CTX archive_sha256_ctx;
 typedef SHA2_CTX archive_sha256_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM)
 typedef CC_SHA256_CTX archive_shs256_ctx;
+#elif defined(ARCHIVE_CRYPTO_SHA256_NETTLE)
+typedef struct sha256_ctx archive_sha256_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA256_OPENSSL)
 typedef EVP_MD_CTX archive_sha256_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA256_WIN)
@@ -170,6 +192,8 @@ typedef SHA384_CTX archive_sha384_ctx;
 typedef SHA2_CTX archive_sha384_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM)
 typedef CC_SHA512_CTX archive_shs384_ctx;
+#elif defined(ARCHIVE_CRYPTO_SHA384_NETTLE)
+typedef struct sha384_ctx archive_sha384_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA384_OPENSSL)
 typedef EVP_MD_CTX archive_sha384_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA384_WIN)
@@ -186,6 +210,8 @@ typedef SHA512_CTX archive_sha512_ctx;
 typedef SHA2_CTX archive_sha512_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM)
 typedef CC_SHA512_CTX archive_shs512_ctx;
+#elif defined(ARCHIVE_CRYPTO_SHA512_NETTLE)
+typedef struct sha512_ctx archive_sha512_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA512_OPENSSL)
 typedef EVP_MD_CTX archive_sha512_ctx;
 #elif defined(ARCHIVE_CRYPTO_SHA512_WIN)
@@ -197,6 +223,7 @@ typedef unsigned char archive_sha512_ctx;
 /* defines */
 #if defined(ARCHIVE_CRYPTO_MD5_LIBC) ||\
   defined(ARCHIVE_CRYPTO_MD5_LIBSYSTEM) ||\
+  defined(ARCHIVE_CRYPTO_MD5_NETTLE) ||\
   defined(ARCHIVE_CRYPTO_MD5_OPENSSL) ||\
   defined(ARCHIVE_CRYPTO_MD5_WIN)
 #define ARCHIVE_HAS_MD5
@@ -209,6 +236,7 @@ typedef unsigned char archive_sha512_ctx;
 #endif
 
 #if defined(ARCHIVE_CRYPTO_RMD160_LIBC) ||\
+  defined(ARCHIVE_CRYPTO_RMD160_NETTLE) ||\
   defined(ARCHIVE_CRYPTO_RMD160_OPENSSL)
 #define ARCHIVE_HAS_RMD160
 #define archive_rmd160_init(ctx)\
@@ -221,6 +249,7 @@ typedef unsigned char archive_sha512_ctx;
 
 #if defined(ARCHIVE_CRYPTO_SHA1_LIBC) ||\
   defined(ARCHIVE_CRYPTO_SHA1_LIBSYSTEM) ||\
+  defined(ARCHIVE_CRYPTO_SHA1_NETTLE) ||\
   defined(ARCHIVE_CRYPTO_SHA1_OPENSSL) ||\
   defined(ARCHIVE_CRYPTO_SHA1_WIN)
 #define ARCHIVE_HAS_SHA1
@@ -236,6 +265,7 @@ typedef unsigned char archive_sha512_ctx;
   defined(ARCHIVE_CRYPTO_SHA256_LIBC2) ||\
   defined(ARCHIVE_CRYPTO_SHA256_LIBC3) ||\
   defined(ARCHIVE_CRYPTO_SHA256_LIBSYSTEM) ||\
+  defined(ARCHIVE_CRYPTO_SHA256_NETTLE) ||\
   defined(ARCHIVE_CRYPTO_SHA256_OPENSSL) ||\
   defined(ARCHIVE_CRYPTO_SHA256_WIN)
 #define ARCHIVE_HAS_SHA256
@@ -251,6 +281,7 @@ typedef unsigned char archive_sha512_ctx;
   defined(ARCHIVE_CRYPTO_SHA384_LIBC2) ||\
   defined(ARCHIVE_CRYPTO_SHA384_LIBC3) ||\
   defined(ARCHIVE_CRYPTO_SHA384_LIBSYSTEM) ||\
+  defined(ARCHIVE_CRYPTO_SHA384_NETTLE) ||\
   defined(ARCHIVE_CRYPTO_SHA384_OPENSSL) ||\
   defined(ARCHIVE_CRYPTO_SHA384_WIN)
 #define ARCHIVE_HAS_SHA384
@@ -266,6 +297,7 @@ typedef unsigned char archive_sha512_ctx;
   defined(ARCHIVE_CRYPTO_SHA512_LIBC2) ||\
   defined(ARCHIVE_CRYPTO_SHA512_LIBC3) ||\
   defined(ARCHIVE_CRYPTO_SHA512_LIBSYSTEM) ||\
+  defined(ARCHIVE_CRYPTO_SHA512_NETTLE) ||\
   defined(ARCHIVE_CRYPTO_SHA512_OPENSSL) ||\
   defined(ARCHIVE_CRYPTO_SHA512_WIN)
 #define ARCHIVE_HAS_SHA512