pkgconfig: Fix libgcrypt.pc.
[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   t = hd->bctx.nblocks;
274   if (sizeof t == sizeof hd->bctx.nblocks)
275     th = hd->bctx.nblocks_high;
276   else
277     th = hd->bctx.nblocks >> 32;
278
279   /* multiply by 64 to make a byte count */
280   lsb = t << 6;
281   msb = (th << 6) | (t >> 26);
282   /* add the count */
283   t = lsb;
284   if ((lsb += hd->bctx.count) < t)
285     msb++;
286   /* multiply by 8 to make a bit count */
287   t = lsb;
288   lsb <<= 3;
289   msb <<= 3;
290   msb |= t >> 29;
291
292   if (hd->bctx.count < 56)  /* enough room */
293     {
294       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad */
295       if (hd->bctx.count < 56)
296         memset (&hd->bctx.buf[hd->bctx.count], 0, 56 - hd->bctx.count);
297       hd->bctx.count = 56;
298
299       /* append the 64 bit count */
300       buf_put_be32(hd->bctx.buf + 56, msb);
301       buf_put_be32(hd->bctx.buf + 60, lsb);
302       burn = (*hd->bctx.bwrite) ( hd, hd->bctx.buf, 1 );
303     }
304   else  /* need one extra block */
305     {
306       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad character */
307       /* fill pad and next block with zeroes */
308       memset (&hd->bctx.buf[hd->bctx.count], 0, 64 - hd->bctx.count + 56);
309       hd->bctx.count = 64 + 56;
310
311       /* append the 64 bit count */
312       buf_put_be32(hd->bctx.buf + 64 + 56, msb);
313       buf_put_be32(hd->bctx.buf + 64 + 60, lsb);
314       burn = (*hd->bctx.bwrite) ( hd, hd->bctx.buf, 2 );
315     }
316
317   p = hd->bctx.buf;
318 #define X(a) do { buf_put_be32(p, hd->h##a); p += 4; } while(0)
319   X(0);
320   X(1);
321   X(2);
322   X(3);
323   X(4);
324   X(5);
325   X(6);
326   X(7);
327 #undef X
328
329   _gcry_burn_stack (burn);
330 }
331
332 static byte *
333 sm3_read (void *context)
334 {
335   SM3_CONTEXT *hd = context;
336
337   return hd->bctx.buf;
338 }
339
340
341 /* Shortcut functions which puts the hash value of the supplied buffer
342  * into outbuf which must have a size of 32 bytes.  */
343 void
344 _gcry_sm3_hash_buffer (void *outbuf, const void *buffer, size_t length)
345 {
346   SM3_CONTEXT hd;
347
348   sm3_init (&hd, 0);
349   _gcry_md_block_write (&hd, buffer, length);
350   sm3_final (&hd);
351   memcpy (outbuf, hd.bctx.buf, 32);
352 }
353
354
355 /* Variant of the above shortcut function using multiple buffers.  */
356 void
357 _gcry_sm3_hash_buffers (void *outbuf, const gcry_buffer_t *iov, int iovcnt)
358 {
359   SM3_CONTEXT hd;
360
361   sm3_init (&hd, 0);
362   for (;iovcnt > 0; iov++, iovcnt--)
363     _gcry_md_block_write (&hd,
364                           (const char*)iov[0].data + iov[0].off, iov[0].len);
365   sm3_final (&hd);
366   memcpy (outbuf, hd.bctx.buf, 32);
367 }
368
369
370 \f
371 /*
372      Self-test section.
373  */
374
375
376 static gpg_err_code_t
377 selftests_sm3 (int extended, selftest_report_func_t report)
378 {
379   const char *what;
380   const char *errtxt;
381
382   what = "short string (spec example 1)";
383   errtxt = _gcry_hash_selftest_check_one
384     (GCRY_MD_SM3, 0,
385      "abc", 3,
386      "\x66\xc7\xf0\xf4\x62\xee\xed\xd9\xd1\xf2\xd4\x6b\xdc\x10\xe4\xe2"
387      "\x41\x67\xc4\x87\x5c\xf2\xf7\xa2\x29\x7d\xa0\x2b\x8f\x4b\xa8\xe0", 32);
388   if (errtxt)
389     goto failed;
390
391   if (extended)
392     {
393       what = "long string (spec example 2)";
394       errtxt = _gcry_hash_selftest_check_one
395         (GCRY_MD_SM3, 0,
396          "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd", 64,
397          "\xde\xbe\x9f\xf9\x22\x75\xb8\xa1\x38\x60\x48\x89\xc1\x8e\x5a\x4d"
398          "\x6f\xdb\x70\xe5\x38\x7e\x57\x65\x29\x3d\xcb\xa3\x9c\x0c\x57\x32",
399          32);
400       if (errtxt)
401         goto failed;
402
403       what = "long string";
404       errtxt = _gcry_hash_selftest_check_one
405         (GCRY_MD_SM3, 0,
406          "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
407          "\x63\x9b\x6c\xc5\xe6\x4d\x9e\x37\xa3\x90\xb1\x92\xdf\x4f\xa1\xea"
408          "\x07\x20\xab\x74\x7f\xf6\x92\xb9\xf3\x8c\x4e\x66\xad\x7b\x8c\x05",
409          32);
410       if (errtxt)
411         goto failed;
412
413       what = "one million \"a\"";
414       errtxt = _gcry_hash_selftest_check_one
415         (GCRY_MD_SM3, 1,
416          NULL, 0,
417          "\xc8\xaa\xf8\x94\x29\x55\x40\x29\xe2\x31\x94\x1a\x2a\xcc\x0a\xd6"
418          "\x1f\xf2\xa5\xac\xd8\xfa\xdd\x25\x84\x7a\x3a\x73\x2b\x3b\x02\xc3",
419          32);
420       if (errtxt)
421         goto failed;
422     }
423
424   return 0; /* Succeeded. */
425
426  failed:
427   if (report)
428     report ("digest", GCRY_MD_SM3, what, errtxt);
429   return GPG_ERR_SELFTEST_FAILED;
430 }
431
432
433 /* Run a full self-test for ALGO and return 0 on success.  */
434 static gpg_err_code_t
435 run_selftests (int algo, int extended, selftest_report_func_t report)
436 {
437   gpg_err_code_t ec;
438
439   switch (algo)
440     {
441     case GCRY_MD_SM3:
442       ec = selftests_sm3 (extended, report);
443       break;
444     default:
445       ec = GPG_ERR_DIGEST_ALGO;
446       break;
447
448     }
449   return ec;
450 }
451
452 static byte asn_sm3[] = /* Object ID is 1.2.156.10197.401 */
453   { 0x30, 0x2F, 0x30, 0x0B, 0x06, 0x07, 0x2A, 0x81,
454     0x1C, 0xCF, 0x55, 0x83, 0x11, 0x05, 0x00, 0x04,
455     0x20 };
456
457 static gcry_md_oid_spec_t oid_spec_sm3[] =
458   {
459     /* China Electronics Standardization Instutute,
460        OID White paper (2015), Table 6 */
461     { "1.2.156.10197.401" },
462     { NULL },
463   };
464
465 gcry_md_spec_t _gcry_digest_spec_sm3 =
466   {
467     GCRY_MD_SM3, {0, 0},
468     "SM3", asn_sm3, DIM (asn_sm3), oid_spec_sm3, 32,
469     sm3_init, _gcry_md_block_write, sm3_final, sm3_read, NULL,
470     _gcry_sm3_hash_buffer, _gcry_sm3_hash_buffers,
471     sizeof (SM3_CONTEXT),
472     run_selftests
473   };