frontend/src/blake2.c

   1 /*
   2    This is a stripped-down and simplified "64-Bit only" version of BLAKE2s
   3    BLAKE2 reference source code package - reference C implementations
   4    Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
   5    terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
   6    your option.  The terms of these licenses can be found at:
   7    - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
   8    - OpenSSL license   : https://www.openssl.org/source/license.html
   9    - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
  10    More information about the BLAKE2 hash function can be found at
  11    https://blake2.net.
  12 */
  13
  14 #include "blake2.h"
  15
  16 /* -------------------------------------------------------------------------- */
  17 /* blake2-impl.h                                                              */
  18 /* -------------------------------------------------------------------------- */
  19
  20 #if defined(_MSC_VER)
  21 #       define BLAKE2_PACKED(X) __pragma(pack(push, 1)) X __pragma(pack(pop))
  22 #else
  23 #       define BLAKE2_PACKED(X) X __attribute__((packed))
  24 #endif
  25
  26 #if !defined(__cplusplus) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L)
  27 #       if defined(_MSC_VER)
  28 #               define BLAKE2_INLINE __inline
  29 #       elif defined(__GNUC__)
  30 #               define BLAKE2_INLINE __inline__
  31 #       else
  32 #               define BLAKE2_INLINE
  33 #       endif
  34 #else
  35 #       define BLAKE2_INLINE inline
  36 #endif
  37
  38 static const uint32_t blake2s_IV[8] =
  39 {
  40         0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
  41         0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL
  42 };
  43
  44 static const uint8_t blake2s_sigma[10][16] =
  45 {
  46         {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 },
  47         { 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3 },
  48         { 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4 },
  49         {  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8 },
  50         {  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13 },
  51         {  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9 },
  52         { 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11 },
  53         { 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10 },
  54         {  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5 },
  55         { 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0 },
  56 };
  57
  58 static BLAKE2_INLINE uint32_t load32(const void *const src)
  59 {
  60         const uint8_t *const p = (const uint8_t*)src;
  61         return
  62                 ((uint32_t)(p[0]) <<  0) |
  63                 ((uint32_t)(p[1]) <<  8) |
  64                 ((uint32_t)(p[2]) << 16) |
  65                 ((uint32_t)(p[3]) << 24);
  66 }
  67
  68 static BLAKE2_INLINE uint64_t make64(const uint32_t a, const uint32_t b)
  69 {
  70         return
  71                 ((uint64_t)(a) <<  0) |
  72                 ((uint64_t)(b) << 32);
  73 }
  74
  75 static BLAKE2_INLINE uint32_t rotr32(const uint32_t w, const unsigned c)
  76 {
  77         return (w >> c) | (w << (32 - c));
  78 }
  79
  80 /* -------------------------------------------------------------------------- */
  81 /* blake2s-ref.c                                                              */
  82 /* -------------------------------------------------------------------------- */
  83
  84 static void blake2s_set_lastnode(blake2s_t *const S)
  85 {
  86         S->f[1] = (uint32_t)-1;
  87 }
  88
  89 /* Some helper functions, not necessarily useful */
  90 static int blake2s_is_lastblock(const blake2s_t *const S)
  91 {
  92         return S->f[0] != 0;
  93 }
  94
  95 static void blake2s_set_lastblock(blake2s_t *const S)
  96 {
  97         if (S->last_node)
  98                 blake2s_set_lastnode(S);
  99         S->f[0] = (uint32_t)-1;
 100 }
 101
 102 static void blake2s_increment_counter(blake2s_t *const S, const uint32_t inc)
 103 {
 104         S->t[0] += inc;
 105         S->t[1] += (S->t[0] < inc);
 106 }
 107
 108 /* Sequential blake2s initialization */
 109 void blake2s_init(blake2s_t *const S)
 110 {
 111         size_t i;
 112         memset(S, 0, sizeof(blake2s_t));
 113
 114         for (i = 0; i < 8; ++i)
 115                 S->h[i] = blake2s_IV[i];
 116
 117         /* IV XOR ParamBlock, assuming P.digest_length = sizeof(uint64_t) */
 118         S->h[0] ^= 0x01010008UL;
 119 }
 120
 121 #define G(r,i,a,b,c,d) do \
 122 { \
 123         a = a + b + m[blake2s_sigma[r][2*i+0]]; \
 124         d = rotr32(d ^ a, 16);                  \
 125         c = c + d;                              \
 126         b = rotr32(b ^ c, 12);                  \
 127         a = a + b + m[blake2s_sigma[r][2*i+1]]; \
 128         d = rotr32(d ^ a, 8);                   \
 129         c = c + d;                              \
 130         b = rotr32(b ^ c, 7);                   \
 131 } \
 132 while(0)
 133
 134 #define ROUND(r) do \
 135 { \
 136         G(r, 0, v[0], v[4], v[ 8], v[12]); \
 137         G(r, 1, v[1], v[5], v[ 9], v[13]); \
 138         G(r, 2, v[2], v[6], v[10], v[14]); \
 139         G(r, 3, v[3], v[7], v[11], v[15]); \
 140         G(r, 4, v[0], v[5], v[10], v[15]); \
 141         G(r, 5, v[1], v[6], v[11], v[12]); \
 142         G(r, 6, v[2], v[7], v[ 8], v[13]); \
 143         G(r, 7, v[3], v[4], v[ 9], v[14]); \
 144 } \
 145 while(0)
 146
 147 static void blake2s_compress(blake2s_t *const S, const uint8_t in[BLAKE2S_BLOCKBYTES])
 148 {
 149         uint32_t m[16];
 150         uint32_t v[16];
 151         size_t i;
 152
 153         for (i = 0; i < 16; ++i)
 154         {
 155                 m[i] = load32(in + i * sizeof(m[i]));
 156         }
 157
 158         for (i = 0; i < 8; ++i)
 159         {
 160                 v[i] = S->h[i];
 161         }
 162
 163         v[ 8] = blake2s_IV[0];
 164         v[ 9] = blake2s_IV[1];
 165         v[10] = blake2s_IV[2];
 166         v[11] = blake2s_IV[3];
 167         v[12] = S->t[0] ^ blake2s_IV[4];
 168         v[13] = S->t[1] ^ blake2s_IV[5];
 169         v[14] = S->f[0] ^ blake2s_IV[6];
 170         v[15] = S->f[1] ^ blake2s_IV[7];
 171
 172         ROUND(0);
 173         ROUND(1);
 174         ROUND(2);
 175         ROUND(3);
 176         ROUND(4);
 177         ROUND(5);
 178         ROUND(6);
 179         ROUND(7);
 180         ROUND(8);
 181         ROUND(9);
 182
 183         for (i = 0; i < 8; ++i)
 184         {
 185                 S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
 186         }
 187 }
 188
 189 #undef G
 190 #undef ROUND
 191
 192 void blake2s_update(blake2s_t *const S, const void *const pin, size_t inlen)
 193 {
 194         const unsigned char* in = (const unsigned char*)pin;
 195         if (inlen > 0)
 196         {
 197                 size_t left = S->buflen;
 198                 size_t fill = BLAKE2S_BLOCKBYTES - left;
 199                 if (inlen > fill)
 200                 {
 201                         S->buflen = 0;
 202                         memcpy(S->buf + left, in, fill); /* Fill buffer */
 203                         blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES);
 204                         blake2s_compress(S, S->buf); /* Compress */
 205                         in += fill; inlen -= fill;
 206                         while (inlen > BLAKE2S_BLOCKBYTES)
 207                         {
 208                                 blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES);
 209                                 blake2s_compress(S, in);
 210                                 in += BLAKE2S_BLOCKBYTES;
 211                                 inlen -= BLAKE2S_BLOCKBYTES;
 212                         }
 213                 }
 214                 memcpy(S->buf + S->buflen, in, inlen);
 215                 S->buflen += inlen;
 216         }
 217 }
 218
 219 uint64_t blake2s_final(blake2s_t *const S)
 220 {
 221         if (blake2s_is_lastblock(S))
 222                 return 0U;
 223
 224         blake2s_increment_counter(S, (uint32_t)S->buflen);
 225         blake2s_set_lastblock(S);
 226         memset(S->buf + S->buflen, 0, BLAKE2S_BLOCKBYTES - S->buflen); /* Padding */
 227         blake2s_compress(S, S->buf);
 228
 229         return make64(S->h[0], S->h[1]);
 230 }
 231
 232 uint64_t blake2s_compute(const void *const pin, const size_t inlen)
 233 {
 234         blake2s_t state;
 235
 236         if ((pin != NULL) && (inlen > 0U))
 237         {
 238                 blake2s_init(&state);
 239                 blake2s_update(&state, pin, inlen);
 240                 return blake2s_final(&state);
 241         }
 242
 243         return 0xCCF2B16074DF93CEull;
 244 }