/* ---- HASH FUNCTIONS ---- */
#ifdef SHA512
struct sha512_state {
    ulong64  length, state[8];
    unsigned long curlen;
    unsigned char buf[128];
};
#endif

#ifdef SHA256
struct sha256_state {
    ulong64 length;
    ulong32 state[8], curlen;
    unsigned char buf[64];
};
#endif

#ifdef SHA1
struct sha1_state {
    ulong64 length;
    ulong32 state[5], curlen;
    unsigned char buf[64];
};
#endif

#ifdef MD5
struct md5_state {
    ulong64 length;
    ulong32 state[4], curlen;
    unsigned char buf[64];
};
#endif

#ifdef MD4
struct md4_state {
    ulong64 length;
    ulong32 state[4], curlen;
    unsigned char buf[64];
};
#endif

#ifdef TIGER
struct tiger_state {
    ulong64 state[3], length;
    unsigned long curlen;
    unsigned char buf[64];
};
#endif

#ifdef MD2
struct md2_state {
    unsigned char chksum[16], X[48], buf[16];
    unsigned long curlen;
};
#endif

#ifdef RIPEMD128
struct rmd128_state {
    ulong64 length;
    unsigned char buf[64];
    ulong32 curlen, state[4];
};
#endif

#ifdef RIPEMD160
struct rmd160_state {
    ulong64 length;
    unsigned char buf[64];
    ulong32 curlen, state[5];
};
#endif

#ifdef WHIRLPOOL
struct whirlpool_state {
    ulong64 length, state[8];
    unsigned char buf[64];
    ulong32 curlen;
};
#endif

typedef union Hash_state {
#ifdef WHIRLPOOL
    struct whirlpool_state whirlpool;
#endif
#ifdef SHA512
    struct sha512_state sha512;
#endif
#ifdef SHA256
    struct sha256_state sha256;
#endif
#ifdef SHA1
    struct sha1_state   sha1;
#endif
#ifdef MD5
    struct md5_state    md5;
#endif
#ifdef MD4
    struct md4_state    md4;
#endif
#ifdef MD2
    struct md2_state    md2;
#endif
#ifdef TIGER
    struct tiger_state  tiger;
#endif
#ifdef RIPEMD128
    struct rmd128_state rmd128;
#endif
#ifdef RIPEMD160
    struct rmd160_state rmd160;
#endif
} hash_state;

extern  struct _hash_descriptor {
    char *name;
    unsigned char ID;
    unsigned long hashsize;       /* digest output size in bytes  */
    unsigned long blocksize;      /* the block size the hash uses */
    unsigned char DER[64];        /* DER encoded identifier */
    unsigned long DERlen;         /* length of DER encoding */
    void (*init)(hash_state *);
    int (*process)(hash_state *, const unsigned char *, unsigned long);
    int (*done)(hash_state *, unsigned char *);
    int  (*test)(void);
} hash_descriptor[];


#ifdef WHIRLPOOL
 void whirlpool_init(hash_state * md);
 int whirlpool_process(hash_state * md, const unsigned char *buf, unsigned long len);
 int whirlpool_done(hash_state * md, unsigned char *hash);
 int  whirlpool_test(void);
 extern const struct _hash_descriptor whirlpool_desc;
#endif

#ifdef SHA512
 void sha512_init(hash_state * md);
 int sha512_process(hash_state * md, const unsigned char *buf, unsigned long len);
 int sha512_done(hash_state * md, unsigned char *hash);
 int  sha512_test(void);
 extern const struct _hash_descriptor sha512_desc;
#endif

#ifdef SHA384
#ifndef SHA512
   #error SHA512 is required for SHA384
#endif
 void sha384_init(hash_state * md);
#define sha384_process sha512_process
 int sha384_done(hash_state * md, unsigned char *hash);
 int  sha384_test(void);
 extern const struct _hash_descriptor sha384_desc;
#endif

#ifdef SHA256
 void sha256_init(hash_state * md);
 int sha256_process(hash_state * md, const unsigned char *buf, unsigned long len);
 int sha256_done(hash_state * md, unsigned char *hash);
 int  sha256_test(void);
 extern const struct _hash_descriptor sha256_desc;

#ifdef SHA224
#ifndef SHA256
   #error SHA256 is required for SHA224
#endif
 void sha224_init(hash_state * md);
#define sha224_process sha256_process
 int sha224_done(hash_state * md, unsigned char *hash);
 int  sha224_test(void);
 extern const struct _hash_descriptor sha224_desc;
#endif
#endif

#ifdef SHA1
 void sha1_init(hash_state * md);
 int sha1_process(hash_state * md, const unsigned char *buf, unsigned long len);
 int sha1_done(hash_state * md, unsigned char *hash);
 int  sha1_test(void);
 extern const struct _hash_descriptor sha1_desc;
#endif

#ifdef MD5
 void md5_init(hash_state * md);
 int md5_process(hash_state * md, const unsigned char *buf, unsigned long len);
 int md5_done(hash_state * md, unsigned char *hash);
 int  md5_test(void);
 extern const struct _hash_descriptor md5_desc;
#endif

#ifdef MD4
 void md4_init(hash_state * md);
 int md4_process(hash_state * md, const unsigned char *buf, unsigned long len);
 int md4_done(hash_state * md, unsigned char *hash);
 int  md4_test(void);
 extern const struct _hash_descriptor md4_desc;
#endif

#ifdef MD2
 void md2_init(hash_state * md);
 int md2_process(hash_state * md, const unsigned char *buf, unsigned long len);
 int md2_done(hash_state * md, unsigned char *hash);
 int  md2_test(void);
 extern const struct _hash_descriptor md2_desc;
#endif

#ifdef TIGER
 void tiger_init(hash_state * md);
 int tiger_process(hash_state * md, const unsigned char *buf, unsigned long len);
 int tiger_done(hash_state * md, unsigned char *hash);
 int  tiger_test(void);
 extern const struct _hash_descriptor tiger_desc;
#endif

#ifdef RIPEMD128
 void rmd128_init(hash_state * md);
 int rmd128_process(hash_state * md, const unsigned char *buf, unsigned long len);
 int rmd128_done(hash_state * md, unsigned char *hash);
 int  rmd128_test(void);
 extern const struct _hash_descriptor rmd128_desc;
#endif

#ifdef RIPEMD160
 void rmd160_init(hash_state * md);
 int rmd160_process(hash_state * md, const unsigned char *buf, unsigned long len);
 int rmd160_done(hash_state * md, unsigned char *hash);
 int  rmd160_test(void);
 extern const struct _hash_descriptor rmd160_desc;
#endif


 int find_hash(const char *name);
 int find_hash_id(unsigned char ID);
 int find_hash_any(const char *name, int digestlen);
 int register_hash(const struct _hash_descriptor *hash);
 int unregister_hash(const struct _hash_descriptor *hash);
 int hash_is_valid(int idx);

 int hash_memory(int hash, const unsigned char *data, unsigned long len, unsigned char *dst, unsigned long *outlen);
 int hash_filehandle(int hash, FILE *in, unsigned char *dst, unsigned long *outlen);
 int hash_file(int hash, const char *fname, unsigned char *dst, unsigned long *outlen);

/* a simple macro for making hash "process" functions */
#define HASH_PROCESS(func_name, compress_name, state_var, block_size)                       \
int func_name (hash_state * md, const unsigned char *buf, unsigned long len)               \
{                                                                                           \
    unsigned long n;                                                                        \
    _ARGCHK(md != NULL);                                                                    \
    _ARGCHK(buf != NULL);                                                                   \
    if (md-> state_var .curlen > sizeof(md-> state_var .buf)) {                             \
       return CRYPT_INVALID_ARG;                                                            \
    }                                                                                       \
    while (len > 0) {                                                                       \
        if (md-> state_var .curlen == 0 && len >= block_size) {                             \
           compress_name (md, (unsigned char *)buf);                                        \
           md-> state_var .length += block_size * 8;                                        \
           buf             += block_size;                                                   \
           len             -= block_size;                                                   \
        } else {                                                                            \
           n = MIN(len, (block_size - md-> state_var .curlen));                             \
           memcpy(md-> state_var .buf + md-> state_var.curlen, buf, (size_t)n);             \
           md-> state_var .curlen += n;                                                     \
           buf             += n;                                                            \
           len             -= n;                                                            \
           if (md-> state_var .curlen == block_size) {                                      \
              compress_name (md, md-> state_var .buf);                                      \
              md-> state_var .length += 8*block_size;                                       \
              md-> state_var .curlen = 0;                                                   \
           }                                                                                \
       }                                                                                    \
    }                                                                                       \
    return CRYPT_OK;                                                                        \
}

#ifdef HMAC
typedef struct Hmac_state {
     hash_state     md;
     int            hash;
     hash_state     hashstate;
     unsigned char  key[MAXBLOCKSIZE];
} hmac_state;

 int hmac_init(hmac_state *hmac, int hash, const unsigned char *key, unsigned long keylen);
 int hmac_process(hmac_state *hmac, const unsigned char *buf, unsigned long len);
 int hmac_done(hmac_state *hmac, unsigned char *hashOut, unsigned long *outlen);
 int hmac_test(void);
 int hmac_memory(int hash, const unsigned char *key, unsigned long keylen,
                       const unsigned char *data, unsigned long len, 
                       unsigned char *dst, unsigned long *dstlen);
 int hmac_file(int hash, const char *fname, const unsigned char *key,
                     unsigned long keylen, 
                     unsigned char *dst, unsigned long *dstlen);
#endif

#ifdef OMAC

typedef struct {
   int             cipher_idx, 
                   buflen,
                   blklen;
   unsigned char   block[MAXBLOCKSIZE],
                   prev[MAXBLOCKSIZE],
                   Lu[2][MAXBLOCKSIZE];
   symmetric_key   key;
} omac_state;

 int omac_init(omac_state *omac, int cipher, const unsigned char *key, unsigned long keylen);
 int omac_process(omac_state *state, const unsigned char *buf, unsigned long len);
 int omac_done(omac_state *state, unsigned char *out, unsigned long *outlen);
 int omac_memory(int cipher, const unsigned char *key, unsigned long keylen,
                const unsigned char *msg, unsigned long msglen,
                unsigned char *out, unsigned long *outlen);
 int omac_file(int cipher, const unsigned char *key, unsigned long keylen,
              const char *filename, unsigned char *out, unsigned long *outlen);
 int omac_test(void);
#endif /* OMAC */

#ifdef PMAC

typedef struct {
   unsigned char     Ls[32][MAXBLOCKSIZE],    /* L shifted by i bits to the left */
                     Li[MAXBLOCKSIZE],        /* value of Li [current value, we calc from previous recall] */
                     Lr[MAXBLOCKSIZE],        /* L * x^-1 */
                     block[MAXBLOCKSIZE],     /* currently accumulated block */
                     checksum[MAXBLOCKSIZE];  /* current checksum */

   symmetric_key     key;                     /* scheduled key for cipher */
   unsigned long     block_index;             /* index # for current block */
   int               cipher_idx,              /* cipher idx */
                     block_len,               /* length of block */
                     buflen;                  /* number of bytes in the buffer */
} pmac_state;

 int pmac_init(pmac_state *pmac, int cipher, const unsigned char *key, unsigned long keylen);
 int pmac_process(pmac_state *state, const unsigned char *buf, unsigned long len);
 int pmac_done(pmac_state *state, unsigned char *out, unsigned long *outlen);

 int pmac_memory(int cipher, const unsigned char *key, unsigned long keylen,
                const unsigned char *msg, unsigned long msglen,
                unsigned char *out, unsigned long *outlen);

 int pmac_file(int cipher, const unsigned char *key, unsigned long keylen,
              const char *filename, unsigned char *out, unsigned long *outlen);

 int pmac_test(void);

/* internal functions */
 int pmac_ntz(unsigned long x);
 void pmac_shift_xor(pmac_state *pmac);

#endif /* PMAC */

#ifdef EAX_MODE

#if !(defined(OMAC) && defined(CTR))
   #error EAX_MODE requires OMAC and CTR
#endif

typedef struct {
   unsigned char N[MAXBLOCKSIZE];
   symmetric_CTR ctr;
   omac_state    headeromac, ctomac;
} eax_state;

 int eax_init(eax_state *eax, int cipher, const unsigned char *key, unsigned long keylen,
                    const unsigned char *nonce, unsigned long noncelen,
                    const unsigned char *header, unsigned long headerlen);

 int eax_encrypt(eax_state *eax, const unsigned char *pt, unsigned char *ct, unsigned long length);
 int eax_decrypt(eax_state *eax, const unsigned char *ct, unsigned char *pt, unsigned long length);
 int eax_addheader(eax_state *eax, const unsigned char *header, unsigned long length);
 int eax_done(eax_state *eax, unsigned char *tag, unsigned long *taglen);

 int eax_encrypt_authenticate_memory(int cipher,
    const unsigned char *key,    unsigned long keylen,
    const unsigned char *nonce,  unsigned long noncelen,
    const unsigned char *header, unsigned long headerlen,
    const unsigned char *pt,     unsigned long ptlen,
          unsigned char *ct,
          unsigned char *tag,    unsigned long *taglen);

 int eax_decrypt_verify_memory(int cipher,
    const unsigned char *key,    unsigned long keylen,
    const unsigned char *nonce,  unsigned long noncelen,
    const unsigned char *header, unsigned long headerlen,
    const unsigned char *ct,     unsigned long ctlen,
          unsigned char *pt,
          unsigned char *tag,    unsigned long taglen,
          int           *res);

 int eax_test(void);
#endif /* EAX MODE */

#ifdef OCB_MODE
typedef struct {
   unsigned char     L[MAXBLOCKSIZE],         /* L value */
                     Ls[32][MAXBLOCKSIZE],    /* L shifted by i bits to the left */
                     Li[MAXBLOCKSIZE],        /* value of Li [current value, we calc from previous recall] */
                     Lr[MAXBLOCKSIZE],        /* L * x^-1 */
                     R[MAXBLOCKSIZE],         /* R value */
                     checksum[MAXBLOCKSIZE];  /* current checksum */

   symmetric_key     key;                     /* scheduled key for cipher */
   unsigned long     block_index;             /* index # for current block */
   int               cipher,                  /* cipher idx */
                     block_len;               /* length of block */
} ocb_state;

 int ocb_init(ocb_state *ocb, int cipher, 
             const unsigned char *key, unsigned long keylen, const unsigned char *nonce);

 int ocb_encrypt(ocb_state *ocb, const unsigned char *pt, unsigned char *ct);
 int ocb_decrypt(ocb_state *ocb, const unsigned char *ct, unsigned char *pt);

 int ocb_done_encrypt(ocb_state *ocb, 
                     const unsigned char *pt,  unsigned long ptlen,
                           unsigned char *ct, 
                           unsigned char *tag, unsigned long *taglen);

 int ocb_done_decrypt(ocb_state *ocb, 
                     const unsigned char *ct,  unsigned long ctlen,
                           unsigned char *pt, 
                     const unsigned char *tag, unsigned long taglen, int *res);

 int ocb_encrypt_authenticate_memory(int cipher,
    const unsigned char *key,    unsigned long keylen,
    const unsigned char *nonce,  
    const unsigned char *pt,     unsigned long ptlen,
          unsigned char *ct,
          unsigned char *tag,    unsigned long *taglen);

 int ocb_decrypt_verify_memory(int cipher,
    const unsigned char *key,    unsigned long keylen,
    const unsigned char *nonce,  
    const unsigned char *ct,     unsigned long ctlen,
          unsigned char *pt,
    const unsigned char *tag,    unsigned long taglen,
          int           *res);

 int ocb_test(void);

/* internal functions */
 void ocb_shift_xor(ocb_state *ocb, unsigned char *Z);
 int ocb_ntz(unsigned long x);
 int __ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen,
                     unsigned char *ct, unsigned char *tag, unsigned long *taglen, int mode);

#endif /* OCB_MODE */