sha3.h

Go to the documentation of this file.

 
#ifndef SHA3_H
#define SHA3_H
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#include <stddef.h> // size_t
#include <stdint.h> // uint8_t, uint64_t
 
typedef union {
  uint8_t u8[200]; 
  uint64_t u64[25]; 
} sha3_state_t;
 
typedef struct {
  size_t num_bytes; 
  sha3_state_t a; 
  _Bool finalized; 
} sha3_t;
 
typedef struct {
  size_t num_bytes; 
  sha3_state_t a; 
  _Bool squeezing; 
} sha3_xof_t;
 
void sha3_224(const uint8_t *src, size_t len, uint8_t dst[static 28]);
 
void sha3_224_init(sha3_t *hash);
 
_Bool sha3_224_absorb(sha3_t *hash, const uint8_t *src, const size_t len);
 
void sha3_224_final(sha3_t *hash, uint8_t dst[28]);
 
void sha3_256(const uint8_t *src, size_t len, uint8_t dst[static 32]);
 
void sha3_256_init(sha3_t *hash);
 
_Bool sha3_256_absorb(sha3_t *hash, const uint8_t *src, const size_t len);
 
void sha3_256_final(sha3_t *hash, uint8_t dst[32]);
 
void sha3_384(const uint8_t *src, size_t len, uint8_t dst[static 48]);
 
void sha3_384_init(sha3_t *hash);
 
_Bool sha3_384_absorb(sha3_t *hash, const uint8_t *src, const size_t len);
 
void sha3_384_final(sha3_t *hash, uint8_t dst[48]);
 
void sha3_512(const uint8_t *src, size_t len, uint8_t dst[static 64]);
 
void sha3_512_init(sha3_t *hash);
 
_Bool sha3_512_absorb(sha3_t *hash, const uint8_t *src, const size_t len);
 
void sha3_512_final(sha3_t *hash, uint8_t dst[64]);
 
void hmac_sha3_224(const uint8_t *k, const size_t k_len, const uint8_t *m, const size_t m_len, uint8_t dst[28]);
 
void hmac_sha3_256(const uint8_t *k, const size_t k_len, const uint8_t *m, const size_t m_len, uint8_t dst[32]);
 
void hmac_sha3_384(const uint8_t *k, const size_t k_len, const uint8_t *m, const size_t m_len, uint8_t dst[48]);
 
void hmac_sha3_512(const uint8_t *k, const size_t k_len, const uint8_t *m, const size_t m_len, uint8_t dst[64]);
 
typedef struct {
  sha3_t inner, 
         outer; 
  _Bool finalized; 
} hmac_sha3_t;
 
void hmac_sha3_224_init(hmac_sha3_t *hmac, const uint8_t *k, const size_t k_len);
 
_Bool hmac_sha3_224_absorb(hmac_sha3_t *hmac, const uint8_t *src, const size_t len);
 
void hmac_sha3_224_final(hmac_sha3_t *hmac, uint8_t dst[28]);
 
void hmac_sha3_256_init(hmac_sha3_t *hmac, const uint8_t *k, const size_t k_len);
 
_Bool hmac_sha3_256_absorb(hmac_sha3_t *hmac, const uint8_t *src, const size_t len);
 
void hmac_sha3_256_final(hmac_sha3_t *hmac, uint8_t dst[32]);
 
void hmac_sha3_384_init(hmac_sha3_t *hmac, const uint8_t *k, const size_t k_len);
 
_Bool hmac_sha3_384_absorb(hmac_sha3_t *hmac, const uint8_t *src, const size_t len);
 
void hmac_sha3_384_final(hmac_sha3_t *hmac, uint8_t dst[48]);
 
void hmac_sha3_512_init(hmac_sha3_t *hmac, const uint8_t *k, const size_t k_len);
 
_Bool hmac_sha3_512_absorb(hmac_sha3_t *hmac, const uint8_t *src, const size_t len);
 
void hmac_sha3_512_final(hmac_sha3_t *hmac, uint8_t dst[64]);
 
void shake128(const uint8_t *m, size_t m_len, uint8_t dst[static 16]);
 
void shake256(const uint8_t *m, size_t m_len, uint8_t dst[static 32]);
 
void shake128_xof_init(sha3_xof_t * const xof);
 
_Bool shake128_xof_absorb(sha3_xof_t *xof, const uint8_t *m, const size_t len);
 
void shake128_xof_squeeze(sha3_xof_t *xof, uint8_t *dst, const size_t dst_len);
 
void shake128_xof_once(const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void shake256_xof_init(sha3_xof_t *xof);
 
_Bool shake256_xof_absorb(sha3_xof_t *xof, const uint8_t *m, const size_t len);
 
void shake256_xof_squeeze(sha3_xof_t *xof, uint8_t *dst, const size_t dst_len);
 
void shake256_xof_once(const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
typedef struct {
  const uint8_t *name; 
  const size_t name_len; 
  const uint8_t *custom; 
  const size_t custom_len; 
} cshake_params_t;
 
void cshake128(const cshake_params_t params, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void cshake256(const cshake_params_t params, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void cshake128_xof_init(sha3_xof_t *xof, const cshake_params_t params);
 
_Bool cshake128_xof_absorb(sha3_xof_t *xof, const uint8_t *src, const size_t len);
 
void cshake128_xof_squeeze(sha3_xof_t *xof, uint8_t *dst, const size_t len);
 
void cshake256_xof_init(sha3_xof_t *xof, const cshake_params_t params);
 
_Bool cshake256_xof_absorb(sha3_xof_t *xof, const uint8_t *src, const size_t len);
 
void cshake256_xof_squeeze(sha3_xof_t *xof, uint8_t *dst, const size_t len);
 
typedef struct {
  const uint8_t *key; 
  const size_t key_len; 
  const uint8_t *custom; 
  const size_t custom_len; 
} kmac_params_t;
 
void kmac128(const kmac_params_t params, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void kmac256(const kmac_params_t params, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void kmac128_xof_init(sha3_xof_t *xof, const kmac_params_t params);
 
_Bool kmac128_xof_absorb(sha3_xof_t *xof, const uint8_t *src, const size_t len);
 
void kmac128_xof_squeeze(sha3_xof_t *xof, uint8_t *dst, const size_t len);
 
void kmac128_xof_once(const kmac_params_t params, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void kmac256_xof_init(sha3_xof_t *xof, const kmac_params_t params);
 
_Bool kmac256_xof_absorb(sha3_xof_t *xof, const uint8_t *src, const size_t len);
 
void kmac256_xof_squeeze(sha3_xof_t *xof, uint8_t *dst, const size_t len);
 
void kmac256_xof_once(const kmac_params_t params, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
typedef struct {
  const uint8_t *ptr; 
  size_t len; 
} tuplehash_str_t;
 
typedef struct {
  const tuplehash_str_t *strs; 
  const size_t num_strs; 
  const uint8_t *custom; 
  const size_t custom_len; 
} tuplehash_params_t;
 
void tuplehash128(const tuplehash_params_t params, uint8_t *dst, const size_t dst_len);
 
void tuplehash256(const tuplehash_params_t params, uint8_t *dst, const size_t dst_len);
 
void tuplehash128_xof_init(sha3_xof_t *xof, const tuplehash_params_t params);
 
void tuplehash128_xof_squeeze(sha3_xof_t *xof, uint8_t *dst, const size_t len);
 
void tuplehash128_xof_once(const tuplehash_params_t params, uint8_t *dst, const size_t dst_len);
 
void tuplehash256_xof_init(sha3_xof_t *xof, const tuplehash_params_t params);
 
void tuplehash256_xof_squeeze(sha3_xof_t *xof, uint8_t *dst, const size_t len);
 
void tuplehash256_xof_once(const tuplehash_params_t params, uint8_t *dst, const size_t len);
 
typedef struct {
  const size_t block_len; 
  const uint8_t *custom; 
  const size_t custom_len; 
} parallelhash_params_t;
 
typedef struct {
  sha3_xof_t root_xof, 
             curr_xof; 
  size_t ofs, 
         block_len, 
         num_blocks; 
  _Bool squeezing; 
} parallelhash_t;
 
void parallelhash128(const parallelhash_params_t params, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void parallelhash256(const parallelhash_params_t params, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void parallelhash128_xof_init(parallelhash_t *xof, const parallelhash_params_t params);
 
void parallelhash128_xof_absorb(parallelhash_t *hash, const uint8_t *src, const size_t len);
 
void parallelhash128_xof_squeeze(parallelhash_t *xof, uint8_t *dst, const size_t len);
 
void parallelhash128_xof_once(const parallelhash_params_t params, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void parallelhash256_xof_init(parallelhash_t *xof, const parallelhash_params_t params);
 
void parallelhash256_xof_absorb(parallelhash_t *hash, const uint8_t *src, const size_t len);
 
void parallelhash256_xof_squeeze(parallelhash_t *xof, uint8_t *dst, const size_t len);
 
void parallelhash256_xof_once(const parallelhash_params_t params, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void turboshake128(const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void turboshake128_custom(const uint8_t pad, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void turboshake256(const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void turboshake256_custom(const uint8_t pad, const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
typedef struct {
  sha3_xof_t xof; 
  uint8_t pad; 
} turboshake_t;
 
void turboshake128_init(turboshake_t *ts);
 
_Bool turboshake128_init_custom(turboshake_t *ts, const uint8_t pad);
 
_Bool turboshake128_absorb(turboshake_t *ts, const uint8_t *src, const size_t len);
 
void turboshake128_squeeze(turboshake_t *ts, uint8_t *dst, const size_t len);
 
void turboshake256_init(turboshake_t *ts);
 
_Bool turboshake256_init_custom(turboshake_t *ts, const uint8_t pad);
 
_Bool turboshake256_absorb(turboshake_t *ts, const uint8_t *src, const size_t len);
 
void turboshake256_squeeze(turboshake_t *ts, uint8_t *dst, const size_t len);
 
typedef struct {
  turboshake_t ts; 
} k12_t;
 
void k12_once(const uint8_t *src, const size_t src_len, uint8_t *dst, const size_t dst_len);
 
void k12_custom_once(const uint8_t *src, const size_t src_len, const uint8_t *custom, const size_t custom_len, uint8_t *dst, const size_t dst_len);
 
void k12_init(k12_t *k12, const uint8_t *src, const size_t src_len, const uint8_t *custom, const size_t custom_len);
 
void k12_squeeze(k12_t *k12, uint8_t *dst, const size_t dst_len);
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* SHA3_H */