This source file includes following definitions.
- sm3_init_ctx
- set_uint32
- sm3_read_ctx
- sm3_conclude_ctx
- sm3_finish_ctx
- sm3_buffer
- sm3_process_bytes
- sm3_process_block
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 #include <config.h>
27
28
29 #if HAVE_OPENSSL_SM3
30 # define GL_OPENSSL_INLINE _GL_EXTERN_INLINE
31 #endif
32 #include "sm3.h"
33
34 #include <stdalign.h>
35 #include <stdint.h>
36 #include <string.h>
37
38 #include <byteswap.h>
39 #ifdef WORDS_BIGENDIAN
40 # define SWAP(n) (n)
41 #else
42 # define SWAP(n) bswap_32 (n)
43 #endif
44
45 #ifndef DEBUG_SM3
46 # define DEBUG_SM3 0
47 #endif
48
49 #if ! DEBUG_SM3
50 # define dbg_printf(fmt, ...) do { } while (0)
51 #else
52 # define dbg_printf printf
53 #endif
54
55 #if ! HAVE_OPENSSL_SM3
56
57
58
59 static const unsigned char fillbuf[64] = { 0x80, 0 };
60
61
62
63
64
65
66
67 void
68 sm3_init_ctx (struct sm3_ctx *ctx)
69 {
70 ctx->state[0] = 0x7380166fUL;
71 ctx->state[1] = 0x4914b2b9UL;
72 ctx->state[2] = 0x172442d7UL;
73 ctx->state[3] = 0xda8a0600UL;
74 ctx->state[4] = 0xa96f30bcUL;
75 ctx->state[5] = 0x163138aaUL;
76 ctx->state[6] = 0xe38dee4dUL;
77 ctx->state[7] = 0xb0fb0e4eUL;
78
79 ctx->total[0] = ctx->total[1] = 0;
80 ctx->buflen = 0;
81 }
82
83
84
85
86 static void
87 set_uint32 (char *cp, uint32_t v)
88 {
89 memcpy (cp, &v, sizeof v);
90 }
91
92
93
94 void *
95 sm3_read_ctx (const struct sm3_ctx *ctx, void *resbuf)
96 {
97 int i;
98 char *r = resbuf;
99
100 for (i = 0; i < 8; i++)
101 set_uint32 (r + i * sizeof ctx->state[0], SWAP (ctx->state[i]));
102
103 return resbuf;
104 }
105
106
107
108 static void
109 sm3_conclude_ctx (struct sm3_ctx *ctx)
110 {
111
112 size_t bytes = ctx->buflen;
113 size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
114
115
116 ctx->total[0] += bytes;
117 if (ctx->total[0] < bytes)
118 ++ctx->total[1];
119
120
121
122
123 set_uint32 ((char *) &ctx->buffer[size - 2],
124 SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29)));
125 set_uint32 ((char *) &ctx->buffer[size - 1],
126 SWAP (ctx->total[0] << 3));
127
128 memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
129
130
131 sm3_process_block (ctx->buffer, size * 4, ctx);
132 }
133
134 void *
135 sm3_finish_ctx (struct sm3_ctx *ctx, void *resbuf)
136 {
137 sm3_conclude_ctx (ctx);
138 return sm3_read_ctx (ctx, resbuf);
139 }
140
141
142
143
144
145 void *
146 sm3_buffer (const char *buffer, size_t len, void *resblock)
147 {
148 struct sm3_ctx ctx;
149
150
151 sm3_init_ctx (&ctx);
152
153
154 sm3_process_bytes (buffer, len, &ctx);
155
156
157 return sm3_finish_ctx (&ctx, resblock);
158 }
159
160 void
161 sm3_process_bytes (const void *buffer, size_t len, struct sm3_ctx *ctx)
162 {
163
164
165 if (ctx->buflen != 0)
166 {
167 size_t left_over = ctx->buflen;
168 size_t add = 128 - left_over > len ? len : 128 - left_over;
169
170 memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
171 ctx->buflen += add;
172
173 if (ctx->buflen > 64)
174 {
175 sm3_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
176
177 ctx->buflen &= 63;
178
179
180 memcpy (ctx->buffer,
181 &((char *) ctx->buffer)[(left_over + add) & ~63],
182 ctx->buflen);
183 }
184
185 buffer = (const char *) buffer + add;
186 len -= add;
187 }
188
189
190 if (len >= 64)
191 {
192 #if !(_STRING_ARCH_unaligned || _STRING_INLINE_unaligned)
193 # define UNALIGNED_P(p) ((uintptr_t) (p) % alignof (uint32_t) != 0)
194 if (UNALIGNED_P (buffer))
195 while (len > 64)
196 {
197 sm3_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
198 buffer = (const char *) buffer + 64;
199 len -= 64;
200 }
201 else
202 #endif
203 {
204 sm3_process_block (buffer, len & ~63, ctx);
205 buffer = (const char *) buffer + (len & ~63);
206 len &= 63;
207 }
208 }
209
210
211 if (len > 0)
212 {
213 size_t left_over = ctx->buflen;
214
215 memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
216 left_over += len;
217 if (left_over >= 64)
218 {
219 sm3_process_block (ctx->buffer, 64, ctx);
220 left_over -= 64;
221
222
223 memcpy (ctx->buffer, &ctx->buffer[16], left_over);
224 }
225 ctx->buflen = left_over;
226 }
227 }
228
229
230
231
232 #define T(j) sm3_round_constants[j]
233 static const uint32_t sm3_round_constants[64] = {
234 0x79cc4519UL, 0xf3988a32UL, 0xe7311465UL, 0xce6228cbUL,
235 0x9cc45197UL, 0x3988a32fUL, 0x7311465eUL, 0xe6228cbcUL,
236 0xcc451979UL, 0x988a32f3UL, 0x311465e7UL, 0x6228cbceUL,
237 0xc451979cUL, 0x88a32f39UL, 0x11465e73UL, 0x228cbce6UL,
238 0x9d8a7a87UL, 0x3b14f50fUL, 0x7629ea1eUL, 0xec53d43cUL,
239 0xd8a7a879UL, 0xb14f50f3UL, 0x629ea1e7UL, 0xc53d43ceUL,
240 0x8a7a879dUL, 0x14f50f3bUL, 0x29ea1e76UL, 0x53d43cecUL,
241 0xa7a879d8UL, 0x4f50f3b1UL, 0x9ea1e762UL, 0x3d43cec5UL,
242 0x7a879d8aUL, 0xf50f3b14UL, 0xea1e7629UL, 0xd43cec53UL,
243 0xa879d8a7UL, 0x50f3b14fUL, 0xa1e7629eUL, 0x43cec53dUL,
244 0x879d8a7aUL, 0x0f3b14f5UL, 0x1e7629eaUL, 0x3cec53d4UL,
245 0x79d8a7a8UL, 0xf3b14f50UL, 0xe7629ea1UL, 0xcec53d43UL,
246 0x9d8a7a87UL, 0x3b14f50fUL, 0x7629ea1eUL, 0xec53d43cUL,
247 0xd8a7a879UL, 0xb14f50f3UL, 0x629ea1e7UL, 0xc53d43ceUL,
248 0x8a7a879dUL, 0x14f50f3bUL, 0x29ea1e76UL, 0x53d43cecUL,
249 0xa7a879d8UL, 0x4f50f3b1UL, 0x9ea1e762UL, 0x3d43cec5UL,
250 };
251
252
253 #define FF1(X,Y,Z) ( X ^ Y ^ Z )
254 #define FF2(X,Y,Z) ( ( X & Y ) | ( X & Z ) | ( Y & Z ) )
255 #define GG1(X,Y,Z) ( X ^ Y ^ Z )
256 #define GG2(X,Y,Z) ( ( X & Y ) | ( ~X & Z ) )
257
258
259
260
261
262 void
263 sm3_process_block (const void *buffer, size_t len, struct sm3_ctx *ctx)
264 {
265 const uint32_t *words = buffer;
266 size_t nwords = len / sizeof (uint32_t);
267 const uint32_t *endp = words + nwords;
268 uint32_t x[16];
269 uint32_t a = ctx->state[0];
270 uint32_t b = ctx->state[1];
271 uint32_t c = ctx->state[2];
272 uint32_t d = ctx->state[3];
273 uint32_t e = ctx->state[4];
274 uint32_t f = ctx->state[5];
275 uint32_t g = ctx->state[6];
276 uint32_t h = ctx->state[7];
277 uint32_t lolen = len;
278
279
280
281
282 ctx->total[0] += lolen;
283 ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen);
284
285 #define rol(x, n) (((x) << ((n) & 31)) | ((x) >> ((32 - (n)) & 31)))
286 #define P0(x) ((x)^rol(x,9)^rol(x,17))
287 #define P1(x) ((x)^rol(x,15)^rol(x,23))
288
289 #define W1(I) ( x[I&0x0f] )
290 #define W2(I) ( tw = P1(x[I&0x0f]^x[(I-9)&0x0f]^rol(x[(I-3)&0x0f],15)) \
291 ^ rol(x[(I-13)&0x0f],7) ^ x[(I-6)&0x0f] \
292 , x[I&0x0f] = tw )
293
294 #define R(i,A,B,C,D,E,F,G,H,T,W1,W2) \
295 do { \
296 if (++j) \
297 dbg_printf("%2d %08x %08x %08x %08x %08x %08x %08x %08x\n", \
298 j-1, A, B, C, D, E, F, G, H); \
299 ss1 = rol(rol(A,12) + E + T,7); \
300 ss2 = ss1 ^ rol(A,12); \
301 D += FF##i(A,B,C) + ss2 + (W1 ^ W2); \
302 H += GG##i(E,F,G) + ss1 + W1; \
303 B = rol(B,9); \
304 F = rol(F,19); \
305 H = P0(H); \
306 } while(0)
307
308 #define R1(A,B,C,D,E,F,G,H,T,W1,W2) R(1,A,B,C,D,E,F,G,H,T,W1,W2)
309 #define R2(A,B,C,D,E,F,G,H,T,W1,W2) R(2,A,B,C,D,E,F,G,H,T,W1,W2)
310
311 while (words < endp)
312 {
313 uint32_t tw;
314 uint32_t ss1, ss2;
315 int j;
316
317 for (j = 0; j < 16; j++)
318 {
319 x[j] = SWAP (*words);
320 words++;
321 }
322
323 j = -1;
324
325 dbg_printf (" j A B C D E "
326 " F G H\n");
327 dbg_printf (" %08x %08x %08x %08x %08x %08x %08x %08x\n",
328 a, b, c, d, e, f, g, h);
329
330 R1( a, b, c, d, e, f, g, h, T( 0), W1( 0), W1( 4) );
331 R1( d, a, b, c, h, e, f, g, T( 1), W1( 1), W1( 5) );
332 R1( c, d, a, b, g, h, e, f, T( 2), W1( 2), W1( 6) );
333 R1( b, c, d, a, f, g, h, e, T( 3), W1( 3), W1( 7) );
334 R1( a, b, c, d, e, f, g, h, T( 4), W1( 4), W1( 8) );
335 R1( d, a, b, c, h, e, f, g, T( 5), W1( 5), W1( 9) );
336 R1( c, d, a, b, g, h, e, f, T( 6), W1( 6), W1(10) );
337 R1( b, c, d, a, f, g, h, e, T( 7), W1( 7), W1(11) );
338 R1( a, b, c, d, e, f, g, h, T( 8), W1( 8), W1(12) );
339 R1( d, a, b, c, h, e, f, g, T( 9), W1( 9), W1(13) );
340 R1( c, d, a, b, g, h, e, f, T(10), W1(10), W1(14) );
341 R1( b, c, d, a, f, g, h, e, T(11), W1(11), W1(15) );
342 R1( a, b, c, d, e, f, g, h, T(12), W1(12), W2(16) );
343 R1( d, a, b, c, h, e, f, g, T(13), W1(13), W2(17) );
344 R1( c, d, a, b, g, h, e, f, T(14), W1(14), W2(18) );
345 R1( b, c, d, a, f, g, h, e, T(15), W1(15), W2(19) );
346 R2( a, b, c, d, e, f, g, h, T(16), W1(16), W2(20) );
347 R2( d, a, b, c, h, e, f, g, T(17), W1(17), W2(21) );
348 R2( c, d, a, b, g, h, e, f, T(18), W1(18), W2(22) );
349 R2( b, c, d, a, f, g, h, e, T(19), W1(19), W2(23) );
350 R2( a, b, c, d, e, f, g, h, T(20), W1(20), W2(24) );
351 R2( d, a, b, c, h, e, f, g, T(21), W1(21), W2(25) );
352 R2( c, d, a, b, g, h, e, f, T(22), W1(22), W2(26) );
353 R2( b, c, d, a, f, g, h, e, T(23), W1(23), W2(27) );
354 R2( a, b, c, d, e, f, g, h, T(24), W1(24), W2(28) );
355 R2( d, a, b, c, h, e, f, g, T(25), W1(25), W2(29) );
356 R2( c, d, a, b, g, h, e, f, T(26), W1(26), W2(30) );
357 R2( b, c, d, a, f, g, h, e, T(27), W1(27), W2(31) );
358 R2( a, b, c, d, e, f, g, h, T(28), W1(28), W2(32) );
359 R2( d, a, b, c, h, e, f, g, T(29), W1(29), W2(33) );
360 R2( c, d, a, b, g, h, e, f, T(30), W1(30), W2(34) );
361 R2( b, c, d, a, f, g, h, e, T(31), W1(31), W2(35) );
362 R2( a, b, c, d, e, f, g, h, T(32), W1(32), W2(36) );
363 R2( d, a, b, c, h, e, f, g, T(33), W1(33), W2(37) );
364 R2( c, d, a, b, g, h, e, f, T(34), W1(34), W2(38) );
365 R2( b, c, d, a, f, g, h, e, T(35), W1(35), W2(39) );
366 R2( a, b, c, d, e, f, g, h, T(36), W1(36), W2(40) );
367 R2( d, a, b, c, h, e, f, g, T(37), W1(37), W2(41) );
368 R2( c, d, a, b, g, h, e, f, T(38), W1(38), W2(42) );
369 R2( b, c, d, a, f, g, h, e, T(39), W1(39), W2(43) );
370 R2( a, b, c, d, e, f, g, h, T(40), W1(40), W2(44) );
371 R2( d, a, b, c, h, e, f, g, T(41), W1(41), W2(45) );
372 R2( c, d, a, b, g, h, e, f, T(42), W1(42), W2(46) );
373 R2( b, c, d, a, f, g, h, e, T(43), W1(43), W2(47) );
374 R2( a, b, c, d, e, f, g, h, T(44), W1(44), W2(48) );
375 R2( d, a, b, c, h, e, f, g, T(45), W1(45), W2(49) );
376 R2( c, d, a, b, g, h, e, f, T(46), W1(46), W2(50) );
377 R2( b, c, d, a, f, g, h, e, T(47), W1(47), W2(51) );
378 R2( a, b, c, d, e, f, g, h, T(48), W1(48), W2(52) );
379 R2( d, a, b, c, h, e, f, g, T(49), W1(49), W2(53) );
380 R2( c, d, a, b, g, h, e, f, T(50), W1(50), W2(54) );
381 R2( b, c, d, a, f, g, h, e, T(51), W1(51), W2(55) );
382 R2( a, b, c, d, e, f, g, h, T(52), W1(52), W2(56) );
383 R2( d, a, b, c, h, e, f, g, T(53), W1(53), W2(57) );
384 R2( c, d, a, b, g, h, e, f, T(54), W1(54), W2(58) );
385 R2( b, c, d, a, f, g, h, e, T(55), W1(55), W2(59) );
386 R2( a, b, c, d, e, f, g, h, T(56), W1(56), W2(60) );
387 R2( d, a, b, c, h, e, f, g, T(57), W1(57), W2(61) );
388 R2( c, d, a, b, g, h, e, f, T(58), W1(58), W2(62) );
389 R2( b, c, d, a, f, g, h, e, T(59), W1(59), W2(63) );
390 R2( a, b, c, d, e, f, g, h, T(60), W1(60), W2(64) );
391 R2( d, a, b, c, h, e, f, g, T(61), W1(61), W2(65) );
392 R2( c, d, a, b, g, h, e, f, T(62), W1(62), W2(66) );
393 R2( b, c, d, a, f, g, h, e, T(63), W1(63), W2(67) );
394
395 dbg_printf("%2d %08x %08x %08x %08x %08x %08x %08x %08x\n",
396 j, a, b, c, d, e, f, g, h);
397
398 a = ctx->state[0] ^= a;
399 b = ctx->state[1] ^= b;
400 c = ctx->state[2] ^= c;
401 d = ctx->state[3] ^= d;
402 e = ctx->state[4] ^= e;
403 f = ctx->state[5] ^= f;
404 g = ctx->state[6] ^= g;
405 h = ctx->state[7] ^= h;
406 }
407 }
408
409 #endif
410
411
412
413
414
415
416