From 0b7a86168c77ad66b2b2456403803835596f3ffc Mon Sep 17 00:00:00 2001 From: "alexey.lysiuk" Date: Sun, 14 Jun 2020 12:16:40 +0300 Subject: [PATCH] add sodium 1.0.18 --- deps/sodium/include/sodium.h | 69 +++++++ deps/sodium/include/sodium/core.h | 28 +++ .../include/sodium/crypto_aead_aes256gcm.h | 179 +++++++++++++++++ .../sodium/crypto_aead_chacha20poly1305.h | 180 ++++++++++++++++++ .../sodium/crypto_aead_xchacha20poly1305.h | 100 ++++++++++ deps/sodium/include/sodium/crypto_auth.h | 46 +++++ .../include/sodium/crypto_auth_hmacsha256.h | 70 +++++++ .../include/sodium/crypto_auth_hmacsha512.h | 68 +++++++ .../sodium/crypto_auth_hmacsha512256.h | 65 +++++++ deps/sodium/include/sodium/crypto_box.h | 177 +++++++++++++++++ .../crypto_box_curve25519xchacha20poly1305.h | 164 ++++++++++++++++ .../crypto_box_curve25519xsalsa20poly1305.h | 112 +++++++++++ .../include/sodium/crypto_core_ed25519.h | 100 ++++++++++ .../include/sodium/crypto_core_hchacha20.h | 36 ++++ .../include/sodium/crypto_core_hsalsa20.h | 36 ++++ .../include/sodium/crypto_core_ristretto255.h | 100 ++++++++++ .../include/sodium/crypto_core_salsa20.h | 36 ++++ .../include/sodium/crypto_core_salsa2012.h | 36 ++++ .../include/sodium/crypto_core_salsa208.h | 40 ++++ .../include/sodium/crypto_generichash.h | 84 ++++++++ .../sodium/crypto_generichash_blake2b.h | 118 ++++++++++++ deps/sodium/include/sodium/crypto_hash.h | 40 ++++ .../include/sodium/crypto_hash_sha256.h | 60 ++++++ .../include/sodium/crypto_hash_sha512.h | 60 ++++++ deps/sodium/include/sodium/crypto_kdf.h | 53 ++++++ .../include/sodium/crypto_kdf_blake2b.h | 44 +++++ deps/sodium/include/sodium/crypto_kx.h | 66 +++++++ .../include/sodium/crypto_onetimeauth.h | 65 +++++++ .../sodium/crypto_onetimeauth_poly1305.h | 72 +++++++ deps/sodium/include/sodium/crypto_pwhash.h | 147 ++++++++++++++ .../include/sodium/crypto_pwhash_argon2i.h | 122 ++++++++++++ .../include/sodium/crypto_pwhash_argon2id.h | 122 ++++++++++++ .../crypto_pwhash_scryptsalsa208sha256.h | 120 ++++++++++++ .../sodium/include/sodium/crypto_scalarmult.h | 46 +++++ .../sodium/crypto_scalarmult_curve25519.h | 42 ++++ .../sodium/crypto_scalarmult_ed25519.h | 51 +++++ .../sodium/crypto_scalarmult_ristretto255.h | 43 +++++ deps/sodium/include/sodium/crypto_secretbox.h | 93 +++++++++ .../crypto_secretbox_xchacha20poly1305.h | 70 +++++++ .../crypto_secretbox_xsalsa20poly1305.h | 69 +++++++ .../crypto_secretstream_xchacha20poly1305.h | 108 +++++++++++ deps/sodium/include/sodium/crypto_shorthash.h | 41 ++++ .../sodium/crypto_shorthash_siphash24.h | 50 +++++ deps/sodium/include/sodium/crypto_sign.h | 107 +++++++++++ .../include/sodium/crypto_sign_ed25519.h | 124 ++++++++++++ .../crypto_sign_edwards25519sha512batch.h | 55 ++++++ deps/sodium/include/sodium/crypto_stream.h | 59 ++++++ .../include/sodium/crypto_stream_chacha20.h | 106 +++++++++++ .../include/sodium/crypto_stream_salsa20.h | 61 ++++++ .../include/sodium/crypto_stream_salsa2012.h | 53 ++++++ .../include/sodium/crypto_stream_salsa208.h | 56 ++++++ .../include/sodium/crypto_stream_xchacha20.h | 61 ++++++ .../include/sodium/crypto_stream_xsalsa20.h | 61 ++++++ deps/sodium/include/sodium/crypto_verify_16.h | 23 +++ deps/sodium/include/sodium/crypto_verify_32.h | 23 +++ deps/sodium/include/sodium/crypto_verify_64.h | 23 +++ deps/sodium/include/sodium/export.h | 57 ++++++ deps/sodium/include/sodium/randombytes.h | 72 +++++++ .../sodium/randombytes_internal_random.h | 22 +++ .../include/sodium/randombytes_sysrandom.h | 19 ++ deps/sodium/include/sodium/runtime.h | 52 +++++ deps/sodium/include/sodium/utils.h | 179 +++++++++++++++++ deps/sodium/include/sodium/version.h | 33 ++++ deps/sodium/lib/libsodium.a | Bin 0 -> 1269272 bytes 64 files changed, 4674 insertions(+) create mode 100644 deps/sodium/include/sodium.h create mode 100644 deps/sodium/include/sodium/core.h create mode 100644 deps/sodium/include/sodium/crypto_aead_aes256gcm.h create mode 100644 deps/sodium/include/sodium/crypto_aead_chacha20poly1305.h create mode 100644 deps/sodium/include/sodium/crypto_aead_xchacha20poly1305.h create mode 100644 deps/sodium/include/sodium/crypto_auth.h create mode 100644 deps/sodium/include/sodium/crypto_auth_hmacsha256.h create mode 100644 deps/sodium/include/sodium/crypto_auth_hmacsha512.h create mode 100644 deps/sodium/include/sodium/crypto_auth_hmacsha512256.h create mode 100644 deps/sodium/include/sodium/crypto_box.h create mode 100644 deps/sodium/include/sodium/crypto_box_curve25519xchacha20poly1305.h create mode 100644 deps/sodium/include/sodium/crypto_box_curve25519xsalsa20poly1305.h create mode 100644 deps/sodium/include/sodium/crypto_core_ed25519.h create mode 100644 deps/sodium/include/sodium/crypto_core_hchacha20.h create mode 100644 deps/sodium/include/sodium/crypto_core_hsalsa20.h create mode 100644 deps/sodium/include/sodium/crypto_core_ristretto255.h create mode 100644 deps/sodium/include/sodium/crypto_core_salsa20.h create mode 100644 deps/sodium/include/sodium/crypto_core_salsa2012.h create mode 100644 deps/sodium/include/sodium/crypto_core_salsa208.h create mode 100644 deps/sodium/include/sodium/crypto_generichash.h create mode 100644 deps/sodium/include/sodium/crypto_generichash_blake2b.h create mode 100644 deps/sodium/include/sodium/crypto_hash.h create mode 100644 deps/sodium/include/sodium/crypto_hash_sha256.h create mode 100644 deps/sodium/include/sodium/crypto_hash_sha512.h create mode 100644 deps/sodium/include/sodium/crypto_kdf.h create mode 100644 deps/sodium/include/sodium/crypto_kdf_blake2b.h create mode 100644 deps/sodium/include/sodium/crypto_kx.h create mode 100644 deps/sodium/include/sodium/crypto_onetimeauth.h create mode 100644 deps/sodium/include/sodium/crypto_onetimeauth_poly1305.h create mode 100644 deps/sodium/include/sodium/crypto_pwhash.h create mode 100644 deps/sodium/include/sodium/crypto_pwhash_argon2i.h create mode 100644 deps/sodium/include/sodium/crypto_pwhash_argon2id.h create mode 100644 deps/sodium/include/sodium/crypto_pwhash_scryptsalsa208sha256.h create mode 100644 deps/sodium/include/sodium/crypto_scalarmult.h create mode 100644 deps/sodium/include/sodium/crypto_scalarmult_curve25519.h create mode 100644 deps/sodium/include/sodium/crypto_scalarmult_ed25519.h create mode 100644 deps/sodium/include/sodium/crypto_scalarmult_ristretto255.h create mode 100644 deps/sodium/include/sodium/crypto_secretbox.h create mode 100644 deps/sodium/include/sodium/crypto_secretbox_xchacha20poly1305.h create mode 100644 deps/sodium/include/sodium/crypto_secretbox_xsalsa20poly1305.h create mode 100644 deps/sodium/include/sodium/crypto_secretstream_xchacha20poly1305.h create mode 100644 deps/sodium/include/sodium/crypto_shorthash.h create mode 100644 deps/sodium/include/sodium/crypto_shorthash_siphash24.h create mode 100644 deps/sodium/include/sodium/crypto_sign.h create mode 100644 deps/sodium/include/sodium/crypto_sign_ed25519.h create mode 100644 deps/sodium/include/sodium/crypto_sign_edwards25519sha512batch.h create mode 100644 deps/sodium/include/sodium/crypto_stream.h create mode 100644 deps/sodium/include/sodium/crypto_stream_chacha20.h create mode 100644 deps/sodium/include/sodium/crypto_stream_salsa20.h create mode 100644 deps/sodium/include/sodium/crypto_stream_salsa2012.h create mode 100644 deps/sodium/include/sodium/crypto_stream_salsa208.h create mode 100644 deps/sodium/include/sodium/crypto_stream_xchacha20.h create mode 100644 deps/sodium/include/sodium/crypto_stream_xsalsa20.h create mode 100644 deps/sodium/include/sodium/crypto_verify_16.h create mode 100644 deps/sodium/include/sodium/crypto_verify_32.h create mode 100644 deps/sodium/include/sodium/crypto_verify_64.h create mode 100644 deps/sodium/include/sodium/export.h create mode 100644 deps/sodium/include/sodium/randombytes.h create mode 100644 deps/sodium/include/sodium/randombytes_internal_random.h create mode 100644 deps/sodium/include/sodium/randombytes_sysrandom.h create mode 100644 deps/sodium/include/sodium/runtime.h create mode 100644 deps/sodium/include/sodium/utils.h create mode 100644 deps/sodium/include/sodium/version.h create mode 100644 deps/sodium/lib/libsodium.a diff --git a/deps/sodium/include/sodium.h b/deps/sodium/include/sodium.h new file mode 100644 index 00000000..295f911c --- /dev/null +++ b/deps/sodium/include/sodium.h @@ -0,0 +1,69 @@ + +#ifndef sodium_H +#define sodium_H + +#include "sodium/version.h" + +#include "sodium/core.h" +#include "sodium/crypto_aead_aes256gcm.h" +#include "sodium/crypto_aead_chacha20poly1305.h" +#include "sodium/crypto_aead_xchacha20poly1305.h" +#include "sodium/crypto_auth.h" +#include "sodium/crypto_auth_hmacsha256.h" +#include "sodium/crypto_auth_hmacsha512.h" +#include "sodium/crypto_auth_hmacsha512256.h" +#include "sodium/crypto_box.h" +#include "sodium/crypto_box_curve25519xsalsa20poly1305.h" +#include "sodium/crypto_core_hsalsa20.h" +#include "sodium/crypto_core_hchacha20.h" +#include "sodium/crypto_core_salsa20.h" +#include "sodium/crypto_core_salsa2012.h" +#include "sodium/crypto_core_salsa208.h" +#include "sodium/crypto_generichash.h" +#include "sodium/crypto_generichash_blake2b.h" +#include "sodium/crypto_hash.h" +#include "sodium/crypto_hash_sha256.h" +#include "sodium/crypto_hash_sha512.h" +#include "sodium/crypto_kdf.h" +#include "sodium/crypto_kdf_blake2b.h" +#include "sodium/crypto_kx.h" +#include "sodium/crypto_onetimeauth.h" +#include "sodium/crypto_onetimeauth_poly1305.h" +#include "sodium/crypto_pwhash.h" +#include "sodium/crypto_pwhash_argon2i.h" +#include "sodium/crypto_scalarmult.h" +#include "sodium/crypto_scalarmult_curve25519.h" +#include "sodium/crypto_secretbox.h" +#include "sodium/crypto_secretbox_xsalsa20poly1305.h" +#include "sodium/crypto_secretstream_xchacha20poly1305.h" +#include "sodium/crypto_shorthash.h" +#include "sodium/crypto_shorthash_siphash24.h" +#include "sodium/crypto_sign.h" +#include "sodium/crypto_sign_ed25519.h" +#include "sodium/crypto_stream.h" +#include "sodium/crypto_stream_chacha20.h" +#include "sodium/crypto_stream_salsa20.h" +#include "sodium/crypto_stream_xsalsa20.h" +#include "sodium/crypto_verify_16.h" +#include "sodium/crypto_verify_32.h" +#include "sodium/crypto_verify_64.h" +#include "sodium/randombytes.h" +#include "sodium/randombytes_internal_random.h" +#include "sodium/randombytes_sysrandom.h" +#include "sodium/runtime.h" +#include "sodium/utils.h" + +#ifndef SODIUM_LIBRARY_MINIMAL +# include "sodium/crypto_box_curve25519xchacha20poly1305.h" +# include "sodium/crypto_core_ed25519.h" +# include "sodium/crypto_core_ristretto255.h" +# include "sodium/crypto_scalarmult_ed25519.h" +# include "sodium/crypto_scalarmult_ristretto255.h" +# include "sodium/crypto_secretbox_xchacha20poly1305.h" +# include "sodium/crypto_pwhash_scryptsalsa208sha256.h" +# include "sodium/crypto_stream_salsa2012.h" +# include "sodium/crypto_stream_salsa208.h" +# include "sodium/crypto_stream_xchacha20.h" +#endif + +#endif diff --git a/deps/sodium/include/sodium/core.h b/deps/sodium/include/sodium/core.h new file mode 100644 index 00000000..dd088d2c --- /dev/null +++ b/deps/sodium/include/sodium/core.h @@ -0,0 +1,28 @@ + +#ifndef sodium_core_H +#define sodium_core_H + +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SODIUM_EXPORT +int sodium_init(void) + __attribute__ ((warn_unused_result)); + +/* ---- */ + +SODIUM_EXPORT +int sodium_set_misuse_handler(void (*handler)(void)); + +SODIUM_EXPORT +void sodium_misuse(void) + __attribute__ ((noreturn)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_aead_aes256gcm.h b/deps/sodium/include/sodium/crypto_aead_aes256gcm.h new file mode 100644 index 00000000..9baeb3f1 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_aead_aes256gcm.h @@ -0,0 +1,179 @@ +#ifndef crypto_aead_aes256gcm_H +#define crypto_aead_aes256gcm_H + +/* + * WARNING: Despite being the most popular AEAD construction due to its + * use in TLS, safely using AES-GCM in a different context is tricky. + * + * No more than ~ 350 GB of input data should be encrypted with a given key. + * This is for ~ 16 KB messages -- Actual figures vary according to + * message sizes. + * + * In addition, nonces are short and repeated nonces would totally destroy + * the security of this scheme. + * + * Nonces should thus come from atomic counters, which can be difficult to + * set up in a distributed environment. + * + * Unless you absolutely need AES-GCM, use crypto_aead_xchacha20poly1305_ietf_*() + * instead. It doesn't have any of these limitations. + * Or, if you don't need to authenticate additional data, just stick to + * crypto_secretbox(). + */ + +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +SODIUM_EXPORT +int crypto_aead_aes256gcm_is_available(void); + +#define crypto_aead_aes256gcm_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_aead_aes256gcm_keybytes(void); + +#define crypto_aead_aes256gcm_NSECBYTES 0U +SODIUM_EXPORT +size_t crypto_aead_aes256gcm_nsecbytes(void); + +#define crypto_aead_aes256gcm_NPUBBYTES 12U +SODIUM_EXPORT +size_t crypto_aead_aes256gcm_npubbytes(void); + +#define crypto_aead_aes256gcm_ABYTES 16U +SODIUM_EXPORT +size_t crypto_aead_aes256gcm_abytes(void); + +#define crypto_aead_aes256gcm_MESSAGEBYTES_MAX \ + SODIUM_MIN(SODIUM_SIZE_MAX - crypto_aead_aes256gcm_ABYTES, \ + (16ULL * ((1ULL << 32) - 2ULL))) +SODIUM_EXPORT +size_t crypto_aead_aes256gcm_messagebytes_max(void); + +typedef struct CRYPTO_ALIGN(16) crypto_aead_aes256gcm_state_ { + unsigned char opaque[512]; +} crypto_aead_aes256gcm_state; + +SODIUM_EXPORT +size_t crypto_aead_aes256gcm_statebytes(void); + +SODIUM_EXPORT +int crypto_aead_aes256gcm_encrypt(unsigned char *c, + unsigned long long *clen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *nsec, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((nonnull(1, 8, 9))); + +SODIUM_EXPORT +int crypto_aead_aes256gcm_decrypt(unsigned char *m, + unsigned long long *mlen_p, + unsigned char *nsec, + const unsigned char *c, + unsigned long long clen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(4, 8, 9))); + +SODIUM_EXPORT +int crypto_aead_aes256gcm_encrypt_detached(unsigned char *c, + unsigned char *mac, + unsigned long long *maclen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *nsec, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((nonnull(1, 2, 9, 10))); + +SODIUM_EXPORT +int crypto_aead_aes256gcm_decrypt_detached(unsigned char *m, + unsigned char *nsec, + const unsigned char *c, + unsigned long long clen, + const unsigned char *mac, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(3, 5, 8, 9))); + +/* -- Precomputation interface -- */ + +SODIUM_EXPORT +int crypto_aead_aes256gcm_beforenm(crypto_aead_aes256gcm_state *ctx_, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_aead_aes256gcm_encrypt_afternm(unsigned char *c, + unsigned long long *clen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *nsec, + const unsigned char *npub, + const crypto_aead_aes256gcm_state *ctx_) + __attribute__ ((nonnull(1, 8, 9))); + +SODIUM_EXPORT +int crypto_aead_aes256gcm_decrypt_afternm(unsigned char *m, + unsigned long long *mlen_p, + unsigned char *nsec, + const unsigned char *c, + unsigned long long clen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *npub, + const crypto_aead_aes256gcm_state *ctx_) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(4, 8, 9))); + +SODIUM_EXPORT +int crypto_aead_aes256gcm_encrypt_detached_afternm(unsigned char *c, + unsigned char *mac, + unsigned long long *maclen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *nsec, + const unsigned char *npub, + const crypto_aead_aes256gcm_state *ctx_) + __attribute__ ((nonnull(1, 2, 9, 10))); + +SODIUM_EXPORT +int crypto_aead_aes256gcm_decrypt_detached_afternm(unsigned char *m, + unsigned char *nsec, + const unsigned char *c, + unsigned long long clen, + const unsigned char *mac, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *npub, + const crypto_aead_aes256gcm_state *ctx_) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(3, 5, 8, 9))); + +SODIUM_EXPORT +void crypto_aead_aes256gcm_keygen(unsigned char k[crypto_aead_aes256gcm_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_aead_chacha20poly1305.h b/deps/sodium/include/sodium/crypto_aead_chacha20poly1305.h new file mode 100644 index 00000000..5d671df1 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_aead_chacha20poly1305.h @@ -0,0 +1,180 @@ +#ifndef crypto_aead_chacha20poly1305_H +#define crypto_aead_chacha20poly1305_H + +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +/* -- IETF ChaCha20-Poly1305 construction with a 96-bit nonce and a 32-bit internal counter -- */ + +#define crypto_aead_chacha20poly1305_ietf_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_aead_chacha20poly1305_ietf_keybytes(void); + +#define crypto_aead_chacha20poly1305_ietf_NSECBYTES 0U +SODIUM_EXPORT +size_t crypto_aead_chacha20poly1305_ietf_nsecbytes(void); + +#define crypto_aead_chacha20poly1305_ietf_NPUBBYTES 12U + +SODIUM_EXPORT +size_t crypto_aead_chacha20poly1305_ietf_npubbytes(void); + +#define crypto_aead_chacha20poly1305_ietf_ABYTES 16U +SODIUM_EXPORT +size_t crypto_aead_chacha20poly1305_ietf_abytes(void); + +#define crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX \ + SODIUM_MIN(SODIUM_SIZE_MAX - crypto_aead_chacha20poly1305_ietf_ABYTES, \ + (64ULL * ((1ULL << 32) - 1ULL))) +SODIUM_EXPORT +size_t crypto_aead_chacha20poly1305_ietf_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_aead_chacha20poly1305_ietf_encrypt(unsigned char *c, + unsigned long long *clen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *nsec, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((nonnull(1, 8, 9))); + +SODIUM_EXPORT +int crypto_aead_chacha20poly1305_ietf_decrypt(unsigned char *m, + unsigned long long *mlen_p, + unsigned char *nsec, + const unsigned char *c, + unsigned long long clen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(4, 8, 9))); + +SODIUM_EXPORT +int crypto_aead_chacha20poly1305_ietf_encrypt_detached(unsigned char *c, + unsigned char *mac, + unsigned long long *maclen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *nsec, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((nonnull(1, 2, 9, 10))); + +SODIUM_EXPORT +int crypto_aead_chacha20poly1305_ietf_decrypt_detached(unsigned char *m, + unsigned char *nsec, + const unsigned char *c, + unsigned long long clen, + const unsigned char *mac, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(3, 5, 8, 9))); + +SODIUM_EXPORT +void crypto_aead_chacha20poly1305_ietf_keygen(unsigned char k[crypto_aead_chacha20poly1305_ietf_KEYBYTES]) + __attribute__ ((nonnull)); + +/* -- Original ChaCha20-Poly1305 construction with a 64-bit nonce and a 64-bit internal counter -- */ + +#define crypto_aead_chacha20poly1305_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_aead_chacha20poly1305_keybytes(void); + +#define crypto_aead_chacha20poly1305_NSECBYTES 0U +SODIUM_EXPORT +size_t crypto_aead_chacha20poly1305_nsecbytes(void); + +#define crypto_aead_chacha20poly1305_NPUBBYTES 8U +SODIUM_EXPORT +size_t crypto_aead_chacha20poly1305_npubbytes(void); + +#define crypto_aead_chacha20poly1305_ABYTES 16U +SODIUM_EXPORT +size_t crypto_aead_chacha20poly1305_abytes(void); + +#define crypto_aead_chacha20poly1305_MESSAGEBYTES_MAX \ + (SODIUM_SIZE_MAX - crypto_aead_chacha20poly1305_ABYTES) +SODIUM_EXPORT +size_t crypto_aead_chacha20poly1305_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_aead_chacha20poly1305_encrypt(unsigned char *c, + unsigned long long *clen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *nsec, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((nonnull(1, 8, 9))); + +SODIUM_EXPORT +int crypto_aead_chacha20poly1305_decrypt(unsigned char *m, + unsigned long long *mlen_p, + unsigned char *nsec, + const unsigned char *c, + unsigned long long clen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(4, 8, 9))); + +SODIUM_EXPORT +int crypto_aead_chacha20poly1305_encrypt_detached(unsigned char *c, + unsigned char *mac, + unsigned long long *maclen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *nsec, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((nonnull(1, 2, 9, 10))); + +SODIUM_EXPORT +int crypto_aead_chacha20poly1305_decrypt_detached(unsigned char *m, + unsigned char *nsec, + const unsigned char *c, + unsigned long long clen, + const unsigned char *mac, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(3, 5, 8, 9))); + +SODIUM_EXPORT +void crypto_aead_chacha20poly1305_keygen(unsigned char k[crypto_aead_chacha20poly1305_KEYBYTES]) + __attribute__ ((nonnull)); + +/* Aliases */ + +#define crypto_aead_chacha20poly1305_IETF_KEYBYTES crypto_aead_chacha20poly1305_ietf_KEYBYTES +#define crypto_aead_chacha20poly1305_IETF_NSECBYTES crypto_aead_chacha20poly1305_ietf_NSECBYTES +#define crypto_aead_chacha20poly1305_IETF_NPUBBYTES crypto_aead_chacha20poly1305_ietf_NPUBBYTES +#define crypto_aead_chacha20poly1305_IETF_ABYTES crypto_aead_chacha20poly1305_ietf_ABYTES +#define crypto_aead_chacha20poly1305_IETF_MESSAGEBYTES_MAX crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_aead_xchacha20poly1305.h b/deps/sodium/include/sodium/crypto_aead_xchacha20poly1305.h new file mode 100644 index 00000000..6643b0cb --- /dev/null +++ b/deps/sodium/include/sodium/crypto_aead_xchacha20poly1305.h @@ -0,0 +1,100 @@ +#ifndef crypto_aead_xchacha20poly1305_H +#define crypto_aead_xchacha20poly1305_H + +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_aead_xchacha20poly1305_ietf_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_aead_xchacha20poly1305_ietf_keybytes(void); + +#define crypto_aead_xchacha20poly1305_ietf_NSECBYTES 0U +SODIUM_EXPORT +size_t crypto_aead_xchacha20poly1305_ietf_nsecbytes(void); + +#define crypto_aead_xchacha20poly1305_ietf_NPUBBYTES 24U +SODIUM_EXPORT +size_t crypto_aead_xchacha20poly1305_ietf_npubbytes(void); + +#define crypto_aead_xchacha20poly1305_ietf_ABYTES 16U +SODIUM_EXPORT +size_t crypto_aead_xchacha20poly1305_ietf_abytes(void); + +#define crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX \ + (SODIUM_SIZE_MAX - crypto_aead_xchacha20poly1305_ietf_ABYTES) +SODIUM_EXPORT +size_t crypto_aead_xchacha20poly1305_ietf_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_aead_xchacha20poly1305_ietf_encrypt(unsigned char *c, + unsigned long long *clen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *nsec, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((nonnull(1, 8, 9))); + +SODIUM_EXPORT +int crypto_aead_xchacha20poly1305_ietf_decrypt(unsigned char *m, + unsigned long long *mlen_p, + unsigned char *nsec, + const unsigned char *c, + unsigned long long clen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(4, 8, 9))); + +SODIUM_EXPORT +int crypto_aead_xchacha20poly1305_ietf_encrypt_detached(unsigned char *c, + unsigned char *mac, + unsigned long long *maclen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *nsec, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((nonnull(1, 2, 9, 10))); + +SODIUM_EXPORT +int crypto_aead_xchacha20poly1305_ietf_decrypt_detached(unsigned char *m, + unsigned char *nsec, + const unsigned char *c, + unsigned long long clen, + const unsigned char *mac, + const unsigned char *ad, + unsigned long long adlen, + const unsigned char *npub, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(3, 5, 8, 9))); + +SODIUM_EXPORT +void crypto_aead_xchacha20poly1305_ietf_keygen(unsigned char k[crypto_aead_xchacha20poly1305_ietf_KEYBYTES]) + __attribute__ ((nonnull)); + +/* Aliases */ + +#define crypto_aead_xchacha20poly1305_IETF_KEYBYTES crypto_aead_xchacha20poly1305_ietf_KEYBYTES +#define crypto_aead_xchacha20poly1305_IETF_NSECBYTES crypto_aead_xchacha20poly1305_ietf_NSECBYTES +#define crypto_aead_xchacha20poly1305_IETF_NPUBBYTES crypto_aead_xchacha20poly1305_ietf_NPUBBYTES +#define crypto_aead_xchacha20poly1305_IETF_ABYTES crypto_aead_xchacha20poly1305_ietf_ABYTES +#define crypto_aead_xchacha20poly1305_IETF_MESSAGEBYTES_MAX crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_auth.h b/deps/sodium/include/sodium/crypto_auth.h new file mode 100644 index 00000000..540aee0e --- /dev/null +++ b/deps/sodium/include/sodium/crypto_auth.h @@ -0,0 +1,46 @@ +#ifndef crypto_auth_H +#define crypto_auth_H + +#include + +#include "crypto_auth_hmacsha512256.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_auth_BYTES crypto_auth_hmacsha512256_BYTES +SODIUM_EXPORT +size_t crypto_auth_bytes(void); + +#define crypto_auth_KEYBYTES crypto_auth_hmacsha512256_KEYBYTES +SODIUM_EXPORT +size_t crypto_auth_keybytes(void); + +#define crypto_auth_PRIMITIVE "hmacsha512256" +SODIUM_EXPORT +const char *crypto_auth_primitive(void); + +SODIUM_EXPORT +int crypto_auth(unsigned char *out, const unsigned char *in, + unsigned long long inlen, const unsigned char *k) + __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_auth_verify(const unsigned char *h, const unsigned char *in, + unsigned long long inlen, const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +void crypto_auth_keygen(unsigned char k[crypto_auth_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_auth_hmacsha256.h b/deps/sodium/include/sodium/crypto_auth_hmacsha256.h new file mode 100644 index 00000000..3da864c7 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_auth_hmacsha256.h @@ -0,0 +1,70 @@ +#ifndef crypto_auth_hmacsha256_H +#define crypto_auth_hmacsha256_H + +#include +#include "crypto_hash_sha256.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_auth_hmacsha256_BYTES 32U +SODIUM_EXPORT +size_t crypto_auth_hmacsha256_bytes(void); + +#define crypto_auth_hmacsha256_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_auth_hmacsha256_keybytes(void); + +SODIUM_EXPORT +int crypto_auth_hmacsha256(unsigned char *out, + const unsigned char *in, + unsigned long long inlen, + const unsigned char *k) __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_auth_hmacsha256_verify(const unsigned char *h, + const unsigned char *in, + unsigned long long inlen, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4))); + +/* ------------------------------------------------------------------------- */ + +typedef struct crypto_auth_hmacsha256_state { + crypto_hash_sha256_state ictx; + crypto_hash_sha256_state octx; +} crypto_auth_hmacsha256_state; + +SODIUM_EXPORT +size_t crypto_auth_hmacsha256_statebytes(void); + +SODIUM_EXPORT +int crypto_auth_hmacsha256_init(crypto_auth_hmacsha256_state *state, + const unsigned char *key, + size_t keylen) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_auth_hmacsha256_update(crypto_auth_hmacsha256_state *state, + const unsigned char *in, + unsigned long long inlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_auth_hmacsha256_final(crypto_auth_hmacsha256_state *state, + unsigned char *out) __attribute__ ((nonnull)); + + +SODIUM_EXPORT +void crypto_auth_hmacsha256_keygen(unsigned char k[crypto_auth_hmacsha256_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_auth_hmacsha512.h b/deps/sodium/include/sodium/crypto_auth_hmacsha512.h new file mode 100644 index 00000000..d992cb81 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_auth_hmacsha512.h @@ -0,0 +1,68 @@ +#ifndef crypto_auth_hmacsha512_H +#define crypto_auth_hmacsha512_H + +#include +#include "crypto_hash_sha512.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_auth_hmacsha512_BYTES 64U +SODIUM_EXPORT +size_t crypto_auth_hmacsha512_bytes(void); + +#define crypto_auth_hmacsha512_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_auth_hmacsha512_keybytes(void); + +SODIUM_EXPORT +int crypto_auth_hmacsha512(unsigned char *out, + const unsigned char *in, + unsigned long long inlen, + const unsigned char *k) __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_auth_hmacsha512_verify(const unsigned char *h, + const unsigned char *in, + unsigned long long inlen, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4))); + +/* ------------------------------------------------------------------------- */ + +typedef struct crypto_auth_hmacsha512_state { + crypto_hash_sha512_state ictx; + crypto_hash_sha512_state octx; +} crypto_auth_hmacsha512_state; + +SODIUM_EXPORT +size_t crypto_auth_hmacsha512_statebytes(void); + +SODIUM_EXPORT +int crypto_auth_hmacsha512_init(crypto_auth_hmacsha512_state *state, + const unsigned char *key, + size_t keylen) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_auth_hmacsha512_update(crypto_auth_hmacsha512_state *state, + const unsigned char *in, + unsigned long long inlen) __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_auth_hmacsha512_final(crypto_auth_hmacsha512_state *state, + unsigned char *out) __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_auth_hmacsha512_keygen(unsigned char k[crypto_auth_hmacsha512_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_auth_hmacsha512256.h b/deps/sodium/include/sodium/crypto_auth_hmacsha512256.h new file mode 100644 index 00000000..3fb52638 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_auth_hmacsha512256.h @@ -0,0 +1,65 @@ +#ifndef crypto_auth_hmacsha512256_H +#define crypto_auth_hmacsha512256_H + +#include +#include "crypto_auth_hmacsha512.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_auth_hmacsha512256_BYTES 32U +SODIUM_EXPORT +size_t crypto_auth_hmacsha512256_bytes(void); + +#define crypto_auth_hmacsha512256_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_auth_hmacsha512256_keybytes(void); + +SODIUM_EXPORT +int crypto_auth_hmacsha512256(unsigned char *out, + const unsigned char *in, + unsigned long long inlen, + const unsigned char *k) __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_auth_hmacsha512256_verify(const unsigned char *h, + const unsigned char *in, + unsigned long long inlen, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4))); + +/* ------------------------------------------------------------------------- */ + +typedef crypto_auth_hmacsha512_state crypto_auth_hmacsha512256_state; + +SODIUM_EXPORT +size_t crypto_auth_hmacsha512256_statebytes(void); + +SODIUM_EXPORT +int crypto_auth_hmacsha512256_init(crypto_auth_hmacsha512256_state *state, + const unsigned char *key, + size_t keylen) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_auth_hmacsha512256_update(crypto_auth_hmacsha512256_state *state, + const unsigned char *in, + unsigned long long inlen) __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_auth_hmacsha512256_final(crypto_auth_hmacsha512256_state *state, + unsigned char *out) __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_auth_hmacsha512256_keygen(unsigned char k[crypto_auth_hmacsha512256_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_box.h b/deps/sodium/include/sodium/crypto_box.h new file mode 100644 index 00000000..e060dd29 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_box.h @@ -0,0 +1,177 @@ +#ifndef crypto_box_H +#define crypto_box_H + +/* + * THREAD SAFETY: crypto_box_keypair() is thread-safe, + * provided that sodium_init() was called before. + * + * Other functions are always thread-safe. + */ + +#include + +#include "crypto_box_curve25519xsalsa20poly1305.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_box_SEEDBYTES crypto_box_curve25519xsalsa20poly1305_SEEDBYTES +SODIUM_EXPORT +size_t crypto_box_seedbytes(void); + +#define crypto_box_PUBLICKEYBYTES crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES +SODIUM_EXPORT +size_t crypto_box_publickeybytes(void); + +#define crypto_box_SECRETKEYBYTES crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES +SODIUM_EXPORT +size_t crypto_box_secretkeybytes(void); + +#define crypto_box_NONCEBYTES crypto_box_curve25519xsalsa20poly1305_NONCEBYTES +SODIUM_EXPORT +size_t crypto_box_noncebytes(void); + +#define crypto_box_MACBYTES crypto_box_curve25519xsalsa20poly1305_MACBYTES +SODIUM_EXPORT +size_t crypto_box_macbytes(void); + +#define crypto_box_MESSAGEBYTES_MAX crypto_box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX +SODIUM_EXPORT +size_t crypto_box_messagebytes_max(void); + +#define crypto_box_PRIMITIVE "curve25519xsalsa20poly1305" +SODIUM_EXPORT +const char *crypto_box_primitive(void); + +SODIUM_EXPORT +int crypto_box_seed_keypair(unsigned char *pk, unsigned char *sk, + const unsigned char *seed) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_box_keypair(unsigned char *pk, unsigned char *sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_box_easy(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *pk, const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4, 5, 6))); + +SODIUM_EXPORT +int crypto_box_open_easy(unsigned char *m, const unsigned char *c, + unsigned long long clen, const unsigned char *n, + const unsigned char *pk, const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5, 6))); + +SODIUM_EXPORT +int crypto_box_detached(unsigned char *c, unsigned char *mac, + const unsigned char *m, unsigned long long mlen, + const unsigned char *n, const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 2, 5, 6, 7))); + +SODIUM_EXPORT +int crypto_box_open_detached(unsigned char *m, const unsigned char *c, + const unsigned char *mac, + unsigned long long clen, + const unsigned char *n, + const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 3, 5, 6, 7))); + +/* -- Precomputation interface -- */ + +#define crypto_box_BEFORENMBYTES crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES +SODIUM_EXPORT +size_t crypto_box_beforenmbytes(void); + +SODIUM_EXPORT +int crypto_box_beforenm(unsigned char *k, const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_box_easy_afternm(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) __attribute__ ((nonnull(1, 4, 5))); + +SODIUM_EXPORT +int crypto_box_open_easy_afternm(unsigned char *m, const unsigned char *c, + unsigned long long clen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5))); + +SODIUM_EXPORT +int crypto_box_detached_afternm(unsigned char *c, unsigned char *mac, + const unsigned char *m, unsigned long long mlen, + const unsigned char *n, const unsigned char *k) + __attribute__ ((nonnull(1, 2, 5, 6))); + +SODIUM_EXPORT +int crypto_box_open_detached_afternm(unsigned char *m, const unsigned char *c, + const unsigned char *mac, + unsigned long long clen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 3, 5, 6))); + +/* -- Ephemeral SK interface -- */ + +#define crypto_box_SEALBYTES (crypto_box_PUBLICKEYBYTES + crypto_box_MACBYTES) +SODIUM_EXPORT +size_t crypto_box_sealbytes(void); + +SODIUM_EXPORT +int crypto_box_seal(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *pk) + __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_box_seal_open(unsigned char *m, const unsigned char *c, + unsigned long long clen, + const unsigned char *pk, const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5))); + +/* -- NaCl compatibility interface ; Requires padding -- */ + +#define crypto_box_ZEROBYTES crypto_box_curve25519xsalsa20poly1305_ZEROBYTES +SODIUM_EXPORT +size_t crypto_box_zerobytes(void); + +#define crypto_box_BOXZEROBYTES crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES +SODIUM_EXPORT +size_t crypto_box_boxzerobytes(void); + +SODIUM_EXPORT +int crypto_box(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *pk, const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4, 5, 6))); + +SODIUM_EXPORT +int crypto_box_open(unsigned char *m, const unsigned char *c, + unsigned long long clen, const unsigned char *n, + const unsigned char *pk, const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5, 6))); + +SODIUM_EXPORT +int crypto_box_afternm(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) __attribute__ ((nonnull(1, 4, 5))); + +SODIUM_EXPORT +int crypto_box_open_afternm(unsigned char *m, const unsigned char *c, + unsigned long long clen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_box_curve25519xchacha20poly1305.h b/deps/sodium/include/sodium/crypto_box_curve25519xchacha20poly1305.h new file mode 100644 index 00000000..26a3d31e --- /dev/null +++ b/deps/sodium/include/sodium/crypto_box_curve25519xchacha20poly1305.h @@ -0,0 +1,164 @@ + +#ifndef crypto_box_curve25519xchacha20poly1305_H +#define crypto_box_curve25519xchacha20poly1305_H + +#include +#include "crypto_stream_xchacha20.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_box_curve25519xchacha20poly1305_SEEDBYTES 32U +SODIUM_EXPORT +size_t crypto_box_curve25519xchacha20poly1305_seedbytes(void); + +#define crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES 32U +SODIUM_EXPORT +size_t crypto_box_curve25519xchacha20poly1305_publickeybytes(void); + +#define crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES 32U +SODIUM_EXPORT +size_t crypto_box_curve25519xchacha20poly1305_secretkeybytes(void); + +#define crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES 32U +SODIUM_EXPORT +size_t crypto_box_curve25519xchacha20poly1305_beforenmbytes(void); + +#define crypto_box_curve25519xchacha20poly1305_NONCEBYTES 24U +SODIUM_EXPORT +size_t crypto_box_curve25519xchacha20poly1305_noncebytes(void); + +#define crypto_box_curve25519xchacha20poly1305_MACBYTES 16U +SODIUM_EXPORT +size_t crypto_box_curve25519xchacha20poly1305_macbytes(void); + +#define crypto_box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX \ + (crypto_stream_xchacha20_MESSAGEBYTES_MAX - crypto_box_curve25519xchacha20poly1305_MACBYTES) +SODIUM_EXPORT +size_t crypto_box_curve25519xchacha20poly1305_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_seed_keypair(unsigned char *pk, + unsigned char *sk, + const unsigned char *seed) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_keypair(unsigned char *pk, + unsigned char *sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_easy(unsigned char *c, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, + const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4, 5, 6))); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_open_easy(unsigned char *m, + const unsigned char *c, + unsigned long long clen, + const unsigned char *n, + const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5, 6))); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_detached(unsigned char *c, + unsigned char *mac, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, + const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 2, 5, 6, 7))); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_open_detached(unsigned char *m, + const unsigned char *c, + const unsigned char *mac, + unsigned long long clen, + const unsigned char *n, + const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 3, 5, 6, 7))); + +/* -- Precomputation interface -- */ + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_beforenm(unsigned char *k, + const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_easy_afternm(unsigned char *c, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull(1, 4, 5))); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_open_easy_afternm(unsigned char *m, + const unsigned char *c, + unsigned long long clen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5))); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_detached_afternm(unsigned char *c, + unsigned char *mac, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull(1, 2, 5, 6))); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_open_detached_afternm(unsigned char *m, + const unsigned char *c, + const unsigned char *mac, + unsigned long long clen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 3, 5, 6))); + +/* -- Ephemeral SK interface -- */ + +#define crypto_box_curve25519xchacha20poly1305_SEALBYTES \ + (crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES + \ + crypto_box_curve25519xchacha20poly1305_MACBYTES) + +SODIUM_EXPORT +size_t crypto_box_curve25519xchacha20poly1305_sealbytes(void); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_seal(unsigned char *c, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *pk) + __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_box_curve25519xchacha20poly1305_seal_open(unsigned char *m, + const unsigned char *c, + unsigned long long clen, + const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_box_curve25519xsalsa20poly1305.h b/deps/sodium/include/sodium/crypto_box_curve25519xsalsa20poly1305.h new file mode 100644 index 00000000..e733f499 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_box_curve25519xsalsa20poly1305.h @@ -0,0 +1,112 @@ +#ifndef crypto_box_curve25519xsalsa20poly1305_H +#define crypto_box_curve25519xsalsa20poly1305_H + +#include +#include "crypto_stream_xsalsa20.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_box_curve25519xsalsa20poly1305_SEEDBYTES 32U +SODIUM_EXPORT +size_t crypto_box_curve25519xsalsa20poly1305_seedbytes(void); + +#define crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES 32U +SODIUM_EXPORT +size_t crypto_box_curve25519xsalsa20poly1305_publickeybytes(void); + +#define crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES 32U +SODIUM_EXPORT +size_t crypto_box_curve25519xsalsa20poly1305_secretkeybytes(void); + +#define crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES 32U +SODIUM_EXPORT +size_t crypto_box_curve25519xsalsa20poly1305_beforenmbytes(void); + +#define crypto_box_curve25519xsalsa20poly1305_NONCEBYTES 24U +SODIUM_EXPORT +size_t crypto_box_curve25519xsalsa20poly1305_noncebytes(void); + +#define crypto_box_curve25519xsalsa20poly1305_MACBYTES 16U +SODIUM_EXPORT +size_t crypto_box_curve25519xsalsa20poly1305_macbytes(void); + +/* Only for the libsodium API - The NaCl compatibility API would require BOXZEROBYTES extra bytes */ +#define crypto_box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX \ + (crypto_stream_xsalsa20_MESSAGEBYTES_MAX - crypto_box_curve25519xsalsa20poly1305_MACBYTES) +SODIUM_EXPORT +size_t crypto_box_curve25519xsalsa20poly1305_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_box_curve25519xsalsa20poly1305_seed_keypair(unsigned char *pk, + unsigned char *sk, + const unsigned char *seed) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_box_curve25519xsalsa20poly1305_keypair(unsigned char *pk, + unsigned char *sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_box_curve25519xsalsa20poly1305_beforenm(unsigned char *k, + const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +/* -- NaCl compatibility interface ; Requires padding -- */ + +#define crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES 16U +SODIUM_EXPORT +size_t crypto_box_curve25519xsalsa20poly1305_boxzerobytes(void); + +#define crypto_box_curve25519xsalsa20poly1305_ZEROBYTES \ + (crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES + \ + crypto_box_curve25519xsalsa20poly1305_MACBYTES) +SODIUM_EXPORT +size_t crypto_box_curve25519xsalsa20poly1305_zerobytes(void); + +SODIUM_EXPORT +int crypto_box_curve25519xsalsa20poly1305(unsigned char *c, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, + const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4, 5, 6))); + +SODIUM_EXPORT +int crypto_box_curve25519xsalsa20poly1305_open(unsigned char *m, + const unsigned char *c, + unsigned long long clen, + const unsigned char *n, + const unsigned char *pk, + const unsigned char *sk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5, 6))); + +SODIUM_EXPORT +int crypto_box_curve25519xsalsa20poly1305_afternm(unsigned char *c, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull(1, 4, 5))); + +SODIUM_EXPORT +int crypto_box_curve25519xsalsa20poly1305_open_afternm(unsigned char *m, + const unsigned char *c, + unsigned long long clen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_core_ed25519.h b/deps/sodium/include/sodium/crypto_core_ed25519.h new file mode 100644 index 00000000..3eae00c4 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_core_ed25519.h @@ -0,0 +1,100 @@ +#ifndef crypto_core_ed25519_H +#define crypto_core_ed25519_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_core_ed25519_BYTES 32 +SODIUM_EXPORT +size_t crypto_core_ed25519_bytes(void); + +#define crypto_core_ed25519_UNIFORMBYTES 32 +SODIUM_EXPORT +size_t crypto_core_ed25519_uniformbytes(void); + +#define crypto_core_ed25519_HASHBYTES 64 +SODIUM_EXPORT +size_t crypto_core_ed25519_hashbytes(void); + +#define crypto_core_ed25519_SCALARBYTES 32 +SODIUM_EXPORT +size_t crypto_core_ed25519_scalarbytes(void); + +#define crypto_core_ed25519_NONREDUCEDSCALARBYTES 64 +SODIUM_EXPORT +size_t crypto_core_ed25519_nonreducedscalarbytes(void); + +SODIUM_EXPORT +int crypto_core_ed25519_is_valid_point(const unsigned char *p) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_core_ed25519_add(unsigned char *r, + const unsigned char *p, const unsigned char *q) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_core_ed25519_sub(unsigned char *r, + const unsigned char *p, const unsigned char *q) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_core_ed25519_from_uniform(unsigned char *p, const unsigned char *r) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_core_ed25519_from_hash(unsigned char *p, const unsigned char *h) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ed25519_random(unsigned char *p) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ed25519_scalar_random(unsigned char *r) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_core_ed25519_scalar_invert(unsigned char *recip, const unsigned char *s) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ed25519_scalar_negate(unsigned char *neg, const unsigned char *s) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ed25519_scalar_complement(unsigned char *comp, const unsigned char *s) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ed25519_scalar_add(unsigned char *z, const unsigned char *x, + const unsigned char *y) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ed25519_scalar_sub(unsigned char *z, const unsigned char *x, + const unsigned char *y) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ed25519_scalar_mul(unsigned char *z, const unsigned char *x, + const unsigned char *y) + __attribute__ ((nonnull)); + +/* + * The interval `s` is sampled from should be at least 317 bits to ensure almost + * uniformity of `r` over `L`. + */ +SODIUM_EXPORT +void crypto_core_ed25519_scalar_reduce(unsigned char *r, const unsigned char *s) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_core_hchacha20.h b/deps/sodium/include/sodium/crypto_core_hchacha20.h new file mode 100644 index 00000000..ece141b0 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_core_hchacha20.h @@ -0,0 +1,36 @@ +#ifndef crypto_core_hchacha20_H +#define crypto_core_hchacha20_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_core_hchacha20_OUTPUTBYTES 32U +SODIUM_EXPORT +size_t crypto_core_hchacha20_outputbytes(void); + +#define crypto_core_hchacha20_INPUTBYTES 16U +SODIUM_EXPORT +size_t crypto_core_hchacha20_inputbytes(void); + +#define crypto_core_hchacha20_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_core_hchacha20_keybytes(void); + +#define crypto_core_hchacha20_CONSTBYTES 16U +SODIUM_EXPORT +size_t crypto_core_hchacha20_constbytes(void); + +SODIUM_EXPORT +int crypto_core_hchacha20(unsigned char *out, const unsigned char *in, + const unsigned char *k, const unsigned char *c) + __attribute__ ((nonnull(1, 2, 3))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_core_hsalsa20.h b/deps/sodium/include/sodium/crypto_core_hsalsa20.h new file mode 100644 index 00000000..4bf7a487 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_core_hsalsa20.h @@ -0,0 +1,36 @@ +#ifndef crypto_core_hsalsa20_H +#define crypto_core_hsalsa20_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_core_hsalsa20_OUTPUTBYTES 32U +SODIUM_EXPORT +size_t crypto_core_hsalsa20_outputbytes(void); + +#define crypto_core_hsalsa20_INPUTBYTES 16U +SODIUM_EXPORT +size_t crypto_core_hsalsa20_inputbytes(void); + +#define crypto_core_hsalsa20_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_core_hsalsa20_keybytes(void); + +#define crypto_core_hsalsa20_CONSTBYTES 16U +SODIUM_EXPORT +size_t crypto_core_hsalsa20_constbytes(void); + +SODIUM_EXPORT +int crypto_core_hsalsa20(unsigned char *out, const unsigned char *in, + const unsigned char *k, const unsigned char *c) + __attribute__ ((nonnull(1, 2, 3))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_core_ristretto255.h b/deps/sodium/include/sodium/crypto_core_ristretto255.h new file mode 100644 index 00000000..f2820e55 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_core_ristretto255.h @@ -0,0 +1,100 @@ +#ifndef crypto_core_ristretto255_H +#define crypto_core_ristretto255_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_core_ristretto255_BYTES 32 +SODIUM_EXPORT +size_t crypto_core_ristretto255_bytes(void); + +#define crypto_core_ristretto255_HASHBYTES 64 +SODIUM_EXPORT +size_t crypto_core_ristretto255_hashbytes(void); + +#define crypto_core_ristretto255_SCALARBYTES 32 +SODIUM_EXPORT +size_t crypto_core_ristretto255_scalarbytes(void); + +#define crypto_core_ristretto255_NONREDUCEDSCALARBYTES 64 +SODIUM_EXPORT +size_t crypto_core_ristretto255_nonreducedscalarbytes(void); + +SODIUM_EXPORT +int crypto_core_ristretto255_is_valid_point(const unsigned char *p) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_core_ristretto255_add(unsigned char *r, + const unsigned char *p, const unsigned char *q) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_core_ristretto255_sub(unsigned char *r, + const unsigned char *p, const unsigned char *q) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_core_ristretto255_from_hash(unsigned char *p, + const unsigned char *r) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ristretto255_random(unsigned char *p) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ristretto255_scalar_random(unsigned char *r) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_core_ristretto255_scalar_invert(unsigned char *recip, + const unsigned char *s) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ristretto255_scalar_negate(unsigned char *neg, + const unsigned char *s) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ristretto255_scalar_complement(unsigned char *comp, + const unsigned char *s) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ristretto255_scalar_add(unsigned char *z, + const unsigned char *x, + const unsigned char *y) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ristretto255_scalar_sub(unsigned char *z, + const unsigned char *x, + const unsigned char *y) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_core_ristretto255_scalar_mul(unsigned char *z, + const unsigned char *x, + const unsigned char *y) + __attribute__ ((nonnull)); + +/* + * The interval `s` is sampled from should be at least 317 bits to ensure almost + * uniformity of `r` over `L`. + */ +SODIUM_EXPORT +void crypto_core_ristretto255_scalar_reduce(unsigned char *r, + const unsigned char *s) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_core_salsa20.h b/deps/sodium/include/sodium/crypto_core_salsa20.h new file mode 100644 index 00000000..bd79fd9f --- /dev/null +++ b/deps/sodium/include/sodium/crypto_core_salsa20.h @@ -0,0 +1,36 @@ +#ifndef crypto_core_salsa20_H +#define crypto_core_salsa20_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_core_salsa20_OUTPUTBYTES 64U +SODIUM_EXPORT +size_t crypto_core_salsa20_outputbytes(void); + +#define crypto_core_salsa20_INPUTBYTES 16U +SODIUM_EXPORT +size_t crypto_core_salsa20_inputbytes(void); + +#define crypto_core_salsa20_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_core_salsa20_keybytes(void); + +#define crypto_core_salsa20_CONSTBYTES 16U +SODIUM_EXPORT +size_t crypto_core_salsa20_constbytes(void); + +SODIUM_EXPORT +int crypto_core_salsa20(unsigned char *out, const unsigned char *in, + const unsigned char *k, const unsigned char *c) + __attribute__ ((nonnull(1, 2, 3))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_core_salsa2012.h b/deps/sodium/include/sodium/crypto_core_salsa2012.h new file mode 100644 index 00000000..05957591 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_core_salsa2012.h @@ -0,0 +1,36 @@ +#ifndef crypto_core_salsa2012_H +#define crypto_core_salsa2012_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_core_salsa2012_OUTPUTBYTES 64U +SODIUM_EXPORT +size_t crypto_core_salsa2012_outputbytes(void); + +#define crypto_core_salsa2012_INPUTBYTES 16U +SODIUM_EXPORT +size_t crypto_core_salsa2012_inputbytes(void); + +#define crypto_core_salsa2012_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_core_salsa2012_keybytes(void); + +#define crypto_core_salsa2012_CONSTBYTES 16U +SODIUM_EXPORT +size_t crypto_core_salsa2012_constbytes(void); + +SODIUM_EXPORT +int crypto_core_salsa2012(unsigned char *out, const unsigned char *in, + const unsigned char *k, const unsigned char *c) + __attribute__ ((nonnull(1, 2, 3))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_core_salsa208.h b/deps/sodium/include/sodium/crypto_core_salsa208.h new file mode 100644 index 00000000..d2f216af --- /dev/null +++ b/deps/sodium/include/sodium/crypto_core_salsa208.h @@ -0,0 +1,40 @@ +#ifndef crypto_core_salsa208_H +#define crypto_core_salsa208_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_core_salsa208_OUTPUTBYTES 64U +SODIUM_EXPORT +size_t crypto_core_salsa208_outputbytes(void) + __attribute__ ((deprecated)); + +#define crypto_core_salsa208_INPUTBYTES 16U +SODIUM_EXPORT +size_t crypto_core_salsa208_inputbytes(void) + __attribute__ ((deprecated)); + +#define crypto_core_salsa208_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_core_salsa208_keybytes(void) + __attribute__ ((deprecated)); + +#define crypto_core_salsa208_CONSTBYTES 16U +SODIUM_EXPORT +size_t crypto_core_salsa208_constbytes(void) + __attribute__ ((deprecated)); + +SODIUM_EXPORT +int crypto_core_salsa208(unsigned char *out, const unsigned char *in, + const unsigned char *k, const unsigned char *c) + __attribute__ ((nonnull(1, 2, 3))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_generichash.h b/deps/sodium/include/sodium/crypto_generichash.h new file mode 100644 index 00000000..d897e5d2 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_generichash.h @@ -0,0 +1,84 @@ +#ifndef crypto_generichash_H +#define crypto_generichash_H + +#include + +#include "crypto_generichash_blake2b.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_generichash_BYTES_MIN crypto_generichash_blake2b_BYTES_MIN +SODIUM_EXPORT +size_t crypto_generichash_bytes_min(void); + +#define crypto_generichash_BYTES_MAX crypto_generichash_blake2b_BYTES_MAX +SODIUM_EXPORT +size_t crypto_generichash_bytes_max(void); + +#define crypto_generichash_BYTES crypto_generichash_blake2b_BYTES +SODIUM_EXPORT +size_t crypto_generichash_bytes(void); + +#define crypto_generichash_KEYBYTES_MIN crypto_generichash_blake2b_KEYBYTES_MIN +SODIUM_EXPORT +size_t crypto_generichash_keybytes_min(void); + +#define crypto_generichash_KEYBYTES_MAX crypto_generichash_blake2b_KEYBYTES_MAX +SODIUM_EXPORT +size_t crypto_generichash_keybytes_max(void); + +#define crypto_generichash_KEYBYTES crypto_generichash_blake2b_KEYBYTES +SODIUM_EXPORT +size_t crypto_generichash_keybytes(void); + +#define crypto_generichash_PRIMITIVE "blake2b" +SODIUM_EXPORT +const char *crypto_generichash_primitive(void); + +/* + * Important when writing bindings for other programming languages: + * the state address should be 64-bytes aligned. + */ +typedef crypto_generichash_blake2b_state crypto_generichash_state; + +SODIUM_EXPORT +size_t crypto_generichash_statebytes(void); + +SODIUM_EXPORT +int crypto_generichash(unsigned char *out, size_t outlen, + const unsigned char *in, unsigned long long inlen, + const unsigned char *key, size_t keylen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_generichash_init(crypto_generichash_state *state, + const unsigned char *key, + const size_t keylen, const size_t outlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_generichash_update(crypto_generichash_state *state, + const unsigned char *in, + unsigned long long inlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_generichash_final(crypto_generichash_state *state, + unsigned char *out, const size_t outlen) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_generichash_keygen(unsigned char k[crypto_generichash_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_generichash_blake2b.h b/deps/sodium/include/sodium/crypto_generichash_blake2b.h new file mode 100644 index 00000000..fee9d8ad --- /dev/null +++ b/deps/sodium/include/sodium/crypto_generichash_blake2b.h @@ -0,0 +1,118 @@ +#ifndef crypto_generichash_blake2b_H +#define crypto_generichash_blake2b_H + +#include +#include +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#if defined(__IBMC__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC) +# pragma pack(1) +#else +# pragma pack(push, 1) +#endif + +typedef struct CRYPTO_ALIGN(64) crypto_generichash_blake2b_state { + unsigned char opaque[384]; +} crypto_generichash_blake2b_state; + +#if defined(__IBMC__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC) +# pragma pack() +#else +# pragma pack(pop) +#endif + +#define crypto_generichash_blake2b_BYTES_MIN 16U +SODIUM_EXPORT +size_t crypto_generichash_blake2b_bytes_min(void); + +#define crypto_generichash_blake2b_BYTES_MAX 64U +SODIUM_EXPORT +size_t crypto_generichash_blake2b_bytes_max(void); + +#define crypto_generichash_blake2b_BYTES 32U +SODIUM_EXPORT +size_t crypto_generichash_blake2b_bytes(void); + +#define crypto_generichash_blake2b_KEYBYTES_MIN 16U +SODIUM_EXPORT +size_t crypto_generichash_blake2b_keybytes_min(void); + +#define crypto_generichash_blake2b_KEYBYTES_MAX 64U +SODIUM_EXPORT +size_t crypto_generichash_blake2b_keybytes_max(void); + +#define crypto_generichash_blake2b_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_generichash_blake2b_keybytes(void); + +#define crypto_generichash_blake2b_SALTBYTES 16U +SODIUM_EXPORT +size_t crypto_generichash_blake2b_saltbytes(void); + +#define crypto_generichash_blake2b_PERSONALBYTES 16U +SODIUM_EXPORT +size_t crypto_generichash_blake2b_personalbytes(void); + +SODIUM_EXPORT +size_t crypto_generichash_blake2b_statebytes(void); + +SODIUM_EXPORT +int crypto_generichash_blake2b(unsigned char *out, size_t outlen, + const unsigned char *in, + unsigned long long inlen, + const unsigned char *key, size_t keylen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_generichash_blake2b_salt_personal(unsigned char *out, size_t outlen, + const unsigned char *in, + unsigned long long inlen, + const unsigned char *key, + size_t keylen, + const unsigned char *salt, + const unsigned char *personal) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_generichash_blake2b_init(crypto_generichash_blake2b_state *state, + const unsigned char *key, + const size_t keylen, const size_t outlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_generichash_blake2b_init_salt_personal(crypto_generichash_blake2b_state *state, + const unsigned char *key, + const size_t keylen, const size_t outlen, + const unsigned char *salt, + const unsigned char *personal) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_generichash_blake2b_update(crypto_generichash_blake2b_state *state, + const unsigned char *in, + unsigned long long inlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_generichash_blake2b_final(crypto_generichash_blake2b_state *state, + unsigned char *out, + const size_t outlen) __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_generichash_blake2b_keygen(unsigned char k[crypto_generichash_blake2b_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_hash.h b/deps/sodium/include/sodium/crypto_hash.h new file mode 100644 index 00000000..8752f9ca --- /dev/null +++ b/deps/sodium/include/sodium/crypto_hash.h @@ -0,0 +1,40 @@ +#ifndef crypto_hash_H +#define crypto_hash_H + +/* + * WARNING: Unless you absolutely need to use SHA512 for interoperatibility, + * purposes, you might want to consider crypto_generichash() instead. + * Unlike SHA512, crypto_generichash() is not vulnerable to length + * extension attacks. + */ + +#include + +#include "crypto_hash_sha512.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_hash_BYTES crypto_hash_sha512_BYTES +SODIUM_EXPORT +size_t crypto_hash_bytes(void); + +SODIUM_EXPORT +int crypto_hash(unsigned char *out, const unsigned char *in, + unsigned long long inlen) __attribute__ ((nonnull(1))); + +#define crypto_hash_PRIMITIVE "sha512" +SODIUM_EXPORT +const char *crypto_hash_primitive(void) + __attribute__ ((warn_unused_result)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_hash_sha256.h b/deps/sodium/include/sodium/crypto_hash_sha256.h new file mode 100644 index 00000000..b18217e1 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_hash_sha256.h @@ -0,0 +1,60 @@ +#ifndef crypto_hash_sha256_H +#define crypto_hash_sha256_H + +/* + * WARNING: Unless you absolutely need to use SHA256 for interoperatibility, + * purposes, you might want to consider crypto_generichash() instead. + * Unlike SHA256, crypto_generichash() is not vulnerable to length + * extension attacks. + */ + +#include +#include +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +typedef struct crypto_hash_sha256_state { + uint32_t state[8]; + uint64_t count; + uint8_t buf[64]; +} crypto_hash_sha256_state; + +SODIUM_EXPORT +size_t crypto_hash_sha256_statebytes(void); + +#define crypto_hash_sha256_BYTES 32U +SODIUM_EXPORT +size_t crypto_hash_sha256_bytes(void); + +SODIUM_EXPORT +int crypto_hash_sha256(unsigned char *out, const unsigned char *in, + unsigned long long inlen) __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_hash_sha256_init(crypto_hash_sha256_state *state) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_hash_sha256_update(crypto_hash_sha256_state *state, + const unsigned char *in, + unsigned long long inlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_hash_sha256_final(crypto_hash_sha256_state *state, + unsigned char *out) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_hash_sha512.h b/deps/sodium/include/sodium/crypto_hash_sha512.h new file mode 100644 index 00000000..8efa7193 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_hash_sha512.h @@ -0,0 +1,60 @@ +#ifndef crypto_hash_sha512_H +#define crypto_hash_sha512_H + +/* + * WARNING: Unless you absolutely need to use SHA512 for interoperatibility, + * purposes, you might want to consider crypto_generichash() instead. + * Unlike SHA512, crypto_generichash() is not vulnerable to length + * extension attacks. + */ + +#include +#include +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +typedef struct crypto_hash_sha512_state { + uint64_t state[8]; + uint64_t count[2]; + uint8_t buf[128]; +} crypto_hash_sha512_state; + +SODIUM_EXPORT +size_t crypto_hash_sha512_statebytes(void); + +#define crypto_hash_sha512_BYTES 64U +SODIUM_EXPORT +size_t crypto_hash_sha512_bytes(void); + +SODIUM_EXPORT +int crypto_hash_sha512(unsigned char *out, const unsigned char *in, + unsigned long long inlen) __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_hash_sha512_init(crypto_hash_sha512_state *state) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_hash_sha512_update(crypto_hash_sha512_state *state, + const unsigned char *in, + unsigned long long inlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_hash_sha512_final(crypto_hash_sha512_state *state, + unsigned char *out) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_kdf.h b/deps/sodium/include/sodium/crypto_kdf.h new file mode 100644 index 00000000..ac2fc618 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_kdf.h @@ -0,0 +1,53 @@ +#ifndef crypto_kdf_H +#define crypto_kdf_H + +#include +#include + +#include "crypto_kdf_blake2b.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_kdf_BYTES_MIN crypto_kdf_blake2b_BYTES_MIN +SODIUM_EXPORT +size_t crypto_kdf_bytes_min(void); + +#define crypto_kdf_BYTES_MAX crypto_kdf_blake2b_BYTES_MAX +SODIUM_EXPORT +size_t crypto_kdf_bytes_max(void); + +#define crypto_kdf_CONTEXTBYTES crypto_kdf_blake2b_CONTEXTBYTES +SODIUM_EXPORT +size_t crypto_kdf_contextbytes(void); + +#define crypto_kdf_KEYBYTES crypto_kdf_blake2b_KEYBYTES +SODIUM_EXPORT +size_t crypto_kdf_keybytes(void); + +#define crypto_kdf_PRIMITIVE "blake2b" +SODIUM_EXPORT +const char *crypto_kdf_primitive(void) + __attribute__ ((warn_unused_result)); + +SODIUM_EXPORT +int crypto_kdf_derive_from_key(unsigned char *subkey, size_t subkey_len, + uint64_t subkey_id, + const char ctx[crypto_kdf_CONTEXTBYTES], + const unsigned char key[crypto_kdf_KEYBYTES]) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_kdf_keygen(unsigned char k[crypto_kdf_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_kdf_blake2b.h b/deps/sodium/include/sodium/crypto_kdf_blake2b.h new file mode 100644 index 00000000..3ae47dd3 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_kdf_blake2b.h @@ -0,0 +1,44 @@ +#ifndef crypto_kdf_blake2b_H +#define crypto_kdf_blake2b_H + +#include +#include + +#include "crypto_kdf_blake2b.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_kdf_blake2b_BYTES_MIN 16 +SODIUM_EXPORT +size_t crypto_kdf_blake2b_bytes_min(void); + +#define crypto_kdf_blake2b_BYTES_MAX 64 +SODIUM_EXPORT +size_t crypto_kdf_blake2b_bytes_max(void); + +#define crypto_kdf_blake2b_CONTEXTBYTES 8 +SODIUM_EXPORT +size_t crypto_kdf_blake2b_contextbytes(void); + +#define crypto_kdf_blake2b_KEYBYTES 32 +SODIUM_EXPORT +size_t crypto_kdf_blake2b_keybytes(void); + +SODIUM_EXPORT +int crypto_kdf_blake2b_derive_from_key(unsigned char *subkey, size_t subkey_len, + uint64_t subkey_id, + const char ctx[crypto_kdf_blake2b_CONTEXTBYTES], + const unsigned char key[crypto_kdf_blake2b_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_kx.h b/deps/sodium/include/sodium/crypto_kx.h new file mode 100644 index 00000000..347132c3 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_kx.h @@ -0,0 +1,66 @@ +#ifndef crypto_kx_H +#define crypto_kx_H + +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_kx_PUBLICKEYBYTES 32 +SODIUM_EXPORT +size_t crypto_kx_publickeybytes(void); + +#define crypto_kx_SECRETKEYBYTES 32 +SODIUM_EXPORT +size_t crypto_kx_secretkeybytes(void); + +#define crypto_kx_SEEDBYTES 32 +SODIUM_EXPORT +size_t crypto_kx_seedbytes(void); + +#define crypto_kx_SESSIONKEYBYTES 32 +SODIUM_EXPORT +size_t crypto_kx_sessionkeybytes(void); + +#define crypto_kx_PRIMITIVE "x25519blake2b" +SODIUM_EXPORT +const char *crypto_kx_primitive(void); + +SODIUM_EXPORT +int crypto_kx_seed_keypair(unsigned char pk[crypto_kx_PUBLICKEYBYTES], + unsigned char sk[crypto_kx_SECRETKEYBYTES], + const unsigned char seed[crypto_kx_SEEDBYTES]) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_kx_keypair(unsigned char pk[crypto_kx_PUBLICKEYBYTES], + unsigned char sk[crypto_kx_SECRETKEYBYTES]) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_kx_client_session_keys(unsigned char rx[crypto_kx_SESSIONKEYBYTES], + unsigned char tx[crypto_kx_SESSIONKEYBYTES], + const unsigned char client_pk[crypto_kx_PUBLICKEYBYTES], + const unsigned char client_sk[crypto_kx_SECRETKEYBYTES], + const unsigned char server_pk[crypto_kx_PUBLICKEYBYTES]) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(3, 4, 5))); + +SODIUM_EXPORT +int crypto_kx_server_session_keys(unsigned char rx[crypto_kx_SESSIONKEYBYTES], + unsigned char tx[crypto_kx_SESSIONKEYBYTES], + const unsigned char server_pk[crypto_kx_PUBLICKEYBYTES], + const unsigned char server_sk[crypto_kx_SECRETKEYBYTES], + const unsigned char client_pk[crypto_kx_PUBLICKEYBYTES]) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(3, 4, 5))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_onetimeauth.h b/deps/sodium/include/sodium/crypto_onetimeauth.h new file mode 100644 index 00000000..7cd7b070 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_onetimeauth.h @@ -0,0 +1,65 @@ +#ifndef crypto_onetimeauth_H +#define crypto_onetimeauth_H + +#include + +#include "crypto_onetimeauth_poly1305.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +typedef crypto_onetimeauth_poly1305_state crypto_onetimeauth_state; + +SODIUM_EXPORT +size_t crypto_onetimeauth_statebytes(void); + +#define crypto_onetimeauth_BYTES crypto_onetimeauth_poly1305_BYTES +SODIUM_EXPORT +size_t crypto_onetimeauth_bytes(void); + +#define crypto_onetimeauth_KEYBYTES crypto_onetimeauth_poly1305_KEYBYTES +SODIUM_EXPORT +size_t crypto_onetimeauth_keybytes(void); + +#define crypto_onetimeauth_PRIMITIVE "poly1305" +SODIUM_EXPORT +const char *crypto_onetimeauth_primitive(void); + +SODIUM_EXPORT +int crypto_onetimeauth(unsigned char *out, const unsigned char *in, + unsigned long long inlen, const unsigned char *k) + __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_onetimeauth_verify(const unsigned char *h, const unsigned char *in, + unsigned long long inlen, const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_onetimeauth_init(crypto_onetimeauth_state *state, + const unsigned char *key) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_onetimeauth_update(crypto_onetimeauth_state *state, + const unsigned char *in, + unsigned long long inlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_onetimeauth_final(crypto_onetimeauth_state *state, + unsigned char *out) __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_onetimeauth_keygen(unsigned char k[crypto_onetimeauth_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_onetimeauth_poly1305.h b/deps/sodium/include/sodium/crypto_onetimeauth_poly1305.h new file mode 100644 index 00000000..f3e34d86 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_onetimeauth_poly1305.h @@ -0,0 +1,72 @@ +#ifndef crypto_onetimeauth_poly1305_H +#define crypto_onetimeauth_poly1305_H + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#include +#include +#include + +#include + +#include "export.h" + +typedef struct CRYPTO_ALIGN(16) crypto_onetimeauth_poly1305_state { + unsigned char opaque[256]; +} crypto_onetimeauth_poly1305_state; + +SODIUM_EXPORT +size_t crypto_onetimeauth_poly1305_statebytes(void); + +#define crypto_onetimeauth_poly1305_BYTES 16U +SODIUM_EXPORT +size_t crypto_onetimeauth_poly1305_bytes(void); + +#define crypto_onetimeauth_poly1305_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_onetimeauth_poly1305_keybytes(void); + +SODIUM_EXPORT +int crypto_onetimeauth_poly1305(unsigned char *out, + const unsigned char *in, + unsigned long long inlen, + const unsigned char *k) + __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_onetimeauth_poly1305_verify(const unsigned char *h, + const unsigned char *in, + unsigned long long inlen, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_onetimeauth_poly1305_init(crypto_onetimeauth_poly1305_state *state, + const unsigned char *key) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_onetimeauth_poly1305_update(crypto_onetimeauth_poly1305_state *state, + const unsigned char *in, + unsigned long long inlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_onetimeauth_poly1305_final(crypto_onetimeauth_poly1305_state *state, + unsigned char *out) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_onetimeauth_poly1305_keygen(unsigned char k[crypto_onetimeauth_poly1305_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_pwhash.h b/deps/sodium/include/sodium/crypto_pwhash.h new file mode 100644 index 00000000..585a993e --- /dev/null +++ b/deps/sodium/include/sodium/crypto_pwhash.h @@ -0,0 +1,147 @@ +#ifndef crypto_pwhash_H +#define crypto_pwhash_H + +#include + +#include "crypto_pwhash_argon2i.h" +#include "crypto_pwhash_argon2id.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_pwhash_ALG_ARGON2I13 crypto_pwhash_argon2i_ALG_ARGON2I13 +SODIUM_EXPORT +int crypto_pwhash_alg_argon2i13(void); + +#define crypto_pwhash_ALG_ARGON2ID13 crypto_pwhash_argon2id_ALG_ARGON2ID13 +SODIUM_EXPORT +int crypto_pwhash_alg_argon2id13(void); + +#define crypto_pwhash_ALG_DEFAULT crypto_pwhash_ALG_ARGON2ID13 +SODIUM_EXPORT +int crypto_pwhash_alg_default(void); + +#define crypto_pwhash_BYTES_MIN crypto_pwhash_argon2id_BYTES_MIN +SODIUM_EXPORT +size_t crypto_pwhash_bytes_min(void); + +#define crypto_pwhash_BYTES_MAX crypto_pwhash_argon2id_BYTES_MAX +SODIUM_EXPORT +size_t crypto_pwhash_bytes_max(void); + +#define crypto_pwhash_PASSWD_MIN crypto_pwhash_argon2id_PASSWD_MIN +SODIUM_EXPORT +size_t crypto_pwhash_passwd_min(void); + +#define crypto_pwhash_PASSWD_MAX crypto_pwhash_argon2id_PASSWD_MAX +SODIUM_EXPORT +size_t crypto_pwhash_passwd_max(void); + +#define crypto_pwhash_SALTBYTES crypto_pwhash_argon2id_SALTBYTES +SODIUM_EXPORT +size_t crypto_pwhash_saltbytes(void); + +#define crypto_pwhash_STRBYTES crypto_pwhash_argon2id_STRBYTES +SODIUM_EXPORT +size_t crypto_pwhash_strbytes(void); + +#define crypto_pwhash_STRPREFIX crypto_pwhash_argon2id_STRPREFIX +SODIUM_EXPORT +const char *crypto_pwhash_strprefix(void); + +#define crypto_pwhash_OPSLIMIT_MIN crypto_pwhash_argon2id_OPSLIMIT_MIN +SODIUM_EXPORT +size_t crypto_pwhash_opslimit_min(void); + +#define crypto_pwhash_OPSLIMIT_MAX crypto_pwhash_argon2id_OPSLIMIT_MAX +SODIUM_EXPORT +size_t crypto_pwhash_opslimit_max(void); + +#define crypto_pwhash_MEMLIMIT_MIN crypto_pwhash_argon2id_MEMLIMIT_MIN +SODIUM_EXPORT +size_t crypto_pwhash_memlimit_min(void); + +#define crypto_pwhash_MEMLIMIT_MAX crypto_pwhash_argon2id_MEMLIMIT_MAX +SODIUM_EXPORT +size_t crypto_pwhash_memlimit_max(void); + +#define crypto_pwhash_OPSLIMIT_INTERACTIVE crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE +SODIUM_EXPORT +size_t crypto_pwhash_opslimit_interactive(void); + +#define crypto_pwhash_MEMLIMIT_INTERACTIVE crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE +SODIUM_EXPORT +size_t crypto_pwhash_memlimit_interactive(void); + +#define crypto_pwhash_OPSLIMIT_MODERATE crypto_pwhash_argon2id_OPSLIMIT_MODERATE +SODIUM_EXPORT +size_t crypto_pwhash_opslimit_moderate(void); + +#define crypto_pwhash_MEMLIMIT_MODERATE crypto_pwhash_argon2id_MEMLIMIT_MODERATE +SODIUM_EXPORT +size_t crypto_pwhash_memlimit_moderate(void); + +#define crypto_pwhash_OPSLIMIT_SENSITIVE crypto_pwhash_argon2id_OPSLIMIT_SENSITIVE +SODIUM_EXPORT +size_t crypto_pwhash_opslimit_sensitive(void); + +#define crypto_pwhash_MEMLIMIT_SENSITIVE crypto_pwhash_argon2id_MEMLIMIT_SENSITIVE +SODIUM_EXPORT +size_t crypto_pwhash_memlimit_sensitive(void); + +/* + * With this function, do not forget to store all parameters, including the + * algorithm identifier in order to produce deterministic output. + * The crypto_pwhash_* definitions, including crypto_pwhash_ALG_DEFAULT, + * may change. + */ +SODIUM_EXPORT +int crypto_pwhash(unsigned char * const out, unsigned long long outlen, + const char * const passwd, unsigned long long passwdlen, + const unsigned char * const salt, + unsigned long long opslimit, size_t memlimit, int alg) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +/* + * The output string already includes all the required parameters, including + * the algorithm identifier. The string is all that has to be stored in + * order to verify a password. + */ +SODIUM_EXPORT +int crypto_pwhash_str(char out[crypto_pwhash_STRBYTES], + const char * const passwd, unsigned long long passwdlen, + unsigned long long opslimit, size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_str_alg(char out[crypto_pwhash_STRBYTES], + const char * const passwd, unsigned long long passwdlen, + unsigned long long opslimit, size_t memlimit, int alg) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_str_verify(const char str[crypto_pwhash_STRBYTES], + const char * const passwd, + unsigned long long passwdlen) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_str_needs_rehash(const char str[crypto_pwhash_STRBYTES], + unsigned long long opslimit, size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#define crypto_pwhash_PRIMITIVE "argon2i" +SODIUM_EXPORT +const char *crypto_pwhash_primitive(void) + __attribute__ ((warn_unused_result)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_pwhash_argon2i.h b/deps/sodium/include/sodium/crypto_pwhash_argon2i.h new file mode 100644 index 00000000..88ff6221 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_pwhash_argon2i.h @@ -0,0 +1,122 @@ +#ifndef crypto_pwhash_argon2i_H +#define crypto_pwhash_argon2i_H + +#include +#include +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_pwhash_argon2i_ALG_ARGON2I13 1 +SODIUM_EXPORT +int crypto_pwhash_argon2i_alg_argon2i13(void); + +#define crypto_pwhash_argon2i_BYTES_MIN 16U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_bytes_min(void); + +#define crypto_pwhash_argon2i_BYTES_MAX SODIUM_MIN(SODIUM_SIZE_MAX, 4294967295U) +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_bytes_max(void); + +#define crypto_pwhash_argon2i_PASSWD_MIN 0U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_passwd_min(void); + +#define crypto_pwhash_argon2i_PASSWD_MAX 4294967295U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_passwd_max(void); + +#define crypto_pwhash_argon2i_SALTBYTES 16U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_saltbytes(void); + +#define crypto_pwhash_argon2i_STRBYTES 128U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_strbytes(void); + +#define crypto_pwhash_argon2i_STRPREFIX "$argon2i$" +SODIUM_EXPORT +const char *crypto_pwhash_argon2i_strprefix(void); + +#define crypto_pwhash_argon2i_OPSLIMIT_MIN 3U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_opslimit_min(void); + +#define crypto_pwhash_argon2i_OPSLIMIT_MAX 4294967295U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_opslimit_max(void); + +#define crypto_pwhash_argon2i_MEMLIMIT_MIN 8192U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_memlimit_min(void); + +#define crypto_pwhash_argon2i_MEMLIMIT_MAX \ + ((SIZE_MAX >= 4398046510080U) ? 4398046510080U : (SIZE_MAX >= 2147483648U) ? 2147483648U : 32768U) +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_memlimit_max(void); + +#define crypto_pwhash_argon2i_OPSLIMIT_INTERACTIVE 4U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_opslimit_interactive(void); + +#define crypto_pwhash_argon2i_MEMLIMIT_INTERACTIVE 33554432U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_memlimit_interactive(void); + +#define crypto_pwhash_argon2i_OPSLIMIT_MODERATE 6U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_opslimit_moderate(void); + +#define crypto_pwhash_argon2i_MEMLIMIT_MODERATE 134217728U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_memlimit_moderate(void); + +#define crypto_pwhash_argon2i_OPSLIMIT_SENSITIVE 8U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_opslimit_sensitive(void); + +#define crypto_pwhash_argon2i_MEMLIMIT_SENSITIVE 536870912U +SODIUM_EXPORT +size_t crypto_pwhash_argon2i_memlimit_sensitive(void); + +SODIUM_EXPORT +int crypto_pwhash_argon2i(unsigned char * const out, + unsigned long long outlen, + const char * const passwd, + unsigned long long passwdlen, + const unsigned char * const salt, + unsigned long long opslimit, size_t memlimit, + int alg) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_argon2i_str(char out[crypto_pwhash_argon2i_STRBYTES], + const char * const passwd, + unsigned long long passwdlen, + unsigned long long opslimit, size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_argon2i_str_verify(const char str[crypto_pwhash_argon2i_STRBYTES], + const char * const passwd, + unsigned long long passwdlen) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_argon2i_str_needs_rehash(const char str[crypto_pwhash_argon2i_STRBYTES], + unsigned long long opslimit, size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_pwhash_argon2id.h b/deps/sodium/include/sodium/crypto_pwhash_argon2id.h new file mode 100644 index 00000000..7183abd1 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_pwhash_argon2id.h @@ -0,0 +1,122 @@ +#ifndef crypto_pwhash_argon2id_H +#define crypto_pwhash_argon2id_H + +#include +#include +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_pwhash_argon2id_ALG_ARGON2ID13 2 +SODIUM_EXPORT +int crypto_pwhash_argon2id_alg_argon2id13(void); + +#define crypto_pwhash_argon2id_BYTES_MIN 16U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_bytes_min(void); + +#define crypto_pwhash_argon2id_BYTES_MAX SODIUM_MIN(SODIUM_SIZE_MAX, 4294967295U) +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_bytes_max(void); + +#define crypto_pwhash_argon2id_PASSWD_MIN 0U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_passwd_min(void); + +#define crypto_pwhash_argon2id_PASSWD_MAX 4294967295U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_passwd_max(void); + +#define crypto_pwhash_argon2id_SALTBYTES 16U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_saltbytes(void); + +#define crypto_pwhash_argon2id_STRBYTES 128U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_strbytes(void); + +#define crypto_pwhash_argon2id_STRPREFIX "$argon2id$" +SODIUM_EXPORT +const char *crypto_pwhash_argon2id_strprefix(void); + +#define crypto_pwhash_argon2id_OPSLIMIT_MIN 1U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_opslimit_min(void); + +#define crypto_pwhash_argon2id_OPSLIMIT_MAX 4294967295U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_opslimit_max(void); + +#define crypto_pwhash_argon2id_MEMLIMIT_MIN 8192U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_memlimit_min(void); + +#define crypto_pwhash_argon2id_MEMLIMIT_MAX \ + ((SIZE_MAX >= 4398046510080U) ? 4398046510080U : (SIZE_MAX >= 2147483648U) ? 2147483648U : 32768U) +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_memlimit_max(void); + +#define crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE 2U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_opslimit_interactive(void); + +#define crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE 67108864U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_memlimit_interactive(void); + +#define crypto_pwhash_argon2id_OPSLIMIT_MODERATE 3U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_opslimit_moderate(void); + +#define crypto_pwhash_argon2id_MEMLIMIT_MODERATE 268435456U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_memlimit_moderate(void); + +#define crypto_pwhash_argon2id_OPSLIMIT_SENSITIVE 4U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_opslimit_sensitive(void); + +#define crypto_pwhash_argon2id_MEMLIMIT_SENSITIVE 1073741824U +SODIUM_EXPORT +size_t crypto_pwhash_argon2id_memlimit_sensitive(void); + +SODIUM_EXPORT +int crypto_pwhash_argon2id(unsigned char * const out, + unsigned long long outlen, + const char * const passwd, + unsigned long long passwdlen, + const unsigned char * const salt, + unsigned long long opslimit, size_t memlimit, + int alg) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_argon2id_str(char out[crypto_pwhash_argon2id_STRBYTES], + const char * const passwd, + unsigned long long passwdlen, + unsigned long long opslimit, size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_argon2id_str_verify(const char str[crypto_pwhash_argon2id_STRBYTES], + const char * const passwd, + unsigned long long passwdlen) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_argon2id_str_needs_rehash(const char str[crypto_pwhash_argon2id_STRBYTES], + unsigned long long opslimit, size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_pwhash_scryptsalsa208sha256.h b/deps/sodium/include/sodium/crypto_pwhash_scryptsalsa208sha256.h new file mode 100644 index 00000000..5c0bf7d3 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_pwhash_scryptsalsa208sha256.h @@ -0,0 +1,120 @@ +#ifndef crypto_pwhash_scryptsalsa208sha256_H +#define crypto_pwhash_scryptsalsa208sha256_H + +#include +#include +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_pwhash_scryptsalsa208sha256_BYTES_MIN 16U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_bytes_min(void); + +#define crypto_pwhash_scryptsalsa208sha256_BYTES_MAX \ + SODIUM_MIN(SODIUM_SIZE_MAX, 0x1fffffffe0ULL) +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_bytes_max(void); + +#define crypto_pwhash_scryptsalsa208sha256_PASSWD_MIN 0U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_passwd_min(void); + +#define crypto_pwhash_scryptsalsa208sha256_PASSWD_MAX SODIUM_SIZE_MAX +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_passwd_max(void); + +#define crypto_pwhash_scryptsalsa208sha256_SALTBYTES 32U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_saltbytes(void); + +#define crypto_pwhash_scryptsalsa208sha256_STRBYTES 102U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_strbytes(void); + +#define crypto_pwhash_scryptsalsa208sha256_STRPREFIX "$7$" +SODIUM_EXPORT +const char *crypto_pwhash_scryptsalsa208sha256_strprefix(void); + +#define crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN 32768U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_opslimit_min(void); + +#define crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX 4294967295U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_opslimit_max(void); + +#define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN 16777216U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_memlimit_min(void); + +#define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX \ + SODIUM_MIN(SIZE_MAX, 68719476736ULL) +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_memlimit_max(void); + +#define crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE 524288U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_opslimit_interactive(void); + +#define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE 16777216U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_memlimit_interactive(void); + +#define crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE 33554432U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive(void); + +#define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE 1073741824U +SODIUM_EXPORT +size_t crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive(void); + +SODIUM_EXPORT +int crypto_pwhash_scryptsalsa208sha256(unsigned char * const out, + unsigned long long outlen, + const char * const passwd, + unsigned long long passwdlen, + const unsigned char * const salt, + unsigned long long opslimit, + size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_scryptsalsa208sha256_str(char out[crypto_pwhash_scryptsalsa208sha256_STRBYTES], + const char * const passwd, + unsigned long long passwdlen, + unsigned long long opslimit, + size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_scryptsalsa208sha256_str_verify(const char str[crypto_pwhash_scryptsalsa208sha256_STRBYTES], + const char * const passwd, + unsigned long long passwdlen) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_scryptsalsa208sha256_ll(const uint8_t * passwd, size_t passwdlen, + const uint8_t * salt, size_t saltlen, + uint64_t N, uint32_t r, uint32_t p, + uint8_t * buf, size_t buflen) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_pwhash_scryptsalsa208sha256_str_needs_rehash(const char str[crypto_pwhash_scryptsalsa208sha256_STRBYTES], + unsigned long long opslimit, + size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_scalarmult.h b/deps/sodium/include/sodium/crypto_scalarmult.h new file mode 100644 index 00000000..1c685853 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_scalarmult.h @@ -0,0 +1,46 @@ +#ifndef crypto_scalarmult_H +#define crypto_scalarmult_H + +#include + +#include "crypto_scalarmult_curve25519.h" +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_scalarmult_BYTES crypto_scalarmult_curve25519_BYTES +SODIUM_EXPORT +size_t crypto_scalarmult_bytes(void); + +#define crypto_scalarmult_SCALARBYTES crypto_scalarmult_curve25519_SCALARBYTES +SODIUM_EXPORT +size_t crypto_scalarmult_scalarbytes(void); + +#define crypto_scalarmult_PRIMITIVE "curve25519" +SODIUM_EXPORT +const char *crypto_scalarmult_primitive(void); + +SODIUM_EXPORT +int crypto_scalarmult_base(unsigned char *q, const unsigned char *n) + __attribute__ ((nonnull)); + +/* + * NOTE: Do not use the result of this function directly for key exchange. + * + * Hash the result with the public keys in order to compute a shared + * secret key: H(q || client_pk || server_pk) + * + * Or unless this is not an option, use the crypto_kx() API instead. + */ +SODIUM_EXPORT +int crypto_scalarmult(unsigned char *q, const unsigned char *n, + const unsigned char *p) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_scalarmult_curve25519.h b/deps/sodium/include/sodium/crypto_scalarmult_curve25519.h new file mode 100644 index 00000000..60e9d0c5 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_scalarmult_curve25519.h @@ -0,0 +1,42 @@ +#ifndef crypto_scalarmult_curve25519_H +#define crypto_scalarmult_curve25519_H + +#include + +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_scalarmult_curve25519_BYTES 32U +SODIUM_EXPORT +size_t crypto_scalarmult_curve25519_bytes(void); + +#define crypto_scalarmult_curve25519_SCALARBYTES 32U +SODIUM_EXPORT +size_t crypto_scalarmult_curve25519_scalarbytes(void); + +/* + * NOTE: Do not use the result of this function directly for key exchange. + * + * Hash the result with the public keys in order to compute a shared + * secret key: H(q || client_pk || server_pk) + * + * Or unless this is not an option, use the crypto_kx() API instead. + */ +SODIUM_EXPORT +int crypto_scalarmult_curve25519(unsigned char *q, const unsigned char *n, + const unsigned char *p) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_scalarmult_curve25519_base(unsigned char *q, + const unsigned char *n) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_scalarmult_ed25519.h b/deps/sodium/include/sodium/crypto_scalarmult_ed25519.h new file mode 100644 index 00000000..2dfa4d70 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_scalarmult_ed25519.h @@ -0,0 +1,51 @@ + +#ifndef crypto_scalarmult_ed25519_H +#define crypto_scalarmult_ed25519_H + +#include + +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_scalarmult_ed25519_BYTES 32U +SODIUM_EXPORT +size_t crypto_scalarmult_ed25519_bytes(void); + +#define crypto_scalarmult_ed25519_SCALARBYTES 32U +SODIUM_EXPORT +size_t crypto_scalarmult_ed25519_scalarbytes(void); + +/* + * NOTE: Do not use the result of this function directly for key exchange. + * + * Hash the result with the public keys in order to compute a shared + * secret key: H(q || client_pk || server_pk) + * + * Or unless this is not an option, use the crypto_kx() API instead. + */ +SODIUM_EXPORT +int crypto_scalarmult_ed25519(unsigned char *q, const unsigned char *n, + const unsigned char *p) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_scalarmult_ed25519_noclamp(unsigned char *q, const unsigned char *n, + const unsigned char *p) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_scalarmult_ed25519_base(unsigned char *q, const unsigned char *n) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_scalarmult_ed25519_base_noclamp(unsigned char *q, const unsigned char *n) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_scalarmult_ristretto255.h b/deps/sodium/include/sodium/crypto_scalarmult_ristretto255.h new file mode 100644 index 00000000..40a45cce --- /dev/null +++ b/deps/sodium/include/sodium/crypto_scalarmult_ristretto255.h @@ -0,0 +1,43 @@ + +#ifndef crypto_scalarmult_ristretto255_H +#define crypto_scalarmult_ristretto255_H + +#include + +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_scalarmult_ristretto255_BYTES 32U +SODIUM_EXPORT +size_t crypto_scalarmult_ristretto255_bytes(void); + +#define crypto_scalarmult_ristretto255_SCALARBYTES 32U +SODIUM_EXPORT +size_t crypto_scalarmult_ristretto255_scalarbytes(void); + +/* + * NOTE: Do not use the result of this function directly for key exchange. + * + * Hash the result with the public keys in order to compute a shared + * secret key: H(q || client_pk || server_pk) + * + * Or unless this is not an option, use the crypto_kx() API instead. + */ +SODIUM_EXPORT +int crypto_scalarmult_ristretto255(unsigned char *q, const unsigned char *n, + const unsigned char *p) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_scalarmult_ristretto255_base(unsigned char *q, + const unsigned char *n) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_secretbox.h b/deps/sodium/include/sodium/crypto_secretbox.h new file mode 100644 index 00000000..1d3709db --- /dev/null +++ b/deps/sodium/include/sodium/crypto_secretbox.h @@ -0,0 +1,93 @@ +#ifndef crypto_secretbox_H +#define crypto_secretbox_H + +#include + +#include "crypto_secretbox_xsalsa20poly1305.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_secretbox_KEYBYTES crypto_secretbox_xsalsa20poly1305_KEYBYTES +SODIUM_EXPORT +size_t crypto_secretbox_keybytes(void); + +#define crypto_secretbox_NONCEBYTES crypto_secretbox_xsalsa20poly1305_NONCEBYTES +SODIUM_EXPORT +size_t crypto_secretbox_noncebytes(void); + +#define crypto_secretbox_MACBYTES crypto_secretbox_xsalsa20poly1305_MACBYTES +SODIUM_EXPORT +size_t crypto_secretbox_macbytes(void); + +#define crypto_secretbox_PRIMITIVE "xsalsa20poly1305" +SODIUM_EXPORT +const char *crypto_secretbox_primitive(void); + +#define crypto_secretbox_MESSAGEBYTES_MAX crypto_secretbox_xsalsa20poly1305_MESSAGEBYTES_MAX +SODIUM_EXPORT +size_t crypto_secretbox_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_secretbox_easy(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) __attribute__ ((nonnull(1, 4, 5))); + +SODIUM_EXPORT +int crypto_secretbox_open_easy(unsigned char *m, const unsigned char *c, + unsigned long long clen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5))); + +SODIUM_EXPORT +int crypto_secretbox_detached(unsigned char *c, unsigned char *mac, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull(1, 2, 5, 6))); + +SODIUM_EXPORT +int crypto_secretbox_open_detached(unsigned char *m, + const unsigned char *c, + const unsigned char *mac, + unsigned long long clen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 3, 5, 6))); + +SODIUM_EXPORT +void crypto_secretbox_keygen(unsigned char k[crypto_secretbox_KEYBYTES]) + __attribute__ ((nonnull)); + +/* -- NaCl compatibility interface ; Requires padding -- */ + +#define crypto_secretbox_ZEROBYTES crypto_secretbox_xsalsa20poly1305_ZEROBYTES +SODIUM_EXPORT +size_t crypto_secretbox_zerobytes(void); + +#define crypto_secretbox_BOXZEROBYTES crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES +SODIUM_EXPORT +size_t crypto_secretbox_boxzerobytes(void); + +SODIUM_EXPORT +int crypto_secretbox(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) __attribute__ ((nonnull(1, 4, 5))); + +SODIUM_EXPORT +int crypto_secretbox_open(unsigned char *m, const unsigned char *c, + unsigned long long clen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_secretbox_xchacha20poly1305.h b/deps/sodium/include/sodium/crypto_secretbox_xchacha20poly1305.h new file mode 100644 index 00000000..6ec674e3 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_secretbox_xchacha20poly1305.h @@ -0,0 +1,70 @@ +#ifndef crypto_secretbox_xchacha20poly1305_H +#define crypto_secretbox_xchacha20poly1305_H + +#include +#include "crypto_stream_xchacha20.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_secretbox_xchacha20poly1305_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_secretbox_xchacha20poly1305_keybytes(void); + +#define crypto_secretbox_xchacha20poly1305_NONCEBYTES 24U +SODIUM_EXPORT +size_t crypto_secretbox_xchacha20poly1305_noncebytes(void); + +#define crypto_secretbox_xchacha20poly1305_MACBYTES 16U +SODIUM_EXPORT +size_t crypto_secretbox_xchacha20poly1305_macbytes(void); + +#define crypto_secretbox_xchacha20poly1305_MESSAGEBYTES_MAX \ + (crypto_stream_xchacha20_MESSAGEBYTES_MAX - crypto_secretbox_xchacha20poly1305_MACBYTES) +SODIUM_EXPORT +size_t crypto_secretbox_xchacha20poly1305_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_secretbox_xchacha20poly1305_easy(unsigned char *c, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull(1, 4, 5))); + +SODIUM_EXPORT +int crypto_secretbox_xchacha20poly1305_open_easy(unsigned char *m, + const unsigned char *c, + unsigned long long clen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5))); + +SODIUM_EXPORT +int crypto_secretbox_xchacha20poly1305_detached(unsigned char *c, + unsigned char *mac, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull(1, 2, 5, 6))); + +SODIUM_EXPORT +int crypto_secretbox_xchacha20poly1305_open_detached(unsigned char *m, + const unsigned char *c, + const unsigned char *mac, + unsigned long long clen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 3, 5, 6))); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_secretbox_xsalsa20poly1305.h b/deps/sodium/include/sodium/crypto_secretbox_xsalsa20poly1305.h new file mode 100644 index 00000000..be0874cb --- /dev/null +++ b/deps/sodium/include/sodium/crypto_secretbox_xsalsa20poly1305.h @@ -0,0 +1,69 @@ +#ifndef crypto_secretbox_xsalsa20poly1305_H +#define crypto_secretbox_xsalsa20poly1305_H + +#include +#include "crypto_stream_xsalsa20.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_secretbox_xsalsa20poly1305_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_secretbox_xsalsa20poly1305_keybytes(void); + +#define crypto_secretbox_xsalsa20poly1305_NONCEBYTES 24U +SODIUM_EXPORT +size_t crypto_secretbox_xsalsa20poly1305_noncebytes(void); + +#define crypto_secretbox_xsalsa20poly1305_MACBYTES 16U +SODIUM_EXPORT +size_t crypto_secretbox_xsalsa20poly1305_macbytes(void); + +/* Only for the libsodium API - The NaCl compatibility API would require BOXZEROBYTES extra bytes */ +#define crypto_secretbox_xsalsa20poly1305_MESSAGEBYTES_MAX \ + (crypto_stream_xsalsa20_MESSAGEBYTES_MAX - crypto_secretbox_xsalsa20poly1305_MACBYTES) +SODIUM_EXPORT +size_t crypto_secretbox_xsalsa20poly1305_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_secretbox_xsalsa20poly1305(unsigned char *c, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull(1, 4, 5))); + +SODIUM_EXPORT +int crypto_secretbox_xsalsa20poly1305_open(unsigned char *m, + const unsigned char *c, + unsigned long long clen, + const unsigned char *n, + const unsigned char *k) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(2, 4, 5))); + +SODIUM_EXPORT +void crypto_secretbox_xsalsa20poly1305_keygen(unsigned char k[crypto_secretbox_xsalsa20poly1305_KEYBYTES]) + __attribute__ ((nonnull)); + +/* -- NaCl compatibility interface ; Requires padding -- */ + +#define crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES 16U +SODIUM_EXPORT +size_t crypto_secretbox_xsalsa20poly1305_boxzerobytes(void); + +#define crypto_secretbox_xsalsa20poly1305_ZEROBYTES \ + (crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES + \ + crypto_secretbox_xsalsa20poly1305_MACBYTES) +SODIUM_EXPORT +size_t crypto_secretbox_xsalsa20poly1305_zerobytes(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_secretstream_xchacha20poly1305.h b/deps/sodium/include/sodium/crypto_secretstream_xchacha20poly1305.h new file mode 100644 index 00000000..b22e4e93 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_secretstream_xchacha20poly1305.h @@ -0,0 +1,108 @@ +#ifndef crypto_secretstream_xchacha20poly1305_H +#define crypto_secretstream_xchacha20poly1305_H + +#include + +#include "crypto_aead_xchacha20poly1305.h" +#include "crypto_stream_chacha20.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_secretstream_xchacha20poly1305_ABYTES \ + (1U + crypto_aead_xchacha20poly1305_ietf_ABYTES) +SODIUM_EXPORT +size_t crypto_secretstream_xchacha20poly1305_abytes(void); + +#define crypto_secretstream_xchacha20poly1305_HEADERBYTES \ + crypto_aead_xchacha20poly1305_ietf_NPUBBYTES +SODIUM_EXPORT +size_t crypto_secretstream_xchacha20poly1305_headerbytes(void); + +#define crypto_secretstream_xchacha20poly1305_KEYBYTES \ + crypto_aead_xchacha20poly1305_ietf_KEYBYTES +SODIUM_EXPORT +size_t crypto_secretstream_xchacha20poly1305_keybytes(void); + +#define crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX \ + SODIUM_MIN(SODIUM_SIZE_MAX - crypto_secretstream_xchacha20poly1305_ABYTES, \ + (64ULL * ((1ULL << 32) - 2ULL))) +SODIUM_EXPORT +size_t crypto_secretstream_xchacha20poly1305_messagebytes_max(void); + +#define crypto_secretstream_xchacha20poly1305_TAG_MESSAGE 0x00 +SODIUM_EXPORT +unsigned char crypto_secretstream_xchacha20poly1305_tag_message(void); + +#define crypto_secretstream_xchacha20poly1305_TAG_PUSH 0x01 +SODIUM_EXPORT +unsigned char crypto_secretstream_xchacha20poly1305_tag_push(void); + +#define crypto_secretstream_xchacha20poly1305_TAG_REKEY 0x02 +SODIUM_EXPORT +unsigned char crypto_secretstream_xchacha20poly1305_tag_rekey(void); + +#define crypto_secretstream_xchacha20poly1305_TAG_FINAL \ + (crypto_secretstream_xchacha20poly1305_TAG_PUSH | \ + crypto_secretstream_xchacha20poly1305_TAG_REKEY) +SODIUM_EXPORT +unsigned char crypto_secretstream_xchacha20poly1305_tag_final(void); + +typedef struct crypto_secretstream_xchacha20poly1305_state { + unsigned char k[crypto_stream_chacha20_ietf_KEYBYTES]; + unsigned char nonce[crypto_stream_chacha20_ietf_NONCEBYTES]; + unsigned char _pad[8]; +} crypto_secretstream_xchacha20poly1305_state; + +SODIUM_EXPORT +size_t crypto_secretstream_xchacha20poly1305_statebytes(void); + +SODIUM_EXPORT +void crypto_secretstream_xchacha20poly1305_keygen + (unsigned char k[crypto_secretstream_xchacha20poly1305_KEYBYTES]) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_secretstream_xchacha20poly1305_init_push + (crypto_secretstream_xchacha20poly1305_state *state, + unsigned char header[crypto_secretstream_xchacha20poly1305_HEADERBYTES], + const unsigned char k[crypto_secretstream_xchacha20poly1305_KEYBYTES]) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_secretstream_xchacha20poly1305_push + (crypto_secretstream_xchacha20poly1305_state *state, + unsigned char *c, unsigned long long *clen_p, + const unsigned char *m, unsigned long long mlen, + const unsigned char *ad, unsigned long long adlen, unsigned char tag) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_secretstream_xchacha20poly1305_init_pull + (crypto_secretstream_xchacha20poly1305_state *state, + const unsigned char header[crypto_secretstream_xchacha20poly1305_HEADERBYTES], + const unsigned char k[crypto_secretstream_xchacha20poly1305_KEYBYTES]) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_secretstream_xchacha20poly1305_pull + (crypto_secretstream_xchacha20poly1305_state *state, + unsigned char *m, unsigned long long *mlen_p, unsigned char *tag_p, + const unsigned char *c, unsigned long long clen, + const unsigned char *ad, unsigned long long adlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +void crypto_secretstream_xchacha20poly1305_rekey + (crypto_secretstream_xchacha20poly1305_state *state); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_shorthash.h b/deps/sodium/include/sodium/crypto_shorthash.h new file mode 100644 index 00000000..fecaa88b --- /dev/null +++ b/deps/sodium/include/sodium/crypto_shorthash.h @@ -0,0 +1,41 @@ +#ifndef crypto_shorthash_H +#define crypto_shorthash_H + +#include + +#include "crypto_shorthash_siphash24.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_shorthash_BYTES crypto_shorthash_siphash24_BYTES +SODIUM_EXPORT +size_t crypto_shorthash_bytes(void); + +#define crypto_shorthash_KEYBYTES crypto_shorthash_siphash24_KEYBYTES +SODIUM_EXPORT +size_t crypto_shorthash_keybytes(void); + +#define crypto_shorthash_PRIMITIVE "siphash24" +SODIUM_EXPORT +const char *crypto_shorthash_primitive(void); + +SODIUM_EXPORT +int crypto_shorthash(unsigned char *out, const unsigned char *in, + unsigned long long inlen, const unsigned char *k) + __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +void crypto_shorthash_keygen(unsigned char k[crypto_shorthash_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_shorthash_siphash24.h b/deps/sodium/include/sodium/crypto_shorthash_siphash24.h new file mode 100644 index 00000000..1e6f72a6 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_shorthash_siphash24.h @@ -0,0 +1,50 @@ +#ifndef crypto_shorthash_siphash24_H +#define crypto_shorthash_siphash24_H + +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +/* -- 64-bit output -- */ + +#define crypto_shorthash_siphash24_BYTES 8U +SODIUM_EXPORT +size_t crypto_shorthash_siphash24_bytes(void); + +#define crypto_shorthash_siphash24_KEYBYTES 16U +SODIUM_EXPORT +size_t crypto_shorthash_siphash24_keybytes(void); + +SODIUM_EXPORT +int crypto_shorthash_siphash24(unsigned char *out, const unsigned char *in, + unsigned long long inlen, const unsigned char *k) + __attribute__ ((nonnull(1, 4))); + +#ifndef SODIUM_LIBRARY_MINIMAL +/* -- 128-bit output -- */ + +#define crypto_shorthash_siphashx24_BYTES 16U +SODIUM_EXPORT +size_t crypto_shorthash_siphashx24_bytes(void); + +#define crypto_shorthash_siphashx24_KEYBYTES 16U +SODIUM_EXPORT +size_t crypto_shorthash_siphashx24_keybytes(void); + +SODIUM_EXPORT +int crypto_shorthash_siphashx24(unsigned char *out, const unsigned char *in, + unsigned long long inlen, const unsigned char *k) + __attribute__ ((nonnull(1, 4))); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_sign.h b/deps/sodium/include/sodium/crypto_sign.h new file mode 100644 index 00000000..f5fafb12 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_sign.h @@ -0,0 +1,107 @@ +#ifndef crypto_sign_H +#define crypto_sign_H + +/* + * THREAD SAFETY: crypto_sign_keypair() is thread-safe, + * provided that sodium_init() was called before. + * + * Other functions, including crypto_sign_seed_keypair() are always thread-safe. + */ + +#include + +#include "crypto_sign_ed25519.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +typedef crypto_sign_ed25519ph_state crypto_sign_state; + +SODIUM_EXPORT +size_t crypto_sign_statebytes(void); + +#define crypto_sign_BYTES crypto_sign_ed25519_BYTES +SODIUM_EXPORT +size_t crypto_sign_bytes(void); + +#define crypto_sign_SEEDBYTES crypto_sign_ed25519_SEEDBYTES +SODIUM_EXPORT +size_t crypto_sign_seedbytes(void); + +#define crypto_sign_PUBLICKEYBYTES crypto_sign_ed25519_PUBLICKEYBYTES +SODIUM_EXPORT +size_t crypto_sign_publickeybytes(void); + +#define crypto_sign_SECRETKEYBYTES crypto_sign_ed25519_SECRETKEYBYTES +SODIUM_EXPORT +size_t crypto_sign_secretkeybytes(void); + +#define crypto_sign_MESSAGEBYTES_MAX crypto_sign_ed25519_MESSAGEBYTES_MAX +SODIUM_EXPORT +size_t crypto_sign_messagebytes_max(void); + +#define crypto_sign_PRIMITIVE "ed25519" +SODIUM_EXPORT +const char *crypto_sign_primitive(void); + +SODIUM_EXPORT +int crypto_sign_seed_keypair(unsigned char *pk, unsigned char *sk, + const unsigned char *seed) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_keypair(unsigned char *pk, unsigned char *sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign(unsigned char *sm, unsigned long long *smlen_p, + const unsigned char *m, unsigned long long mlen, + const unsigned char *sk) __attribute__ ((nonnull(1, 5))); + +SODIUM_EXPORT +int crypto_sign_open(unsigned char *m, unsigned long long *mlen_p, + const unsigned char *sm, unsigned long long smlen, + const unsigned char *pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(3, 5))); + +SODIUM_EXPORT +int crypto_sign_detached(unsigned char *sig, unsigned long long *siglen_p, + const unsigned char *m, unsigned long long mlen, + const unsigned char *sk) __attribute__ ((nonnull(1, 5))); + +SODIUM_EXPORT +int crypto_sign_verify_detached(const unsigned char *sig, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_sign_init(crypto_sign_state *state); + +SODIUM_EXPORT +int crypto_sign_update(crypto_sign_state *state, + const unsigned char *m, unsigned long long mlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_sign_final_create(crypto_sign_state *state, unsigned char *sig, + unsigned long long *siglen_p, + const unsigned char *sk) + __attribute__ ((nonnull(1, 2, 4))); + +SODIUM_EXPORT +int crypto_sign_final_verify(crypto_sign_state *state, const unsigned char *sig, + const unsigned char *pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_sign_ed25519.h b/deps/sodium/include/sodium/crypto_sign_ed25519.h new file mode 100644 index 00000000..0fdac42d --- /dev/null +++ b/deps/sodium/include/sodium/crypto_sign_ed25519.h @@ -0,0 +1,124 @@ +#ifndef crypto_sign_ed25519_H +#define crypto_sign_ed25519_H + +#include +#include "crypto_hash_sha512.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +typedef struct crypto_sign_ed25519ph_state { + crypto_hash_sha512_state hs; +} crypto_sign_ed25519ph_state; + +SODIUM_EXPORT +size_t crypto_sign_ed25519ph_statebytes(void); + +#define crypto_sign_ed25519_BYTES 64U +SODIUM_EXPORT +size_t crypto_sign_ed25519_bytes(void); + +#define crypto_sign_ed25519_SEEDBYTES 32U +SODIUM_EXPORT +size_t crypto_sign_ed25519_seedbytes(void); + +#define crypto_sign_ed25519_PUBLICKEYBYTES 32U +SODIUM_EXPORT +size_t crypto_sign_ed25519_publickeybytes(void); + +#define crypto_sign_ed25519_SECRETKEYBYTES (32U + 32U) +SODIUM_EXPORT +size_t crypto_sign_ed25519_secretkeybytes(void); + +#define crypto_sign_ed25519_MESSAGEBYTES_MAX (SODIUM_SIZE_MAX - crypto_sign_ed25519_BYTES) +SODIUM_EXPORT +size_t crypto_sign_ed25519_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_sign_ed25519(unsigned char *sm, unsigned long long *smlen_p, + const unsigned char *m, unsigned long long mlen, + const unsigned char *sk) + __attribute__ ((nonnull(1, 5))); + +SODIUM_EXPORT +int crypto_sign_ed25519_open(unsigned char *m, unsigned long long *mlen_p, + const unsigned char *sm, unsigned long long smlen, + const unsigned char *pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(3, 5))); + +SODIUM_EXPORT +int crypto_sign_ed25519_detached(unsigned char *sig, + unsigned long long *siglen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *sk) + __attribute__ ((nonnull(1, 5))); + +SODIUM_EXPORT +int crypto_sign_ed25519_verify_detached(const unsigned char *sig, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull(1, 4))); + +SODIUM_EXPORT +int crypto_sign_ed25519_keypair(unsigned char *pk, unsigned char *sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519_seed_keypair(unsigned char *pk, unsigned char *sk, + const unsigned char *seed) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519_pk_to_curve25519(unsigned char *curve25519_pk, + const unsigned char *ed25519_pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519_sk_to_curve25519(unsigned char *curve25519_sk, + const unsigned char *ed25519_sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519_sk_to_seed(unsigned char *seed, + const unsigned char *sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519_sk_to_pk(unsigned char *pk, const unsigned char *sk) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519ph_init(crypto_sign_ed25519ph_state *state) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_sign_ed25519ph_update(crypto_sign_ed25519ph_state *state, + const unsigned char *m, + unsigned long long mlen) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_sign_ed25519ph_final_create(crypto_sign_ed25519ph_state *state, + unsigned char *sig, + unsigned long long *siglen_p, + const unsigned char *sk) + __attribute__ ((nonnull(1, 2, 4))); + +SODIUM_EXPORT +int crypto_sign_ed25519ph_final_verify(crypto_sign_ed25519ph_state *state, + const unsigned char *sig, + const unsigned char *pk) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_sign_edwards25519sha512batch.h b/deps/sodium/include/sodium/crypto_sign_edwards25519sha512batch.h new file mode 100644 index 00000000..eed158aa --- /dev/null +++ b/deps/sodium/include/sodium/crypto_sign_edwards25519sha512batch.h @@ -0,0 +1,55 @@ +#ifndef crypto_sign_edwards25519sha512batch_H +#define crypto_sign_edwards25519sha512batch_H + +/* + * WARNING: This construction was a prototype, which should not be used + * any more in new projects. + * + * crypto_sign_edwards25519sha512batch is provided for applications + * initially built with NaCl, but as recommended by the author of this + * construction, new applications should use ed25519 instead. + * + * In Sodium, you should use the high-level crypto_sign_*() functions instead. + */ + +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_sign_edwards25519sha512batch_BYTES 64U +#define crypto_sign_edwards25519sha512batch_PUBLICKEYBYTES 32U +#define crypto_sign_edwards25519sha512batch_SECRETKEYBYTES (32U + 32U) +#define crypto_sign_edwards25519sha512batch_MESSAGEBYTES_MAX (SODIUM_SIZE_MAX - crypto_sign_edwards25519sha512batch_BYTES) + +SODIUM_EXPORT +int crypto_sign_edwards25519sha512batch(unsigned char *sm, + unsigned long long *smlen_p, + const unsigned char *m, + unsigned long long mlen, + const unsigned char *sk) + __attribute__ ((deprecated)) __attribute__ ((nonnull(1, 5))); + +SODIUM_EXPORT +int crypto_sign_edwards25519sha512batch_open(unsigned char *m, + unsigned long long *mlen_p, + const unsigned char *sm, + unsigned long long smlen, + const unsigned char *pk) + __attribute__ ((deprecated)) __attribute__ ((nonnull(3, 5))); + +SODIUM_EXPORT +int crypto_sign_edwards25519sha512batch_keypair(unsigned char *pk, + unsigned char *sk) + __attribute__ ((deprecated)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_stream.h b/deps/sodium/include/sodium/crypto_stream.h new file mode 100644 index 00000000..88dab5f6 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_stream.h @@ -0,0 +1,59 @@ +#ifndef crypto_stream_H +#define crypto_stream_H + +/* + * WARNING: This is just a stream cipher. It is NOT authenticated encryption. + * While it provides some protection against eavesdropping, it does NOT + * provide any security against active attacks. + * Unless you know what you're doing, what you are looking for is probably + * the crypto_box functions. + */ + +#include + +#include "crypto_stream_xsalsa20.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_stream_KEYBYTES crypto_stream_xsalsa20_KEYBYTES +SODIUM_EXPORT +size_t crypto_stream_keybytes(void); + +#define crypto_stream_NONCEBYTES crypto_stream_xsalsa20_NONCEBYTES +SODIUM_EXPORT +size_t crypto_stream_noncebytes(void); + +#define crypto_stream_MESSAGEBYTES_MAX crypto_stream_xsalsa20_MESSAGEBYTES_MAX +SODIUM_EXPORT +size_t crypto_stream_messagebytes_max(void); + +#define crypto_stream_PRIMITIVE "xsalsa20" +SODIUM_EXPORT +const char *crypto_stream_primitive(void); + +SODIUM_EXPORT +int crypto_stream(unsigned char *c, unsigned long long clen, + const unsigned char *n, const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_xor(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_stream_keygen(unsigned char k[crypto_stream_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_stream_chacha20.h b/deps/sodium/include/sodium/crypto_stream_chacha20.h new file mode 100644 index 00000000..40889755 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_stream_chacha20.h @@ -0,0 +1,106 @@ +#ifndef crypto_stream_chacha20_H +#define crypto_stream_chacha20_H + +/* + * WARNING: This is just a stream cipher. It is NOT authenticated encryption. + * While it provides some protection against eavesdropping, it does NOT + * provide any security against active attacks. + * Unless you know what you're doing, what you are looking for is probably + * the crypto_box functions. + */ + +#include +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_stream_chacha20_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_stream_chacha20_keybytes(void); + +#define crypto_stream_chacha20_NONCEBYTES 8U +SODIUM_EXPORT +size_t crypto_stream_chacha20_noncebytes(void); + +#define crypto_stream_chacha20_MESSAGEBYTES_MAX SODIUM_SIZE_MAX +SODIUM_EXPORT +size_t crypto_stream_chacha20_messagebytes_max(void); + +/* ChaCha20 with a 64-bit nonce and a 64-bit counter, as originally designed */ + +SODIUM_EXPORT +int crypto_stream_chacha20(unsigned char *c, unsigned long long clen, + const unsigned char *n, const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_chacha20_xor(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_chacha20_xor_ic(unsigned char *c, const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, uint64_t ic, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_stream_chacha20_keygen(unsigned char k[crypto_stream_chacha20_KEYBYTES]) + __attribute__ ((nonnull)); + +/* ChaCha20 with a 96-bit nonce and a 32-bit counter (IETF) */ + +#define crypto_stream_chacha20_ietf_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_stream_chacha20_ietf_keybytes(void); + +#define crypto_stream_chacha20_ietf_NONCEBYTES 12U +SODIUM_EXPORT +size_t crypto_stream_chacha20_ietf_noncebytes(void); + +#define crypto_stream_chacha20_ietf_MESSAGEBYTES_MAX \ + SODIUM_MIN(SODIUM_SIZE_MAX, 64ULL * (1ULL << 32)) +SODIUM_EXPORT +size_t crypto_stream_chacha20_ietf_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_stream_chacha20_ietf(unsigned char *c, unsigned long long clen, + const unsigned char *n, const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_chacha20_ietf_xor(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_chacha20_ietf_xor_ic(unsigned char *c, const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, uint32_t ic, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_stream_chacha20_ietf_keygen(unsigned char k[crypto_stream_chacha20_ietf_KEYBYTES]) + __attribute__ ((nonnull)); + +/* Aliases */ + +#define crypto_stream_chacha20_IETF_KEYBYTES crypto_stream_chacha20_ietf_KEYBYTES +#define crypto_stream_chacha20_IETF_NONCEBYTES crypto_stream_chacha20_ietf_NONCEBYTES +#define crypto_stream_chacha20_IETF_MESSAGEBYTES_MAX crypto_stream_chacha20_ietf_MESSAGEBYTES_MAX + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_stream_salsa20.h b/deps/sodium/include/sodium/crypto_stream_salsa20.h new file mode 100644 index 00000000..45b3b3e3 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_stream_salsa20.h @@ -0,0 +1,61 @@ +#ifndef crypto_stream_salsa20_H +#define crypto_stream_salsa20_H + +/* + * WARNING: This is just a stream cipher. It is NOT authenticated encryption. + * While it provides some protection against eavesdropping, it does NOT + * provide any security against active attacks. + * Unless you know what you're doing, what you are looking for is probably + * the crypto_box functions. + */ + +#include +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_stream_salsa20_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_stream_salsa20_keybytes(void); + +#define crypto_stream_salsa20_NONCEBYTES 8U +SODIUM_EXPORT +size_t crypto_stream_salsa20_noncebytes(void); + +#define crypto_stream_salsa20_MESSAGEBYTES_MAX SODIUM_SIZE_MAX +SODIUM_EXPORT +size_t crypto_stream_salsa20_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_stream_salsa20(unsigned char *c, unsigned long long clen, + const unsigned char *n, const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_salsa20_xor(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_salsa20_xor_ic(unsigned char *c, const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, uint64_t ic, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_stream_salsa20_keygen(unsigned char k[crypto_stream_salsa20_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_stream_salsa2012.h b/deps/sodium/include/sodium/crypto_stream_salsa2012.h new file mode 100644 index 00000000..6c5d303c --- /dev/null +++ b/deps/sodium/include/sodium/crypto_stream_salsa2012.h @@ -0,0 +1,53 @@ +#ifndef crypto_stream_salsa2012_H +#define crypto_stream_salsa2012_H + +/* + * WARNING: This is just a stream cipher. It is NOT authenticated encryption. + * While it provides some protection against eavesdropping, it does NOT + * provide any security against active attacks. + * Unless you know what you're doing, what you are looking for is probably + * the crypto_box functions. + */ + +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_stream_salsa2012_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_stream_salsa2012_keybytes(void); + +#define crypto_stream_salsa2012_NONCEBYTES 8U +SODIUM_EXPORT +size_t crypto_stream_salsa2012_noncebytes(void); + +#define crypto_stream_salsa2012_MESSAGEBYTES_MAX SODIUM_SIZE_MAX +SODIUM_EXPORT +size_t crypto_stream_salsa2012_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_stream_salsa2012(unsigned char *c, unsigned long long clen, + const unsigned char *n, const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_salsa2012_xor(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_stream_salsa2012_keygen(unsigned char k[crypto_stream_salsa2012_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_stream_salsa208.h b/deps/sodium/include/sodium/crypto_stream_salsa208.h new file mode 100644 index 00000000..d574f304 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_stream_salsa208.h @@ -0,0 +1,56 @@ +#ifndef crypto_stream_salsa208_H +#define crypto_stream_salsa208_H + +/* + * WARNING: This is just a stream cipher. It is NOT authenticated encryption. + * While it provides some protection against eavesdropping, it does NOT + * provide any security against active attacks. + * Unless you know what you're doing, what you are looking for is probably + * the crypto_box functions. + */ + +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_stream_salsa208_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_stream_salsa208_keybytes(void) + __attribute__ ((deprecated)); + +#define crypto_stream_salsa208_NONCEBYTES 8U +SODIUM_EXPORT +size_t crypto_stream_salsa208_noncebytes(void) + __attribute__ ((deprecated)); + +#define crypto_stream_salsa208_MESSAGEBYTES_MAX SODIUM_SIZE_MAX + SODIUM_EXPORT +size_t crypto_stream_salsa208_messagebytes_max(void) + __attribute__ ((deprecated)); + +SODIUM_EXPORT +int crypto_stream_salsa208(unsigned char *c, unsigned long long clen, + const unsigned char *n, const unsigned char *k) + __attribute__ ((deprecated)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_salsa208_xor(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((deprecated)) __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_stream_salsa208_keygen(unsigned char k[crypto_stream_salsa208_KEYBYTES]) + __attribute__ ((deprecated)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_stream_xchacha20.h b/deps/sodium/include/sodium/crypto_stream_xchacha20.h new file mode 100644 index 00000000..c4002db0 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_stream_xchacha20.h @@ -0,0 +1,61 @@ +#ifndef crypto_stream_xchacha20_H +#define crypto_stream_xchacha20_H + +/* + * WARNING: This is just a stream cipher. It is NOT authenticated encryption. + * While it provides some protection against eavesdropping, it does NOT + * provide any security against active attacks. + * Unless you know what you're doing, what you are looking for is probably + * the crypto_box functions. + */ + +#include +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_stream_xchacha20_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_stream_xchacha20_keybytes(void); + +#define crypto_stream_xchacha20_NONCEBYTES 24U +SODIUM_EXPORT +size_t crypto_stream_xchacha20_noncebytes(void); + +#define crypto_stream_xchacha20_MESSAGEBYTES_MAX SODIUM_SIZE_MAX +SODIUM_EXPORT +size_t crypto_stream_xchacha20_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_stream_xchacha20(unsigned char *c, unsigned long long clen, + const unsigned char *n, const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_xchacha20_xor(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_xchacha20_xor_ic(unsigned char *c, const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, uint64_t ic, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_stream_xchacha20_keygen(unsigned char k[crypto_stream_xchacha20_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_stream_xsalsa20.h b/deps/sodium/include/sodium/crypto_stream_xsalsa20.h new file mode 100644 index 00000000..20034e34 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_stream_xsalsa20.h @@ -0,0 +1,61 @@ +#ifndef crypto_stream_xsalsa20_H +#define crypto_stream_xsalsa20_H + +/* + * WARNING: This is just a stream cipher. It is NOT authenticated encryption. + * While it provides some protection against eavesdropping, it does NOT + * provide any security against active attacks. + * Unless you know what you're doing, what you are looking for is probably + * the crypto_box functions. + */ + +#include +#include +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_stream_xsalsa20_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_stream_xsalsa20_keybytes(void); + +#define crypto_stream_xsalsa20_NONCEBYTES 24U +SODIUM_EXPORT +size_t crypto_stream_xsalsa20_noncebytes(void); + +#define crypto_stream_xsalsa20_MESSAGEBYTES_MAX SODIUM_SIZE_MAX +SODIUM_EXPORT +size_t crypto_stream_xsalsa20_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_stream_xsalsa20(unsigned char *c, unsigned long long clen, + const unsigned char *n, const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_xsalsa20_xor(unsigned char *c, const unsigned char *m, + unsigned long long mlen, const unsigned char *n, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_stream_xsalsa20_xor_ic(unsigned char *c, const unsigned char *m, + unsigned long long mlen, + const unsigned char *n, uint64_t ic, + const unsigned char *k) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void crypto_stream_xsalsa20_keygen(unsigned char k[crypto_stream_xsalsa20_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_verify_16.h b/deps/sodium/include/sodium/crypto_verify_16.h new file mode 100644 index 00000000..7b9c8077 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_verify_16.h @@ -0,0 +1,23 @@ +#ifndef crypto_verify_16_H +#define crypto_verify_16_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_verify_16_BYTES 16U +SODIUM_EXPORT +size_t crypto_verify_16_bytes(void); + +SODIUM_EXPORT +int crypto_verify_16(const unsigned char *x, const unsigned char *y) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_verify_32.h b/deps/sodium/include/sodium/crypto_verify_32.h new file mode 100644 index 00000000..9b0f4529 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_verify_32.h @@ -0,0 +1,23 @@ +#ifndef crypto_verify_32_H +#define crypto_verify_32_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_verify_32_BYTES 32U +SODIUM_EXPORT +size_t crypto_verify_32_bytes(void); + +SODIUM_EXPORT +int crypto_verify_32(const unsigned char *x, const unsigned char *y) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/crypto_verify_64.h b/deps/sodium/include/sodium/crypto_verify_64.h new file mode 100644 index 00000000..c83b7302 --- /dev/null +++ b/deps/sodium/include/sodium/crypto_verify_64.h @@ -0,0 +1,23 @@ +#ifndef crypto_verify_64_H +#define crypto_verify_64_H + +#include +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define crypto_verify_64_BYTES 64U +SODIUM_EXPORT +size_t crypto_verify_64_bytes(void); + +SODIUM_EXPORT +int crypto_verify_64(const unsigned char *x, const unsigned char *y) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/export.h b/deps/sodium/include/sodium/export.h new file mode 100644 index 00000000..a0074fc9 --- /dev/null +++ b/deps/sodium/include/sodium/export.h @@ -0,0 +1,57 @@ + +#ifndef sodium_export_H +#define sodium_export_H + +#include +#include +#include + +#if !defined(__clang__) && !defined(__GNUC__) +# ifdef __attribute__ +# undef __attribute__ +# endif +# define __attribute__(a) +#endif + +#ifdef SODIUM_STATIC +# define SODIUM_EXPORT +# define SODIUM_EXPORT_WEAK +#else +# if defined(_MSC_VER) +# ifdef SODIUM_DLL_EXPORT +# define SODIUM_EXPORT __declspec(dllexport) +# else +# define SODIUM_EXPORT __declspec(dllimport) +# endif +# else +# if defined(__SUNPRO_C) +# ifndef __GNU_C__ +# define SODIUM_EXPORT __attribute__ (visibility(__global)) +# else +# define SODIUM_EXPORT __attribute__ __global +# endif +# elif defined(_MSG_VER) +# define SODIUM_EXPORT extern __declspec(dllexport) +# else +# define SODIUM_EXPORT __attribute__ ((visibility ("default"))) +# endif +# endif +# if defined(__ELF__) && !defined(SODIUM_DISABLE_WEAK_FUNCTIONS) +# define SODIUM_EXPORT_WEAK SODIUM_EXPORT __attribute__((weak)) +# else +# define SODIUM_EXPORT_WEAK SODIUM_EXPORT +# endif +#endif + +#ifndef CRYPTO_ALIGN +# if defined(__INTEL_COMPILER) || defined(_MSC_VER) +# define CRYPTO_ALIGN(x) __declspec(align(x)) +# else +# define CRYPTO_ALIGN(x) __attribute__ ((aligned(x))) +# endif +#endif + +#define SODIUM_MIN(A, B) ((A) < (B) ? (A) : (B)) +#define SODIUM_SIZE_MAX SODIUM_MIN(UINT64_MAX, SIZE_MAX) + +#endif diff --git a/deps/sodium/include/sodium/randombytes.h b/deps/sodium/include/sodium/randombytes.h new file mode 100644 index 00000000..a03cc657 --- /dev/null +++ b/deps/sodium/include/sodium/randombytes.h @@ -0,0 +1,72 @@ + +#ifndef randombytes_H +#define randombytes_H + +#include +#include + +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +typedef struct randombytes_implementation { + const char *(*implementation_name)(void); /* required */ + uint32_t (*random)(void); /* required */ + void (*stir)(void); /* optional */ + uint32_t (*uniform)(const uint32_t upper_bound); /* optional, a default implementation will be used if NULL */ + void (*buf)(void * const buf, const size_t size); /* required */ + int (*close)(void); /* optional */ +} randombytes_implementation; + +#define randombytes_BYTES_MAX SODIUM_MIN(SODIUM_SIZE_MAX, 0xffffffffUL) + +#define randombytes_SEEDBYTES 32U +SODIUM_EXPORT +size_t randombytes_seedbytes(void); + +SODIUM_EXPORT +void randombytes_buf(void * const buf, const size_t size) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +void randombytes_buf_deterministic(void * const buf, const size_t size, + const unsigned char seed[randombytes_SEEDBYTES]) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +uint32_t randombytes_random(void); + +SODIUM_EXPORT +uint32_t randombytes_uniform(const uint32_t upper_bound); + +SODIUM_EXPORT +void randombytes_stir(void); + +SODIUM_EXPORT +int randombytes_close(void); + +SODIUM_EXPORT +int randombytes_set_implementation(randombytes_implementation *impl) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +const char *randombytes_implementation_name(void); + +/* -- NaCl compatibility interface -- */ + +SODIUM_EXPORT +void randombytes(unsigned char * const buf, const unsigned long long buf_len) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/randombytes_internal_random.h b/deps/sodium/include/sodium/randombytes_internal_random.h new file mode 100644 index 00000000..2b2b7d6e --- /dev/null +++ b/deps/sodium/include/sodium/randombytes_internal_random.h @@ -0,0 +1,22 @@ + +#ifndef randombytes_internal_random_H +#define randombytes_internal_random_H + +#include "export.h" +#include "randombytes.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SODIUM_EXPORT +extern struct randombytes_implementation randombytes_internal_implementation; + +/* Backwards compatibility with libsodium < 1.0.18 */ +#define randombytes_salsa20_implementation randombytes_internal_implementation + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/randombytes_sysrandom.h b/deps/sodium/include/sodium/randombytes_sysrandom.h new file mode 100644 index 00000000..9e27b674 --- /dev/null +++ b/deps/sodium/include/sodium/randombytes_sysrandom.h @@ -0,0 +1,19 @@ + +#ifndef randombytes_sysrandom_H +#define randombytes_sysrandom_H + +#include "export.h" +#include "randombytes.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SODIUM_EXPORT +extern struct randombytes_implementation randombytes_sysrandom_implementation; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/runtime.h b/deps/sodium/include/sodium/runtime.h new file mode 100644 index 00000000..7f15d58e --- /dev/null +++ b/deps/sodium/include/sodium/runtime.h @@ -0,0 +1,52 @@ + +#ifndef sodium_runtime_H +#define sodium_runtime_H + +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_neon(void); + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_sse2(void); + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_sse3(void); + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_ssse3(void); + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_sse41(void); + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_avx(void); + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_avx2(void); + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_avx512f(void); + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_pclmul(void); + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_aesni(void); + +SODIUM_EXPORT_WEAK +int sodium_runtime_has_rdrand(void); + +/* ------------------------------------------------------------------------- */ + +int _sodium_runtime_get_cpu_features(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/utils.h b/deps/sodium/include/sodium/utils.h new file mode 100644 index 00000000..ac801512 --- /dev/null +++ b/deps/sodium/include/sodium/utils.h @@ -0,0 +1,179 @@ + +#ifndef sodium_utils_H +#define sodium_utils_H + +#include + +#include "export.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef SODIUM_C99 +# if defined(__cplusplus) || !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L +# define SODIUM_C99(X) +# else +# define SODIUM_C99(X) X +# endif +#endif + +SODIUM_EXPORT +void sodium_memzero(void * const pnt, const size_t len); + +SODIUM_EXPORT +void sodium_stackzero(const size_t len); + +/* + * WARNING: sodium_memcmp() must be used to verify if two secret keys + * are equal, in constant time. + * It returns 0 if the keys are equal, and -1 if they differ. + * This function is not designed for lexicographical comparisons. + */ +SODIUM_EXPORT +int sodium_memcmp(const void * const b1_, const void * const b2_, size_t len) + __attribute__ ((warn_unused_result)); + +/* + * sodium_compare() returns -1 if b1_ < b2_, 1 if b1_ > b2_ and 0 if b1_ == b2_ + * It is suitable for lexicographical comparisons, or to compare nonces + * and counters stored in little-endian format. + * However, it is slower than sodium_memcmp(). + */ +SODIUM_EXPORT +int sodium_compare(const unsigned char *b1_, const unsigned char *b2_, + size_t len) __attribute__ ((warn_unused_result)); + +SODIUM_EXPORT +int sodium_is_zero(const unsigned char *n, const size_t nlen); + +SODIUM_EXPORT +void sodium_increment(unsigned char *n, const size_t nlen); + +SODIUM_EXPORT +void sodium_add(unsigned char *a, const unsigned char *b, const size_t len); + +SODIUM_EXPORT +void sodium_sub(unsigned char *a, const unsigned char *b, const size_t len); + +SODIUM_EXPORT +char *sodium_bin2hex(char * const hex, const size_t hex_maxlen, + const unsigned char * const bin, const size_t bin_len) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int sodium_hex2bin(unsigned char * const bin, const size_t bin_maxlen, + const char * const hex, const size_t hex_len, + const char * const ignore, size_t * const bin_len, + const char ** const hex_end) + __attribute__ ((nonnull(1))); + +#define sodium_base64_VARIANT_ORIGINAL 1 +#define sodium_base64_VARIANT_ORIGINAL_NO_PADDING 3 +#define sodium_base64_VARIANT_URLSAFE 5 +#define sodium_base64_VARIANT_URLSAFE_NO_PADDING 7 + +/* + * Computes the required length to encode BIN_LEN bytes as a base64 string + * using the given variant. The computed length includes a trailing \0. + */ +#define sodium_base64_ENCODED_LEN(BIN_LEN, VARIANT) \ + (((BIN_LEN) / 3U) * 4U + \ + ((((BIN_LEN) - ((BIN_LEN) / 3U) * 3U) | (((BIN_LEN) - ((BIN_LEN) / 3U) * 3U) >> 1)) & 1U) * \ + (4U - (~((((VARIANT) & 2U) >> 1) - 1U) & (3U - ((BIN_LEN) - ((BIN_LEN) / 3U) * 3U)))) + 1U) + +SODIUM_EXPORT +size_t sodium_base64_encoded_len(const size_t bin_len, const int variant); + +SODIUM_EXPORT +char *sodium_bin2base64(char * const b64, const size_t b64_maxlen, + const unsigned char * const bin, const size_t bin_len, + const int variant) __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int sodium_base642bin(unsigned char * const bin, const size_t bin_maxlen, + const char * const b64, const size_t b64_len, + const char * const ignore, size_t * const bin_len, + const char ** const b64_end, const int variant) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int sodium_mlock(void * const addr, const size_t len) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int sodium_munlock(void * const addr, const size_t len) + __attribute__ ((nonnull)); + +/* WARNING: sodium_malloc() and sodium_allocarray() are not general-purpose + * allocation functions. + * + * They return a pointer to a region filled with 0xd0 bytes, immediately + * followed by a guard page. + * As a result, accessing a single byte after the requested allocation size + * will intentionally trigger a segmentation fault. + * + * A canary and an additional guard page placed before the beginning of the + * region may also kill the process if a buffer underflow is detected. + * + * The memory layout is: + * [unprotected region size (read only)][guard page (no access)][unprotected pages (read/write)][guard page (no access)] + * With the layout of the unprotected pages being: + * [optional padding][16-bytes canary][user region] + * + * However: + * - These functions are significantly slower than standard functions + * - Each allocation requires 3 or 4 additional pages + * - The returned address will not be aligned if the allocation size is not + * a multiple of the required alignment. For this reason, these functions + * are designed to store data, such as secret keys and messages. + * + * sodium_malloc() can be used to allocate any libsodium data structure. + * + * The crypto_generichash_state structure is packed and its length is + * either 357 or 361 bytes. For this reason, when using sodium_malloc() to + * allocate a crypto_generichash_state structure, padding must be added in + * order to ensure proper alignment. crypto_generichash_statebytes() + * returns the rounded up structure size, and should be prefered to sizeof(): + * state = sodium_malloc(crypto_generichash_statebytes()); + */ + +SODIUM_EXPORT +void *sodium_malloc(const size_t size) + __attribute__ ((malloc)); + +SODIUM_EXPORT +void *sodium_allocarray(size_t count, size_t size) + __attribute__ ((malloc)); + +SODIUM_EXPORT +void sodium_free(void *ptr); + +SODIUM_EXPORT +int sodium_mprotect_noaccess(void *ptr) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int sodium_mprotect_readonly(void *ptr) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int sodium_mprotect_readwrite(void *ptr) __attribute__ ((nonnull)); + +SODIUM_EXPORT +int sodium_pad(size_t *padded_buflen_p, unsigned char *buf, + size_t unpadded_buflen, size_t blocksize, size_t max_buflen) + __attribute__ ((nonnull(2))); + +SODIUM_EXPORT +int sodium_unpad(size_t *unpadded_buflen_p, const unsigned char *buf, + size_t padded_buflen, size_t blocksize) + __attribute__ ((nonnull(2))); + +/* -------- */ + +int _sodium_alloc_init(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/include/sodium/version.h b/deps/sodium/include/sodium/version.h new file mode 100644 index 00000000..201a290e --- /dev/null +++ b/deps/sodium/include/sodium/version.h @@ -0,0 +1,33 @@ + +#ifndef sodium_version_H +#define sodium_version_H + +#include "export.h" + +#define SODIUM_VERSION_STRING "1.0.18" + +#define SODIUM_LIBRARY_VERSION_MAJOR 10 +#define SODIUM_LIBRARY_VERSION_MINOR 3 + + +#ifdef __cplusplus +extern "C" { +#endif + +SODIUM_EXPORT +const char *sodium_version_string(void); + +SODIUM_EXPORT +int sodium_library_version_major(void); + +SODIUM_EXPORT +int sodium_library_version_minor(void); + +SODIUM_EXPORT +int sodium_library_minimal(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/deps/sodium/lib/libsodium.a b/deps/sodium/lib/libsodium.a new file mode 100644 index 0000000000000000000000000000000000000000..06e496740c7f56460fb9f2cd54d156ee3dac89a2 GIT binary patch literal 1269272 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%0DP;1p91s+Lw^_n>12P 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%0Djr9FXPmCefFRo*_I;{Qaw~+_OO1drb7F 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

@+RLXw*zG~kT_-+DU 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%0D-FufhKXNcq2J@NIyU{~AEbUvBvS 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

-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 w@BmcmMM*OV literal 0 HcmV?d00001