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.B[CTX->bufsize]), 0, sizeof(CTX->buffer) - CTX->bufsize);
  52     CTX->buffer.B[CTX->bufsize] = 1;
  53
  54 }
  55
  56 static INLINE void add512(union uint512_u * RESTRICT x,
  57                           const union uint512_u * RESTRICT y)
  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         x->QWORD[i] = sum;
  84     }
  85 #else
  86     const unsigned char *yp;
  87     unsigned char *xp;
  88     unsigned int i;
  89     int buf;
  90
  91     xp = (unsigned char *)&x[0];
  92     yp = (const unsigned char *)&y[0];
  93
  94     buf = 0;
  95     for (i = 0; i < 64; i++) {
  96         buf = xp[i] + yp[i] + (buf >> 8);
  97         xp[i] = (unsigned char)buf & 0xFF;
  98     }
  99 #endif
 100 }
 101
 102 static void g(union uint512_u *h, const union uint512_u * RESTRICT N,
 103               const union uint512_u * RESTRICT m)
 104 {
 105 #ifdef __GOST3411_HAS_SSE2__
 106     __m128i xmm0, xmm2, xmm4, xmm6; /* XMMR0-quadruple */
 107     __m128i xmm1, xmm3, xmm5, xmm7; /* XMMR1-quadruple */
 108     unsigned int i;
 109
 110     LOAD(N, xmm0, xmm2, xmm4, xmm6);
 111     XLPS128M(h, xmm0, xmm2, xmm4, xmm6);
 112
 113     LOAD(m, xmm1, xmm3, xmm5, xmm7);
 114     XLPS128R(xmm0, xmm2, xmm4, xmm6, xmm1, xmm3, xmm5, xmm7);
 115
 116     for (i = 0; i < 11; i++)
 117         ROUND128(i, xmm0, xmm2, xmm4, xmm6, xmm1, xmm3, xmm5, xmm7);
 118
 119     XLPS128M((&C[11]), xmm0, xmm2, xmm4, xmm6);
 120     X128R(xmm0, xmm2, xmm4, xmm6, xmm1, xmm3, xmm5, xmm7);
 121
 122     X128M(h, xmm0, xmm2, xmm4, xmm6);
 123     X128M(m, xmm0, xmm2, xmm4, xmm6);
 124
 125     UNLOAD(h, xmm0, xmm2, xmm4, xmm6);
 126
 127     /* Restore the Floating-point status on the CPU */
 128     _mm_empty();
 129 #else
 130     union uint512_u Ki, data;
 131     unsigned int i;
 132
 133     XLPS(h, N, (&data));
 134
 135     /* Starting E() */
 136     Ki = data;
 137     XLPS((&Ki), ((const union uint512_u *)&m[0]), (&data));
 138
 139     for (i = 0; i < 11; i++)
 140         ROUND(i, (&Ki), (&data));
 141
 142     XLPS((&Ki), (&C[11]), (&Ki));
 143     X((&Ki), (&data), (&data));
 144     /* E() done */
 145
 146     X((&data), h, (&data));
 147     X((&data), m, h);
 148 #endif
 149 }
 150
 151 static INLINE void stage2(gost2012_hash_ctx * CTX, const union uint512_u *data)
 152 {
 153     g(&(CTX->h), &(CTX->N), data);
 154
 155     add512(&(CTX->N), &buffer512);
 156     add512(&(CTX->Sigma), data);
 157 }
 158
 159 static INLINE void stage3(gost2012_hash_ctx * CTX)
 160 {
 161     pad(CTX);
 162     g(&(CTX->h), &(CTX->N), &(CTX->buffer));
 163     add512(&(CTX->Sigma), &CTX->buffer);
 164
 165     memset(&(CTX->buffer.B[0]), 0, sizeof(uint512_u));
 166 #ifndef __GOST3411_BIG_ENDIAN__
 167     CTX->buffer.QWORD[0] = CTX->bufsize << 3;
 168 #else
 169     CTX->buffer.QWORD[0] = BSWAP64(CTX->bufsize << 3);
 170 #endif
 171     add512(&(CTX->N), &(CTX->buffer));
 172
 173     g(&(CTX->h), &buffer0, &(CTX->N));
 174     g(&(CTX->h), &buffer0, &(CTX->Sigma));
 175 }
 176
 177 /*
 178  * Hash block of arbitrary length
 179  *
 180  */
 181 void gost2012_hash_block(gost2012_hash_ctx * CTX,
 182                          const unsigned char *data, size_t len)
 183 {
 184     register size_t chunksize;
 185     register size_t bufsize = CTX->bufsize;
 186
 187     if (bufsize == 0) {
 188         while (len >= 64) {
 189             memcpy(&CTX->buffer.B[0], data, 64);
 190             stage2(CTX, &(CTX->buffer));
 191             data += 64;
 192             len -= 64;
 193         }
 194     }
 195
 196     while (len) {
 197         chunksize = 64 - bufsize;
 198         if (chunksize > len)
 199             chunksize = len;
 200
 201         memcpy(&CTX->buffer.B[bufsize], data, chunksize);
 202
 203         bufsize += chunksize;
 204         len -= chunksize;
 205         data += chunksize;
 206
 207         if (bufsize == 64) {
 208             stage2(CTX, &(CTX->buffer) );
 209             bufsize = 0;
 210         }
 211     }
 212     CTX->bufsize = bufsize;
 213 }
 214
 215 /*
 216  * Compute hash value from current state of ctx
 217  * state of hash ctx becomes invalid and cannot be used for further
 218  * hashing.
 219  */
 220 void gost2012_finish_hash(gost2012_hash_ctx * CTX, unsigned char *digest)
 221 {
 222     stage3(CTX);
 223
 224     CTX->bufsize = 0;
 225
 226     if (CTX->digest_size == 256)
 227         memcpy(digest, &(CTX->h.QWORD[4]), 32);
 228     else
 229         memcpy(digest, &(CTX->h.QWORD[0]), 64);
 230 }