pd.if.org Git - uuid/blob - hash.h

   1 #include <stdint.h>
   2 #include <string.h>
   3
   4 typedef uint64_t ulong64;
   5 typedef uint32_t ulong32;
   6
   7 #define CRYPT_OK 0
   8 #define CRYPT_INVALID_ARG 1
   9 #define CRYPT_NOP 2
  10 #define CRYPT_FAIL_TESTVECTOR 3
  11 #define XMEMCMP memcmp
  12 #define LTC_ARGCHK(x)
  13
  14 struct sha1_state {
  15     ulong64 length;
  16     ulong32 state[5], curlen;
  17     unsigned char buf[64];
  18 };
  19
  20 struct md5_state {
  21     ulong64 length;
  22     ulong32 state[4], curlen;
  23     unsigned char buf[64];
  24 };
  25
  26 typedef union Hash_state {
  27     struct sha1_state   sha1;
  28     struct md5_state    md5;
  29     void *data;
  30 } hash_state;
  31
  32 int sha1_init(hash_state * md);
  33 int sha1_process(hash_state * md, const unsigned char *in, unsigned long inlen);
  34 int sha1_done(hash_state * md, unsigned char *hash);
  35 int sha1_test(void);
  36
  37 int md5_init(hash_state * md);
  38 int md5_process(hash_state * md, const unsigned char *in, unsigned long inlen);
  39 int md5_done(hash_state * md, unsigned char *hash);
  40 int md5_test(void);
  41
  42 /* a simple macro for making hash "process" functions */
  43 #define HASH_PROCESS(func_name, compress_name, state_var, block_size)                       \
  44 int func_name (hash_state * md, const unsigned char *in, unsigned long inlen)               \
  45 {                                                                                           \
  46     unsigned long n;                                                                        \
  47     int           err;                                                                      \
  48     LTC_ARGCHK(md != NULL);                                                                 \
  49     LTC_ARGCHK(in != NULL);                                                                 \
  50     if (md-> state_var .curlen > sizeof(md-> state_var .buf)) {                             \
  51        return CRYPT_INVALID_ARG;                                                            \
  52     }                                                                                       \
  53     while (inlen > 0) {                                                                     \
  54         if (md-> state_var .curlen == 0 && inlen >= block_size) {                           \
  55            if ((err = compress_name (md, (unsigned char *)in)) != CRYPT_OK) {               \
  56               return err;                                                                   \
  57            }                                                                                \
  58            md-> state_var .length += block_size * 8;                                        \
  59            in             += block_size;                                                    \
  60            inlen          -= block_size;                                                    \
  61         } else {                                                                            \
  62            n = MIN(inlen, (block_size - md-> state_var .curlen));                           \
  63            memcpy(md-> state_var .buf + md-> state_var.curlen, in, (size_t)n);              \
  64            md-> state_var .curlen += n;                                                     \
  65            in             += n;                                                             \
  66            inlen          -= n;                                                             \
  67            if (md-> state_var .curlen == block_size) {                                      \
  68               if ((err = compress_name (md, md-> state_var .buf)) != CRYPT_OK) {            \
  69                  return err;                                                                \
  70               }                                                                             \
  71               md-> state_var .length += 8*block_size;                                       \
  72               md-> state_var .curlen = 0;                                                   \
  73            }                                                                                \
  74        }                                                                                    \
  75     }                                                                                       \
  76     return CRYPT_OK;                                                                        \
  77 }