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(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 *N,
 103               const unsigned char *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), ((const union uint512_u *)&m[0]), h);
 148 #endif
 149 }
 150
 151 static INLINE void stage2(gost2012_hash_ctx * CTX, const unsigned char *data)
 152 {
 153     g(&(CTX->h), &(CTX->N), data);
 154
 155     add512(&(CTX->N), &buffer512);
 156     add512(&(CTX->Sigma), (const union uint512_u *)data);
 157 }
 158
 159 static INLINE void stage3(gost2012_hash_ctx * CTX)
 160 {
 161     ALIGN(16) union uint512_u buf;
 162
 163     memset(&buf, 0x00, sizeof buf);
 164     memcpy(&buf, &(CTX->buffer), CTX->bufsize);
 165     memcpy(&(CTX->buffer), &buf, sizeof(uint512_u));
 166
 167     memset(&buf, 0x00, sizeof buf);
 168 #ifndef __GOST3411_BIG_ENDIAN__
 169     buf.QWORD[0] = CTX->bufsize << 3;
 170 #else
 171     buf.QWORD[0] = BSWAP64(CTX->bufsize << 3);
 172 #endif
 173
 174     pad(CTX);
 175
 176     g(&(CTX->h), &(CTX->N), (const unsigned char *)&(CTX->buffer));
 177
 178     add512(&(CTX->N), &buf);
 179     add512(&(CTX->Sigma), (const union uint512_u *)&CTX->buffer[0]);
 180
 181     g(&(CTX->h), &buffer0, (const unsigned char *)&(CTX->N));
 182
 183     g(&(CTX->h), &buffer0, (const unsigned char *)&(CTX->Sigma));
 184 }
 185
 186 /*
 187  * Hash block of arbitrary length
 188  *
 189  */
 190 void gost2012_hash_block(gost2012_hash_ctx * CTX,
 191                          const unsigned char *data, size_t len)
 192 {
 193     size_t chunksize;
 194
 195     while (len > 63 && CTX->bufsize == 0) {
 196         memcpy(&CTX->buffer[0], data, 64);
 197         stage2(CTX, &CTX->buffer[0]);
 198
 199         data += 64;
 200         len -= 64;
 201     }
 202
 203     while (len) {
 204         chunksize = 64 - CTX->bufsize;
 205         if (chunksize > len)
 206             chunksize = len;
 207
 208         memcpy(&CTX->buffer[CTX->bufsize], data, chunksize);
 209
 210         CTX->bufsize += chunksize;
 211         len -= chunksize;
 212         data += chunksize;
 213
 214         if (CTX->bufsize == 64) {
 215             stage2(CTX, CTX->buffer);
 216
 217             CTX->bufsize = 0;
 218         }
 219     }
 220 }
 221
 222 /*
 223  * Compute hash value from current state of ctx
 224  * state of hash ctx becomes invalid and cannot be used for further
 225  * hashing.
 226  */
 227 void gost2012_finish_hash(gost2012_hash_ctx * CTX, unsigned char *digest)
 228 {
 229     stage3(CTX);
 230
 231     CTX->bufsize = 0;
 232
 233     if (CTX->digest_size == 256)
 234         memcpy(digest, &(CTX->h.QWORD[4]), 32);
 235     else
 236         memcpy(digest, &(CTX->h.QWORD[0]), 64);
 237 }