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