Add hash_buffer and hash_buffers pointers to message digest spec
[libgcrypt.git] / cipher / sm3.c
1 /* sm3.c - SM3 hash function
2  * Copyright (C) 2017 Jia Zhang
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20
21 /*  Test vectors:
22
23     "abc"
24     SM3: 66c7f0f4 62eeedd9 d1f2d46b dc10e4e2 4167c487 5cf2f7a2 297da02b 8f4ba8e0
25
26     "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"
27     SM3: debe9ff9 2275b8a1 38604889 c18e5a4d 6fdb70e5 387e5765 293dcba3 9c0c5732
28
29     "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
30     SM3: 639b6cc5 e64d9e37 a390b192 df4fa1ea 0720ab74 7ff692b9 f38c4e66 ad7b8c05
31
32     "a" one million times
33     SM3: c8aaf894 29554029 e231941a 2acc0ad6 1ff2a5ac d8fadd25 847a3a73 2b3b02c3
34
35  */
36
37
38 #include <config.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42
43 #include "g10lib.h"
44 #include "bithelp.h"
45 #include "bufhelp.h"
46 #include "cipher.h"
47 #include "hash-common.h"
48
49
50 typedef struct {
51   gcry_md_block_ctx_t bctx;
52   u32  h0,h1,h2,h3,h4,h5,h6,h7;
53 } SM3_CONTEXT;
54
55
56 static unsigned int
57 transform (void *c, const unsigned char *data, size_t nblks);
58
59
60 static void
61 sm3_init (void *context, unsigned int flags)
62 {
63   SM3_CONTEXT *hd = context;
64   unsigned int features = _gcry_get_hw_features ();
65
66   (void)flags;
67
68   hd->h0 = 0x7380166f;
69   hd->h1 = 0x4914b2b9;
70   hd->h2 = 0x172442d7;
71   hd->h3 = 0xda8a0600;
72   hd->h4 = 0xa96f30bc;
73   hd->h5 = 0x163138aa;
74   hd->h6 = 0xe38dee4d;
75   hd->h7 = 0xb0fb0e4e;
76
77   hd->bctx.nblocks = 0;
78   hd->bctx.nblocks_high = 0;
79   hd->bctx.count = 0;
80   hd->bctx.blocksize = 64;
81   hd->bctx.bwrite = transform;
82
83   (void)features;
84 }
85
86
87 /*
88   Transform the message X which consists of 16 32-bit-words. See
89   GM/T 004-2012 for details.  */
90 #define R(i,a,b,c,d,e,f,g,h,t,w1,w2) do                               \
91           {                                                           \
92             ss1 = rol ((rol ((a), 12) + (e) + (t)), 7);               \
93             ss2 = ss1 ^ rol ((a), 12);                                \
94             d += FF##i(a,b,c) + ss2 + ((w1) ^ (w2));                  \
95             h += GG##i(e,f,g) + ss1 + (w1);                           \
96             b = rol ((b), 9);                                         \
97             f = rol ((f), 19);                                        \
98             h = P0 ((h));                                             \
99           } while (0)
100
101 #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)
102 #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)
103
104 #define FF1(x, y, z)  (x ^ y ^ z)
105
106 #define FF2(x, y, z)  ((x & y) | (x & z) | (y & z))
107
108 #define GG1(x, y, z)  (x ^ y ^ z)
109
110 #define GG2(x, y, z)  ((x & y) | ( ~x & z))
111
112 /* Message expansion */
113 #define P0(x) ((x) ^ rol ((x), 9) ^ rol ((x), 17))
114 #define P1(x) ((x) ^ rol ((x), 15) ^ rol ((x), 23))
115 #define I(i)  ( w[i] = buf_get_be32(data + i * 4) )
116 #define W1(i) ( w[i&0x0f] )
117 #define W2(i) ( w[i&0x0f] =   P1(w[i    &0x0f] \
118                                ^ w[(i-9)&0x0f] \
119                                ^ rol (w[(i-3)&0x0f], 15)) \
120                             ^ rol (w[(i-13)&0x0f], 7) \
121                             ^ w[(i-6)&0x0f] )
122
123 static unsigned int
124 transform_blk (void *ctx, const unsigned char *data)
125 {
126   SM3_CONTEXT *hd = ctx;
127   static const u32 K[64] = {
128     0x79cc4519, 0xf3988a32, 0xe7311465, 0xce6228cb,
129     0x9cc45197, 0x3988a32f, 0x7311465e, 0xe6228cbc,
130     0xcc451979, 0x988a32f3, 0x311465e7, 0x6228cbce,
131     0xc451979c, 0x88a32f39, 0x11465e73, 0x228cbce6,
132     0x9d8a7a87, 0x3b14f50f, 0x7629ea1e, 0xec53d43c,
133     0xd8a7a879, 0xb14f50f3, 0x629ea1e7, 0xc53d43ce,
134     0x8a7a879d, 0x14f50f3b, 0x29ea1e76, 0x53d43cec,
135     0xa7a879d8, 0x4f50f3b1, 0x9ea1e762, 0x3d43cec5,
136     0x7a879d8a, 0xf50f3b14, 0xea1e7629, 0xd43cec53,
137     0xa879d8a7, 0x50f3b14f, 0xa1e7629e, 0x43cec53d,
138     0x879d8a7a, 0x0f3b14f5, 0x1e7629ea, 0x3cec53d4,
139     0x79d8a7a8, 0xf3b14f50, 0xe7629ea1, 0xcec53d43,
140     0x9d8a7a87, 0x3b14f50f, 0x7629ea1e, 0xec53d43c,
141     0xd8a7a879, 0xb14f50f3, 0x629ea1e7, 0xc53d43ce,
142     0x8a7a879d, 0x14f50f3b, 0x29ea1e76, 0x53d43cec,
143     0xa7a879d8, 0x4f50f3b1, 0x9ea1e762, 0x3d43cec5
144   };
145
146   u32 a,b,c,d,e,f,g,h,ss1,ss2;
147   u32 w[16];
148
149   a = hd->h0;
150   b = hd->h1;
151   c = hd->h2;
152   d = hd->h3;
153   e = hd->h4;
154   f = hd->h5;
155   g = hd->h6;
156   h = hd->h7;
157
158   R1(a, b, c, d, e, f, g, h, K[0], I(0), I(4));
159   R1(d, a, b, c, h, e, f, g, K[1], I(1), I(5));
160   R1(c, d, a, b, g, h, e, f, K[2], I(2), I(6));
161   R1(b, c, d, a, f, g, h, e, K[3], I(3), I(7));
162   R1(a, b, c, d, e, f, g, h, K[4], W1(4), I(8));
163   R1(d, a, b, c, h, e, f, g, K[5], W1(5), I(9));
164   R1(c, d, a, b, g, h, e, f, K[6], W1(6), I(10));
165   R1(b, c, d, a, f, g, h, e, K[7], W1(7), I(11));
166   R1(a, b, c, d, e, f, g, h, K[8], W1(8), I(12));
167   R1(d, a, b, c, h, e, f, g, K[9], W1(9), I(13));
168   R1(c, d, a, b, g, h, e, f, K[10], W1(10), I(14));
169   R1(b, c, d, a, f, g, h, e, K[11], W1(11), I(15));
170   R1(a, b, c, d, e, f, g, h, K[12], W1(12), W2(16));
171   R1(d, a, b, c, h, e, f, g, K[13], W1(13), W2(17));
172   R1(c, d, a, b, g, h, e, f, K[14], W1(14), W2(18));
173   R1(b, c, d, a, f, g, h, e, K[15], W1(15), W2(19));
174
175   R2(a, b, c, d, e, f, g, h, K[16], W1(16), W2(20));
176   R2(d, a, b, c, h, e, f, g, K[17], W1(17), W2(21));
177   R2(c, d, a, b, g, h, e, f, K[18], W1(18), W2(22));
178   R2(b, c, d, a, f, g, h, e, K[19], W1(19), W2(23));
179   R2(a, b, c, d, e, f, g, h, K[20], W1(20), W2(24));
180   R2(d, a, b, c, h, e, f, g, K[21], W1(21), W2(25));
181   R2(c, d, a, b, g, h, e, f, K[22], W1(22), W2(26));
182   R2(b, c, d, a, f, g, h, e, K[23], W1(23), W2(27));
183   R2(a, b, c, d, e, f, g, h, K[24], W1(24), W2(28));
184   R2(d, a, b, c, h, e, f, g, K[25], W1(25), W2(29));
185   R2(c, d, a, b, g, h, e, f, K[26], W1(26), W2(30));
186   R2(b, c, d, a, f, g, h, e, K[27], W1(27), W2(31));
187   R2(a, b, c, d, e, f, g, h, K[28], W1(28), W2(32));
188   R2(d, a, b, c, h, e, f, g, K[29], W1(29), W2(33));
189   R2(c, d, a, b, g, h, e, f, K[30], W1(30), W2(34));
190   R2(b, c, d, a, f, g, h, e, K[31], W1(31), W2(35));
191
192   R2(a, b, c, d, e, f, g, h, K[32], W1(32), W2(36));
193   R2(d, a, b, c, h, e, f, g, K[33], W1(33), W2(37));
194   R2(c, d, a, b, g, h, e, f, K[34], W1(34), W2(38));
195   R2(b, c, d, a, f, g, h, e, K[35], W1(35), W2(39));
196   R2(a, b, c, d, e, f, g, h, K[36], W1(36), W2(40));
197   R2(d, a, b, c, h, e, f, g, K[37], W1(37), W2(41));
198   R2(c, d, a, b, g, h, e, f, K[38], W1(38), W2(42));
199   R2(b, c, d, a, f, g, h, e, K[39], W1(39), W2(43));
200   R2(a, b, c, d, e, f, g, h, K[40], W1(40), W2(44));
201   R2(d, a, b, c, h, e, f, g, K[41], W1(41), W2(45));
202   R2(c, d, a, b, g, h, e, f, K[42], W1(42), W2(46));
203   R2(b, c, d, a, f, g, h, e, K[43], W1(43), W2(47));
204   R2(a, b, c, d, e, f, g, h, K[44], W1(44), W2(48));
205   R2(d, a, b, c, h, e, f, g, K[45], W1(45), W2(49));
206   R2(c, d, a, b, g, h, e, f, K[46], W1(46), W2(50));
207   R2(b, c, d, a, f, g, h, e, K[47], W1(47), W2(51));
208
209   R2(a, b, c, d, e, f, g, h, K[48], W1(48), W2(52));
210   R2(d, a, b, c, h, e, f, g, K[49], W1(49), W2(53));
211   R2(c, d, a, b, g, h, e, f, K[50], W1(50), W2(54));
212   R2(b, c, d, a, f, g, h, e, K[51], W1(51), W2(55));
213   R2(a, b, c, d, e, f, g, h, K[52], W1(52), W2(56));
214   R2(d, a, b, c, h, e, f, g, K[53], W1(53), W2(57));
215   R2(c, d, a, b, g, h, e, f, K[54], W1(54), W2(58));
216   R2(b, c, d, a, f, g, h, e, K[55], W1(55), W2(59));
217   R2(a, b, c, d, e, f, g, h, K[56], W1(56), W2(60));
218   R2(d, a, b, c, h, e, f, g, K[57], W1(57), W2(61));
219   R2(c, d, a, b, g, h, e, f, K[58], W1(58), W2(62));
220   R2(b, c, d, a, f, g, h, e, K[59], W1(59), W2(63));
221   R2(a, b, c, d, e, f, g, h, K[60], W1(60), W2(64));
222   R2(d, a, b, c, h, e, f, g, K[61], W1(61), W2(65));
223   R2(c, d, a, b, g, h, e, f, K[62], W1(62), W2(66));
224   R2(b, c, d, a, f, g, h, e, K[63], W1(63), W2(67));
225
226   hd->h0 ^= a;
227   hd->h1 ^= b;
228   hd->h2 ^= c;
229   hd->h3 ^= d;
230   hd->h4 ^= e;
231   hd->h5 ^= f;
232   hd->h6 ^= g;
233   hd->h7 ^= h;
234
235   return /*burn_stack*/ 26*4+32;
236 }
237 #undef P0
238 #undef P1
239 #undef R
240 #undef R1
241 #undef R2
242
243 static unsigned int
244 transform (void *ctx, const unsigned char *data, size_t nblks)
245 {
246   SM3_CONTEXT *hd = ctx;
247   unsigned int burn;
248
249   do
250     {
251       burn = transform_blk (hd, data);
252       data += 64;
253     }
254   while (--nblks);
255
256   return burn;
257 }
258
259
260 /*
261    The routine finally terminates the computation and returns the
262    digest.  The handle is prepared for a new cycle, but adding bytes
263    to the handle will the destroy the returned buffer.  Returns: 32
264    bytes with the message the digest.  */
265 static void
266 sm3_final(void *context)
267 {
268   SM3_CONTEXT *hd = context;
269   u32 t, th, msb, lsb;
270   byte *p;
271   unsigned int burn;
272
273   _gcry_md_block_write (hd, NULL, 0); /* flush */;
274
275   t = hd->bctx.nblocks;
276   if (sizeof t == sizeof hd->bctx.nblocks)
277     th = hd->bctx.nblocks_high;
278   else
279     th = hd->bctx.nblocks >> 32;
280
281   /* multiply by 64 to make a byte count */
282   lsb = t << 6;
283   msb = (th << 6) | (t >> 26);
284   /* add the count */
285   t = lsb;
286   if ((lsb += hd->bctx.count) < t)
287     msb++;
288   /* multiply by 8 to make a bit count */
289   t = lsb;
290   lsb <<= 3;
291   msb <<= 3;
292   msb |= t >> 29;
293
294   if (hd->bctx.count < 56)
295     { /* enough room */
296       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad */
297       while (hd->bctx.count < 56)
298         hd->bctx.buf[hd->bctx.count++] = 0;  /* pad */
299     }
300   else
301     { /* need one extra block */
302       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad character */
303       while (hd->bctx.count < 64)
304         hd->bctx.buf[hd->bctx.count++] = 0;
305       _gcry_md_block_write (hd, NULL, 0);  /* flush */;
306       memset (hd->bctx.buf, 0, 56 ); /* fill next block with zeroes */
307     }
308   /* append the 64 bit count */
309   buf_put_be32(hd->bctx.buf + 56, msb);
310   buf_put_be32(hd->bctx.buf + 60, lsb);
311   burn = transform (hd, hd->bctx.buf, 1);
312   _gcry_burn_stack (burn);
313
314   p = hd->bctx.buf;
315 #define X(a) do { buf_put_be32(p, hd->h##a); p += 4; } while(0)
316   X(0);
317   X(1);
318   X(2);
319   X(3);
320   X(4);
321   X(5);
322   X(6);
323   X(7);
324 #undef X
325 }
326
327 static byte *
328 sm3_read (void *context)
329 {
330   SM3_CONTEXT *hd = context;
331
332   return hd->bctx.buf;
333 }
334
335
336 /* Shortcut functions which puts the hash value of the supplied buffer
337  * into outbuf which must have a size of 32 bytes.  */
338 void
339 _gcry_sm3_hash_buffer (void *outbuf, const void *buffer, size_t length)
340 {
341   SM3_CONTEXT hd;
342
343   sm3_init (&hd, 0);
344   _gcry_md_block_write (&hd, buffer, length);
345   sm3_final (&hd);
346   memcpy (outbuf, hd.bctx.buf, 32);
347 }
348
349
350 /* Variant of the above shortcut function using multiple buffers.  */
351 void
352 _gcry_sm3_hash_buffers (void *outbuf, const gcry_buffer_t *iov, int iovcnt)
353 {
354   SM3_CONTEXT hd;
355
356   sm3_init (&hd, 0);
357   for (;iovcnt > 0; iov++, iovcnt--)
358     _gcry_md_block_write (&hd,
359                           (const char*)iov[0].data + iov[0].off, iov[0].len);
360   sm3_final (&hd);
361   memcpy (outbuf, hd.bctx.buf, 32);
362 }
363
364
365 \f
366 /*
367      Self-test section.
368  */
369
370
371 static gpg_err_code_t
372 selftests_sm3 (int extended, selftest_report_func_t report)
373 {
374   const char *what;
375   const char *errtxt;
376
377   what = "short string (spec example 1)";
378   errtxt = _gcry_hash_selftest_check_one
379     (GCRY_MD_SM3, 0,
380      "abc", 3,
381      "\x66\xc7\xf0\xf4\x62\xee\xed\xd9\xd1\xf2\xd4\x6b\xdc\x10\xe4\xe2"
382      "\x41\x67\xc4\x87\x5c\xf2\xf7\xa2\x29\x7d\xa0\x2b\x8f\x4b\xa8\xe0", 32);
383   if (errtxt)
384     goto failed;
385
386   if (extended)
387     {
388       what = "long string (spec example 2)";
389       errtxt = _gcry_hash_selftest_check_one
390         (GCRY_MD_SM3, 0,
391          "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd", 64,
392          "\xde\xbe\x9f\xf9\x22\x75\xb8\xa1\x38\x60\x48\x89\xc1\x8e\x5a\x4d"
393          "\x6f\xdb\x70\xe5\x38\x7e\x57\x65\x29\x3d\xcb\xa3\x9c\x0c\x57\x32",
394          32);
395       if (errtxt)
396         goto failed;
397
398       what = "long string";
399       errtxt = _gcry_hash_selftest_check_one
400         (GCRY_MD_SM3, 0,
401          "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
402          "\x63\x9b\x6c\xc5\xe6\x4d\x9e\x37\xa3\x90\xb1\x92\xdf\x4f\xa1\xea"
403          "\x07\x20\xab\x74\x7f\xf6\x92\xb9\xf3\x8c\x4e\x66\xad\x7b\x8c\x05",
404          32);
405       if (errtxt)
406         goto failed;
407
408       what = "one million \"a\"";
409       errtxt = _gcry_hash_selftest_check_one
410         (GCRY_MD_SM3, 1,
411          NULL, 0,
412          "\xc8\xaa\xf8\x94\x29\x55\x40\x29\xe2\x31\x94\x1a\x2a\xcc\x0a\xd6"
413          "\x1f\xf2\xa5\xac\xd8\xfa\xdd\x25\x84\x7a\x3a\x73\x2b\x3b\x02\xc3",
414          32);
415       if (errtxt)
416         goto failed;
417     }
418
419   return 0; /* Succeeded. */
420
421  failed:
422   if (report)
423     report ("digest", GCRY_MD_SM3, what, errtxt);
424   return GPG_ERR_SELFTEST_FAILED;
425 }
426
427
428 /* Run a full self-test for ALGO and return 0 on success.  */
429 static gpg_err_code_t
430 run_selftests (int algo, int extended, selftest_report_func_t report)
431 {
432   gpg_err_code_t ec;
433
434   switch (algo)
435     {
436     case GCRY_MD_SM3:
437       ec = selftests_sm3 (extended, report);
438       break;
439     default:
440       ec = GPG_ERR_DIGEST_ALGO;
441       break;
442
443     }
444   return ec;
445 }
446
447 static byte asn_sm3[] = /* Object ID is 1.2.156.10197.401 */
448   { 0x30, 0x2F, 0x30, 0x0B, 0x06, 0x07, 0x2A, 0x81,
449     0x1C, 0xCF, 0x55, 0x83, 0x11, 0x05, 0x00, 0x04,
450     0x20 };
451
452 static gcry_md_oid_spec_t oid_spec_sm3[] =
453   {
454     /* China Electronics Standardization Instutute,
455        OID White paper (2015), Table 6 */
456     { "1.2.156.10197.401" },
457     { NULL },
458   };
459
460 gcry_md_spec_t _gcry_digest_spec_sm3 =
461   {
462     GCRY_MD_SM3, {0, 1},
463     "SM3", asn_sm3, DIM (asn_sm3), oid_spec_sm3, 32,
464     sm3_init, _gcry_md_block_write, sm3_final, sm3_read, NULL,
465     _gcry_sm3_hash_buffer, _gcry_sm3_hash_buffers,
466     sizeof (SM3_CONTEXT),
467     run_selftests
468   };