gosthash2012.c

   1 /*
   2  * GOST R 34.11-2012 core functions.
   3  *
   4  * Copyright (c) 2013 Cryptocom LTD.
   5  * This file is distributed under the same license as OpenSSL.
   6  *
   7  * Author: Alexey Degtyarev <alexey@renatasystems.org>
   8  *
   9  */
  10
  11 #include "gosthash2012.h"
  12
  13 #if defined(_WIN32) || defined(_WINDOWS)
  14 # define INLINE __inline
  15 #else
  16 # define INLINE inline
  17 #endif
  18
  19 #define BSWAP64(x) \
  20     (((x & 0xFF00000000000000ULL) >> 56) | \
  21      ((x & 0x00FF000000000000ULL) >> 40) | \
  22      ((x & 0x0000FF0000000000ULL) >> 24) | \
  23      ((x & 0x000000FF00000000ULL) >>  8) | \
  24      ((x & 0x00000000FF000000ULL) <<  8) | \
  25      ((x & 0x0000000000FF0000ULL) << 24) | \
  26      ((x & 0x000000000000FF00ULL) << 40) | \
  27      ((x & 0x00000000000000FFULL) << 56))
  28
  29 /*
  30  * Initialize gost2012 hash context structure
  31  */
  32 void init_gost2012_hash_ctx(gost2012_hash_ctx * CTX,
  33                             const unsigned int digest_size)
  34 {
  35     memset(CTX, 0, sizeof(gost2012_hash_ctx));
  36
  37     CTX->digest_size = digest_size;
  38     /*
  39      * IV for 512-bit hash should be 0^512
  40      * IV for 256-bit hash should be (00000001)^64
  41      *
  42      * It's already zeroed when CTX is cleared above, so we only
  43      * need to set it to 0x01-s for 256-bit hash.
  44      */
  45     if (digest_size == 256)
  46         memset(&CTX->h, 0x01, sizeof(uint512_u));
  47 }
  48
  49 static INLINE void pad(gost2012_hash_ctx * CTX)
  50 {
  51     memset(&(CTX->buffer[CTX->bufsize]), 0, sizeof(CTX->buffer) - CTX->bufsize);
  52     CTX->buffer[CTX->bufsize] = 1;
  53
  54 }
  55
  56 static INLINE void add512(const union uint512_u *x,
  57                           const union uint512_u *y, union uint512_u *r)
  58 {
  59 #ifndef __GOST3411_BIG_ENDIAN__
  60     unsigned int CF;
  61     unsigned int i;
  62
  63     CF = 0;
  64     for (i = 0; i < 8; i++) {
  65         const unsigned long long left = x->QWORD[i];
  66         unsigned long long sum;
  67
  68         sum = left + y->QWORD[i] + CF;
  69         /*
  70          * (sum == left): is noop, because it's possible only
  71          * when `left' is added with `0 + 0' or with `ULLONG_MAX + 1',
  72          * in that case `CF' (carry) retain previous value, which is correct,
  73          * because when `left + 0 + 0' there was no overflow (thus no carry),
  74          * and when `left + ULLONG_MAX + 1' value is wrapped back to
  75          * itself with overflow, thus creating carry.
  76          *
  77          * (sum != left):
  78          * if `sum' is not wrapped (sum > left) there should not be carry,
  79          * if `sum' is wrapped (sum < left) there should be carry.
  80          */
  81         if (sum != left)
  82             CF = (sum < left);
  83         r->QWORD[i] = sum;
  84     }
  85 #else
  86     const unsigned char *xp, *yp;
  87     unsigned char *rp;
  88     unsigned int i;
  89     int buf;
  90
  91     xp = (const unsigned char *)&x[0];
  92     yp = (const unsigned char *)&y[0];
  93     rp = (unsigned char *)&r[0];
  94
  95     buf = 0;
  96     for (i = 0; i < 64; i++) {
  97         buf = xp[i] + yp[i] + (buf >> 8);
  98         rp[i] = (unsigned char)buf & 0xFF;
  99     }
 100 #endif
 101 }
 102
 103 static void g(union uint512_u *h, const union uint512_u *N,
 104               const unsigned char *m)
 105 {
 106 #ifdef __GOST3411_HAS_SSE2__
 107     __m128i xmm0, xmm2, xmm4, xmm6; /* XMMR0-quadruple */
 108     __m128i xmm1, xmm3, xmm5, xmm7; /* XMMR1-quadruple */
 109     unsigned int i;
 110
 111     LOAD(N, xmm0, xmm2, xmm4, xmm6);
 112     XLPS128M(h, xmm0, xmm2, xmm4, xmm6);
 113
 114     LOAD(m, xmm1, xmm3, xmm5, xmm7);
 115     XLPS128R(xmm0, xmm2, xmm4, xmm6, xmm1, xmm3, xmm5, xmm7);
 116
 117     for (i = 0; i < 11; i++)
 118         ROUND128(i, xmm0, xmm2, xmm4, xmm6, xmm1, xmm3, xmm5, xmm7);
 119
 120     XLPS128M((&C[11]), xmm0, xmm2, xmm4, xmm6);
 121     X128R(xmm0, xmm2, xmm4, xmm6, xmm1, xmm3, xmm5, xmm7);
 122
 123     X128M(h, xmm0, xmm2, xmm4, xmm6);
 124     X128M(m, xmm0, xmm2, xmm4, xmm6);
 125
 126     UNLOAD(h, xmm0, xmm2, xmm4, xmm6);
 127
 128     /* Restore the Floating-point status on the CPU */
 129     _mm_empty();
 130 #else
 131     union uint512_u Ki, data;
 132     unsigned int i;
 133
 134     XLPS(h, N, (&data));
 135
 136     /* Starting E() */
 137     Ki = data;
 138     XLPS((&Ki), ((const union uint512_u *)&m[0]), (&data));
 139
 140     for (i = 0; i < 11; i++)
 141         ROUND(i, (&Ki), (&data));
 142
 143     XLPS((&Ki), (&C[11]), (&Ki));
 144     X((&Ki), (&data), (&data));
 145     /* E() done */
 146
 147     X((&data), h, (&data));
 148     X((&data), ((const union uint512_u *)&m[0]), h);
 149 #endif
 150 }
 151
 152 static INLINE void stage2(gost2012_hash_ctx * CTX, const unsigned char *data)
 153 {
 154     union uint512_u m;
 155
 156     memcpy(&m, data, sizeof(m));
 157     g(&(CTX->h), &(CTX->N), (const unsigned char *)&m);
 158
 159     add512(&(CTX->N), &buffer512, &(CTX->N));
 160     add512(&(CTX->Sigma), &m, &(CTX->Sigma));
 161 }
 162
 163 static INLINE void stage3(gost2012_hash_ctx * CTX)
 164 {
 165     ALIGN(16) union uint512_u buf;
 166
 167     memset(&buf, 0x00, sizeof buf);
 168     memcpy(&buf, &(CTX->buffer), CTX->bufsize);
 169     memcpy(&(CTX->buffer), &buf, sizeof(uint512_u));
 170
 171     memset(&buf, 0x00, sizeof buf);
 172 #ifndef __GOST3411_BIG_ENDIAN__
 173     buf.QWORD[0] = CTX->bufsize << 3;
 174 #else
 175     buf.QWORD[0] = BSWAP64(CTX->bufsize << 3);
 176 #endif
 177
 178     pad(CTX);
 179
 180     g(&(CTX->h), &(CTX->N), (const unsigned char *)&(CTX->buffer));
 181
 182     add512(&(CTX->N), &buf, &(CTX->N));
 183     add512(&(CTX->Sigma), (const union uint512_u *)&CTX->buffer[0],
 184            &(CTX->Sigma));
 185
 186     g(&(CTX->h), &buffer0, (const unsigned char *)&(CTX->N));
 187
 188     g(&(CTX->h), &buffer0, (const unsigned char *)&(CTX->Sigma));
 189 }
 190
 191 /*
 192  * Hash block of arbitrary length
 193  *
 194  */
 195 void gost2012_hash_block(gost2012_hash_ctx * CTX,
 196                          const unsigned char *data, size_t len)
 197 {
 198     size_t chunksize;
 199
 200     while (len > 63 && CTX->bufsize == 0) {
 201         stage2(CTX, data);
 202
 203         data += 64;
 204         len -= 64;
 205     }
 206
 207     while (len) {
 208         chunksize = 64 - CTX->bufsize;
 209         if (chunksize > len)
 210             chunksize = len;
 211
 212         memcpy(&CTX->buffer[CTX->bufsize], data, chunksize);
 213
 214         CTX->bufsize += chunksize;
 215         len -= chunksize;
 216         data += chunksize;
 217
 218         if (CTX->bufsize == 64) {
 219             stage2(CTX, CTX->buffer);
 220
 221             CTX->bufsize = 0;
 222         }
 223     }
 224 }
 225
 226 /*
 227  * Compute hash value from current state of ctx
 228  * state of hash ctx becomes invalid and cannot be used for further
 229  * hashing.
 230  */
 231 void gost2012_finish_hash(gost2012_hash_ctx * CTX, unsigned char *digest)
 232 {
 233     stage3(CTX);
 234
 235     CTX->bufsize = 0;
 236
 237     if (CTX->digest_size == 256)
 238         memcpy(digest, &(CTX->h.QWORD[4]), 32);
 239     else
 240         memcpy(digest, &(CTX->h.QWORD[0]), 64);
 241 }