1 /* ====================================================================
2 * Copyright (c) 2014 - 2017 The GmSSL Project. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in
13 * the documentation and/or other materials provided with the
14 * distribution.
15 *
16 * 3. All advertising materials mentioning features or use of this
17 * software must display the following acknowledgment:
18 * "This product includes software developed by the GmSSL Project.
19 * (http://gmssl.org/)"
20 *
21 * 4. The name "GmSSL Project" must not be used to endorse or promote
22 * products derived from this software without prior written
23 * permission. For written permission, please contact
24 * guanzhi1980@gmail.com.
25 *
26 * 5. Products derived from this software may not be called "GmSSL"
27 * nor may "GmSSL" appear in their names without prior written
28 * permission of the GmSSL Project.
29 *
30 * 6. Redistributions of any form whatsoever must retain the following
31 * acknowledgment:
32 * "This product includes software developed by the GmSSL Project
33 * (http://gmssl.org/)"
34 *
35 * THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
36 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
39 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
46 * OF THE POSSIBILITY OF SUCH DAMAGE.
47 * ====================================================================
48 */
49 #include <stdint.h>
50 #include <string.h>
51 #include "modes_lcl.h"
52
53 typedef struct {
54 uint32_t digest[8];
55 uint64_t nblocks;
56 unsigned char block[64];
57 int num;
58 } rkgm_sm3_ctx_t;
59
60 #define SM3_DIGEST_LENGTH 32
61 #define SM3_BLOCK_SIZE 64
62 #define SM3_CBLOCK (SM3_BLOCK_SIZE)
63 #define SM3_HMAC_SIZE (SM3_DIGEST_LENGTH)
64
65 void rkgm_sm3_init(rkgm_sm3_ctx_t *ctx);
66 void rkgm_sm3_update(rkgm_sm3_ctx_t *ctx, const unsigned char* data, size_t data_len);
67 void rkgm_sm3_final(rkgm_sm3_ctx_t *ctx, unsigned char digest[SM3_DIGEST_LENGTH]);
68 void rkgm_sm3_compress(uint32_t digest[8], const unsigned char block[SM3_BLOCK_SIZE]);
69
70 static void sm3_compress_blocks(uint32_t digest[8],
71 const unsigned char *data, size_t blocks);
72
73
rkgm_sm3_init(rkgm_sm3_ctx_t * ctx)74 void rkgm_sm3_init(rkgm_sm3_ctx_t *ctx)
75 {
76 memset(ctx, 0, sizeof(*ctx));
77 ctx->digest[0] = 0x7380166F;
78 ctx->digest[1] = 0x4914B2B9;
79 ctx->digest[2] = 0x172442D7;
80 ctx->digest[3] = 0xDA8A0600;
81 ctx->digest[4] = 0xA96F30BC;
82 ctx->digest[5] = 0x163138AA;
83 ctx->digest[6] = 0xE38DEE4D;
84 ctx->digest[7] = 0xB0FB0E4E;
85 }
86
sm3_compute_id_digest(unsigned char z[32],const char * id,const unsigned char x[32],const unsigned char y[32])87 void sm3_compute_id_digest(unsigned char z[32], const char *id,
88 const unsigned char x[32], const unsigned char y[32])
89 {
90 unsigned char zin[] = {
91 0x00, 0x80,
92 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
93 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
94 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF,
95 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
96 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
97 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC,
98 0x28, 0xE9, 0xFA, 0x9E, 0x9D, 0x9F, 0x5E, 0x34,
99 0x4D, 0x5A, 0x9E, 0x4B, 0xCF, 0x65, 0x09, 0xA7,
100 0xF3, 0x97, 0x89, 0xF5, 0x15, 0xAB, 0x8F, 0x92,
101 0xDD, 0xBC, 0xBD, 0x41, 0x4D, 0x94, 0x0E, 0x93,
102 0x32, 0xC4, 0xAE, 0x2C, 0x1F, 0x19, 0x81, 0x19,
103 0x5F, 0x99, 0x04, 0x46, 0x6A, 0x39, 0xC9, 0x94,
104 0x8F, 0xE3, 0x0B, 0xBF, 0xF2, 0x66, 0x0B, 0xE1,
105 0x71, 0x5A, 0x45, 0x89, 0x33, 0x4C, 0x74, 0xC7,
106 0xBC, 0x37, 0x36, 0xA2, 0xF4, 0xF6, 0x77, 0x9C,
107 0x59, 0xBD, 0xCE, 0xE3, 0x6B, 0x69, 0x21, 0x53,
108 0xD0, 0xA9, 0x87, 0x7C, 0xC6, 0x2A, 0x47, 0x40,
109 0x02, 0xDF, 0x32, 0xE5, 0x21, 0x39, 0xF0, 0xA0,
110 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
111 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
112 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
113 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
114 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
115 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
116 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
117 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
118 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
119 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
120 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
121 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
122 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
123 0x00, 0x00, 0x00, 0x00, 0x06, 0x90,
124 };
125
126 if (!id || strcmp(id, "1234567812345678")) {
127 unsigned int digest[8] = {
128 0xadadedb5U, 0x0446043fU, 0x08a87aceU, 0xe86d2243U,
129 0x8e232383U, 0xbfc81fe2U, 0xcf9117c8U, 0x4707011dU,
130 };
131 memcpy(&zin[128], x, 32);
132 memcpy(&zin[160], y, 32);
133 sm3_compress_blocks(digest, zin, 2);
134 PUTU32(z , digest[0]);
135 PUTU32(z + 4, digest[1]);
136 PUTU32(z + 8, digest[2]);
137 PUTU32(z + 12, digest[3]);
138 PUTU32(z + 16, digest[4]);
139 PUTU32(z + 20, digest[5]);
140 PUTU32(z + 24, digest[6]);
141 PUTU32(z + 28, digest[7]);
142
143 } else {
144 rkgm_sm3_ctx_t ctx;
145 unsigned char idbits[2];
146 size_t len;
147
148 len = strlen(id);
149 idbits[0] = (unsigned char)(len >> 5);
150 idbits[1] = (unsigned char)(len << 3);
151
152 rkgm_sm3_init(&ctx);
153 rkgm_sm3_update(&ctx, idbits, 2);
154 rkgm_sm3_update(&ctx, (unsigned char *)id, len);
155 rkgm_sm3_update(&ctx, zin + 18, 128);
156 rkgm_sm3_update(&ctx, x, 32);
157 rkgm_sm3_update(&ctx, y, 32);
158 rkgm_sm3_final(&ctx, z);
159 }
160 }
161
sm3_sm2_init(rkgm_sm3_ctx_t * ctx,const char * id,const unsigned char * x,const unsigned char * y)162 int sm3_sm2_init(rkgm_sm3_ctx_t *ctx, const char *id,
163 const unsigned char *x, const unsigned char *y)
164 {
165 unsigned char z[32];
166 if ((id && strlen(id) > 65535/8) || !x || !y) {
167 return 0;
168 }
169 sm3_compute_id_digest(z, id, x, y);
170 rkgm_sm3_init(ctx);
171 rkgm_sm3_update(ctx, z, 32);
172 return 1;
173 }
174
rkgm_sm3_update(rkgm_sm3_ctx_t * ctx,const unsigned char * data,size_t data_len)175 void rkgm_sm3_update(rkgm_sm3_ctx_t *ctx, const unsigned char *data, size_t data_len)
176 {
177 size_t blocks;
178
179 if (ctx->num) {
180 unsigned int left = SM3_BLOCK_SIZE - ctx->num;
181 if (data_len < left) {
182 memcpy(ctx->block + ctx->num, data, data_len);
183 ctx->num += data_len;
184 return;
185 } else {
186 memcpy(ctx->block + ctx->num, data, left);
187 sm3_compress_blocks(ctx->digest, ctx->block, 1);
188 ctx->nblocks++;
189 data += left;
190 data_len -= left;
191 }
192 }
193
194 blocks = data_len / SM3_BLOCK_SIZE;
195 sm3_compress_blocks(ctx->digest, data, blocks);
196 ctx->nblocks += blocks;
197 data += SM3_BLOCK_SIZE * blocks;
198 data_len -= SM3_BLOCK_SIZE * blocks;
199
200 ctx->num = data_len;
201 if (data_len) {
202 memcpy(ctx->block, data, data_len);
203 }
204 }
205
rkgm_sm3_final(rkgm_sm3_ctx_t * ctx,unsigned char * digest)206 void rkgm_sm3_final(rkgm_sm3_ctx_t *ctx, unsigned char *digest)
207 {
208 int i;
209
210 ctx->block[ctx->num] = 0x80;
211
212 if (ctx->num + 9 <= SM3_BLOCK_SIZE) {
213 memset(ctx->block + ctx->num + 1, 0, SM3_BLOCK_SIZE - ctx->num - 9);
214 } else {
215 memset(ctx->block + ctx->num + 1, 0, SM3_BLOCK_SIZE - ctx->num - 1);
216 rkgm_sm3_compress(ctx->digest, ctx->block);
217 memset(ctx->block, 0, SM3_BLOCK_SIZE - 8);
218 }
219 PUTU32(ctx->block + 56, ctx->nblocks >> 23);
220 PUTU32(ctx->block + 60, (ctx->nblocks << 9) + (ctx->num << 3));
221
222 rkgm_sm3_compress(ctx->digest, ctx->block);
223 for (i = 0; i < 8; i++) {
224 PUTU32(digest + i*4, ctx->digest[i]);
225 }
226 }
227
228 #define ROTL(x,n) (((x)<<(n)) | ((x)>>(32-(n))))
229 #define P0(x) ((x) ^ ROL32((x), 9) ^ ROL32((x),17))
230 #define P1(x) ((x) ^ ROL32((x),15) ^ ROL32((x),23))
231
232 #define FF00(x,y,z) ((x) ^ (y) ^ (z))
233 #define FF16(x,y,z) (((x)&(y)) | ((x)&(z)) | ((y)&(z)))
234 #define GG00(x,y,z) ((x) ^ (y) ^ (z))
235 #define GG16(x,y,z) ((((y)^(z)) & (x)) ^ (z))
236
237 #define R(A, B, C, D, E, F, G, H, xx) \
238 SS1 = ROL32((ROL32(A, 12) + E + K[j]), 7); \
239 SS2 = SS1 ^ ROL32(A, 12); \
240 TT1 = FF##xx(A, B, C) + D + SS2 + (W[j] ^ W[j + 4]); \
241 TT2 = GG##xx(E, F, G) + H + SS1 + W[j]; \
242 B = ROL32(B, 9); \
243 H = TT1; \
244 F = ROL32(F, 19); \
245 D = P0(TT2); \
246 j++
247
248 #define R8(A, B, C, D, E, F, G, H, xx) \
249 R(A, B, C, D, E, F, G, H, xx); \
250 R(H, A, B, C, D, E, F, G, xx); \
251 R(G, H, A, B, C, D, E, F, xx); \
252 R(F, G, H, A, B, C, D, E, xx); \
253 R(E, F, G, H, A, B, C, D, xx); \
254 R(D, E, F, G, H, A, B, C, xx); \
255 R(C, D, E, F, G, H, A, B, xx); \
256 R(B, C, D, E, F, G, H, A, xx)
257
258
259
260 #define T00 0x79cc4519U
261 #define T16 0x7a879d8aU
262
263 #define K0 0x79cc4519U
264 #define K1 0xf3988a32U
265 #define K2 0xe7311465U
266 #define K3 0xce6228cbU
267 #define K4 0x9cc45197U
268 #define K5 0x3988a32fU
269 #define K6 0x7311465eU
270 #define K7 0xe6228cbcU
271 #define K8 0xcc451979U
272 #define K9 0x988a32f3U
273 #define K10 0x311465e7U
274 #define K11 0x6228cbceU
275 #define K12 0xc451979cU
276 #define K13 0x88a32f39U
277 #define K14 0x11465e73U
278 #define K15 0x228cbce6U
279 #define K16 0x9d8a7a87U
280 #define K17 0x3b14f50fU
281 #define K18 0x7629ea1eU
282 #define K19 0xec53d43cU
283 #define K20 0xd8a7a879U
284 #define K21 0xb14f50f3U
285 #define K22 0x629ea1e7U
286 #define K23 0xc53d43ceU
287 #define K24 0x8a7a879dU
288 #define K25 0x14f50f3bU
289 #define K26 0x29ea1e76U
290 #define K27 0x53d43cecU
291 #define K28 0xa7a879d8U
292 #define K29 0x4f50f3b1U
293 #define K30 0x9ea1e762U
294 #define K31 0x3d43cec5U
295 #define K32 0x7a879d8aU
296 #define K33 0xf50f3b14U
297 #define K34 0xea1e7629U
298 #define K35 0xd43cec53U
299 #define K36 0xa879d8a7U
300 #define K37 0x50f3b14fU
301 #define K38 0xa1e7629eU
302 #define K39 0x43cec53dU
303 #define K40 0x879d8a7aU
304 #define K41 0x0f3b14f5U
305 #define K42 0x1e7629eaU
306 #define K43 0x3cec53d4U
307 #define K44 0x79d8a7a8U
308 #define K45 0xf3b14f50U
309 #define K46 0xe7629ea1U
310 #define K47 0xcec53d43U
311 #define K48 0x9d8a7a87U
312 #define K49 0x3b14f50fU
313 #define K50 0x7629ea1eU
314 #define K51 0xec53d43cU
315 #define K52 0xd8a7a879U
316 #define K53 0xb14f50f3U
317 #define K54 0x629ea1e7U
318 #define K55 0xc53d43ceU
319 #define K56 0x8a7a879dU
320 #define K57 0x14f50f3bU
321 #define K58 0x29ea1e76U
322 #define K59 0x53d43cecU
323 #define K60 0xa7a879d8U
324 #define K61 0x4f50f3b1U
325 #define K62 0x9ea1e762U
326 #define K63 0x3d43cec5U
327
328 uint32_t K[64] = {
329 K0, K1, K2, K3, K4, K5, K6, K7,
330 K8, K9, K10, K11, K12, K13, K14, K15,
331 K16, K17, K18, K19, K20, K21, K22, K23,
332 K24, K25, K26, K27, K28, K29, K30, K31,
333 K32, K33, K34, K35, K36, K37, K38, K39,
334 K40, K41, K42, K43, K44, K45, K46, K47,
335 K48, K49, K50, K51, K52, K53, K54, K55,
336 K56, K57, K58, K59, K60, K61, K62, K63,
337 /*
338 0x79cc4519U, 0xf3988a32U, 0xe7311465U, 0xce6228cbU,
339 0x9cc45197U, 0x3988a32fU, 0x7311465eU, 0xe6228cbcU,
340 0xcc451979U, 0x988a32f3U, 0x311465e7U, 0x6228cbceU,
341 0xc451979cU, 0x88a32f39U, 0x11465e73U, 0x228cbce6U,
342 0x9d8a7a87U, 0x3b14f50fU, 0x7629ea1eU, 0xec53d43cU,
343 0xd8a7a879U, 0xb14f50f3U, 0x629ea1e7U, 0xc53d43ceU,
344 0x8a7a879dU, 0x14f50f3bU, 0x29ea1e76U, 0x53d43cecU,
345 0xa7a879d8U, 0x4f50f3b1U, 0x9ea1e762U, 0x3d43cec5U,
346 0x7a879d8aU, 0xf50f3b14U, 0xea1e7629U, 0xd43cec53U,
347 0xa879d8a7U, 0x50f3b14fU, 0xa1e7629eU, 0x43cec53dU,
348 0x879d8a7aU, 0x0f3b14f5U, 0x1e7629eaU, 0x3cec53d4U,
349 0x79d8a7a8U, 0xf3b14f50U, 0xe7629ea1U, 0xcec53d43U,
350 0x9d8a7a87U, 0x3b14f50fU, 0x7629ea1eU, 0xec53d43cU,
351 0xd8a7a879U, 0xb14f50f3U, 0x629ea1e7U, 0xc53d43ceU,
352 0x8a7a879dU, 0x14f50f3bU, 0x29ea1e76U, 0x53d43cecU,
353 0xa7a879d8U, 0x4f50f3b1U, 0x9ea1e762U, 0x3d43cec5U,
354 */
355 };
356
sm3_compress_blocks(uint32_t digest[8],const unsigned char * data,size_t blocks)357 static void sm3_compress_blocks(uint32_t digest[8],
358 const unsigned char *data, size_t blocks)
359 {
360 uint32_t A;
361 uint32_t B;
362 uint32_t C;
363 uint32_t D;
364 uint32_t E;
365 uint32_t F;
366 uint32_t G;
367 uint32_t H;
368 uint32_t W[68];
369 uint32_t SS1, SS2, TT1, TT2;
370 int j;
371
372 #ifdef SM3_SSE3
373 __m128i X, T, R;
374 __m128i M = _mm_setr_epi32(0, 0, 0, 0xffffffff);
375 __m128i V = _mm_setr_epi8(3,2,1,0,7,6,5,4,11,10,9,8,15,14,13,12);
376 #endif
377
378 while (blocks--) {
379
380 A = digest[0];
381 B = digest[1];
382 C = digest[2];
383 D = digest[3];
384 E = digest[4];
385 F = digest[5];
386 G = digest[6];
387 H = digest[7];
388
389
390 #ifdef SM3_SSE3
391
392 for (j = 0; j < 16; j += 4) {
393 X = _mm_loadu_si128((__m128i *)(data + j * 4));
394 X = _mm_shuffle_epi8(X, V);
395 _mm_storeu_si128((__m128i *)(W + j), X);
396 }
397
398 for (j = 16; j < 68; j += 4) {
399 /* X = (W[j - 3], W[j - 2], W[j - 1], 0) */
400 X = _mm_loadu_si128((__m128i *)(W + j - 3));
401 X = _mm_andnot_si128(M, X);
402
403 X = _mm_rotl_epi32(X, 15);
404 T = _mm_loadu_si128((__m128i *)(W + j - 9));
405 X = _mm_xor_si128(X, T);
406 T = _mm_loadu_si128((__m128i *)(W + j - 16));
407 X = _mm_xor_si128(X, T);
408
409 /* P1() */
410 T = _mm_rotl_epi32(X, (23 - 15));
411 T = _mm_xor_si128(T, X);
412 T = _mm_rotl_epi32(T, 15);
413 X = _mm_xor_si128(X, T);
414
415 T = _mm_loadu_si128((__m128i *)(W + j - 13));
416 T = _mm_rotl_epi32(T, 7);
417 X = _mm_xor_si128(X, T);
418 T = _mm_loadu_si128((__m128i *)(W + j - 6));
419 X = _mm_xor_si128(X, T);
420
421 /* W[j + 3] ^= P1(ROL32(W[j + 1], 15)) */
422 R = _mm_shuffle_epi32(X, 0);
423 R = _mm_and_si128(R, M);
424 T = _mm_rotl_epi32(R, 15);
425 T = _mm_xor_si128(T, R);
426 T = _mm_rotl_epi32(T, 9);
427 R = _mm_xor_si128(R, T);
428 R = _mm_rotl_epi32(R, 6);
429 X = _mm_xor_si128(X, R);
430
431 _mm_storeu_si128((__m128i *)(W + j), X);
432 }
433 #else
434 for (j = 0; j < 16; j++)
435 W[j] = GETU32(data + j*4);
436
437 for (; j < 68; j++)
438 W[j] = P1(W[j - 16] ^ W[j - 9] ^ ROL32(W[j - 3], 15))
439 ^ ROL32(W[j - 13], 7) ^ W[j - 6];
440 #endif
441
442
443 j = 0;
444
445 #define FULL_UNROLL
446 #ifdef FULL_UNROLL
447 R8(A, B, C, D, E, F, G, H, 00);
448 R8(A, B, C, D, E, F, G, H, 00);
449 R8(A, B, C, D, E, F, G, H, 16);
450 R8(A, B, C, D, E, F, G, H, 16);
451 R8(A, B, C, D, E, F, G, H, 16);
452 R8(A, B, C, D, E, F, G, H, 16);
453 R8(A, B, C, D, E, F, G, H, 16);
454 R8(A, B, C, D, E, F, G, H, 16);
455 #else
456 for (; j < 16; j++) {
457 SS1 = ROL32((ROL32(A, 12) + E + K(j)), 7);
458 SS2 = SS1 ^ ROL32(A, 12);
459 TT1 = FF00(A, B, C) + D + SS2 + (W[j] ^ W[j + 4]);
460 TT2 = GG00(E, F, G) + H + SS1 + W[j];
461 D = C;
462 C = ROL32(B, 9);
463 B = A;
464 A = TT1;
465 H = G;
466 G = ROL32(F, 19);
467 F = E;
468 E = P0(TT2);
469 }
470
471 for (; j < 64; j++) {
472 SS1 = ROL32((ROL32(A, 12) + E + K(j)), 7);
473 SS2 = SS1 ^ ROL32(A, 12);
474 TT1 = FF16(A, B, C) + D + SS2 + (W[j] ^ W[j + 4]);
475 TT2 = GG16(E, F, G) + H + SS1 + W[j];
476 D = C;
477 C = ROL32(B, 9);
478 B = A;
479 A = TT1;
480 H = G;
481 G = ROL32(F, 19);
482 F = E;
483 E = P0(TT2);
484 }
485 #endif
486
487 digest[0] ^= A;
488 digest[1] ^= B;
489 digest[2] ^= C;
490 digest[3] ^= D;
491 digest[4] ^= E;
492 digest[5] ^= F;
493 digest[6] ^= G;
494 digest[7] ^= H;
495
496 data += 64;
497 }
498 }
499
rkgm_sm3_compress(uint32_t digest[8],const unsigned char block[64])500 void rkgm_sm3_compress(uint32_t digest[8], const unsigned char block[64])
501 {
502 return sm3_compress_blocks(digest, block, 1);
503 }
504
rk_hash_sm3(const unsigned char * in,unsigned int in_len,unsigned char * out,unsigned int * out_len)505 int rk_hash_sm3(const unsigned char *in, unsigned int in_len,
506 unsigned char *out, unsigned int *out_len)
507 {
508 rkgm_sm3_ctx_t ctx;
509
510 rkgm_sm3_init(&ctx);
511 rkgm_sm3_update(&ctx, in, in_len);
512 rkgm_sm3_final(&ctx, out);
513
514 memset(&ctx, 0, sizeof(rkgm_sm3_ctx_t));
515
516 *out_len = SM3_DIGEST_LENGTH;
517
518 return 0;
519 }
520