ascon.h

Go to the documentation of this file.

 
#ifndef ASCON_H
#define ASCON_H
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#include <stdint.h> /* For uint8_t, uint_fast8_t, uint64_t */
#include <stddef.h> /* For size_t, NULL */
#include <stdbool.h> /* For bool, true, false */
 
#if defined(ASCON_INPUT_ASSERTS) && !defined(ASCON_ASSERT)
// Redefining ASCON_INPUT_ASSERTS otherwise Doxygen does not find it
#undef ASCON_INPUT_ASSERTS
#define ASCON_INPUT_ASSERTS 1
#include <assert.h> /* For assert() */
#define ASCON_ASSERT(expr) assert(expr)
#elif !defined(ASCON_ASSERT)
// Neither ASCON_INPUT_ASSERTS nor ASCON_ASSERT are defined,
// so make the assert macro do nothing.
#define ASCON_ASSERT(expr)
#endif
 
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(_WIN64) || defined(__NT__)
#define ASCON_WINDOWS 1
#define ASCON_API __declspec(dllexport)
#else
#define ASCON_API
#endif
 
#define ASCON_API_VERSION_MAJOR 1
#define ASCON_API_VERSION_MINOR 2
#define ASCON_API_VERSION_BUGFIX 1
#define ASCON_API_VERSION "1.2.1"
 
#define ASCON_AEAD128_KEY_LEN 16U
 
#define ASCON_AEAD128a_KEY_LEN 16U
 
#define ASCON_AEAD80pq_KEY_LEN 20U
 
#define ASCON_AEAD_NONCE_LEN 16U
 
#define ASCON_AEAD_TAG_MIN_SECURE_LEN 16U
 
#define ASCON_HASH_DIGEST_LEN 32U
 
#define ASCON_HASHA_DIGEST_LEN ASCON_HASH_DIGEST_LEN
 
#define ASCON_RATE 8U
 
#define ASCON_DOUBLE_RATE (2U * ASCON_RATE)
 
#define ASCON_TAG_OK true
#define ASCON_TAG_INVALID false
 
typedef struct ascon_sponge
{
    uint64_t x0;
    uint64_t x1;
    uint64_t x2;
    uint64_t x3;
    uint64_t x4;
} ascon_sponge_t;
 
typedef struct ascon_bufstate
{
    ascon_sponge_t sponge;
 
    uint8_t buffer[ASCON_DOUBLE_RATE];
 
    uint8_t buffer_len;
 
    uint8_t flow_state;
 
    uint8_t pad[6];
} ascon_bufstate_t;
 
typedef ascon_bufstate_t ascon_hash_ctx_t;
 
typedef struct ascon_aead_ctx
{
    ascon_bufstate_t bufstate;
 
    uint64_t k0;
 
    uint64_t k1;
 
    uint64_t k2;
} ascon_aead_ctx_t;
 
ASCON_API void
ascon_aead128_encrypt(uint8_t* ciphertext,
                      uint8_t* tag,
                      const uint8_t key[ASCON_AEAD128_KEY_LEN],
                      const uint8_t nonce[ASCON_AEAD_NONCE_LEN],
                      const uint8_t* assoc_data,
                      const uint8_t* plaintext,
                      size_t assoc_data_len,
                      size_t plaintext_len,
                      size_t tag_len);
 
ASCON_API void
ascon_aead128_init(ascon_aead_ctx_t* ctx,
                   const uint8_t key[ASCON_AEAD128_KEY_LEN],
                   const uint8_t nonce[ASCON_AEAD_NONCE_LEN]);
 
ASCON_API void
ascon_aead128_assoc_data_update(ascon_aead_ctx_t* ctx,
                                const uint8_t* assoc_data,
                                size_t assoc_data_len);
 
ASCON_API size_t
ascon_aead128_encrypt_update(ascon_aead_ctx_t* ctx,
                             uint8_t* ciphertext,
                             const uint8_t* plaintext,
                             size_t plaintext_len);
 
ASCON_API size_t
ascon_aead128_encrypt_final(ascon_aead_ctx_t* ctx,
                            uint8_t* ciphertext,
                            uint8_t* tag,
                            size_t tag_len);
 
ASCON_API bool
ascon_aead128_decrypt(uint8_t* plaintext,
                      const uint8_t key[ASCON_AEAD128_KEY_LEN],
                      const uint8_t nonce[ASCON_AEAD_NONCE_LEN],
                      const uint8_t* assoc_data,
                      const uint8_t* ciphertext,
                      const uint8_t* expected_tag,
                      size_t assoc_data_len,
                      size_t ciphertext_len,
                      size_t expected_tag_len);
 
ASCON_API size_t
ascon_aead128_decrypt_update(ascon_aead_ctx_t* ctx,
                             uint8_t* plaintext,
                             const uint8_t* ciphertext,
                             size_t ciphertext_len);
 
ASCON_API size_t
ascon_aead128_decrypt_final(ascon_aead_ctx_t* ctx,
                            uint8_t* plaintext,
                            bool* is_tag_valid,
                            const uint8_t* expected_tag,
                            size_t expected_tag_len);
 
ASCON_API void
ascon_aead_cleanup(ascon_aead_ctx_t* ctx);
 
ASCON_API void
ascon_aead128a_encrypt(uint8_t* ciphertext,
                       uint8_t* tag,
                       const uint8_t key[ASCON_AEAD128_KEY_LEN],
                       const uint8_t nonce[ASCON_AEAD_NONCE_LEN],
                       const uint8_t* assoc_data,
                       const uint8_t* plaintext,
                       size_t assoc_data_len,
                       size_t plaintext_len,
                       size_t tag_len);
 
 
ASCON_API void
ascon_aead128a_init(ascon_aead_ctx_t* ctx,
                    const uint8_t key[ASCON_AEAD128a_KEY_LEN],
                    const uint8_t nonce[ASCON_AEAD_NONCE_LEN]);
 
ASCON_API void
ascon_aead128a_assoc_data_update(ascon_aead_ctx_t* ctx,
                                 const uint8_t* assoc_data,
                                 size_t assoc_data_len);
 
ASCON_API size_t
ascon_aead128a_encrypt_update(ascon_aead_ctx_t* ctx,
                              uint8_t* ciphertext,
                              const uint8_t* plaintext,
                              size_t plaintext_len);
 
 
ASCON_API size_t
ascon_aead128a_encrypt_final(ascon_aead_ctx_t* ctx,
                             uint8_t* ciphertext,
                             uint8_t* tag,
                             size_t tag_len);
 
ASCON_API bool
ascon_aead128a_decrypt(uint8_t* plaintext,
                       const uint8_t key[ASCON_AEAD128a_KEY_LEN],
                       const uint8_t nonce[ASCON_AEAD_NONCE_LEN],
                       const uint8_t* assoc_data,
                       const uint8_t* ciphertext,
                       const uint8_t* expected_tag,
                       size_t assoc_data_len,
                       size_t ciphertext_len,
                       size_t expected_tag_len);
 
ASCON_API size_t
ascon_aead128a_decrypt_update(ascon_aead_ctx_t* ctx,
                              uint8_t* plaintext,
                              const uint8_t* ciphertext,
                              size_t ciphertext_len);
 
 
ASCON_API size_t
ascon_aead128a_decrypt_final(ascon_aead_ctx_t* ctx,
                             uint8_t* plaintext,
                             bool* is_tag_valid,
                             const uint8_t* expected_tag,
                             size_t expected_tag_len);
 
 
ASCON_API void
ascon_aead80pq_encrypt(uint8_t* ciphertext,
                       uint8_t* tag,
                       const uint8_t key[ASCON_AEAD80pq_KEY_LEN],
                       const uint8_t nonce[ASCON_AEAD_NONCE_LEN],
                       const uint8_t* assoc_data,
                       const uint8_t* plaintext,
                       size_t assoc_data_len,
                       size_t plaintext_len,
                       size_t tag_len);
 
 
ASCON_API void
ascon_aead80pq_init(ascon_aead_ctx_t* ctx,
                    const uint8_t key[ASCON_AEAD80pq_KEY_LEN],
                    const uint8_t nonce[ASCON_AEAD_NONCE_LEN]);
 
ASCON_API void
ascon_aead80pq_assoc_data_update(ascon_aead_ctx_t* ctx,
                                 const uint8_t* assoc_data,
                                 size_t assoc_data_len);
 
ASCON_API size_t
ascon_aead80pq_encrypt_update(ascon_aead_ctx_t* ctx,
                              uint8_t* ciphertext,
                              const uint8_t* plaintext,
                              size_t plaintext_len);
 
 
ASCON_API size_t
ascon_aead80pq_encrypt_final(ascon_aead_ctx_t* ctx,
                             uint8_t* ciphertext,
                             uint8_t* tag,
                             size_t tag_len);
 
ASCON_API bool
ascon_aead80pq_decrypt(uint8_t* plaintext,
                       const uint8_t key[ASCON_AEAD80pq_KEY_LEN],
                       const uint8_t nonce[ASCON_AEAD_NONCE_LEN],
                       const uint8_t* assoc_data,
                       const uint8_t* ciphertext,
                       const uint8_t* expected_tag,
                       size_t assoc_data_len,
                       size_t ciphertext_len,
                       size_t expected_tag_len);
 
ASCON_API size_t
ascon_aead80pq_decrypt_update(ascon_aead_ctx_t* ctx,
                              uint8_t* plaintext,
                              const uint8_t* ciphertext,
                              size_t ciphertext_len);
 
ASCON_API size_t
ascon_aead80pq_decrypt_final(ascon_aead_ctx_t* ctx,
                             uint8_t* plaintext,
                             bool* is_tag_valid,
                             const uint8_t* expected_tag,
                             size_t expected_tag_len);
 
ASCON_API void
ascon_hash(uint8_t digest[ASCON_HASH_DIGEST_LEN],
           const uint8_t* data,
           size_t data_len);
 
ASCON_API void
ascon_hasha(uint8_t digest[ASCON_HASHA_DIGEST_LEN],
            const uint8_t* data,
            size_t data_len);
 
ASCON_API bool
ascon_hash_matches(const uint8_t expected_digest[ASCON_HASH_DIGEST_LEN],
                   const uint8_t* data,
                   size_t data_len);
 
ASCON_API bool
ascon_hasha_matches(const uint8_t expected_digest[ASCON_HASHA_DIGEST_LEN],
                    const uint8_t* data,
                    size_t data_len);
 
ASCON_API void
ascon_hash_init(ascon_hash_ctx_t* ctx);
 
ASCON_API void
ascon_hasha_init(ascon_hash_ctx_t* ctx);
 
ASCON_API void
ascon_hash_update(ascon_hash_ctx_t* ctx,
                  const uint8_t* data,
                  size_t data_len);
 
ASCON_API void
ascon_hasha_update(ascon_hash_ctx_t* ctx,
                   const uint8_t* data,
                   size_t data_len);
 
ASCON_API void
ascon_hash_final(ascon_hash_ctx_t* ctx,
                 uint8_t digest[ASCON_HASH_DIGEST_LEN]);
 
ASCON_API void
ascon_hasha_final(ascon_hash_ctx_t* ctx,
                  uint8_t digest[ASCON_HASHA_DIGEST_LEN]);
 
ASCON_API bool
ascon_hash_final_matches(ascon_hash_ctx_t* ctx,
                         const uint8_t expected_digest[ASCON_HASH_DIGEST_LEN]);
 
ASCON_API bool
ascon_hasha_final_matches(ascon_hash_ctx_t* ctx,
                          const uint8_t expected_digest[ASCON_HASHA_DIGEST_LEN]);
 
ASCON_API void
ascon_hash_xof(uint8_t* digest,
               const uint8_t* data,
               size_t digest_len,
               size_t data_len);
 
ASCON_API void
ascon_hasha_xof(uint8_t* digest,
                const uint8_t* data,
                size_t digest_len,
                size_t data_len);
 
ASCON_API bool
ascon_hash_xof_matches(const uint8_t* expected_digest,
                       const uint8_t* data,
                       size_t expected_digest_len,
                       size_t data_len);
 
ASCON_API bool
ascon_hasha_xof_matches(const uint8_t* expected_digest,
                        const uint8_t* data,
                        size_t expected_digest_len,
                        size_t data_len);
 
ASCON_API void
ascon_hash_xof_init(ascon_hash_ctx_t* ctx);
 
ASCON_API void
ascon_hasha_xof_init(ascon_hash_ctx_t* ctx);
 
ASCON_API void
ascon_hash_xof_update(ascon_hash_ctx_t* ctx,
                      const uint8_t* data,
                      size_t data_len);
 
ASCON_API void
ascon_hasha_xof_update(ascon_hash_ctx_t* ctx,
                       const uint8_t* data,
                       size_t data_len);
 
ASCON_API void
ascon_hash_xof_final(ascon_hash_ctx_t* ctx,
                     uint8_t* digest,
                     size_t digest_len);
 
ASCON_API void
ascon_hasha_xof_final(ascon_hash_ctx_t* ctx,
                      uint8_t* digest,
                      size_t digest_len);
 
ASCON_API bool
ascon_hash_xof_final_matches(ascon_hash_ctx_t* ctx,
                             const uint8_t* expected_digest,
                             size_t expected_digest_len);
 
ASCON_API bool
ascon_hasha_xof_final_matches(ascon_hash_ctx_t* ctx,
                              const uint8_t* expected_digest,
                              size_t expected_digest_len);
 
ASCON_API void
ascon_hash_cleanup(ascon_hash_ctx_t* ctx);
 
#ifdef __cplusplus
}
#endif
 
#endif  /* ASCON_H */