[nettle] Update the Win32 precompiled build of Nettle from 3.8.1 to 3.9.1.

Compiled using gcc-13.2.0 and MinGW-w64 11.0.0.

NOTE: The .debug files are no longer included because no one used them.

extlib/nettle.win32/README.txt

@@ -1,13 +1,17 @@
-GNU Nettle 3.7.3, precompiled for Win32.
+GNU Nettle 3.9.1, precompiled for Win32.
 
 License: LGPLv3 or LGPLv2.1
 ASM optimizations are enabled in "fat binary" mode.
 
 i386 build:
-- Compiled with i686-w64-mingw32-gcc 9.3.0.
-  - Ubuntu version: 9.3.0-7ubuntu1+22~exp1ubuntu4
+- Compiled with i686-w64-mingw32-gcc 13.2.0.
+- Using MinGW-w64 11.0.0.
 - i686-optimized.
 
 amd64 build:
-- Compiled with x86_64-w64-mingw32-gcc 9.3.0.
-  - Ubuntu version: 9.3.0-7ubuntu1+22~exp1ubuntu4
+- Compiled with x86_64-w64-mingw32-gcc 13.2.0.
+- Using MinGW-w64 11.0.0.
+
+To obtain the original nettle-3.9.1, visit:
+- https://www.lysator.liu.se/~nisse/nettle/
+- https://ftp.gnu.org/gnu/nettle/

extlib/nettle.win32/include/nettle/balloon.h

@@ -0,0 +1,98 @@
+/* balloon.h
+
+   Balloon password-hashing algorithm.
+
+   Copyright (C) 2022 Zoltan Fridrich
+   Copyright (C) 2022 Red Hat, Inc.
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 2 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+/* For a description of the algorithm, see:
+ * Boneh, D., Corrigan-Gibbs, H., Schechter, S. (2017, May 12). Balloon Hashing:
+ * A Memory-Hard Function Providing Provable Protection Against Sequential Attacks.
+ * Retrieved Sep 1, 2022, from https://eprint.iacr.org/2016/027.pdf
+ */
+
+#ifndef NETTLE_BALLOON_H_INCLUDED
+#define NETTLE_BALLOON_H_INCLUDED
+
+#include "nettle-types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Name mangling */
+#define balloon nettle_balloon
+#define balloon_itch nettle_balloon_itch
+#define balloon_sha1 nettle_balloon_sha1
+#define balloon_sha256 nettle_balloon_sha256
+#define balloon_sha384 nettle_balloon_sha384
+#define balloon_sha512 nettle_balloon_sha512
+
+void
+balloon(void *hash_ctx,
+        nettle_hash_update_func *update,
+        nettle_hash_digest_func *digest,
+        size_t digest_size, size_t s_cost, size_t t_cost,
+        size_t passwd_length, const uint8_t *passwd,
+        size_t salt_length, const uint8_t *salt,
+        uint8_t *scratch, uint8_t *dst);
+
+size_t
+balloon_itch(size_t digest_size, size_t s_cost);
+
+void
+balloon_sha1(size_t s_cost, size_t t_cost,
+             size_t passwd_length, const uint8_t *passwd,
+             size_t salt_length, const uint8_t *salt,
+             uint8_t *scratch, uint8_t *dst);
+
+void
+balloon_sha256(size_t s_cost, size_t t_cost,
+               size_t passwd_length, const uint8_t *passwd,
+               size_t salt_length, const uint8_t *salt,
+               uint8_t *scratch, uint8_t *dst);
+
+void
+balloon_sha384(size_t s_cost, size_t t_cost,
+               size_t passwd_length, const uint8_t *passwd,
+               size_t salt_length, const uint8_t *salt,
+               uint8_t *scratch, uint8_t *dst);
+
+void
+balloon_sha512(size_t s_cost, size_t t_cost,
+               size_t passwd_length, const uint8_t *passwd,
+               size_t salt_length, const uint8_t *salt,
+               uint8_t *scratch, uint8_t *dst);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NETTLE_BALLOON_H_INCLUDED */

extlib/nettle.win32/include/nettle/ccm.h

@@ -193,6 +193,9 @@ void
 ccm_aes128_digest(struct ccm_aes128_ctx *ctx,
 		  size_t length, uint8_t *digest);
 
+/* FIXME: For next API/ABI break: first argument should be const
+   struct aes128_ctx *, and similarly for other ccm_*_message
+   functions below. */
 void
 ccm_aes128_encrypt_message(struct ccm_aes128_ctx *ctx,
 			   size_t nlength, const uint8_t *nonce,

extlib/nettle.win32/include/nettle/gcm.h

@@ -40,6 +40,7 @@
 
 #include "aes.h"
 #include "camellia.h"
+#include "sm4.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -95,6 +96,13 @@ extern "C" {
 #define gcm_camellia256_decrypt nettle_gcm_camellia256_decrypt
 #define gcm_camellia256_digest nettle_gcm_camellia256_digest
 
+#define gcm_sm4_set_key nettle_gcm_sm4_set_key
+#define gcm_sm4_set_iv nettle_gcm_sm4_set_iv
+#define gcm_sm4_update nettle_gcm_sm4_update
+#define gcm_sm4_encrypt nettle_gcm_sm4_encrypt
+#define gcm_sm4_decrypt nettle_gcm_sm4_decrypt
+#define gcm_sm4_digest nettle_gcm_sm4_digest
+
 #define GCM_BLOCK_SIZE 16
 #define GCM_IV_SIZE (GCM_BLOCK_SIZE - 4)
 #define GCM_DIGEST_SIZE 16
@@ -322,7 +330,22 @@ void gcm_camellia256_decrypt(struct gcm_camellia256_ctx *ctx,
 void gcm_camellia256_digest(struct gcm_camellia256_ctx *ctx,
 			    size_t length, uint8_t *digest);
 
-  
+
+struct gcm_sm4_ctx GCM_CTX(struct sm4_ctx);
+
+void gcm_sm4_set_key(struct gcm_sm4_ctx *ctx, const uint8_t *key);
+void gcm_sm4_set_iv(struct gcm_sm4_ctx *ctx,
+		    size_t length, const uint8_t *iv);
+void gcm_sm4_update(struct gcm_sm4_ctx *ctx,
+		    size_t length, const uint8_t *data);
+void gcm_sm4_encrypt(struct gcm_sm4_ctx *ctx,
+		     size_t length, uint8_t *dst, const uint8_t *src);
+void gcm_sm4_decrypt(struct gcm_sm4_ctx *ctx,
+		     size_t length, uint8_t *dst, const uint8_t *src);
+void gcm_sm4_digest(struct gcm_sm4_ctx *ctx,
+		    size_t length, uint8_t *digest);
+
+
 #ifdef __cplusplus
 }
 #endif

extlib/nettle.win32/include/nettle/md5.h

@@ -44,6 +44,7 @@ extern "C" {
 #define md5_init nettle_md5_init
 #define md5_update nettle_md5_update
 #define md5_digest nettle_md5_digest
+#define md5_compress nettle_md5_compress
 
 #define MD5_DIGEST_SIZE 16
 #define MD5_BLOCK_SIZE 64
@@ -74,11 +75,12 @@ md5_digest(struct md5_ctx *ctx,
 	   size_t length,
 	   uint8_t *digest);
 
-/* Internal compression function. STATE points to 4 uint32_t words,
+/* MD5 compression function. STATE points to 4 uint32_t words,
    and DATA points to 64 bytes of input data, possibly unaligned. */
 void
-nettle_md5_compress(uint32_t *state, const uint8_t *data);
+md5_compress(uint32_t *state, const uint8_t *data);
 
+/* Old name, for backwards compatibility. */
 #define _nettle_md5_compress nettle_md5_compress
 
 #ifdef __cplusplus

extlib/nettle.win32/include/nettle/nettle-meta.h

@@ -89,6 +89,8 @@ extern const struct nettle_cipher nettle_arctwo64;
 extern const struct nettle_cipher nettle_arctwo128;
 extern const struct nettle_cipher nettle_arctwo_gutmann128;
 
+extern const struct nettle_cipher nettle_sm4;
+
 struct nettle_hash
 {
   const char *name;
@@ -198,6 +200,7 @@ extern const struct nettle_aead nettle_gcm_aes192;
 extern const struct nettle_aead nettle_gcm_aes256;
 extern const struct nettle_aead nettle_gcm_camellia128;
 extern const struct nettle_aead nettle_gcm_camellia256;
+extern const struct nettle_aead nettle_gcm_sm4;
 extern const struct nettle_aead nettle_eax_aes128;
 extern const struct nettle_aead nettle_chacha_poly1305;
 

extlib/nettle.win32/include/nettle/ocb.h

@@ -0,0 +1,189 @@
+/* ocb.h
+
+   OCB AEAD mode, RFC 7253
+
+   Copyright (C) 2021 Niels Möller
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 2 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#ifndef NETTLE_OCB_H_INCLUDED
+#define NETTLE_OCB_H_INCLUDED
+
+#include "nettle-types.h"
+#include "aes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Name mangling */
+#define ocb_set_key nettle_ocb_set_key
+#define ocb_set_nonce nettle_ocb_set_nonce
+#define ocb_update nettle_ocb_update
+#define ocb_encrypt nettle_ocb_encrypt
+#define ocb_decrypt nettle_ocb_decrypt
+#define ocb_digest nettle_ocb_digest
+#define ocb_encrypt_message nettle_ocb_encrypt_message
+#define ocb_decrypt_message nettle_ocb_decrypt_message
+#define ocb_aes128_set_encrypt_key nettle_ocb_aes128_set_encrypt_key
+#define ocb_aes128_set_decrypt_key nettle_ocb_aes128_set_decrypt_key
+#define ocb_aes128_set_nonce nettle_ocb_aes128_set_nonce
+#define ocb_aes128_update nettle_ocb_aes128_update
+#define ocb_aes128_encrypt nettle_ocb_aes128_encrypt
+#define ocb_aes128_decrypt nettle_ocb_aes128_decrypt
+#define ocb_aes128_digest nettle_ocb_aes128_digest
+#define ocb_aes128_encrypt_message nettle_ocb_aes128_encrypt_message
+#define ocb_aes128_decrypt_message nettle_ocb_aes128_decrypt_message
+
+#define OCB_BLOCK_SIZE 16
+#define OCB_DIGEST_SIZE 16
+#define OCB_MAX_NONCE_SIZE 15
+
+struct ocb_key {
+  /* L_*, L_$ and L_0, and one reserved entry */
+  union nettle_block16 L[4];
+};
+
+struct ocb_ctx {
+  /* Initial offset, Offset_0 in the spec. */
+  union nettle_block16 initial;
+  /* Offset, updated per block. */
+  union nettle_block16 offset;
+  /* Authentication for the associated data */
+  union nettle_block16 sum;
+  /* Authentication for the message */
+  union nettle_block16 checksum;
+  /* Count of processed blocks. */
+  size_t data_count;
+  size_t message_count;
+};
+
+void
+ocb_set_key (struct ocb_key *key, const void *cipher, nettle_cipher_func *f);
+
+void
+ocb_set_nonce (struct ocb_ctx *ctx,
+	       const void *cipher, nettle_cipher_func *f,
+	       size_t tag_length, size_t nonce_length, const uint8_t *nonce);
+
+void
+ocb_update (struct ocb_ctx *ctx, const struct ocb_key *key,
+	    const void *cipher, nettle_cipher_func *f,
+	    size_t length, const uint8_t *data);
+
+void
+ocb_encrypt (struct ocb_ctx *ctx, const struct ocb_key *key,
+	     const void *cipher, nettle_cipher_func *f,
+	     size_t length, uint8_t *dst, const uint8_t *src);
+
+void
+ocb_decrypt (struct ocb_ctx *ctx, const struct ocb_key *key,
+	     const void *encrypt_ctx, nettle_cipher_func *encrypt,
+	     const void *decrypt_ctx, nettle_cipher_func *decrypt,
+	     size_t length, uint8_t *dst, const uint8_t *src);
+
+void
+ocb_digest (const struct ocb_ctx *ctx, const struct ocb_key *key,
+	    const void *cipher, nettle_cipher_func *f,
+	    size_t length, uint8_t *digest);
+
+
+void
+ocb_encrypt_message (const struct ocb_key *ocb_key,
+		     const void *cipher, nettle_cipher_func *f,
+		     size_t nlength, const uint8_t *nonce,
+		     size_t alength, const uint8_t *adata,
+		     size_t tlength,
+		     size_t clength, uint8_t *dst, const uint8_t *src);
+
+int
+ocb_decrypt_message (const struct ocb_key *ocb_key,
+		     const void *encrypt_ctx, nettle_cipher_func *encrypt,
+		     const void *decrypt_ctx, nettle_cipher_func *decrypt,
+		     size_t nlength, const uint8_t *nonce,
+		     size_t alength, const uint8_t *adata,
+		     size_t tlength,
+		     size_t mlength, uint8_t *dst, const uint8_t *src);
+
+/* OCB-AES */
+/* This struct represents an expanded key for ocb-aes encryption. For
+   decryption, a separate decryption context is needed as well. */
+struct ocb_aes128_encrypt_key
+{
+  struct ocb_key ocb;
+  struct aes128_ctx encrypt;
+};
+
+void
+ocb_aes128_set_encrypt_key (struct ocb_aes128_encrypt_key *ocb, const uint8_t *key);
+
+void
+ocb_aes128_set_decrypt_key (struct ocb_aes128_encrypt_key *ocb, struct aes128_ctx *decrypt,
+			    const uint8_t *key);
+
+void
+ocb_aes128_set_nonce (struct ocb_ctx *ctx, const struct ocb_aes128_encrypt_key *key,
+		      size_t tag_length, size_t nonce_length, const uint8_t *nonce);
+
+void
+ocb_aes128_update (struct ocb_ctx *ctx, const struct ocb_aes128_encrypt_key *key,
+		   size_t length, const uint8_t *data);
+
+void
+ocb_aes128_encrypt(struct ocb_ctx *ctx, const struct ocb_aes128_encrypt_key *key,
+		   size_t length, uint8_t *dst, const uint8_t *src);
+
+void
+ocb_aes128_decrypt(struct ocb_ctx *ctx, const struct ocb_aes128_encrypt_key *key,
+		   const struct aes128_ctx *decrypt,
+		   size_t length, uint8_t *dst, const uint8_t *src);
+
+void
+ocb_aes128_digest(struct ocb_ctx *ctx, const struct ocb_aes128_encrypt_key *key,
+		  size_t length, uint8_t *digest);
+
+void
+ocb_aes128_encrypt_message (const struct ocb_aes128_encrypt_key *key,
+			    size_t nlength, const uint8_t *nonce,
+			    size_t alength, const uint8_t *adata,
+			    size_t tlength,
+			    size_t clength, uint8_t *dst, const uint8_t *src);
+
+int
+ocb_aes128_decrypt_message (const struct ocb_aes128_encrypt_key *key,
+			    const struct aes128_ctx *decrypt,
+			    size_t nlength, const uint8_t *nonce,
+			    size_t alength, const uint8_t *adata,
+			    size_t tlength,
+			    size_t mlength, uint8_t *dst, const uint8_t *src);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NETTLE_OCB_H_INCLUDED */

extlib/nettle.win32/include/nettle/sha1.h

@@ -44,6 +44,7 @@ extern "C" {
 #define sha1_init nettle_sha1_init
 #define sha1_update nettle_sha1_update
 #define sha1_digest nettle_sha1_digest
+#define sha1_compress nettle_sha1_compress
 
 /* SHA1 */
 
@@ -76,11 +77,12 @@ sha1_digest(struct sha1_ctx *ctx,
 	    size_t length,
 	    uint8_t *digest);
 
-/* Internal compression function. STATE points to 5 uint32_t words,
+/* SHA1 compression function. STATE points to 5 uint32_t words,
    and DATA points to 64 bytes of input data, possibly unaligned. */
 void
-nettle_sha1_compress(uint32_t *state, const uint8_t *data);
+sha1_compress(uint32_t *state, const uint8_t *data);
 
+/* Old name, for backwards compatibility. */
 #define _nettle_sha1_compress nettle_sha1_compress
 
 #ifdef __cplusplus

extlib/nettle.win32/include/nettle/sha2.h

@@ -46,11 +46,13 @@ extern "C" {
 #define sha256_init nettle_sha256_init
 #define sha256_update nettle_sha256_update
 #define sha256_digest nettle_sha256_digest
+#define sha256_compress nettle_sha256_compress
 #define sha384_init nettle_sha384_init
 #define sha384_digest nettle_sha384_digest
 #define sha512_init nettle_sha512_init
 #define sha512_update nettle_sha512_update
 #define sha512_digest nettle_sha512_digest
+#define sha512_compress nettle_sha512_compress
 #define sha512_224_init   nettle_sha512_224_init
 #define sha512_224_digest nettle_sha512_224_digest
 #define sha512_256_init   nettle_sha512_256_init
@@ -91,6 +93,8 @@ sha256_digest(struct sha256_ctx *ctx,
 	      size_t length,
 	      uint8_t *digest);
 
+void
+sha256_compress(uint32_t *state, const uint8_t *input);
 
 /* SHA224, a truncated SHA256 with different initial state. */
 
@@ -138,6 +142,8 @@ sha512_digest(struct sha512_ctx *ctx,
 	      size_t length,
 	      uint8_t *digest);
 
+void
+sha512_compress(uint64_t *state, const uint8_t *input);
 
 /* SHA384, a truncated SHA512 with different initial state. */
 
@@ -186,7 +192,7 @@ void
 sha512_256_digest(struct sha512_256_ctx *ctx,
                   size_t length,
                   uint8_t *digest);
-  
+
 #ifdef __cplusplus
 }
 #endif

extlib/nettle.win32/include/nettle/siv-gcm.h

@@ -0,0 +1,107 @@
+/* siv-gcm.h
+
+   AES-GCM-SIV, RFC8452
+
+   Copyright (C) 2022 Red Hat, Inc.
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 2 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#ifndef NETTLE_SIV_GCM_H_INCLUDED
+#define NETTLE_SIV_GCM_H_INCLUDED
+
+#include "nettle-types.h"
+#include "nettle-meta.h"
+#include "aes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Name mangling */
+#define siv_gcm_encrypt_message nettle_siv_gcm_encrypt_message
+#define siv_gcm_decrypt_message nettle_siv_gcm_decrypt_message
+#define siv_gcm_aes128_encrypt_message nettle_siv_gcm_aes128_encrypt_message
+#define siv_gcm_aes128_decrypt_message nettle_siv_gcm_aes128_decrypt_message
+#define siv_gcm_aes256_encrypt_message nettle_siv_gcm_aes256_encrypt_message
+#define siv_gcm_aes256_decrypt_message nettle_siv_gcm_aes256_decrypt_message
+
+/* For AES-GCM-SIV, the block size of the underlying cipher shall be 128 bits. */
+#define SIV_GCM_BLOCK_SIZE 16
+#define SIV_GCM_DIGEST_SIZE 16
+#define SIV_GCM_NONCE_SIZE 12
+
+/* Generic interface.  NC must be a block cipher with 128-bit block
+   size, and keysize that is a multiple of 64 bits, such as AES-128 or
+   AES-256.  */
+void
+siv_gcm_encrypt_message (const struct nettle_cipher *nc,
+			 const void *ctx,
+			 void *ctr_ctx,
+			 size_t nlength, const uint8_t *nonce,
+			 size_t alength, const uint8_t *adata,
+			 size_t clength, uint8_t *dst, const uint8_t *src);
+
+int
+siv_gcm_decrypt_message (const struct nettle_cipher *nc,
+			 const void *ctx,
+			 void *ctr_ctx,
+			 size_t nlength, const uint8_t *nonce,
+			 size_t alength, const uint8_t *adata,
+			 size_t mlength, uint8_t *dst, const uint8_t *src);
+
+/* AEAD_AES_128_GCM_SIV */
+void
+siv_gcm_aes128_encrypt_message (const struct aes128_ctx *ctx,
+				size_t nlength, const uint8_t *nonce,
+				size_t alength, const uint8_t *adata,
+				size_t clength, uint8_t *dst, const uint8_t *src);
+
+int
+siv_gcm_aes128_decrypt_message (const struct aes128_ctx *ctx,
+				size_t nlength, const uint8_t *nonce,
+				size_t alength, const uint8_t *adata,
+				size_t mlength, uint8_t *dst, const uint8_t *src);
+
+/* AEAD_AES_256_GCM_SIV */
+void
+siv_gcm_aes256_encrypt_message (const struct aes256_ctx *ctx,
+				size_t nlength, const uint8_t *nonce,
+				size_t alength, const uint8_t *adata,
+				size_t clength, uint8_t *dst, const uint8_t *src);
+
+int
+siv_gcm_aes256_decrypt_message (const struct aes256_ctx *ctx,
+				size_t nlength, const uint8_t *nonce,
+				size_t alength, const uint8_t *adata,
+				size_t mlength, uint8_t *dst, const uint8_t *src);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NETTLE_SIV_H_INCLUDED */

extlib/nettle.win32/include/nettle/sm4.h

@@ -0,0 +1,69 @@
+/* sm4.h
+
+   Copyright (C) 2022 Tianjia Zhang <tianjia.zhang@linux.alibaba.com>
+
+   This file is part of GNU Nettle.
+
+   GNU Nettle is free software: you can redistribute it and/or
+   modify it under the terms of either:
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at your
+       option) any later version.
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 2 of the License, or (at your
+       option) any later version.
+
+   or both in parallel, as here.
+
+   GNU Nettle is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see http://www.gnu.org/licenses/.
+*/
+
+#ifndef NETTLE_SM4_H_INCLUDED
+#define NETTLE_SM4_H_INCLUDED
+
+#include "nettle-types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Name mangling */
+#define sm4_set_encrypt_key nettle_sm4_set_encrypt_key
+#define sm4_set_decrypt_key nettle_sm4_set_decrypt_key
+#define sm4_crypt nettle_sm4_crypt
+
+#define SM4_BLOCK_SIZE 16
+#define SM4_KEY_SIZE 16
+
+struct sm4_ctx
+{
+  uint32_t rkey[32];
+};
+
+void
+sm4_set_encrypt_key(struct sm4_ctx *ctx, const uint8_t *key);
+
+void
+sm4_set_decrypt_key(struct sm4_ctx *ctx, const uint8_t *key);
+
+void
+sm4_crypt(const struct sm4_ctx *context,
+	  size_t length, uint8_t *dst,
+	  const uint8_t *src);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NETTLE_SM4_H_INCLUDED */

extlib/nettle.win32/include/nettle/version.h

@@ -41,7 +41,7 @@ extern "C" {
 
 /* Individual version numbers in decimal */
 #define NETTLE_VERSION_MAJOR 3
-#define NETTLE_VERSION_MINOR 7
+#define NETTLE_VERSION_MINOR 9
 
 #define NETTLE_USE_MINI_GMP 1
 

extlib/nettle.win32/include/nettle/xts.h

@@ -83,12 +83,12 @@ xts_aes128_set_decrypt_key(struct xts_aes128_key *xts_key,
                            const uint8_t *key);
 
 void
-xts_aes128_encrypt_message(struct xts_aes128_key *xtskey,
+xts_aes128_encrypt_message(const struct xts_aes128_key *xtskey,
                            const uint8_t *tweak, size_t length,
                            uint8_t *dst, const uint8_t *src);
 
 void
-xts_aes128_decrypt_message(struct xts_aes128_key *xts_key,
+xts_aes128_decrypt_message(const struct xts_aes128_key *xts_key,
                            const uint8_t *tweak, size_t length,
                            uint8_t *dst, const uint8_t *src);
 
@@ -107,12 +107,12 @@ xts_aes256_set_decrypt_key(struct xts_aes256_key *xts_key,
                            const uint8_t *key);
 
 void
-xts_aes256_encrypt_message(struct xts_aes256_key *xts_key,
+xts_aes256_encrypt_message(const struct xts_aes256_key *xts_key,
                            const uint8_t *tweak, size_t length,
                            uint8_t *dst, const uint8_t *src);
 
 void
-xts_aes256_decrypt_message(struct xts_aes256_key *xts_key,
+xts_aes256_decrypt_message(const struct xts_aes256_key *xts_key,
                            const uint8_t *tweak, size_t length,
                            uint8_t *dst, const uint8_t *src);
 

extlib/nettle.win32/lib.amd64/build.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+export CFLAGS="-O2 -pipe -static-libgcc -fstrict-aliasing -fcf-protection -ftree-vectorize"
+export LDFLAGS="-Wl,-O1 -static-libgcc -Wl,--dynamicbase -Wl,--nxcompat -Wl,--high-entropy-va -Wl,--subsystem,console:5.02"
+../configure --host=x86_64-w64-mingw32 \
+	--enable-mini-gmp \
+	--enable-fat \
+	--enable-x86-aesni \
+	--enable-x86-sha-ni \
+	--enable-x86-pclmul

extlib/nettle.win32/lib.amd64/libhogweed-6.def

@@ -41,51 +41,51 @@ EXPORTS
     _nettle_ecc_mul_g @40
     _nettle_ecc_mul_g_eh @41
     _nettle_ecc_mul_m @42
-    _nettle_ecc_pm1_redc @43
-    _nettle_ecc_pp1_redc @44
-    _nettle_ecc_secp192r1_modp @45
-    _nettle_ecc_secp256r1_redc @46
-    _nettle_ecc_secp384r1_modp @47
-    _nettle_ed25519_sha512 @48 DATA
-    _nettle_ed448_shake256 @49 DATA
-    _nettle_eddsa_compress @50
-    _nettle_eddsa_compress_itch @51
-    _nettle_eddsa_decompress @52
-    _nettle_eddsa_decompress_itch @53
-    _nettle_eddsa_expand_key @54
-    _nettle_eddsa_hash @55
-    _nettle_eddsa_public_key @56
-    _nettle_eddsa_public_key_itch @57
-    _nettle_eddsa_sign @58
-    _nettle_eddsa_sign_itch @59
-    _nettle_eddsa_verify @60
-    _nettle_eddsa_verify_itch @61
-    _nettle_generate_pocklington_prime @62
-    _nettle_gmp_alloc @63
-    _nettle_gmp_alloc_limbs @64
-    _nettle_gmp_free @65
-    _nettle_gmp_free_limbs @66
-    _nettle_gost_gc256b @67 DATA
-    _nettle_gost_gc512a @68 DATA
-    _nettle_gost_hash @69
-    _nettle_mpn_get_base256 @70
-    _nettle_mpn_get_base256_le @71
-    _nettle_mpn_set_base256 @72
-    _nettle_mpn_set_base256_le @73
-    _nettle_mpz_limbs_copy @74
-    _nettle_mpz_set_n @75
-    _nettle_pkcs1_sec_decrypt @76
-    _nettle_pkcs1_sec_decrypt_variable @77
-    _nettle_pkcs1_signature_prefix @78
-    _nettle_rsa_blind @79
-    _nettle_rsa_check_size @80
-    _nettle_rsa_sec_compute_root_tr @81
-    _nettle_rsa_unblind @82
-    _nettle_rsa_verify @83
-    _nettle_rsa_verify_recover @84
-    _nettle_sec_add_1 @85
-    _nettle_sec_sub_1 @86
-    _nettle_sec_tabselect @87
+    _nettle_ecc_nonsec_add_jjj @43
+    _nettle_ecc_pm1_redc @44
+    _nettle_ecc_pp1_redc @45
+    _nettle_ecc_secp192r1_modp @46
+    _nettle_ecc_secp256r1_redc @47
+    _nettle_ecc_secp384r1_modp @48
+    _nettle_ed25519_sha512 @49 DATA
+    _nettle_ed448_shake256 @50 DATA
+    _nettle_eddsa_compress @51
+    _nettle_eddsa_compress_itch @52
+    _nettle_eddsa_decompress @53
+    _nettle_eddsa_decompress_itch @54
+    _nettle_eddsa_expand_key @55
+    _nettle_eddsa_hash @56
+    _nettle_eddsa_public_key @57
+    _nettle_eddsa_public_key_itch @58
+    _nettle_eddsa_sign @59
+    _nettle_eddsa_sign_itch @60
+    _nettle_eddsa_verify @61
+    _nettle_eddsa_verify_itch @62
+    _nettle_generate_pocklington_prime @63
+    _nettle_gmp_alloc @64
+    _nettle_gmp_alloc_limbs @65
+    _nettle_gmp_free @66
+    _nettle_gmp_free_limbs @67
+    _nettle_gost_gc256b @68 DATA
+    _nettle_gost_gc512a @69 DATA
+    _nettle_gost_hash @70
+    _nettle_mpn_get_base256 @71
+    _nettle_mpn_get_base256_le @72
+    _nettle_mpn_set_base256 @73
+    _nettle_mpn_set_base256_le @74
+    _nettle_mpz_limbs_copy @75
+    _nettle_mpz_set_n @76
+    _nettle_pkcs1_sec_decrypt @77
+    _nettle_pkcs1_sec_decrypt_variable @78
+    _nettle_pkcs1_signature_prefix @79
+    _nettle_rsa_blind @80
+    _nettle_rsa_check_size @81
+    _nettle_rsa_sec_compute_root_tr @82
+    _nettle_rsa_unblind @83
+    _nettle_rsa_verify @84
+    _nettle_rsa_verify_recover @85
+    _nettle_sec_add_1 @86
+    _nettle_sec_sub_1 @87
     _nettle_sec_zero_p @88
     _nettle_secp_192r1 @89 DATA
     _nettle_secp_224r1 @90 DATA
@@ -118,328 +118,329 @@ EXPORTS
     mpn_rshift @117
     mpn_scan0 @118
     mpn_scan1 @119
-    mpn_set_str @120
-    mpn_sqr @121
-    mpn_sqrtrem @122
-    mpn_sub @123
-    mpn_sub_1 @124
-    mpn_sub_n @125
-    mpn_submul_1 @126
-    mpn_zero @127
-    mpn_zero_p @128
-    mpz_2fac_ui @129
-    mpz_abs @130
-    mpz_add @131
-    mpz_add_ui @132
-    mpz_addmul @133
-    mpz_addmul_ui @134
-    mpz_and @135
-    mpz_bin_uiui @136
-    mpz_cdiv_q @137
-    mpz_cdiv_q_2exp @138
-    mpz_cdiv_q_ui @139
-    mpz_cdiv_qr @140
-    mpz_cdiv_qr_ui @141
-    mpz_cdiv_r @142
-    mpz_cdiv_r_2exp @143
-    mpz_cdiv_r_ui @144
-    mpz_cdiv_ui @145
-    mpz_clear @146
-    mpz_clrbit @147
-    mpz_cmp @148
-    mpz_cmp_d @149
-    mpz_cmp_si @150
-    mpz_cmp_ui @151
-    mpz_cmpabs @152
-    mpz_cmpabs_d @153
-    mpz_cmpabs_ui @154
-    mpz_com @155
-    mpz_combit @156
-    mpz_congruent_p @157
-    mpz_divexact @158
-    mpz_divexact_ui @159
-    mpz_divisible_p @160
-    mpz_divisible_ui_p @161
-    mpz_export @162
-    mpz_fac_ui @163
-    mpz_fdiv_q @164
-    mpz_fdiv_q_2exp @165
-    mpz_fdiv_q_ui @166
-    mpz_fdiv_qr @167
-    mpz_fdiv_qr_ui @168
-    mpz_fdiv_r @169
-    mpz_fdiv_r_2exp @170
-    mpz_fdiv_r_ui @171
-    mpz_fdiv_ui @172
-    mpz_fits_sint_p @173
-    mpz_fits_slong_p @174
-    mpz_fits_sshort_p @175
-    mpz_fits_uint_p @176
-    mpz_fits_ulong_p @177
-    mpz_fits_ushort_p @178
-    mpz_gcd @179
-    mpz_gcd_ui @180
-    mpz_gcdext @181
-    mpz_get_d @182
-    mpz_get_si @183
-    mpz_get_str @184
-    mpz_get_ui @185
-    mpz_getlimbn @186
-    mpz_hamdist @187
-    mpz_import @188
-    mpz_init @189
-    mpz_init2 @190
-    mpz_init_set @191
-    mpz_init_set_d @192
-    mpz_init_set_si @193
-    mpz_init_set_str @194
-    mpz_init_set_ui @195
-    mpz_invert @196
-    mpz_ior @197
-    mpz_lcm @198
-    mpz_lcm_ui @199
-    mpz_limbs_finish @200
-    mpz_limbs_modify @201
-    mpz_limbs_read @202
-    mpz_limbs_write @203
-    mpz_mfac_uiui @204
-    mpz_mod @205
-    mpz_mod_ui @206
-    mpz_mul @207
-    mpz_mul_2exp @208
-    mpz_mul_si @209
-    mpz_mul_ui @210
-    mpz_neg @211
-    mpz_out_str @212
-    mpz_perfect_square_p @213
-    mpz_popcount @214
-    mpz_pow_ui @215
-    mpz_powm @216
-    mpz_powm_ui @217
-    mpz_probab_prime_p @218
-    mpz_realloc2 @219
-    mpz_roinit_n @220
-    mpz_root @221
-    mpz_rootrem @222
-    mpz_scan0 @223
-    mpz_scan1 @224
-    mpz_set @225
-    mpz_set_d @226
-    mpz_set_si @227
-    mpz_set_str @228
-    mpz_set_ui @229
-    mpz_setbit @230
-    mpz_sgn @231
-    mpz_size @232
-    mpz_sizeinbase @233
-    mpz_sqrt @234
-    mpz_sqrtrem @235
-    mpz_sub @236
-    mpz_sub_ui @237
-    mpz_submul @238
-    mpz_submul_ui @239
-    mpz_swap @240
-    mpz_tdiv_q @241
-    mpz_tdiv_q_2exp @242
-    mpz_tdiv_q_ui @243
-    mpz_tdiv_qr @244
-    mpz_tdiv_qr_ui @245
-    mpz_tdiv_r @246
-    mpz_tdiv_r_2exp @247
-    mpz_tdiv_r_ui @248
-    mpz_tdiv_ui @249
-    mpz_tstbit @250
-    mpz_ui_pow_ui @251
-    mpz_ui_sub @252
-    mpz_xor @253
-    nettle_asn1_der_decode_bitstring @254
-    nettle_asn1_der_decode_bitstring_last @255
-    nettle_asn1_der_decode_constructed @256
-    nettle_asn1_der_decode_constructed_last @257
-    nettle_asn1_der_get_bignum @258
-    nettle_asn1_der_get_uint32 @259
-    nettle_asn1_der_iterator_first @260
-    nettle_asn1_der_iterator_next @261
-    nettle_curve25519_mul @262
-    nettle_curve25519_mul_g @263
-    nettle_curve448_mul @264
-    nettle_curve448_mul_g @265
-    nettle_dsa_compat_generate_keypair @266
-    nettle_dsa_generate_keypair @267
-    nettle_dsa_generate_params @268
-    nettle_dsa_keypair_from_sexp_alist @269
-    nettle_dsa_keypair_to_sexp @270
-    nettle_dsa_openssl_private_key_from_der_iterator @271
-    nettle_dsa_params_clear @272
-    nettle_dsa_params_from_der_iterator @273
-    nettle_dsa_params_init @274
-    nettle_dsa_private_key_clear @275
-    nettle_dsa_private_key_init @276
-    nettle_dsa_public_key_clear @277
-    nettle_dsa_public_key_from_der_iterator @278
-    nettle_dsa_public_key_init @279
-    nettle_dsa_sha1_keypair_from_sexp @280
-    nettle_dsa_sha1_sign @281
-    nettle_dsa_sha1_sign_digest @282
-    nettle_dsa_sha1_verify @283
-    nettle_dsa_sha1_verify_digest @284
-    nettle_dsa_sha256_keypair_from_sexp @285
-    nettle_dsa_sha256_sign @286
-    nettle_dsa_sha256_sign_digest @287
-    nettle_dsa_sha256_verify @288
-    nettle_dsa_sha256_verify_digest @289
-    nettle_dsa_sign @290
-    nettle_dsa_signature_clear @291
-    nettle_dsa_signature_from_sexp @292
-    nettle_dsa_signature_init @293
-    nettle_dsa_verify @294
-    nettle_ecc_bit_size @295
-    nettle_ecc_ecdsa_sign @296
-    nettle_ecc_ecdsa_sign_itch @297
-    nettle_ecc_ecdsa_verify @298
-    nettle_ecc_ecdsa_verify_itch @299
-    nettle_ecc_gostdsa_sign @300
-    nettle_ecc_gostdsa_sign_itch @301
-    nettle_ecc_gostdsa_verify @302
-    nettle_ecc_gostdsa_verify_itch @303
-    nettle_ecc_point_clear @304
-    nettle_ecc_point_get @305
-    nettle_ecc_point_init @306
-    nettle_ecc_point_mul @307
-    nettle_ecc_point_mul_g @308
-    nettle_ecc_point_set @309
-    nettle_ecc_scalar_clear @310
-    nettle_ecc_scalar_get @311
-    nettle_ecc_scalar_init @312
-    nettle_ecc_scalar_random @313
-    nettle_ecc_scalar_set @314
-    nettle_ecc_size @315
-    nettle_ecc_size_a @316
-    nettle_ecc_size_j @317
-    nettle_ecdsa_generate_keypair @318
-    nettle_ecdsa_sign @319
-    nettle_ecdsa_verify @320
-    nettle_ed25519_sha512_public_key @321
-    nettle_ed25519_sha512_sign @322
-    nettle_ed25519_sha512_verify @323
-    nettle_ed448_shake256_public_key @324
-    nettle_ed448_shake256_sign @325
-    nettle_ed448_shake256_verify @326
-    nettle_get_gost_gc256b @327
-    nettle_get_gost_gc512a @328
-    nettle_get_secp_192r1 @329
-    nettle_get_secp_224r1 @330
-    nettle_get_secp_256r1 @331
-    nettle_get_secp_384r1 @332
-    nettle_get_secp_521r1 @333
-    nettle_gostdsa_sign @334
-    nettle_gostdsa_verify @335
-    nettle_gostdsa_vko @336
-    nettle_mpz_get_str_256 @337
-    nettle_mpz_init_set_str_256_s @338
-    nettle_mpz_init_set_str_256_u @339
-    nettle_mpz_random @340
-    nettle_mpz_random_size @341
-    nettle_mpz_set_sexp @342
-    nettle_mpz_set_str_256_s @343
-    nettle_mpz_set_str_256_u @344
-    nettle_mpz_sizeinbase_256_s @345
-    nettle_mpz_sizeinbase_256_u @346
-    nettle_openssl_provate_key_from_der @347
-    nettle_pgp_armor @348
-    nettle_pgp_crc24 @349
-    nettle_pgp_put_header @350
-    nettle_pgp_put_header_length @351
-    nettle_pgp_put_length @352
-    nettle_pgp_put_mpi @353
-    nettle_pgp_put_public_rsa_key @354
-    nettle_pgp_put_rsa_sha1_signature @355
-    nettle_pgp_put_string @356
-    nettle_pgp_put_sub_packet @357
-    nettle_pgp_put_uint16 @358
-    nettle_pgp_put_uint32 @359
-    nettle_pgp_put_userid @360
-    nettle_pgp_sub_packet_end @361
-    nettle_pgp_sub_packet_start @362
-    nettle_pkcs1_decrypt @363
-    nettle_pkcs1_encrypt @364
-    nettle_pkcs1_rsa_digest_encode @365
-    nettle_pkcs1_rsa_md5_encode @366
-    nettle_pkcs1_rsa_md5_encode_digest @367
-    nettle_pkcs1_rsa_sha1_encode @368
-    nettle_pkcs1_rsa_sha1_encode_digest @369
-    nettle_pkcs1_rsa_sha256_encode @370
-    nettle_pkcs1_rsa_sha256_encode_digest @371
-    nettle_pkcs1_rsa_sha512_encode @372
-    nettle_pkcs1_rsa_sha512_encode_digest @373
-    nettle_pss_encode_mgf1 @374
-    nettle_pss_mgf1 @375
-    nettle_pss_verify_mgf1 @376
-    nettle_random_prime @377
-    nettle_rsa_compute_root @378
-    nettle_rsa_compute_root_tr @379
-    nettle_rsa_decrypt @380
-    nettle_rsa_decrypt_tr @381
-    nettle_rsa_encrypt @382
-    nettle_rsa_generate_keypair @383
-    nettle_rsa_keypair_from_der @384
-    nettle_rsa_keypair_from_sexp @385
-    nettle_rsa_keypair_from_sexp_alist @386
-    nettle_rsa_keypair_to_openpgp @387
-    nettle_rsa_keypair_to_sexp @388
-    nettle_rsa_md5_sign @389
-    nettle_rsa_md5_sign_digest @390
-    nettle_rsa_md5_sign_digest_tr @391
-    nettle_rsa_md5_sign_tr @392
-    nettle_rsa_md5_verify @393
-    nettle_rsa_md5_verify_digest @394
-    nettle_rsa_pkcs1_sign @395
-    nettle_rsa_pkcs1_sign_tr @396
-    nettle_rsa_pkcs1_verify @397
-    nettle_rsa_private_key_clear @398
-    nettle_rsa_private_key_from_der_iterator @399
-    nettle_rsa_private_key_init @400
-    nettle_rsa_private_key_prepare @401
-    nettle_rsa_pss_sha256_sign_digest_tr @402
-    nettle_rsa_pss_sha256_verify_digest @403
-    nettle_rsa_pss_sha384_sign_digest_tr @404
-    nettle_rsa_pss_sha384_verify_digest @405
-    nettle_rsa_pss_sha512_sign_digest_tr @406
-    nettle_rsa_pss_sha512_verify_digest @407
-    nettle_rsa_public_key_clear @408
-    nettle_rsa_public_key_from_der_iterator @409
-    nettle_rsa_public_key_init @410
-    nettle_rsa_public_key_prepare @411
-    nettle_rsa_sec_decrypt @412
-    nettle_rsa_sha1_sign @413
-    nettle_rsa_sha1_sign_digest @414
-    nettle_rsa_sha1_sign_digest_tr @415
-    nettle_rsa_sha1_sign_tr @416
-    nettle_rsa_sha1_verify @417
-    nettle_rsa_sha1_verify_digest @418
-    nettle_rsa_sha256_sign @419
-    nettle_rsa_sha256_sign_digest @420
-    nettle_rsa_sha256_sign_digest_tr @421
-    nettle_rsa_sha256_sign_tr @422
-    nettle_rsa_sha256_verify @423
-    nettle_rsa_sha256_verify_digest @424
-    nettle_rsa_sha512_sign @425
-    nettle_rsa_sha512_sign_digest @426
-    nettle_rsa_sha512_sign_digest_tr @427
-    nettle_rsa_sha512_sign_tr @428
-    nettle_rsa_sha512_verify @429
-    nettle_rsa_sha512_verify_digest @430
-    nettle_sexp_format @431
-    nettle_sexp_iterator_assoc @432
-    nettle_sexp_iterator_check_type @433
-    nettle_sexp_iterator_check_types @434
-    nettle_sexp_iterator_enter_list @435
-    nettle_sexp_iterator_exit_list @436
-    nettle_sexp_iterator_first @437
-    nettle_sexp_iterator_get_uint32 @438
-    nettle_sexp_iterator_next @439
-    nettle_sexp_iterator_subexpr @440
-    nettle_sexp_transport_format @441
-    nettle_sexp_transport_iterator_first @442
-    nettle_sexp_transport_vformat @443
-    nettle_sexp_vformat @444
+    mpn_sec_tabselect @120
+    mpn_set_str @121
+    mpn_sqr @122
+    mpn_sqrtrem @123
+    mpn_sub @124
+    mpn_sub_1 @125
+    mpn_sub_n @126
+    mpn_submul_1 @127
+    mpn_zero @128
+    mpn_zero_p @129
+    mpz_2fac_ui @130
+    mpz_abs @131
+    mpz_add @132
+    mpz_add_ui @133
+    mpz_addmul @134
+    mpz_addmul_ui @135
+    mpz_and @136
+    mpz_bin_uiui @137
+    mpz_cdiv_q @138
+    mpz_cdiv_q_2exp @139
+    mpz_cdiv_q_ui @140
+    mpz_cdiv_qr @141
+    mpz_cdiv_qr_ui @142
+    mpz_cdiv_r @143
+    mpz_cdiv_r_2exp @144
+    mpz_cdiv_r_ui @145
+    mpz_cdiv_ui @146
+    mpz_clear @147
+    mpz_clrbit @148
+    mpz_cmp @149
+    mpz_cmp_d @150
+    mpz_cmp_si @151
+    mpz_cmp_ui @152
+    mpz_cmpabs @153
+    mpz_cmpabs_d @154
+    mpz_cmpabs_ui @155
+    mpz_com @156
+    mpz_combit @157
+    mpz_congruent_p @158
+    mpz_divexact @159
+    mpz_divexact_ui @160
+    mpz_divisible_p @161
+    mpz_divisible_ui_p @162
+    mpz_export @163
+    mpz_fac_ui @164
+    mpz_fdiv_q @165
+    mpz_fdiv_q_2exp @166
+    mpz_fdiv_q_ui @167
+    mpz_fdiv_qr @168
+    mpz_fdiv_qr_ui @169
+    mpz_fdiv_r @170
+    mpz_fdiv_r_2exp @171
+    mpz_fdiv_r_ui @172
+    mpz_fdiv_ui @173
+    mpz_fits_sint_p @174
+    mpz_fits_slong_p @175
+    mpz_fits_sshort_p @176
+    mpz_fits_uint_p @177
+    mpz_fits_ulong_p @178
+    mpz_fits_ushort_p @179
+    mpz_gcd @180
+    mpz_gcd_ui @181
+    mpz_gcdext @182
+    mpz_get_d @183
+    mpz_get_si @184
+    mpz_get_str @185
+    mpz_get_ui @186
+    mpz_getlimbn @187
+    mpz_hamdist @188
+    mpz_import @189
+    mpz_init @190
+    mpz_init2 @191
+    mpz_init_set @192
+    mpz_init_set_d @193
+    mpz_init_set_si @194
+    mpz_init_set_str @195
+    mpz_init_set_ui @196
+    mpz_invert @197
+    mpz_ior @198
+    mpz_lcm @199
+    mpz_lcm_ui @200
+    mpz_limbs_finish @201
+    mpz_limbs_modify @202
+    mpz_limbs_read @203
+    mpz_limbs_write @204
+    mpz_mfac_uiui @205
+    mpz_mod @206
+    mpz_mod_ui @207
+    mpz_mul @208
+    mpz_mul_2exp @209
+    mpz_mul_si @210
+    mpz_mul_ui @211
+    mpz_neg @212
+    mpz_out_str @213
+    mpz_perfect_square_p @214
+    mpz_popcount @215
+    mpz_pow_ui @216
+    mpz_powm @217
+    mpz_powm_ui @218
+    mpz_probab_prime_p @219
+    mpz_realloc2 @220
+    mpz_roinit_n @221
+    mpz_root @222
+    mpz_rootrem @223
+    mpz_scan0 @224
+    mpz_scan1 @225
+    mpz_set @226
+    mpz_set_d @227
+    mpz_set_si @228
+    mpz_set_str @229
+    mpz_set_ui @230
+    mpz_setbit @231
+    mpz_sgn @232
+    mpz_size @233
+    mpz_sizeinbase @234
+    mpz_sqrt @235
+    mpz_sqrtrem @236
+    mpz_sub @237
+    mpz_sub_ui @238
+    mpz_submul @239
+    mpz_submul_ui @240
+    mpz_swap @241
+    mpz_tdiv_q @242
+    mpz_tdiv_q_2exp @243
+    mpz_tdiv_q_ui @244
+    mpz_tdiv_qr @245
+    mpz_tdiv_qr_ui @246
+    mpz_tdiv_r @247
+    mpz_tdiv_r_2exp @248
+    mpz_tdiv_r_ui @249
+    mpz_tdiv_ui @250
+    mpz_tstbit @251
+    mpz_ui_pow_ui @252
+    mpz_ui_sub @253
+    mpz_xor @254
+    nettle_asn1_der_decode_bitstring @255
+    nettle_asn1_der_decode_bitstring_last @256
+    nettle_asn1_der_decode_constructed @257
+    nettle_asn1_der_decode_constructed_last @258
+    nettle_asn1_der_get_bignum @259
+    nettle_asn1_der_get_uint32 @260
+    nettle_asn1_der_iterator_first @261
+    nettle_asn1_der_iterator_next @262
+    nettle_curve25519_mul @263
+    nettle_curve25519_mul_g @264
+    nettle_curve448_mul @265
+    nettle_curve448_mul_g @266
+    nettle_dsa_compat_generate_keypair @267
+    nettle_dsa_generate_keypair @268
+    nettle_dsa_generate_params @269
+    nettle_dsa_keypair_from_sexp_alist @270
+    nettle_dsa_keypair_to_sexp @271
+    nettle_dsa_openssl_private_key_from_der_iterator @272
+    nettle_dsa_params_clear @273
+    nettle_dsa_params_from_der_iterator @274
+    nettle_dsa_params_init @275
+    nettle_dsa_private_key_clear @276
+    nettle_dsa_private_key_init @277
+    nettle_dsa_public_key_clear @278
+    nettle_dsa_public_key_from_der_iterator @279
+    nettle_dsa_public_key_init @280
+    nettle_dsa_sha1_keypair_from_sexp @281
+    nettle_dsa_sha1_sign @282
+    nettle_dsa_sha1_sign_digest @283
+    nettle_dsa_sha1_verify @284
+    nettle_dsa_sha1_verify_digest @285
+    nettle_dsa_sha256_keypair_from_sexp @286
+    nettle_dsa_sha256_sign @287
+    nettle_dsa_sha256_sign_digest @288
+    nettle_dsa_sha256_verify @289
+    nettle_dsa_sha256_verify_digest @290
+    nettle_dsa_sign @291
+    nettle_dsa_signature_clear @292
+    nettle_dsa_signature_from_sexp @293
+    nettle_dsa_signature_init @294
+    nettle_dsa_verify @295
+    nettle_ecc_bit_size @296
+    nettle_ecc_ecdsa_sign @297
+    nettle_ecc_ecdsa_sign_itch @298
+    nettle_ecc_ecdsa_verify @299
+    nettle_ecc_ecdsa_verify_itch @300
+    nettle_ecc_gostdsa_sign @301
+    nettle_ecc_gostdsa_sign_itch @302
+    nettle_ecc_gostdsa_verify @303
+    nettle_ecc_gostdsa_verify_itch @304
+    nettle_ecc_point_clear @305
+    nettle_ecc_point_get @306
+    nettle_ecc_point_init @307
+    nettle_ecc_point_mul @308
+    nettle_ecc_point_mul_g @309
+    nettle_ecc_point_set @310
+    nettle_ecc_scalar_clear @311
+    nettle_ecc_scalar_get @312
+    nettle_ecc_scalar_init @313
+    nettle_ecc_scalar_random @314
+    nettle_ecc_scalar_set @315
+    nettle_ecc_size @316
+    nettle_ecc_size_a @317
+    nettle_ecc_size_j @318
+    nettle_ecdsa_generate_keypair @319
+    nettle_ecdsa_sign @320
+    nettle_ecdsa_verify @321
+    nettle_ed25519_sha512_public_key @322
+    nettle_ed25519_sha512_sign @323
+    nettle_ed25519_sha512_verify @324
+    nettle_ed448_shake256_public_key @325
+    nettle_ed448_shake256_sign @326
+    nettle_ed448_shake256_verify @327
+    nettle_get_gost_gc256b @328
+    nettle_get_gost_gc512a @329
+    nettle_get_secp_192r1 @330
+    nettle_get_secp_224r1 @331
+    nettle_get_secp_256r1 @332
+    nettle_get_secp_384r1 @333
+    nettle_get_secp_521r1 @334
+    nettle_gostdsa_sign @335
+    nettle_gostdsa_verify @336
+    nettle_gostdsa_vko @337
+    nettle_mpz_get_str_256 @338
+    nettle_mpz_init_set_str_256_s @339
+    nettle_mpz_init_set_str_256_u @340
+    nettle_mpz_random @341
+    nettle_mpz_random_size @342
+    nettle_mpz_set_sexp @343
+    nettle_mpz_set_str_256_s @344
+    nettle_mpz_set_str_256_u @345
+    nettle_mpz_sizeinbase_256_s @346
+    nettle_mpz_sizeinbase_256_u @347
+    nettle_openssl_provate_key_from_der @348
+    nettle_pgp_armor @349
+    nettle_pgp_crc24 @350
+    nettle_pgp_put_header @351
+    nettle_pgp_put_header_length @352
+    nettle_pgp_put_length @353
+    nettle_pgp_put_mpi @354
+    nettle_pgp_put_public_rsa_key @355
+    nettle_pgp_put_rsa_sha1_signature @356
+    nettle_pgp_put_string @357
+    nettle_pgp_put_sub_packet @358
+    nettle_pgp_put_uint16 @359
+    nettle_pgp_put_uint32 @360
+    nettle_pgp_put_userid @361
+    nettle_pgp_sub_packet_end @362
+    nettle_pgp_sub_packet_start @363
+    nettle_pkcs1_decrypt @364
+    nettle_pkcs1_encrypt @365
+    nettle_pkcs1_rsa_digest_encode @366
+    nettle_pkcs1_rsa_md5_encode @367
+    nettle_pkcs1_rsa_md5_encode_digest @368
+    nettle_pkcs1_rsa_sha1_encode @369
+    nettle_pkcs1_rsa_sha1_encode_digest @370
+    nettle_pkcs1_rsa_sha256_encode @371
+    nettle_pkcs1_rsa_sha256_encode_digest @372
+    nettle_pkcs1_rsa_sha512_encode @373
+    nettle_pkcs1_rsa_sha512_encode_digest @374
+    nettle_pss_encode_mgf1 @375
+    nettle_pss_mgf1 @376
+    nettle_pss_verify_mgf1 @377
+    nettle_random_prime @378
+    nettle_rsa_compute_root @379
+    nettle_rsa_compute_root_tr @380
+    nettle_rsa_decrypt @381
+    nettle_rsa_decrypt_tr @382
+    nettle_rsa_encrypt @383
+    nettle_rsa_generate_keypair @384
+    nettle_rsa_keypair_from_der @385
+    nettle_rsa_keypair_from_sexp @386
+    nettle_rsa_keypair_from_sexp_alist @387
+    nettle_rsa_keypair_to_openpgp @388
+    nettle_rsa_keypair_to_sexp @389
+    nettle_rsa_md5_sign @390
+    nettle_rsa_md5_sign_digest @391
+    nettle_rsa_md5_sign_digest_tr @392
+    nettle_rsa_md5_sign_tr @393
+    nettle_rsa_md5_verify @394
+    nettle_rsa_md5_verify_digest @395
+    nettle_rsa_pkcs1_sign @396
+    nettle_rsa_pkcs1_sign_tr @397
+    nettle_rsa_pkcs1_verify @398
+    nettle_rsa_private_key_clear @399
+    nettle_rsa_private_key_from_der_iterator @400
+    nettle_rsa_private_key_init @401
+    nettle_rsa_private_key_prepare @402
+    nettle_rsa_pss_sha256_sign_digest_tr @403
+    nettle_rsa_pss_sha256_verify_digest @404
+    nettle_rsa_pss_sha384_sign_digest_tr @405
+    nettle_rsa_pss_sha384_verify_digest @406
+    nettle_rsa_pss_sha512_sign_digest_tr @407
+    nettle_rsa_pss_sha512_verify_digest @408
+    nettle_rsa_public_key_clear @409
+    nettle_rsa_public_key_from_der_iterator @410
+    nettle_rsa_public_key_init @411
+    nettle_rsa_public_key_prepare @412
+    nettle_rsa_sec_decrypt @413
+    nettle_rsa_sha1_sign @414
+    nettle_rsa_sha1_sign_digest @415
+    nettle_rsa_sha1_sign_digest_tr @416
+    nettle_rsa_sha1_sign_tr @417
+    nettle_rsa_sha1_verify @418
+    nettle_rsa_sha1_verify_digest @419
+    nettle_rsa_sha256_sign @420
+    nettle_rsa_sha256_sign_digest @421
+    nettle_rsa_sha256_sign_digest_tr @422
+    nettle_rsa_sha256_sign_tr @423
+    nettle_rsa_sha256_verify @424
+    nettle_rsa_sha256_verify_digest @425
+    nettle_rsa_sha512_sign @426
+    nettle_rsa_sha512_sign_digest @427
+    nettle_rsa_sha512_sign_digest_tr @428
+    nettle_rsa_sha512_sign_tr @429
+    nettle_rsa_sha512_verify @430
+    nettle_rsa_sha512_verify_digest @431
+    nettle_sexp_format @432
+    nettle_sexp_iterator_assoc @433
+    nettle_sexp_iterator_check_type @434
+    nettle_sexp_iterator_check_types @435
+    nettle_sexp_iterator_enter_list @436
+    nettle_sexp_iterator_exit_list @437
+    nettle_sexp_iterator_first @438
+    nettle_sexp_iterator_get_uint32 @439
+    nettle_sexp_iterator_next @440
+    nettle_sexp_iterator_subexpr @441
+    nettle_sexp_transport_format @442
+    nettle_sexp_transport_iterator_first @443
+    nettle_sexp_transport_vformat @444
+    nettle_sexp_vformat @445

extlib/nettle.win32/lib.i386/build.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+export CFLAGS="-O2 -march=i686 -pipe -static-libgcc -fstrict-aliasing -fcf-protection -ftree-vectorize -mstackrealign"
+export LDFLAGS="-Wl,-O1 -static-libgcc -Wl,--dynamicbase -Wl,--nxcompat -Wl,--large-address-aware -Wl,--subsystem,console:5.01"
+../configure --host=i686-w64-mingw32 \
+	--enable-mini-gmp \
+	--enable-fat \
+	--enable-x86-aesni \
+	--enable-x86-sha-ni \
+	--enable-x86-pclmul

extlib/nettle.win32/lib.i386/libhogweed-6.def

@@ -39,48 +39,48 @@ EXPORTS
     _nettle_ecc_mul_g @38
     _nettle_ecc_mul_g_eh @39
     _nettle_ecc_mul_m @40
-    _nettle_ecc_pm1_redc @41
-    _nettle_ecc_pp1_redc @42
-    _nettle_ed25519_sha512 @43 DATA
-    _nettle_ed448_shake256 @44 DATA
-    _nettle_eddsa_compress @45
-    _nettle_eddsa_compress_itch @46
-    _nettle_eddsa_decompress @47
-    _nettle_eddsa_decompress_itch @48
-    _nettle_eddsa_expand_key @49
-    _nettle_eddsa_hash @50
-    _nettle_eddsa_public_key @51
-    _nettle_eddsa_public_key_itch @52
-    _nettle_eddsa_sign @53
-    _nettle_eddsa_sign_itch @54
-    _nettle_eddsa_verify @55
-    _nettle_eddsa_verify_itch @56
-    _nettle_generate_pocklington_prime @57
-    _nettle_gmp_alloc @58
-    _nettle_gmp_alloc_limbs @59
-    _nettle_gmp_free @60
-    _nettle_gmp_free_limbs @61
-    _nettle_gost_gc256b @62 DATA
-    _nettle_gost_gc512a @63 DATA
-    _nettle_gost_hash @64
-    _nettle_mpn_get_base256 @65
-    _nettle_mpn_get_base256_le @66
-    _nettle_mpn_set_base256 @67
-    _nettle_mpn_set_base256_le @68
-    _nettle_mpz_limbs_copy @69
-    _nettle_mpz_set_n @70
-    _nettle_pkcs1_sec_decrypt @71
-    _nettle_pkcs1_sec_decrypt_variable @72
-    _nettle_pkcs1_signature_prefix @73
-    _nettle_rsa_blind @74
-    _nettle_rsa_check_size @75
-    _nettle_rsa_sec_compute_root_tr @76
-    _nettle_rsa_unblind @77
-    _nettle_rsa_verify @78
-    _nettle_rsa_verify_recover @79
-    _nettle_sec_add_1 @80
-    _nettle_sec_sub_1 @81
-    _nettle_sec_tabselect @82
+    _nettle_ecc_nonsec_add_jjj @41
+    _nettle_ecc_pm1_redc @42
+    _nettle_ecc_pp1_redc @43
+    _nettle_ed25519_sha512 @44 DATA
+    _nettle_ed448_shake256 @45 DATA
+    _nettle_eddsa_compress @46
+    _nettle_eddsa_compress_itch @47
+    _nettle_eddsa_decompress @48
+    _nettle_eddsa_decompress_itch @49
+    _nettle_eddsa_expand_key @50
+    _nettle_eddsa_hash @51
+    _nettle_eddsa_public_key @52
+    _nettle_eddsa_public_key_itch @53
+    _nettle_eddsa_sign @54
+    _nettle_eddsa_sign_itch @55
+    _nettle_eddsa_verify @56
+    _nettle_eddsa_verify_itch @57
+    _nettle_generate_pocklington_prime @58
+    _nettle_gmp_alloc @59
+    _nettle_gmp_alloc_limbs @60
+    _nettle_gmp_free @61
+    _nettle_gmp_free_limbs @62
+    _nettle_gost_gc256b @63 DATA
+    _nettle_gost_gc512a @64 DATA
+    _nettle_gost_hash @65
+    _nettle_mpn_get_base256 @66
+    _nettle_mpn_get_base256_le @67
+    _nettle_mpn_set_base256 @68
+    _nettle_mpn_set_base256_le @69
+    _nettle_mpz_limbs_copy @70
+    _nettle_mpz_set_n @71
+    _nettle_pkcs1_sec_decrypt @72
+    _nettle_pkcs1_sec_decrypt_variable @73
+    _nettle_pkcs1_signature_prefix @74
+    _nettle_rsa_blind @75
+    _nettle_rsa_check_size @76
+    _nettle_rsa_sec_compute_root_tr @77
+    _nettle_rsa_unblind @78
+    _nettle_rsa_verify @79
+    _nettle_rsa_verify_recover @80
+    _nettle_sec_add_1 @81
+    _nettle_sec_sub_1 @82
     _nettle_sec_zero_p @83
     _nettle_secp_192r1 @84 DATA
     _nettle_secp_224r1 @85 DATA
@@ -113,328 +113,329 @@ EXPORTS
     mpn_rshift @112
     mpn_scan0 @113
     mpn_scan1 @114
-    mpn_set_str @115
-    mpn_sqr @116
-    mpn_sqrtrem @117
-    mpn_sub @118
-    mpn_sub_1 @119
-    mpn_sub_n @120
-    mpn_submul_1 @121
-    mpn_zero @122
-    mpn_zero_p @123
-    mpz_2fac_ui @124
-    mpz_abs @125
-    mpz_add @126
-    mpz_add_ui @127
-    mpz_addmul @128
-    mpz_addmul_ui @129
-    mpz_and @130
-    mpz_bin_uiui @131
-    mpz_cdiv_q @132
-    mpz_cdiv_q_2exp @133
-    mpz_cdiv_q_ui @134
-    mpz_cdiv_qr @135
-    mpz_cdiv_qr_ui @136
-    mpz_cdiv_r @137
-    mpz_cdiv_r_2exp @138
-    mpz_cdiv_r_ui @139
-    mpz_cdiv_ui @140
-    mpz_clear @141
-    mpz_clrbit @142
-    mpz_cmp @143
-    mpz_cmp_d @144
-    mpz_cmp_si @145
-    mpz_cmp_ui @146
-    mpz_cmpabs @147
-    mpz_cmpabs_d @148
-    mpz_cmpabs_ui @149
-    mpz_com @150
-    mpz_combit @151
-    mpz_congruent_p @152
-    mpz_divexact @153
-    mpz_divexact_ui @154
-    mpz_divisible_p @155
-    mpz_divisible_ui_p @156
-    mpz_export @157
-    mpz_fac_ui @158
-    mpz_fdiv_q @159
-    mpz_fdiv_q_2exp @160
-    mpz_fdiv_q_ui @161
-    mpz_fdiv_qr @162
-    mpz_fdiv_qr_ui @163
-    mpz_fdiv_r @164
-    mpz_fdiv_r_2exp @165
-    mpz_fdiv_r_ui @166
-    mpz_fdiv_ui @167
-    mpz_fits_sint_p @168
-    mpz_fits_slong_p @169
-    mpz_fits_sshort_p @170
-    mpz_fits_uint_p @171
-    mpz_fits_ulong_p @172
-    mpz_fits_ushort_p @173
-    mpz_gcd @174
-    mpz_gcd_ui @175
-    mpz_gcdext @176
-    mpz_get_d @177
-    mpz_get_si @178
-    mpz_get_str @179
-    mpz_get_ui @180
-    mpz_getlimbn @181
-    mpz_hamdist @182
-    mpz_import @183
-    mpz_init @184
-    mpz_init2 @185
-    mpz_init_set @186
-    mpz_init_set_d @187
-    mpz_init_set_si @188
-    mpz_init_set_str @189
-    mpz_init_set_ui @190
-    mpz_invert @191
-    mpz_ior @192
-    mpz_lcm @193
-    mpz_lcm_ui @194
-    mpz_limbs_finish @195
-    mpz_limbs_modify @196
-    mpz_limbs_read @197
-    mpz_limbs_write @198
-    mpz_mfac_uiui @199
-    mpz_mod @200
-    mpz_mod_ui @201
-    mpz_mul @202
-    mpz_mul_2exp @203
-    mpz_mul_si @204
-    mpz_mul_ui @205
-    mpz_neg @206
-    mpz_out_str @207
-    mpz_perfect_square_p @208
-    mpz_popcount @209
-    mpz_pow_ui @210
-    mpz_powm @211
-    mpz_powm_ui @212
-    mpz_probab_prime_p @213
-    mpz_realloc2 @214
-    mpz_roinit_n @215
-    mpz_root @216
-    mpz_rootrem @217
-    mpz_scan0 @218
-    mpz_scan1 @219
-    mpz_set @220
-    mpz_set_d @221
-    mpz_set_si @222
-    mpz_set_str @223
-    mpz_set_ui @224
-    mpz_setbit @225
-    mpz_sgn @226
-    mpz_size @227
-    mpz_sizeinbase @228
-    mpz_sqrt @229
-    mpz_sqrtrem @230
-    mpz_sub @231
-    mpz_sub_ui @232
-    mpz_submul @233
-    mpz_submul_ui @234
-    mpz_swap @235
-    mpz_tdiv_q @236
-    mpz_tdiv_q_2exp @237
-    mpz_tdiv_q_ui @238
-    mpz_tdiv_qr @239
-    mpz_tdiv_qr_ui @240
-    mpz_tdiv_r @241
-    mpz_tdiv_r_2exp @242
-    mpz_tdiv_r_ui @243
-    mpz_tdiv_ui @244
-    mpz_tstbit @245
-    mpz_ui_pow_ui @246
-    mpz_ui_sub @247
-    mpz_xor @248
-    nettle_asn1_der_decode_bitstring @249
-    nettle_asn1_der_decode_bitstring_last @250
-    nettle_asn1_der_decode_constructed @251
-    nettle_asn1_der_decode_constructed_last @252
-    nettle_asn1_der_get_bignum @253
-    nettle_asn1_der_get_uint32 @254
-    nettle_asn1_der_iterator_first @255
-    nettle_asn1_der_iterator_next @256
-    nettle_curve25519_mul @257
-    nettle_curve25519_mul_g @258
-    nettle_curve448_mul @259
-    nettle_curve448_mul_g @260
-    nettle_dsa_compat_generate_keypair @261
-    nettle_dsa_generate_keypair @262
-    nettle_dsa_generate_params @263
-    nettle_dsa_keypair_from_sexp_alist @264
-    nettle_dsa_keypair_to_sexp @265
-    nettle_dsa_openssl_private_key_from_der_iterator @266
-    nettle_dsa_params_clear @267
-    nettle_dsa_params_from_der_iterator @268
-    nettle_dsa_params_init @269
-    nettle_dsa_private_key_clear @270
-    nettle_dsa_private_key_init @271
-    nettle_dsa_public_key_clear @272
-    nettle_dsa_public_key_from_der_iterator @273
-    nettle_dsa_public_key_init @274
-    nettle_dsa_sha1_keypair_from_sexp @275
-    nettle_dsa_sha1_sign @276
-    nettle_dsa_sha1_sign_digest @277
-    nettle_dsa_sha1_verify @278
-    nettle_dsa_sha1_verify_digest @279
-    nettle_dsa_sha256_keypair_from_sexp @280
-    nettle_dsa_sha256_sign @281
-    nettle_dsa_sha256_sign_digest @282
-    nettle_dsa_sha256_verify @283
-    nettle_dsa_sha256_verify_digest @284
-    nettle_dsa_sign @285
-    nettle_dsa_signature_clear @286
-    nettle_dsa_signature_from_sexp @287
-    nettle_dsa_signature_init @288
-    nettle_dsa_verify @289
-    nettle_ecc_bit_size @290
-    nettle_ecc_ecdsa_sign @291
-    nettle_ecc_ecdsa_sign_itch @292
-    nettle_ecc_ecdsa_verify @293
-    nettle_ecc_ecdsa_verify_itch @294
-    nettle_ecc_gostdsa_sign @295
-    nettle_ecc_gostdsa_sign_itch @296
-    nettle_ecc_gostdsa_verify @297
-    nettle_ecc_gostdsa_verify_itch @298
-    nettle_ecc_point_clear @299
-    nettle_ecc_point_get @300
-    nettle_ecc_point_init @301
-    nettle_ecc_point_mul @302
-    nettle_ecc_point_mul_g @303
-    nettle_ecc_point_set @304
-    nettle_ecc_scalar_clear @305
-    nettle_ecc_scalar_get @306
-    nettle_ecc_scalar_init @307
-    nettle_ecc_scalar_random @308
-    nettle_ecc_scalar_set @309
-    nettle_ecc_size @310
-    nettle_ecc_size_a @311
-    nettle_ecc_size_j @312
-    nettle_ecdsa_generate_keypair @313
-    nettle_ecdsa_sign @314
-    nettle_ecdsa_verify @315
-    nettle_ed25519_sha512_public_key @316
-    nettle_ed25519_sha512_sign @317
-    nettle_ed25519_sha512_verify @318
-    nettle_ed448_shake256_public_key @319
-    nettle_ed448_shake256_sign @320
-    nettle_ed448_shake256_verify @321
-    nettle_get_gost_gc256b @322
-    nettle_get_gost_gc512a @323
-    nettle_get_secp_192r1 @324
-    nettle_get_secp_224r1 @325
-    nettle_get_secp_256r1 @326
-    nettle_get_secp_384r1 @327
-    nettle_get_secp_521r1 @328
-    nettle_gostdsa_sign @329
-    nettle_gostdsa_verify @330
-    nettle_gostdsa_vko @331
-    nettle_mpz_get_str_256 @332
-    nettle_mpz_init_set_str_256_s @333
-    nettle_mpz_init_set_str_256_u @334
-    nettle_mpz_random @335
-    nettle_mpz_random_size @336
-    nettle_mpz_set_sexp @337
-    nettle_mpz_set_str_256_s @338
-    nettle_mpz_set_str_256_u @339
-    nettle_mpz_sizeinbase_256_s @340
-    nettle_mpz_sizeinbase_256_u @341
-    nettle_openssl_provate_key_from_der @342
-    nettle_pgp_armor @343
-    nettle_pgp_crc24 @344
-    nettle_pgp_put_header @345
-    nettle_pgp_put_header_length @346
-    nettle_pgp_put_length @347
-    nettle_pgp_put_mpi @348
-    nettle_pgp_put_public_rsa_key @349
-    nettle_pgp_put_rsa_sha1_signature @350
-    nettle_pgp_put_string @351
-    nettle_pgp_put_sub_packet @352
-    nettle_pgp_put_uint16 @353
-    nettle_pgp_put_uint32 @354
-    nettle_pgp_put_userid @355
-    nettle_pgp_sub_packet_end @356
-    nettle_pgp_sub_packet_start @357
-    nettle_pkcs1_decrypt @358
-    nettle_pkcs1_encrypt @359
-    nettle_pkcs1_rsa_digest_encode @360
-    nettle_pkcs1_rsa_md5_encode @361
-    nettle_pkcs1_rsa_md5_encode_digest @362
-    nettle_pkcs1_rsa_sha1_encode @363
-    nettle_pkcs1_rsa_sha1_encode_digest @364
-    nettle_pkcs1_rsa_sha256_encode @365
-    nettle_pkcs1_rsa_sha256_encode_digest @366
-    nettle_pkcs1_rsa_sha512_encode @367
-    nettle_pkcs1_rsa_sha512_encode_digest @368
-    nettle_pss_encode_mgf1 @369
-    nettle_pss_mgf1 @370
-    nettle_pss_verify_mgf1 @371
-    nettle_random_prime @372
-    nettle_rsa_compute_root @373
-    nettle_rsa_compute_root_tr @374
-    nettle_rsa_decrypt @375
-    nettle_rsa_decrypt_tr @376
-    nettle_rsa_encrypt @377
-    nettle_rsa_generate_keypair @378
-    nettle_rsa_keypair_from_der @379
-    nettle_rsa_keypair_from_sexp @380
-    nettle_rsa_keypair_from_sexp_alist @381
-    nettle_rsa_keypair_to_openpgp @382
-    nettle_rsa_keypair_to_sexp @383
-    nettle_rsa_md5_sign @384
-    nettle_rsa_md5_sign_digest @385
-    nettle_rsa_md5_sign_digest_tr @386
-    nettle_rsa_md5_sign_tr @387
-    nettle_rsa_md5_verify @388
-    nettle_rsa_md5_verify_digest @389
-    nettle_rsa_pkcs1_sign @390
-    nettle_rsa_pkcs1_sign_tr @391
-    nettle_rsa_pkcs1_verify @392
-    nettle_rsa_private_key_clear @393
-    nettle_rsa_private_key_from_der_iterator @394
-    nettle_rsa_private_key_init @395
-    nettle_rsa_private_key_prepare @396
-    nettle_rsa_pss_sha256_sign_digest_tr @397
-    nettle_rsa_pss_sha256_verify_digest @398
-    nettle_rsa_pss_sha384_sign_digest_tr @399
-    nettle_rsa_pss_sha384_verify_digest @400
-    nettle_rsa_pss_sha512_sign_digest_tr @401
-    nettle_rsa_pss_sha512_verify_digest @402
-    nettle_rsa_public_key_clear @403
-    nettle_rsa_public_key_from_der_iterator @404
-    nettle_rsa_public_key_init @405
-    nettle_rsa_public_key_prepare @406
-    nettle_rsa_sec_decrypt @407
-    nettle_rsa_sha1_sign @408
-    nettle_rsa_sha1_sign_digest @409
-    nettle_rsa_sha1_sign_digest_tr @410
-    nettle_rsa_sha1_sign_tr @411
-    nettle_rsa_sha1_verify @412
-    nettle_rsa_sha1_verify_digest @413
-    nettle_rsa_sha256_sign @414
-    nettle_rsa_sha256_sign_digest @415
-    nettle_rsa_sha256_sign_digest_tr @416
-    nettle_rsa_sha256_sign_tr @417
-    nettle_rsa_sha256_verify @418
-    nettle_rsa_sha256_verify_digest @419
-    nettle_rsa_sha512_sign @420
-    nettle_rsa_sha512_sign_digest @421
-    nettle_rsa_sha512_sign_digest_tr @422
-    nettle_rsa_sha512_sign_tr @423
-    nettle_rsa_sha512_verify @424
-    nettle_rsa_sha512_verify_digest @425
-    nettle_sexp_format @426
-    nettle_sexp_iterator_assoc @427
-    nettle_sexp_iterator_check_type @428
-    nettle_sexp_iterator_check_types @429
-    nettle_sexp_iterator_enter_list @430
-    nettle_sexp_iterator_exit_list @431
-    nettle_sexp_iterator_first @432
-    nettle_sexp_iterator_get_uint32 @433
-    nettle_sexp_iterator_next @434
-    nettle_sexp_iterator_subexpr @435
-    nettle_sexp_transport_format @436
-    nettle_sexp_transport_iterator_first @437
-    nettle_sexp_transport_vformat @438
-    nettle_sexp_vformat @439
+    mpn_sec_tabselect @115
+    mpn_set_str @116
+    mpn_sqr @117
+    mpn_sqrtrem @118
+    mpn_sub @119
+    mpn_sub_1 @120
+    mpn_sub_n @121
+    mpn_submul_1 @122
+    mpn_zero @123
+    mpn_zero_p @124
+    mpz_2fac_ui @125
+    mpz_abs @126
+    mpz_add @127
+    mpz_add_ui @128
+    mpz_addmul @129
+    mpz_addmul_ui @130
+    mpz_and @131
+    mpz_bin_uiui @132
+    mpz_cdiv_q @133
+    mpz_cdiv_q_2exp @134
+    mpz_cdiv_q_ui @135
+    mpz_cdiv_qr @136
+    mpz_cdiv_qr_ui @137
+    mpz_cdiv_r @138
+    mpz_cdiv_r_2exp @139
+    mpz_cdiv_r_ui @140
+    mpz_cdiv_ui @141
+    mpz_clear @142
+    mpz_clrbit @143
+    mpz_cmp @144
+    mpz_cmp_d @145
+    mpz_cmp_si @146
+    mpz_cmp_ui @147
+    mpz_cmpabs @148
+    mpz_cmpabs_d @149
+    mpz_cmpabs_ui @150
+    mpz_com @151
+    mpz_combit @152
+    mpz_congruent_p @153
+    mpz_divexact @154
+    mpz_divexact_ui @155
+    mpz_divisible_p @156
+    mpz_divisible_ui_p @157
+    mpz_export @158
+    mpz_fac_ui @159
+    mpz_fdiv_q @160
+    mpz_fdiv_q_2exp @161
+    mpz_fdiv_q_ui @162
+    mpz_fdiv_qr @163
+    mpz_fdiv_qr_ui @164
+    mpz_fdiv_r @165
+    mpz_fdiv_r_2exp @166
+    mpz_fdiv_r_ui @167
+    mpz_fdiv_ui @168
+    mpz_fits_sint_p @169
+    mpz_fits_slong_p @170
+    mpz_fits_sshort_p @171
+    mpz_fits_uint_p @172
+    mpz_fits_ulong_p @173
+    mpz_fits_ushort_p @174
+    mpz_gcd @175
+    mpz_gcd_ui @176
+    mpz_gcdext @177
+    mpz_get_d @178
+    mpz_get_si @179
+    mpz_get_str @180
+    mpz_get_ui @181
+    mpz_getlimbn @182
+    mpz_hamdist @183
+    mpz_import @184
+    mpz_init @185
+    mpz_init2 @186
+    mpz_init_set @187
+    mpz_init_set_d @188
+    mpz_init_set_si @189
+    mpz_init_set_str @190
+    mpz_init_set_ui @191
+    mpz_invert @192
+    mpz_ior @193
+    mpz_lcm @194
+    mpz_lcm_ui @195
+    mpz_limbs_finish @196
+    mpz_limbs_modify @197
+    mpz_limbs_read @198
+    mpz_limbs_write @199
+    mpz_mfac_uiui @200
+    mpz_mod @201
+    mpz_mod_ui @202
+    mpz_mul @203
+    mpz_mul_2exp @204
+    mpz_mul_si @205
+    mpz_mul_ui @206
+    mpz_neg @207
+    mpz_out_str @208
+    mpz_perfect_square_p @209
+    mpz_popcount @210
+    mpz_pow_ui @211
+    mpz_powm @212
+    mpz_powm_ui @213
+    mpz_probab_prime_p @214
+    mpz_realloc2 @215
+    mpz_roinit_n @216
+    mpz_root @217
+    mpz_rootrem @218
+    mpz_scan0 @219
+    mpz_scan1 @220
+    mpz_set @221
+    mpz_set_d @222
+    mpz_set_si @223
+    mpz_set_str @224
+    mpz_set_ui @225
+    mpz_setbit @226
+    mpz_sgn @227
+    mpz_size @228
+    mpz_sizeinbase @229
+    mpz_sqrt @230
+    mpz_sqrtrem @231
+    mpz_sub @232
+    mpz_sub_ui @233
+    mpz_submul @234
+    mpz_submul_ui @235
+    mpz_swap @236
+    mpz_tdiv_q @237
+    mpz_tdiv_q_2exp @238
+    mpz_tdiv_q_ui @239
+    mpz_tdiv_qr @240
+    mpz_tdiv_qr_ui @241
+    mpz_tdiv_r @242
+    mpz_tdiv_r_2exp @243
+    mpz_tdiv_r_ui @244
+    mpz_tdiv_ui @245
+    mpz_tstbit @246
+    mpz_ui_pow_ui @247
+    mpz_ui_sub @248
+    mpz_xor @249
+    nettle_asn1_der_decode_bitstring @250
+    nettle_asn1_der_decode_bitstring_last @251
+    nettle_asn1_der_decode_constructed @252
+    nettle_asn1_der_decode_constructed_last @253
+    nettle_asn1_der_get_bignum @254
+    nettle_asn1_der_get_uint32 @255
+    nettle_asn1_der_iterator_first @256
+    nettle_asn1_der_iterator_next @257
+    nettle_curve25519_mul @258
+    nettle_curve25519_mul_g @259
+    nettle_curve448_mul @260
+    nettle_curve448_mul_g @261
+    nettle_dsa_compat_generate_keypair @262
+    nettle_dsa_generate_keypair @263
+    nettle_dsa_generate_params @264
+    nettle_dsa_keypair_from_sexp_alist @265
+    nettle_dsa_keypair_to_sexp @266
+    nettle_dsa_openssl_private_key_from_der_iterator @267
+    nettle_dsa_params_clear @268
+    nettle_dsa_params_from_der_iterator @269
+    nettle_dsa_params_init @270
+    nettle_dsa_private_key_clear @271
+    nettle_dsa_private_key_init @272
+    nettle_dsa_public_key_clear @273
+    nettle_dsa_public_key_from_der_iterator @274
+    nettle_dsa_public_key_init @275
+    nettle_dsa_sha1_keypair_from_sexp @276
+    nettle_dsa_sha1_sign @277
+    nettle_dsa_sha1_sign_digest @278
+    nettle_dsa_sha1_verify @279
+    nettle_dsa_sha1_verify_digest @280
+    nettle_dsa_sha256_keypair_from_sexp @281
+    nettle_dsa_sha256_sign @282
+    nettle_dsa_sha256_sign_digest @283
+    nettle_dsa_sha256_verify @284
+    nettle_dsa_sha256_verify_digest @285
+    nettle_dsa_sign @286
+    nettle_dsa_signature_clear @287
+    nettle_dsa_signature_from_sexp @288
+    nettle_dsa_signature_init @289
+    nettle_dsa_verify @290
+    nettle_ecc_bit_size @291
+    nettle_ecc_ecdsa_sign @292
+    nettle_ecc_ecdsa_sign_itch @293
+    nettle_ecc_ecdsa_verify @294
+    nettle_ecc_ecdsa_verify_itch @295
+    nettle_ecc_gostdsa_sign @296
+    nettle_ecc_gostdsa_sign_itch @297
+    nettle_ecc_gostdsa_verify @298
+    nettle_ecc_gostdsa_verify_itch @299
+    nettle_ecc_point_clear @300
+    nettle_ecc_point_get @301
+    nettle_ecc_point_init @302
+    nettle_ecc_point_mul @303
+    nettle_ecc_point_mul_g @304
+    nettle_ecc_point_set @305
+    nettle_ecc_scalar_clear @306
+    nettle_ecc_scalar_get @307
+    nettle_ecc_scalar_init @308
+    nettle_ecc_scalar_random @309
+    nettle_ecc_scalar_set @310
+    nettle_ecc_size @311
+    nettle_ecc_size_a @312
+    nettle_ecc_size_j @313
+    nettle_ecdsa_generate_keypair @314
+    nettle_ecdsa_sign @315
+    nettle_ecdsa_verify @316
+    nettle_ed25519_sha512_public_key @317
+    nettle_ed25519_sha512_sign @318
+    nettle_ed25519_sha512_verify @319
+    nettle_ed448_shake256_public_key @320
+    nettle_ed448_shake256_sign @321
+    nettle_ed448_shake256_verify @322
+    nettle_get_gost_gc256b @323
+    nettle_get_gost_gc512a @324
+    nettle_get_secp_192r1 @325
+    nettle_get_secp_224r1 @326
+    nettle_get_secp_256r1 @327
+    nettle_get_secp_384r1 @328
+    nettle_get_secp_521r1 @329
+    nettle_gostdsa_sign @330
+    nettle_gostdsa_verify @331
+    nettle_gostdsa_vko @332
+    nettle_mpz_get_str_256 @333
+    nettle_mpz_init_set_str_256_s @334
+    nettle_mpz_init_set_str_256_u @335
+    nettle_mpz_random @336
+    nettle_mpz_random_size @337
+    nettle_mpz_set_sexp @338
+    nettle_mpz_set_str_256_s @339
+    nettle_mpz_set_str_256_u @340
+    nettle_mpz_sizeinbase_256_s @341
+    nettle_mpz_sizeinbase_256_u @342
+    nettle_openssl_provate_key_from_der @343
+    nettle_pgp_armor @344
+    nettle_pgp_crc24 @345
+    nettle_pgp_put_header @346
+    nettle_pgp_put_header_length @347
+    nettle_pgp_put_length @348
+    nettle_pgp_put_mpi @349
+    nettle_pgp_put_public_rsa_key @350
+    nettle_pgp_put_rsa_sha1_signature @351
+    nettle_pgp_put_string @352
+    nettle_pgp_put_sub_packet @353
+    nettle_pgp_put_uint16 @354
+    nettle_pgp_put_uint32 @355
+    nettle_pgp_put_userid @356
+    nettle_pgp_sub_packet_end @357
+    nettle_pgp_sub_packet_start @358
+    nettle_pkcs1_decrypt @359
+    nettle_pkcs1_encrypt @360
+    nettle_pkcs1_rsa_digest_encode @361
+    nettle_pkcs1_rsa_md5_encode @362
+    nettle_pkcs1_rsa_md5_encode_digest @363
+    nettle_pkcs1_rsa_sha1_encode @364
+    nettle_pkcs1_rsa_sha1_encode_digest @365
+    nettle_pkcs1_rsa_sha256_encode @366
+    nettle_pkcs1_rsa_sha256_encode_digest @367
+    nettle_pkcs1_rsa_sha512_encode @368
+    nettle_pkcs1_rsa_sha512_encode_digest @369
+    nettle_pss_encode_mgf1 @370
+    nettle_pss_mgf1 @371
+    nettle_pss_verify_mgf1 @372
+    nettle_random_prime @373
+    nettle_rsa_compute_root @374
+    nettle_rsa_compute_root_tr @375
+    nettle_rsa_decrypt @376
+    nettle_rsa_decrypt_tr @377
+    nettle_rsa_encrypt @378
+    nettle_rsa_generate_keypair @379
+    nettle_rsa_keypair_from_der @380
+    nettle_rsa_keypair_from_sexp @381
+    nettle_rsa_keypair_from_sexp_alist @382
+    nettle_rsa_keypair_to_openpgp @383
+    nettle_rsa_keypair_to_sexp @384
+    nettle_rsa_md5_sign @385
+    nettle_rsa_md5_sign_digest @386
+    nettle_rsa_md5_sign_digest_tr @387
+    nettle_rsa_md5_sign_tr @388
+    nettle_rsa_md5_verify @389
+    nettle_rsa_md5_verify_digest @390
+    nettle_rsa_pkcs1_sign @391
+    nettle_rsa_pkcs1_sign_tr @392
+    nettle_rsa_pkcs1_verify @393
+    nettle_rsa_private_key_clear @394
+    nettle_rsa_private_key_from_der_iterator @395
+    nettle_rsa_private_key_init @396
+    nettle_rsa_private_key_prepare @397
+    nettle_rsa_pss_sha256_sign_digest_tr @398
+    nettle_rsa_pss_sha256_verify_digest @399
+    nettle_rsa_pss_sha384_sign_digest_tr @400
+    nettle_rsa_pss_sha384_verify_digest @401
+    nettle_rsa_pss_sha512_sign_digest_tr @402
+    nettle_rsa_pss_sha512_verify_digest @403
+    nettle_rsa_public_key_clear @404
+    nettle_rsa_public_key_from_der_iterator @405
+    nettle_rsa_public_key_init @406
+    nettle_rsa_public_key_prepare @407
+    nettle_rsa_sec_decrypt @408
+    nettle_rsa_sha1_sign @409
+    nettle_rsa_sha1_sign_digest @410
+    nettle_rsa_sha1_sign_digest_tr @411
+    nettle_rsa_sha1_sign_tr @412
+    nettle_rsa_sha1_verify @413
+    nettle_rsa_sha1_verify_digest @414
+    nettle_rsa_sha256_sign @415
+    nettle_rsa_sha256_sign_digest @416
+    nettle_rsa_sha256_sign_digest_tr @417
+    nettle_rsa_sha256_sign_tr @418
+    nettle_rsa_sha256_verify @419
+    nettle_rsa_sha256_verify_digest @420
+    nettle_rsa_sha512_sign @421
+    nettle_rsa_sha512_sign_digest @422
+    nettle_rsa_sha512_sign_digest_tr @423
+    nettle_rsa_sha512_sign_tr @424
+    nettle_rsa_sha512_verify @425
+    nettle_rsa_sha512_verify_digest @426
+    nettle_sexp_format @427
+    nettle_sexp_iterator_assoc @428
+    nettle_sexp_iterator_check_type @429
+    nettle_sexp_iterator_check_types @430
+    nettle_sexp_iterator_enter_list @431
+    nettle_sexp_iterator_exit_list @432
+    nettle_sexp_iterator_first @433
+    nettle_sexp_iterator_get_uint32 @434
+    nettle_sexp_iterator_next @435
+    nettle_sexp_iterator_subexpr @436
+    nettle_sexp_transport_format @437
+    nettle_sexp_transport_iterator_first @438
+    nettle_sexp_transport_vformat @439
+    nettle_sexp_vformat @440