pd.if.org Git - zpackage/blob - lib/blake2.h

   1 #ifndef BLAKE2_H
   2 #define BLAKE2_H
   3
   4 #include <stddef.h>
   5 #include <stdint.h>
   6
   7 #if defined(_MSC_VER)
   8 #define BLAKE2_PACKED(x) __pragma(pack(push, 1)) x __pragma(pack(pop))
   9 #else
  10 #define BLAKE2_PACKED(x) x __attribute__((packed))
  11 #endif
  12
  13 enum blake2s_constant {
  14         BLAKE2S_BLOCKBYTES = 64,
  15         BLAKE2S_OUTBYTES = 32,
  16         BLAKE2S_KEYBYTES = 32,
  17         BLAKE2S_SALTBYTES = 8,
  18         BLAKE2S_PERSONALBYTES = 8
  19 };
  20
  21 enum blake2b_constant {
  22         BLAKE2B_BLOCKBYTES = 128,
  23         BLAKE2B_OUTBYTES = 64,
  24         BLAKE2B_KEYBYTES = 64,
  25         BLAKE2B_SALTBYTES = 16,
  26         BLAKE2B_PERSONALBYTES = 16
  27 };
  28
  29 typedef struct blake2s_state__ {
  30         uint32_t h[8];
  31         uint32_t t[2];
  32         uint32_t f[2];
  33         uint8_t buf[BLAKE2S_BLOCKBYTES];
  34         size_t buflen;
  35         size_t outlen;
  36         uint8_t last_node;
  37 } blake2s_state;
  38
  39 typedef struct blake2b_state__ {
  40         uint64_t h[8];
  41         uint64_t t[2];
  42         uint64_t f[2];
  43         uint8_t buf[BLAKE2B_BLOCKBYTES];
  44         size_t buflen;
  45         size_t outlen;
  46         uint8_t last_node;
  47 } blake2b_state;
  48
  49 typedef struct blake2sp_state__ {
  50         blake2s_state S[8][1];
  51         blake2s_state R[1];
  52         uint8_t buf[8 * BLAKE2S_BLOCKBYTES];
  53         size_t buflen;
  54         size_t outlen;
  55 } blake2sp_state;
  56
  57 typedef struct blake2bp_state__ {
  58         blake2b_state S[4][1];
  59         blake2b_state R[1];
  60         uint8_t buf[4 * BLAKE2B_BLOCKBYTES];
  61         size_t buflen;
  62         size_t outlen;
  63 } blake2bp_state;
  64
  65
  66 BLAKE2_PACKED(struct blake2s_param__ {
  67               uint8_t digest_length;    /* 1 */
  68               uint8_t key_length;       /* 2 */
  69               uint8_t fanout;   /* 3 */
  70               uint8_t depth;    /* 4 */
  71               uint32_t leaf_length;     /* 8 */
  72               uint32_t node_offset;     /* 12 */
  73               uint16_t xof_length;      /* 14 */
  74               uint8_t node_depth;       /* 15 */
  75               uint8_t inner_length;     /* 16 */
  76               /* uint8_t  reserved[0]; */
  77               uint8_t salt[BLAKE2S_SALTBYTES];  /* 24 */
  78               uint8_t personal[BLAKE2S_PERSONALBYTES];  /* 32 */
  79               });
  80
  81 typedef struct blake2s_param__ blake2s_param;
  82
  83 BLAKE2_PACKED(struct blake2b_param__ {
  84               uint8_t digest_length;    /* 1 */
  85               uint8_t key_length;       /* 2 */
  86               uint8_t fanout;   /* 3 */
  87               uint8_t depth;    /* 4 */
  88               uint32_t leaf_length;     /* 8 */
  89               uint32_t node_offset;     /* 12 */
  90               uint32_t xof_length;      /* 16 */
  91               uint8_t node_depth;       /* 17 */
  92               uint8_t inner_length;     /* 18 */
  93               uint8_t reserved[14];     /* 32 */
  94               uint8_t salt[BLAKE2B_SALTBYTES];  /* 48 */
  95               uint8_t personal[BLAKE2B_PERSONALBYTES];  /* 64 */
  96               });
  97
  98 typedef struct blake2b_param__ blake2b_param;
  99
 100 typedef struct blake2xs_state__ {
 101         blake2s_state S[1];
 102         blake2s_param P[1];
 103 } blake2xs_state;
 104
 105 typedef struct blake2xb_state__ {
 106         blake2b_state S[1];
 107         blake2b_param P[1];
 108 } blake2xb_state;
 109
 110   /* Padded structs result in a compile-time error */
 111 enum {
 112         BLAKE2_DUMMY_1 = 1 / (sizeof(blake2s_param) == BLAKE2S_OUTBYTES),
 113         BLAKE2_DUMMY_2 = 1 / (sizeof(blake2b_param) == BLAKE2B_OUTBYTES)
 114 };
 115
 116   /* Streaming API */
 117 int blake2s_init(blake2s_state * S, size_t outlen);
 118 int blake2s_init_key(blake2s_state * S, size_t outlen, const void *key,
 119                      size_t keylen);
 120 int blake2s_init_param(blake2s_state * S, const blake2s_param * P);
 121 int blake2s_update(blake2s_state * S, const void *in, size_t inlen);
 122 int blake2s_final(blake2s_state * S, void *out, size_t outlen);
 123
 124 int blake2b_init(blake2b_state * S, size_t outlen);
 125 int blake2b_init_key(blake2b_state * S, size_t outlen, const void *key,
 126                      size_t keylen);
 127 int blake2b_init_param(blake2b_state * S, const blake2b_param * P);
 128 int blake2b_update(blake2b_state * S, const void *in, size_t inlen);
 129 int blake2b_final(blake2b_state * S, void *out, size_t outlen);
 130
 131 int blake2sp_init(blake2sp_state * S, size_t outlen);
 132 int blake2sp_init_key(blake2sp_state * S, size_t outlen, const void *key,
 133                       size_t keylen);
 134 int blake2sp_update(blake2sp_state * S, const void *in, size_t inlen);
 135 int blake2sp_final(blake2sp_state * S, void *out, size_t outlen);
 136
 137 int blake2bp_init(blake2bp_state * S, size_t outlen);
 138 int blake2bp_init_key(blake2bp_state * S, size_t outlen, const void *key,
 139                       size_t keylen);
 140 int blake2bp_update(blake2bp_state * S, const void *in, size_t inlen);
 141 int blake2bp_final(blake2bp_state * S, void *out, size_t outlen);
 142
 143   /* Variable output length API */
 144 int blake2xs_init(blake2xs_state * S, const size_t outlen);
 145 int blake2xs_init_key(blake2xs_state * S, const size_t outlen,
 146                       const void *key, size_t keylen);
 147 int blake2xs_update(blake2xs_state * S, const void *in, size_t inlen);
 148 int blake2xs_final(blake2xs_state * S, void *out, size_t outlen);
 149
 150 int blake2xb_init(blake2xb_state * S, const size_t outlen);
 151 int blake2xb_init_key(blake2xb_state * S, const size_t outlen,
 152                       const void *key, size_t keylen);
 153 int blake2xb_update(blake2xb_state * S, const void *in, size_t inlen);
 154 int blake2xb_final(blake2xb_state * S, void *out, size_t outlen);
 155
 156   /* Simple API */
 157 int blake2s(void *out, size_t outlen, const void *in, size_t inlen,
 158             const void *key, size_t keylen);
 159 int blake2b(void *out, size_t outlen, const void *in, size_t inlen,
 160             const void *key, size_t keylen);
 161
 162 int blake2sp(void *out, size_t outlen, const void *in, size_t inlen,
 163              const void *key, size_t keylen);
 164 int blake2bp(void *out, size_t outlen, const void *in, size_t inlen,
 165              const void *key, size_t keylen);
 166
 167 int blake2xs(void *out, size_t outlen, const void *in, size_t inlen,
 168              const void *key, size_t keylen);
 169 int blake2xb(void *out, size_t outlen, const void *in, size_t inlen,
 170              const void *key, size_t keylen);
 171
 172   /* This is simply an alias for blake2b */
 173 int blake2(void *out, size_t outlen, const void *in, size_t inlen,
 174            const void *key, size_t keylen);
 175
 176 #endif