From 9f4a227bb2c4b64a68e22604f4be37e6aad29a86 Mon Sep 17 00:00:00 2001 From: alex Date: Thu, 22 Aug 2024 12:21:14 +0300 Subject: [PATCH] ouih --- New folder/include/sodium.h | 75 ++++++++ New folder/include/sodium/core.h | 28 +++ .../include/sodium/crypto_aead_aegis128l.h | 92 +++++++++ .../include/sodium/crypto_aead_aegis256.h | 92 +++++++++ .../include/sodium/crypto_aead_aes256gcm.h | 179 +++++++++++++++++ .../sodium/crypto_aead_chacha20poly1305.h | 180 ++++++++++++++++++ .../sodium/crypto_aead_xchacha20poly1305.h | 100 ++++++++++ New folder/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 +++++++ New folder/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 | 122 ++++++++++++ New folder/include/sodium/crypto_hash.h | 40 ++++ .../include/sodium/crypto_hash_sha256.h | 60 ++++++ .../include/sodium/crypto_hash_sha512.h | 60 ++++++ New folder/include/sodium/crypto_kdf.h | 53 ++++++ .../include/sodium/crypto_kdf_blake2b.h | 44 +++++ .../include/sodium/crypto_kdf_hkdf_sha256.h | 74 +++++++ .../include/sodium/crypto_kdf_hkdf_sha512.h | 75 ++++++++ New folder/include/sodium/crypto_kx.h | 66 +++++++ .../include/sodium/crypto_onetimeauth.h | 65 +++++++ .../sodium/crypto_onetimeauth_poly1305.h | 72 +++++++ New folder/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 ++++++++++++ New folder/include/sodium/crypto_scalarmult.h | 46 +++++ .../sodium/crypto_scalarmult_curve25519.h | 42 ++++ .../sodium/crypto_scalarmult_ed25519.h | 51 +++++ .../sodium/crypto_scalarmult_ristretto255.h | 43 +++++ New folder/include/sodium/crypto_secretbox.h | 93 +++++++++ .../crypto_secretbox_xchacha20poly1305.h | 70 +++++++ .../crypto_secretbox_xsalsa20poly1305.h | 69 +++++++ .../crypto_secretstream_xchacha20poly1305.h | 108 +++++++++++ New folder/include/sodium/crypto_shorthash.h | 41 ++++ .../sodium/crypto_shorthash_siphash24.h | 50 +++++ New folder/include/sodium/crypto_sign.h | 107 +++++++++++ .../include/sodium/crypto_sign_ed25519.h | 124 ++++++++++++ .../crypto_sign_edwards25519sha512batch.h | 55 ++++++ New folder/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 ++++++ New folder/include/sodium/crypto_verify_16.h | 23 +++ New folder/include/sodium/crypto_verify_32.h | 23 +++ New folder/include/sodium/crypto_verify_64.h | 23 +++ New folder/include/sodium/export.h | 57 ++++++ New folder/include/sodium/randombytes.h | 72 +++++++ .../sodium/randombytes_internal_random.h | 22 +++ .../include/sodium/randombytes_sysrandom.h | 19 ++ New folder/include/sodium/runtime.h | 55 ++++++ New folder/include/sodium/utils.h | 179 +++++++++++++++++ New folder/include/sodium/version.h | 33 ++++ New folder/libsodium.lib | Bin 0 -> 185752 bytes tool3_2048/.vs/tool3/v16/.suo | Bin 49664 -> 54784 bytes tool3_2048/tool3/MainFrm.cpp | 91 ++++++++- tool3_2048/tool3/tool3.vcxproj | 2 +- tool3_2048/x64/Release/libsodium.dll | Bin 0 -> 346624 bytes tool3_2048/x64/Release/tool3.exe | Bin 311296 -> 317440 bytes 73 files changed, 5107 insertions(+), 6 deletions(-) create mode 100644 New folder/include/sodium.h create mode 100644 New folder/include/sodium/core.h create mode 100644 New folder/include/sodium/crypto_aead_aegis128l.h create mode 100644 New folder/include/sodium/crypto_aead_aegis256.h create mode 100644 New folder/include/sodium/crypto_aead_aes256gcm.h create mode 100644 New folder/include/sodium/crypto_aead_chacha20poly1305.h create mode 100644 New folder/include/sodium/crypto_aead_xchacha20poly1305.h create mode 100644 New folder/include/sodium/crypto_auth.h create mode 100644 New folder/include/sodium/crypto_auth_hmacsha256.h create mode 100644 New folder/include/sodium/crypto_auth_hmacsha512.h create mode 100644 New folder/include/sodium/crypto_auth_hmacsha512256.h create mode 100644 New folder/include/sodium/crypto_box.h create mode 100644 New folder/include/sodium/crypto_box_curve25519xchacha20poly1305.h create mode 100644 New folder/include/sodium/crypto_box_curve25519xsalsa20poly1305.h create mode 100644 New folder/include/sodium/crypto_core_ed25519.h create mode 100644 New folder/include/sodium/crypto_core_hchacha20.h create mode 100644 New folder/include/sodium/crypto_core_hsalsa20.h create mode 100644 New folder/include/sodium/crypto_core_ristretto255.h create mode 100644 New folder/include/sodium/crypto_core_salsa20.h create mode 100644 New folder/include/sodium/crypto_core_salsa2012.h create mode 100644 New folder/include/sodium/crypto_core_salsa208.h create mode 100644 New folder/include/sodium/crypto_generichash.h create mode 100644 New folder/include/sodium/crypto_generichash_blake2b.h create mode 100644 New folder/include/sodium/crypto_hash.h create mode 100644 New folder/include/sodium/crypto_hash_sha256.h create mode 100644 New folder/include/sodium/crypto_hash_sha512.h create mode 100644 New folder/include/sodium/crypto_kdf.h create mode 100644 New folder/include/sodium/crypto_kdf_blake2b.h create mode 100644 New folder/include/sodium/crypto_kdf_hkdf_sha256.h create mode 100644 New folder/include/sodium/crypto_kdf_hkdf_sha512.h create mode 100644 New folder/include/sodium/crypto_kx.h create mode 100644 New folder/include/sodium/crypto_onetimeauth.h create mode 100644 New folder/include/sodium/crypto_onetimeauth_poly1305.h create mode 100644 New folder/include/sodium/crypto_pwhash.h create mode 100644 New folder/include/sodium/crypto_pwhash_argon2i.h create mode 100644 New folder/include/sodium/crypto_pwhash_argon2id.h create mode 100644 New folder/include/sodium/crypto_pwhash_scryptsalsa208sha256.h create mode 100644 New folder/include/sodium/crypto_scalarmult.h create mode 100644 New folder/include/sodium/crypto_scalarmult_curve25519.h create mode 100644 New folder/include/sodium/crypto_scalarmult_ed25519.h create mode 100644 New folder/include/sodium/crypto_scalarmult_ristretto255.h create mode 100644 New folder/include/sodium/crypto_secretbox.h create mode 100644 New folder/include/sodium/crypto_secretbox_xchacha20poly1305.h create mode 100644 New folder/include/sodium/crypto_secretbox_xsalsa20poly1305.h create mode 100644 New folder/include/sodium/crypto_secretstream_xchacha20poly1305.h create mode 100644 New folder/include/sodium/crypto_shorthash.h create mode 100644 New folder/include/sodium/crypto_shorthash_siphash24.h create mode 100644 New folder/include/sodium/crypto_sign.h create mode 100644 New folder/include/sodium/crypto_sign_ed25519.h create mode 100644 New folder/include/sodium/crypto_sign_edwards25519sha512batch.h create mode 100644 New folder/include/sodium/crypto_stream.h create mode 100644 New folder/include/sodium/crypto_stream_chacha20.h create mode 100644 New folder/include/sodium/crypto_stream_salsa20.h create mode 100644 New folder/include/sodium/crypto_stream_salsa2012.h create mode 100644 New folder/include/sodium/crypto_stream_salsa208.h create mode 100644 New folder/include/sodium/crypto_stream_xchacha20.h create mode 100644 New folder/include/sodium/crypto_stream_xsalsa20.h create mode 100644 New folder/include/sodium/crypto_verify_16.h create mode 100644 New folder/include/sodium/crypto_verify_32.h create mode 100644 New folder/include/sodium/crypto_verify_64.h create mode 100644 New folder/include/sodium/export.h create mode 100644 New folder/include/sodium/randombytes.h create mode 100644 New folder/include/sodium/randombytes_internal_random.h create mode 100644 New folder/include/sodium/randombytes_sysrandom.h create mode 100644 New folder/include/sodium/runtime.h create mode 100644 New folder/include/sodium/utils.h create mode 100644 New folder/include/sodium/version.h create mode 100644 New folder/libsodium.lib create mode 100644 tool3_2048/x64/Release/libsodium.dll diff --git a/New folder/include/sodium.h b/New folder/include/sodium.h new file mode 100644 index 0000000..86b7a4d --- /dev/null +++ b/New folder/include/sodium.h @@ -0,0 +1,75 @@ + +#ifndef sodium_H +#define sodium_H + +#include "sodium/version.h" + +#include "sodium/core.h" +#include "sodium/crypto_aead_aegis128l.h" +#include "sodium/crypto_aead_aegis256.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_hchacha20.h" +#include "sodium/crypto_core_hsalsa20.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_hkdf_sha256.h" +#include "sodium/crypto_kdf_hkdf_sha512.h" +#include "sodium/crypto_kdf_blake2b.h" +#include "sodium/crypto_kdf_hkdf_sha256.h" +#include "sodium/crypto_kdf_hkdf_sha512.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_pwhash_scryptsalsa208sha256.h" +#include "sodium/crypto_scalarmult_ed25519.h" +#include "sodium/crypto_scalarmult_ristretto255.h" +#include "sodium/crypto_secretbox_xchacha20poly1305.h" +#include "sodium/crypto_stream_salsa2012.h" +#include "sodium/crypto_stream_salsa208.h" +#include "sodium/crypto_stream_xchacha20.h" +#endif + +#endif diff --git a/New folder/include/sodium/core.h b/New folder/include/sodium/core.h new file mode 100644 index 0000000..dd088d2 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_aead_aegis128l.h b/New folder/include/sodium/crypto_aead_aegis128l.h new file mode 100644 index 0000000..0ad019f --- /dev/null +++ b/New folder/include/sodium/crypto_aead_aegis128l.h @@ -0,0 +1,92 @@ +#ifndef crypto_aead_aegis128l_H +#define crypto_aead_aegis128l_H + +#include + +#include "export.h" + +#ifdef __cplusplus +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wlong-long" +#endif +extern "C" { +#endif + +#define crypto_aead_aegis128l_KEYBYTES 16U +SODIUM_EXPORT +size_t crypto_aead_aegis128l_keybytes(void); + +#define crypto_aead_aegis128l_NSECBYTES 0U +SODIUM_EXPORT +size_t crypto_aead_aegis128l_nsecbytes(void); + +#define crypto_aead_aegis128l_NPUBBYTES 16U +SODIUM_EXPORT +size_t crypto_aead_aegis128l_npubbytes(void); + +#define crypto_aead_aegis128l_ABYTES 32U +SODIUM_EXPORT +size_t crypto_aead_aegis128l_abytes(void); + +#define crypto_aead_aegis128l_MESSAGEBYTES_MAX \ + SODIUM_MIN(SODIUM_SIZE_MAX - crypto_aead_aegis128l_ABYTES, (1ULL << 61) - 1) +SODIUM_EXPORT +size_t crypto_aead_aegis128l_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_aead_aegis128l_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_aegis128l_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_aegis128l_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_aegis128l_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_aegis128l_keygen(unsigned char k[crypto_aead_aegis128l_KEYBYTES]) + __attribute__((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/New folder/include/sodium/crypto_aead_aegis256.h b/New folder/include/sodium/crypto_aead_aegis256.h new file mode 100644 index 0000000..26bd18a --- /dev/null +++ b/New folder/include/sodium/crypto_aead_aegis256.h @@ -0,0 +1,92 @@ +#ifndef crypto_aead_aegis256_H +#define crypto_aead_aegis256_H + +#include + +#include "export.h" + +#ifdef __cplusplus +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wlong-long" +#endif +extern "C" { +#endif + +#define crypto_aead_aegis256_KEYBYTES 32U +SODIUM_EXPORT +size_t crypto_aead_aegis256_keybytes(void); + +#define crypto_aead_aegis256_NSECBYTES 0U +SODIUM_EXPORT +size_t crypto_aead_aegis256_nsecbytes(void); + +#define crypto_aead_aegis256_NPUBBYTES 32U +SODIUM_EXPORT +size_t crypto_aead_aegis256_npubbytes(void); + +#define crypto_aead_aegis256_ABYTES 32U +SODIUM_EXPORT +size_t crypto_aead_aegis256_abytes(void); + +#define crypto_aead_aegis256_MESSAGEBYTES_MAX \ + SODIUM_MIN(SODIUM_SIZE_MAX - crypto_aead_aegis256_ABYTES, (1ULL << 61) - 1) +SODIUM_EXPORT +size_t crypto_aead_aegis256_messagebytes_max(void); + +SODIUM_EXPORT +int crypto_aead_aegis256_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_aegis256_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_aegis256_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_aegis256_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_aegis256_keygen(unsigned char k[crypto_aead_aegis256_KEYBYTES]) + __attribute__((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/New folder/include/sodium/crypto_aead_aes256gcm.h b/New folder/include/sodium/crypto_aead_aes256gcm.h new file mode 100644 index 0000000..9baeb3f --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_aead_chacha20poly1305.h b/New folder/include/sodium/crypto_aead_chacha20poly1305.h new file mode 100644 index 0000000..5d671df --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_aead_xchacha20poly1305.h b/New folder/include/sodium/crypto_aead_xchacha20poly1305.h new file mode 100644 index 0000000..6643b0c --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_auth.h b/New folder/include/sodium/crypto_auth.h new file mode 100644 index 0000000..540aee0 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_auth_hmacsha256.h b/New folder/include/sodium/crypto_auth_hmacsha256.h new file mode 100644 index 0000000..3da864c --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_auth_hmacsha512.h b/New folder/include/sodium/crypto_auth_hmacsha512.h new file mode 100644 index 0000000..d992cb8 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_auth_hmacsha512256.h b/New folder/include/sodium/crypto_auth_hmacsha512256.h new file mode 100644 index 0000000..3fb5263 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_box.h b/New folder/include/sodium/crypto_box.h new file mode 100644 index 0000000..e060dd2 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_box_curve25519xchacha20poly1305.h b/New folder/include/sodium/crypto_box_curve25519xchacha20poly1305.h new file mode 100644 index 0000000..26a3d31 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_box_curve25519xsalsa20poly1305.h b/New folder/include/sodium/crypto_box_curve25519xsalsa20poly1305.h new file mode 100644 index 0000000..e733f49 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_core_ed25519.h b/New folder/include/sodium/crypto_core_ed25519.h new file mode 100644 index 0000000..dcc46a6 --- /dev/null +++ b/New folder/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)) __attribute__ ((deprecated)); + +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/New folder/include/sodium/crypto_core_hchacha20.h b/New folder/include/sodium/crypto_core_hchacha20.h new file mode 100644 index 0000000..ece141b --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_core_hsalsa20.h b/New folder/include/sodium/crypto_core_hsalsa20.h new file mode 100644 index 0000000..4bf7a48 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_core_ristretto255.h b/New folder/include/sodium/crypto_core_ristretto255.h new file mode 100644 index 0000000..f2820e5 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_core_salsa20.h b/New folder/include/sodium/crypto_core_salsa20.h new file mode 100644 index 0000000..bd79fd9 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_core_salsa2012.h b/New folder/include/sodium/crypto_core_salsa2012.h new file mode 100644 index 0000000..0595759 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_core_salsa208.h b/New folder/include/sodium/crypto_core_salsa208.h new file mode 100644 index 0000000..d2f216a --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_generichash.h b/New folder/include/sodium/crypto_generichash.h new file mode 100644 index 0000000..d897e5d --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_generichash_blake2b.h b/New folder/include/sodium/crypto_generichash_blake2b.h new file mode 100644 index 0000000..ae3b52f --- /dev/null +++ b/New folder/include/sodium/crypto_generichash_blake2b.h @@ -0,0 +1,122 @@ +#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 + +#ifdef __IBMC__ +# pragma pack(1) +#elif 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; + +#ifdef __IBMC__ +# pragma pack(pop) +#elif 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/New folder/include/sodium/crypto_hash.h b/New folder/include/sodium/crypto_hash.h new file mode 100644 index 0000000..767d548 --- /dev/null +++ b/New folder/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 interoperability, + * 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/New folder/include/sodium/crypto_hash_sha256.h b/New folder/include/sodium/crypto_hash_sha256.h new file mode 100644 index 0000000..c47982a --- /dev/null +++ b/New folder/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 interoperability, + * 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/New folder/include/sodium/crypto_hash_sha512.h b/New folder/include/sodium/crypto_hash_sha512.h new file mode 100644 index 0000000..5b690fb --- /dev/null +++ b/New folder/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 interoperability, + * 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/New folder/include/sodium/crypto_kdf.h b/New folder/include/sodium/crypto_kdf.h new file mode 100644 index 0000000..ac2fc61 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_kdf_blake2b.h b/New folder/include/sodium/crypto_kdf_blake2b.h new file mode 100644 index 0000000..489c7c2 --- /dev/null +++ b/New folder/include/sodium/crypto_kdf_blake2b.h @@ -0,0 +1,44 @@ +#ifndef crypto_kdf_blake2b_H +#define crypto_kdf_blake2b_H + +#include +#include +#include + +#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/New folder/include/sodium/crypto_kdf_hkdf_sha256.h b/New folder/include/sodium/crypto_kdf_hkdf_sha256.h new file mode 100644 index 0000000..e7e7f4d --- /dev/null +++ b/New folder/include/sodium/crypto_kdf_hkdf_sha256.h @@ -0,0 +1,74 @@ +#ifndef crypto_kdf_hkdf_sha256_H +#define crypto_kdf_hkdf_sha256_H + +#include +#include +#include + +#include "crypto_kdf.h" +#include "crypto_auth_hmacsha256.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_kdf_hkdf_sha256_KEYBYTES crypto_auth_hmacsha256_BYTES +SODIUM_EXPORT +size_t crypto_kdf_hkdf_sha256_keybytes(void); + +#define crypto_kdf_hkdf_sha256_BYTES_MIN 0U +SODIUM_EXPORT +size_t crypto_kdf_hkdf_sha256_bytes_min(void); + +#define crypto_kdf_hkdf_sha256_BYTES_MAX (0xff * crypto_auth_hmacsha256_BYTES) +SODIUM_EXPORT +size_t crypto_kdf_hkdf_sha256_bytes_max(void); + +SODIUM_EXPORT +int crypto_kdf_hkdf_sha256_extract(unsigned char prk[crypto_kdf_hkdf_sha256_KEYBYTES], + const unsigned char *salt, size_t salt_len, + const unsigned char *ikm, size_t ikm_len) + __attribute__ ((nonnull(4))); + +SODIUM_EXPORT +void crypto_kdf_hkdf_sha256_keygen(unsigned char prk[crypto_kdf_hkdf_sha256_KEYBYTES]); + +SODIUM_EXPORT +int crypto_kdf_hkdf_sha256_expand(unsigned char *out, size_t out_len, + const char *ctx, size_t ctx_len, + const unsigned char prk[crypto_kdf_hkdf_sha256_KEYBYTES]) + __attribute__ ((nonnull(1))); + +/* ------------------------------------------------------------------------- */ + +typedef struct crypto_kdf_hkdf_sha256_state { + crypto_auth_hmacsha256_state st; +} crypto_kdf_hkdf_sha256_state; + +SODIUM_EXPORT +size_t crypto_kdf_hkdf_sha256_statebytes(void); + +SODIUM_EXPORT +int crypto_kdf_hkdf_sha256_extract_init(crypto_kdf_hkdf_sha256_state *state, + const unsigned char *salt, size_t salt_len) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_kdf_hkdf_sha256_extract_update(crypto_kdf_hkdf_sha256_state *state, + const unsigned char *ikm, size_t ikm_len) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_kdf_hkdf_sha256_extract_final(crypto_kdf_hkdf_sha256_state *state, + unsigned char prk[crypto_kdf_hkdf_sha256_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/New folder/include/sodium/crypto_kdf_hkdf_sha512.h b/New folder/include/sodium/crypto_kdf_hkdf_sha512.h new file mode 100644 index 0000000..0ed205d --- /dev/null +++ b/New folder/include/sodium/crypto_kdf_hkdf_sha512.h @@ -0,0 +1,75 @@ +#ifndef crypto_kdf_hkdf_sha512_H +#define crypto_kdf_hkdf_sha512_H + +#include +#include +#include + +#include "crypto_kdf.h" +#include "crypto_auth_hmacsha512.h" +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +#define crypto_kdf_hkdf_sha512_KEYBYTES crypto_auth_hmacsha512_BYTES +SODIUM_EXPORT +size_t crypto_kdf_hkdf_sha512_keybytes(void); + +#define crypto_kdf_hkdf_sha512_BYTES_MIN 0U +SODIUM_EXPORT +size_t crypto_kdf_hkdf_sha512_bytes_min(void); + +#define crypto_kdf_hkdf_sha512_BYTES_MAX (0xff * crypto_auth_hmacsha512_BYTES) +SODIUM_EXPORT +size_t crypto_kdf_hkdf_sha512_bytes_max(void); + +SODIUM_EXPORT +int crypto_kdf_hkdf_sha512_extract(unsigned char prk[crypto_kdf_hkdf_sha512_KEYBYTES], + const unsigned char *salt, size_t salt_len, + const unsigned char *ikm, size_t ikm_len) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +void crypto_kdf_hkdf_sha512_keygen(unsigned char prk[crypto_kdf_hkdf_sha512_KEYBYTES]) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_kdf_hkdf_sha512_expand(unsigned char *out, size_t out_len, + const char *ctx, size_t ctx_len, + const unsigned char prk[crypto_kdf_hkdf_sha512_KEYBYTES]) + __attribute__ ((nonnull(1))); + +/* ------------------------------------------------------------------------- */ + +typedef struct crypto_kdf_hkdf_sha512_state { + crypto_auth_hmacsha512_state st; +} crypto_kdf_hkdf_sha512_state; + +SODIUM_EXPORT +size_t crypto_kdf_hkdf_sha512_statebytes(void); + +SODIUM_EXPORT +int crypto_kdf_hkdf_sha512_extract_init(crypto_kdf_hkdf_sha512_state *state, + const unsigned char *salt, size_t salt_len) + __attribute__ ((nonnull(1))); + +SODIUM_EXPORT +int crypto_kdf_hkdf_sha512_extract_update(crypto_kdf_hkdf_sha512_state *state, + const unsigned char *ikm, size_t ikm_len) + __attribute__ ((nonnull)); + +SODIUM_EXPORT +int crypto_kdf_hkdf_sha512_extract_final(crypto_kdf_hkdf_sha512_state *state, + unsigned char prk[crypto_kdf_hkdf_sha512_KEYBYTES]) + __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/New folder/include/sodium/crypto_kx.h b/New folder/include/sodium/crypto_kx.h new file mode 100644 index 0000000..347132c --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_onetimeauth.h b/New folder/include/sodium/crypto_onetimeauth.h new file mode 100644 index 0000000..7cd7b07 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_onetimeauth_poly1305.h b/New folder/include/sodium/crypto_onetimeauth_poly1305.h new file mode 100644 index 0000000..1565d37 --- /dev/null +++ b/New folder/include/sodium/crypto_onetimeauth_poly1305.h @@ -0,0 +1,72 @@ +#ifndef crypto_onetimeauth_poly1305_H +#define crypto_onetimeauth_poly1305_H + +#include +#include +#include + +#include + +#include "export.h" + +#ifdef __cplusplus +# ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wlong-long" +# endif +extern "C" { +#endif + +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/New folder/include/sodium/crypto_pwhash.h b/New folder/include/sodium/crypto_pwhash.h new file mode 100644 index 0000000..9683192 --- /dev/null +++ b/New folder/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, + 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, + unsigned long long opslimit, size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#define crypto_pwhash_PRIMITIVE "argon2id,argon2i" +SODIUM_EXPORT +const char *crypto_pwhash_primitive(void) + __attribute__ ((warn_unused_result)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/New folder/include/sodium/crypto_pwhash_argon2i.h b/New folder/include/sodium/crypto_pwhash_argon2i.h new file mode 100644 index 0000000..63abdf4 --- /dev/null +++ b/New folder/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, + 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, + unsigned long long opslimit, size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/New folder/include/sodium/crypto_pwhash_argon2id.h b/New folder/include/sodium/crypto_pwhash_argon2id.h new file mode 100644 index 0000000..98bc83e --- /dev/null +++ b/New folder/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, + 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, + unsigned long long opslimit, size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/New folder/include/sodium/crypto_pwhash_scryptsalsa208sha256.h b/New folder/include/sodium/crypto_pwhash_scryptsalsa208sha256.h new file mode 100644 index 0000000..8956dfb --- /dev/null +++ b/New folder/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, + 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, + unsigned long long opslimit, + size_t memlimit) + __attribute__ ((warn_unused_result)) __attribute__ ((nonnull)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/New folder/include/sodium/crypto_scalarmult.h b/New folder/include/sodium/crypto_scalarmult.h new file mode 100644 index 0000000..1c68585 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_scalarmult_curve25519.h b/New folder/include/sodium/crypto_scalarmult_curve25519.h new file mode 100644 index 0000000..60e9d0c --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_scalarmult_ed25519.h b/New folder/include/sodium/crypto_scalarmult_ed25519.h new file mode 100644 index 0000000..2dfa4d7 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_scalarmult_ristretto255.h b/New folder/include/sodium/crypto_scalarmult_ristretto255.h new file mode 100644 index 0000000..40a45cc --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_secretbox.h b/New folder/include/sodium/crypto_secretbox.h new file mode 100644 index 0000000..1d3709d --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_secretbox_xchacha20poly1305.h b/New folder/include/sodium/crypto_secretbox_xchacha20poly1305.h new file mode 100644 index 0000000..6ec674e --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_secretbox_xsalsa20poly1305.h b/New folder/include/sodium/crypto_secretbox_xsalsa20poly1305.h new file mode 100644 index 0000000..be0874c --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_secretstream_xchacha20poly1305.h b/New folder/include/sodium/crypto_secretstream_xchacha20poly1305.h new file mode 100644 index 0000000..b22e4e9 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_shorthash.h b/New folder/include/sodium/crypto_shorthash.h new file mode 100644 index 0000000..fecaa88 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_shorthash_siphash24.h b/New folder/include/sodium/crypto_shorthash_siphash24.h new file mode 100644 index 0000000..1e6f72a --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_sign.h b/New folder/include/sodium/crypto_sign.h new file mode 100644 index 0000000..f5fafb1 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_sign_ed25519.h b/New folder/include/sodium/crypto_sign_ed25519.h new file mode 100644 index 0000000..0fdac42 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_sign_edwards25519sha512batch.h b/New folder/include/sodium/crypto_sign_edwards25519sha512batch.h new file mode 100644 index 0000000..eed158a --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_stream.h b/New folder/include/sodium/crypto_stream.h new file mode 100644 index 0000000..88dab5f --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_stream_chacha20.h b/New folder/include/sodium/crypto_stream_chacha20.h new file mode 100644 index 0000000..4088975 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_stream_salsa20.h b/New folder/include/sodium/crypto_stream_salsa20.h new file mode 100644 index 0000000..45b3b3e --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_stream_salsa2012.h b/New folder/include/sodium/crypto_stream_salsa2012.h new file mode 100644 index 0000000..6c5d303 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_stream_salsa208.h b/New folder/include/sodium/crypto_stream_salsa208.h new file mode 100644 index 0000000..d574f30 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_stream_xchacha20.h b/New folder/include/sodium/crypto_stream_xchacha20.h new file mode 100644 index 0000000..c4002db --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_stream_xsalsa20.h b/New folder/include/sodium/crypto_stream_xsalsa20.h new file mode 100644 index 0000000..20034e3 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_verify_16.h b/New folder/include/sodium/crypto_verify_16.h new file mode 100644 index 0000000..7b9c807 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_verify_32.h b/New folder/include/sodium/crypto_verify_32.h new file mode 100644 index 0000000..9b0f452 --- /dev/null +++ b/New folder/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/New folder/include/sodium/crypto_verify_64.h b/New folder/include/sodium/crypto_verify_64.h new file mode 100644 index 0000000..c83b730 --- /dev/null +++ b/New folder/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/New folder/include/sodium/export.h b/New folder/include/sodium/export.h new file mode 100644 index 0000000..a0074fc --- /dev/null +++ b/New folder/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/New folder/include/sodium/randombytes.h b/New folder/include/sodium/randombytes.h new file mode 100644 index 0000000..c83a4df --- /dev/null +++ b/New folder/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(const 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/New folder/include/sodium/randombytes_internal_random.h b/New folder/include/sodium/randombytes_internal_random.h new file mode 100644 index 0000000..2b2b7d6 --- /dev/null +++ b/New folder/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/New folder/include/sodium/randombytes_sysrandom.h b/New folder/include/sodium/randombytes_sysrandom.h new file mode 100644 index 0000000..9e27b67 --- /dev/null +++ b/New folder/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/New folder/include/sodium/runtime.h b/New folder/include/sodium/runtime.h new file mode 100644 index 0000000..c1cec85 --- /dev/null +++ b/New folder/include/sodium/runtime.h @@ -0,0 +1,55 @@ + +#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_armcrypto(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/New folder/include/sodium/utils.h b/New folder/include/sodium/utils.h new file mode 100644 index 0000000..f9b3697 --- /dev/null +++ b/New folder/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 preferred 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/New folder/include/sodium/version.h b/New folder/include/sodium/version.h new file mode 100644 index 0000000..e07ae90 --- /dev/null +++ b/New folder/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.20" + +#define SODIUM_LIBRARY_VERSION_MAJOR 26 +#define SODIUM_LIBRARY_VERSION_MINOR 2 + + +#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/New folder/libsodium.lib b/New folder/libsodium.lib new file mode 100644 index 0000000000000000000000000000000000000000..618550a3f60ec32bb7df63c2bf398b860e5736a7 GIT binary patch literal 185752 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 TV25c!lG-1{noQe=uKEI_v)XJ&g2{4f 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 literal 0 HcmV?d00001 diff --git a/tool3_2048/.vs/tool3/v16/.suo b/tool3_2048/.vs/tool3/v16/.suo index 8f5dc5064c805b3648a118af57d786f91f32386a..c825ce36498098cb95c9dea87b8a9454f4836991 100644 GIT binary patch literal 54784 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 delta 4093 zcmd^CeN0=|6@T~n*%;z51Lh-%A%>ESltBDNc&03vU>e+*7_iMk>jp3%YZC|w!QrdJ zk2Z}WH8jL$Qd>0;FfD7EqyZe!OEG*~E(Wf+E?EY4h^t1WP*R3;RKiUPQQojz zA&Y)8RH0cmaB3YIHY2o%RiR2HzE_0g)X+O0-;W{SCYQCY42A8X3hKs!ayeoLq9SCk zf@1O7)bFCU67dwmiFg`Oi=e$~mgn${mu-nPUW=Fi9fOdDbuo9t~Aw z<9j0_2a$`|giynbGyw#TOXN|bU1=!@$tBCHl!7XngAPt1rXjJSF#!sr<)jv+WU?~& z{30MpM(#Ma0#nk)m2`Q-sGLNMKwNx+;!Tvs5kE%IS_*h0X+#`Uj#nm&|9~}@VN`63 zzJb!e5c8-Nd1W2sEpW>`WDFK$o?v?hx>xp!N3n?%ZY6GeIDX|pzw!tAUAG-fBDMHB z&f*Hh6>I}F%R$9-Ca4N{MCLtmoi=4k(Lu;ga3^}i-^YFm|E*O~>{QvW31>tV`X{nh z{0fDu2rMx3bSfyP8|7t|-ans7SMK@C=X1CFULW2DgQ`YS01GM)+)P)(V0z;Ux{EZC zuz+VS9sc^^6pYN7SPPCaW(4&)84*J|yM~NI@oA4fyaoU5P4kPkp~nIA@oyzYcA!Tq zsKY#$4AO)$P{b>g^t48voL%8objOA06zLDp@C*V*64Wx<{~#)z)Nmys6NgAqMmnML zw>*oy^}udvC$)a}mL)=}!EN*q2P~v5NhsaTiD7YV4=Dt<%5(Q75Z=E~;vvKb?owPT z&p}tl=OhN)k9bHlEZ|cN?#vg6-hbL)P-Q?03p5Fjl@Ahf&+-XmEMXyHK8 zqJWgvEcKk2VLn5jnVJS(SMO@h%Td?63^{tfS(D?^Zr11MU5$B~dNt4I>39+I5)}Vz zD+tfWK}CBkoE*;f@7ez@;Y5rnTodK1V4q|>LD6?UIS`c~_ zuykl61bP#}_+qyAh?^XRgGYpzm=2~5|5_LwWDHcp%wZm82ec3v5a5@ut%vbrm;J_9 z1TytffI#5YEpY8MK5-xZGPPr;-IxT+q%UGl;<6rxeZx<}$0r0Ar7&!>aj zw~L09j+*Ap==i47R#u0hIY<)?3slZz`sF?)iMwaRVAI)iQya_Jh+NJ+O5jgteGqtC zib2nXPbW@6|LdM9b(lkCK@MFWn(>}6!tms*r^#7e;aU4Fw?p_4C&2KM@7@QeQ4ck#+4+&6mJyf3d@#j~VE zp8EQHAxvjM+*k@(0W;G@FmZ{4z>yUHi4QW74aT;@`xpEC!nlCSx4|ok-nRuXUJ8Km zbO4SI8NUwAsJ&;5F#mEPo_!XUW=BI;l3dt7mH-!qS|7+lFnc~J;@;xGUkxmFM#WS! zW;~@1rkJsyW<%STZ$<{Zu$SVM-j2^IB+sf~k5aT&GbQ-6GgkbwFgB>%wJzI?ElW^y zFeYs8#Lt0JgcW<$pvNs}rDY$bV3_hyUc%Im~J_uYC#)O}sNr^$V?Hu56< fKb4Teoa%w!0{4Db(9alE!3OU{0OpS>gY5GkHPUu; diff --git a/tool3_2048/tool3/MainFrm.cpp b/tool3_2048/tool3/MainFrm.cpp index dfe99d7..7489a04 100644 --- a/tool3_2048/tool3/MainFrm.cpp +++ b/tool3_2048/tool3/MainFrm.cpp @@ -19,6 +19,7 @@ #include #include #include +#include #include #include @@ -79,6 +80,7 @@ CButton *sx; CButton *tx; CButton *hux; CButton *tux; +CButton *edw; CStatic *b7; CProgressCtrl *dc; HANDLE cl; @@ -108,6 +110,7 @@ int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) tx = new CButton(); hux = new CButton(); tux = new CButton(); + edw = new CButton(); CBitmap wq[2]; @@ -127,10 +130,11 @@ int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) bh->SetBitmap(wq[0]); q->Create(L"stop",BS_BITMAP|WS_CHILD|WS_VISIBLE,CRect(50+170,50,170+170,100),this,233); q->SetBitmap(wq[1]); - sx->Create(L"compressor",BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE|WS_GROUP,CRect(0+10,20+292,98+10,48+292),this,73); - tx->Create(L"decompressor",BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE,CRect(0+111,20+292,118+111,48+292),this,173); - hux->Create(L"-hex32_24",BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE|WS_GROUP,CRect(0+240,20+292,95+240,48+292),this,7987); - tux->Create(L"-wif24",BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE,CRect(0+337,20+292,97+341,48+292),this,543); + sx->Create(L"compressor",BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE|WS_GROUP,CRect(0+1,20+292,98+1,48+292),this,73); + tx->Create(L"decompressor",BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE,CRect(0+100,20+292,118+100,48+292),this,173); + hux->Create(L"hex32",BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE|WS_GROUP,CRect(0+224,20+292,59+225,48+292),this,7987); + tux->Create(L"wif",BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE,CRect(0+285,20+292,45+281,48+292),this,543); + edw->Create(L"Edwards25519",BS_AUTORADIOBUTTON|WS_CHILD|WS_VISIBLE,CRect(327+0,20+292,355+97,48+292),this,54543); b7->Create(L"",WS_CHILD|WS_VISIBLE|SS_WHITEFRAME|SS_SIMPLE,CRect(40,240,423,270),this); dc->Create(WS_VISIBLE|WS_CHILD|PBS_SMOOTH,CRect(120,100+130,120+220,100+170),this,21); dc->SetState(PBST_NORMAL); @@ -180,6 +184,8 @@ void CMainFrame::tr() // bh->Create(L"start",BS_BITMAP|WS_CHILD|WS_VISIBLE|c,CR argc = 3, argv[1] = "-hex32_24"; if(this->IsDlgButtonChecked(543)) argc = 3, argv[1] = "-wif24"; + if(this->IsDlgButtonChecked(54543)) + argc = 3, argv[1] = "-secretkey"; std::vector b; do @@ -278,6 +284,43 @@ void CMainFrame::tr() // bh->Create(L"start",BS_BITMAP|WS_CHILD|WS_VISIBLE|c,CR ::SendMessage(hc, EM_SETTEXTEX, (WPARAM)&fw, (LPARAM)(LPCWSTR)cb); } + if ((argc == 2 == false) && std::string(argv[1]) == "-secretkey") + { + if (b.size() > 24) + { + b7->SetWindowTextW(L"do not mess with it"); + return; + + } + + auto c = b58decode(harbour); + if (c.second.size() == 32 == false) + { + b7->SetWindowTextW(L"do not mess with it"); + return; + + } + + unsigned char bc[32]; + unsigned char f[64]; + + crypto_sign_seed_keypair(bc, f, (unsigned char*)c.second.c_str()); + auto t = b58encode(std::string(( char*)f, 64)); + std::stringstream ewtr4; + + ewtr4 << t.second.c_str() << std::endl << '['; + + for (int k = 0; k < 64; k++) + ewtr4 << (int)f[k] << ", "; + + ewtr4 << ']'; + wchar_t cb[1218] = {}; + mbstowcs(cb, ewtr4.str().c_str(), 747); + SETTEXTEX fw = { 4, 1200 }; + ::SendMessage(hc, EM_SETTEXTEX, (WPARAM)&fw, (LPARAM)(LPCWSTR)cb); + + } + return; } @@ -288,6 +331,9 @@ void CMainFrame::tr() // bh->Create(L"start",BS_BITMAP|WS_CHILD|WS_VISIBLE|c,CR argc = 3, argv[1] = "-hex32_24"; if(this->IsDlgButtonChecked(543)) argc = 3, argv[1] = "-wif24"; + if(this->IsDlgButtonChecked(54543)) + argc = 3, argv[1] = "-secretkey"; + if ((argc == 2 == false) && std::string(argv[1]) == "-hex32_24") { @@ -319,6 +365,40 @@ void CMainFrame::tr() // bh->Create(L"start",BS_BITMAP|WS_CHILD|WS_VISIBLE|c,CR auto t = b58encode(std::string(c.second.c_str() + 1, 32 )); a = t.second; } + if ((argc == 2 == false) && std::string(argv[1]) == "-secretkey") + { + std::pair c; + std::stringstream hc; + unsigned char ewd = {}; + if(a[0] == '[') + { + a.erase(a.cbegin()); + a.erase(a.cend() - 1); + + std::stringstream f(a); + while(f.bad() == false) + { + std::string ffeg; + f >> ffeg; + if (f.fail()) break; + unsigned long afew = sscanf(ffeg.c_str(), "%d", &ewd); + if(afew > 0) hc.write((char *)&ewd, 1); + } + } + c = hc.str().empty() == false ? std::pair(0, hc.str()) : b58decode(a); + unsigned short rev = c.second.size(); + if (rev == 64 == false) + { + CString w; + w.Format(L"%d %d ", ewd, rev); + b7->SetWindowTextW(w + L"do not mess with it f " ); + return; + + } + + auto t = b58encode(std::string(c.second.c_str(), 32 )); + a = t.second; + } std::vector farstone; @@ -425,7 +505,7 @@ std::shared_ptr b(new BYTE[lkm]); auto t = b58encode(wb_final); std::string whydah = t.second; - std::string mill = whydah + '\n' + t_compressed.second; + std::string mill = whydah + '\n' + t_compressed.second; std::string draw = bin2hex(fwec, 16); @@ -444,6 +524,7 @@ std::shared_ptr b(new BYTE[lkm]); UnhookWindowsHookEx(hter); ::c = 0; + HWAVEOUT hWaveOut = 0; WAVEFORMATEX f; f.wFormatTag = WAVE_FORMAT_PCM; // simple, uncompressed format diff --git a/tool3_2048/tool3/tool3.vcxproj b/tool3_2048/tool3/tool3.vcxproj index 4511e89..dfdce81 100644 --- a/tool3_2048/tool3/tool3.vcxproj +++ b/tool3_2048/tool3/tool3.vcxproj @@ -194,7 +194,7 @@ NoErrorReport Default $(SolutionDir)..\New folder;%(AdditionalLibraryDirectories) - libcrypto.lib;winmm.lib;%(AdditionalDependencies) + libcrypto.lib;winmm.lib;libsodium.lib;%(AdditionalDependencies) false diff --git a/tool3_2048/x64/Release/libsodium.dll b/tool3_2048/x64/Release/libsodium.dll new file mode 100644 index 0000000000000000000000000000000000000000..5831c1843282d7b01273de628dc213523e5382cc GIT binary patch literal 346624 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]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 literal 0 HcmV?d00001 diff --git a/tool3_2048/x64/Release/tool3.exe b/tool3_2048/x64/Release/tool3.exe index 59813682d1691a747c776081c7e0e4b7183dba11..f94ca8703b60af7e84f91df4f9c626c2c52169f5 100644 GIT binary patch delta 121034 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 U7VZf5gq=Ty!Pbq7EGf!=02F?vG5`Po