evp.h

Go to the documentation of this file.

 
#ifndef __HASHA_EVP_H
#define __HASHA_EVP_H
 
#include "./internal/feature.h"
#include "./internal/hadefs.h"
#include "./internal/internal.h"

#define ha_ctx(hash)        ha_##hash##_context

#define ha_init_fun(hash)   ha_##hash##_init
#define ha_update_fun(hash) ha_##hash##_update
#define ha_final_fun(hash)  ha_##hash##_final
#define ha_hash_fun(hash)   ha_##hash##_hash

#define ha_init(hash, ctx)  ha_##hash##_init(ctx)

#define ha_update(hash, ctx, buf, buflen)                                 \
  ha_##hash##_update(ctx, buf, buflen)

#define ha_final(hash, ctx, ...) ha_##hash##_final(ctx, ##__VA_ARGS__)

#define ha_hash(hash, buf, buflen, digest, ...)                           \
  ha_##hash##_hash(buf, buflen, digest, ##__VA_ARGS__)
 
#ifdef HA_ADA
#define ha_ada_hash(hash, buf, len, digest, ...)                          \
  do {                                                                    \
    ha_ctx(hash) ctx;                                                     \
    ha_init(hash, &ctx);                                                  \
    ha_update(hash, &ctx, buf, len);                                      \
    ha_final(hash, &ctx, digest, ##__VA_ARGS__);                          \
  } while (0)

#define ha_ada_stream_hash(hash, stream, size, chunksize, buffer, digest, \
                           ...)                                           \
  do {                                                                    \
    ha_ctx(hash) ctx;                                                     \
    ha_init(hash, &ctx);                                                  \
    size_t bytes;                                                         \
    while ((bytes = fread((buffer), (size), (chunksize), (stream))) > 0)  \
    {                                                                     \
      ha_update(hash, &ctx, buffer, bytes);                               \
    }                                                                     \
    ha_final(hash, &ctx, digest, ##__VA_ARGS__);                          \
  } while (0)

#ifdef HA_ADA_COMPATIBILITY
#define ha_buffer_digest(...) ha_ada_hash(__VA_ARGS__)
#define ha_stream_digest(...) ha_ada_stream_hash(__VA_ARGS__)
#endif
#endif
 
#if ha_has_feature(EVP)

enum ha_evp_hashty ha_enum_base(uint8_t)
{
  HA_EVPTY_UNDEFINED, 
  HA_EVPTY_BLAKE2B,   
  HA_EVPTY_BLAKE2S,   
  HA_EVPTY_BLAKE3,    
  HA_EVPTY_KECCAK,    
  HA_EVPTY_MD5,       
  HA_EVPTY_SHA1,      
  HA_EVPTY_SHA2,      
  HA_EVPTY_SHA3,      
};
 
enum ha_enum_base(int8_t)
{
  /* constant: i8 */
  HA_EVPTY_SIZE_DYNAMIC = -1,
};

extern const size_t          g_ha_evp_hasher_size;

typedef struct ha_evp_hasher ha_evp_hasher_t, *ha_evp_phasher_t;
 
HA_EXTERN_C_BEG
 
HA_PUBFUN
void ha_evp_put(struct ha_evp_hasher *hasher, ha_cdigest_t digest, const char *end);

HA_PUBFUN
void ha_evp_fput(struct ha_evp_hasher *hasher, FILE *stream, ha_cdigest_t digest, const char *end);

HA_PUBFUN
signed long ha_evp_hashty_get_digestlen(enum ha_evp_hashty hashty);

HA_PUBFUN
const char *ha_evp_hashty_tostr(enum ha_evp_hashty hashty);
 
/* Used before initialization (ha_evp_setup_hasher) of hasher */

HA_PUBFUN
void ha_evp_hasher_set_keccak_rate(struct ha_evp_hasher *hasher,
                                   uint16_t              rate);
HA_PUBFUN
size_t ha_evp_hasher_keccak_rate(struct ha_evp_hasher *hasher);

HA_PUBFUN
void ha_evp_hasher_set_keccak_custom(struct ha_evp_hasher *hasher,
                                     bool                  custom);

HA_PUBFUN
bool ha_evp_hasher_keccak_custom(struct ha_evp_hasher *hasher);

HA_PUBFUN
size_t ha_evp_hasher_ctxsize(struct ha_evp_hasher *hasher);

HA_PUBFUN
enum ha_evp_hashty ha_evp_hasher_hashty(struct ha_evp_hasher *hasher);

HA_PUBFUN
void ha_evp_hasher_set_hashty(struct ha_evp_hasher *hasher,
                              enum ha_evp_hashty    hashty);

HA_PUBFUN
size_t ha_evp_hasher_digestlen(struct ha_evp_hasher *hasher);

HA_PUBFUN
void ha_evp_hasher_set_digestlen(struct ha_evp_hasher *hasher,
                                 size_t                digestlen);

HA_PUBFUN struct ha_evp_hasher *ha_evp_hasher_new(void);

HA_PUBFUN void ha_evp_hasher_delete(struct ha_evp_hasher *ptr);

HA_PUBFUN void ha_evp_hasher_init(struct ha_evp_hasher *hasher,
                                  enum ha_evp_hashty    hashty,
                                  size_t                digestlen);

HA_PUBFUN void ha_evp_hasher_cleanup(struct ha_evp_hasher *hasher);

HA_PUBFUN void ha_evp_hasher_reinit(struct ha_evp_hasher *hasher,
                                    enum ha_evp_hashty    hashty,
                                    size_t                digestlen);

HA_PUBFUN void ha_evp_hasher_commit(struct ha_evp_hasher *hasher);

HA_PUBFUN void ha_evp_init(struct ha_evp_hasher *hasher);

HA_PUBFUN void ha_evp_update(struct ha_evp_hasher *hasher, ha_inbuf_t buf,
                             size_t len);

HA_PUBFUN void ha_evp_final(struct ha_evp_hasher *hasher,
                            ha_digest_t           digest);

HA_PUBFUN void ha_evp_hash(struct ha_evp_hasher *hasher, ha_inbuf_t buf,
                           size_t len, ha_digest_t digest);

HA_PUBFUN
void ha_evp_digest(struct ha_evp_hasher *hasher, ha_inbuf_t buf,
                   size_t len, ha_digest_t digest);
 
HA_EXTERN_C_END
 
#endif /* ha_has_feature(EVP) */
 
#endif