1.SM3的大致原理
2.源码实现 (参考了openssl)
文件结构
文件sm3.h
1 /*
2 * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright 2017 Ribose Inc. All Rights Reserved.
4 *
5 * Licensed under the OpenSSL license (the "License"). You may not use
6 * this file except in compliance with the License. You can obtain a copy
7 * in the file LICENSE in the source distribution or at
8 * https://www.openssl.org/source/license.html
9 */
10
11 #ifndef OSSL_CRYPTO_SM3_H
12 # define OSSL_CRYPTO_SM3_H
13
14 # ifdef OPENSSL_NO_SM3
15 # error SM3 is disabled.
16 # endif
17
18 # define SM3_DIGEST_LENGTH 32
19 # define SM3_WORD unsigned int
20
21 # define SM3_CBLOCK 64
22 # define SM3_LBLOCK (SM3_CBLOCK/4)
23
24 typedef struct SM3state_st {
25 SM3_WORD A, B, C, D, E, F, G, H;
26 SM3_WORD Nl, Nh;
27 SM3_WORD data[SM3_LBLOCK];
28 unsigned int num;
29 } SM3_CTX;
30
31 int sm3_init(SM3_CTX *c);
32 int sm3_update(SM3_CTX *c, const void *data, size_t len);
33 int sm3_final(unsigned char *md, SM3_CTX *c);
34
35 void sm3_block_data_order(SM3_CTX *c, const void *p, size_t num);
36
37 #endif
sm3.h
文件sm3_local.h
1 /*
2 * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright 2017 Ribose Inc. All Rights Reserved.
4 * Ported from Ribose contributions from Botan.
5 *
6 * Licensed under the OpenSSL license (the "License"). You may not use
7 * this file except in compliance with the License. You can obtain a copy
8 * in the file LICENSE in the source distribution or at
9 * https://www.openssl.org/source/license.html
10 */
11
12 #include <string.h>
13 #include "sm3.h"
14
15 #define DATA_ORDER_IS_BIG_ENDIAN
16
17 #define HASH_LONG SM3_WORD
18 #define HASH_CTX SM3_CTX
19 #define HASH_CBLOCK SM3_CBLOCK
20 #define HASH_UPDATE sm3_update
21 #define HASH_TRANSFORM sm3_transform
22 #define HASH_FINAL sm3_final
23 #define HASH_MAKE_STRING(c, s) \
24 do { \
25 unsigned long ll; \
26 ll=(c)->A; (void)HOST_l2c(ll, (s)); \
27 ll=(c)->B; (void)HOST_l2c(ll, (s)); \
28 ll=(c)->C; (void)HOST_l2c(ll, (s)); \
29 ll=(c)->D; (void)HOST_l2c(ll, (s)); \
30 ll=(c)->E; (void)HOST_l2c(ll, (s)); \
31 ll=(c)->F; (void)HOST_l2c(ll, (s)); \
32 ll=(c)->G; (void)HOST_l2c(ll, (s)); \
33 ll=(c)->H; (void)HOST_l2c(ll, (s)); \
34 } while (0)
35 #define HASH_BLOCK_DATA_ORDER sm3_block_data_order
36
37 void sm3_transform(SM3_CTX *c, const unsigned char *data);
38
39 #include "md32_common.h"
40
41 #define P0(X) (X ^ ROTATE(X, 9) ^ ROTATE(X, 17))
42 #define P1(X) (X ^ ROTATE(X, 15) ^ ROTATE(X, 23))
43
44 #define FF0(X,Y,Z) (X ^ Y ^ Z)
45 #define GG0(X,Y,Z) (X ^ Y ^ Z)
46
47 #define FF1(X,Y,Z) ((X & Y) | ((X | Y) & Z))
48 #define GG1(X,Y,Z) ((Z ^ (X & (Y ^ Z))))
49
50 #define EXPAND(W0,W7,W13,W3,W10) \
51 (P1(W0 ^ W7 ^ ROTATE(W13, 15)) ^ ROTATE(W3, 7) ^ W10)
52
53 #define RND(A, B, C, D, E, F, G, H, TJ, Wi, Wj, FF, GG) \
54 do { \
55 const SM3_WORD A12 = ROTATE(A, 12); \
56 const SM3_WORD A12_SM = A12 + E + TJ; \
57 const SM3_WORD SS1 = ROTATE(A12_SM, 7); \
58 const SM3_WORD TT1 = FF(A, B, C) + D + (SS1 ^ A12) + (Wj); \
59 const SM3_WORD TT2 = GG(E, F, G) + H + SS1 + Wi; \
60 B = ROTATE(B, 9); \
61 D = TT1; \
62 F = ROTATE(F, 19); \
63 H = P0(TT2); \
64 } while(0)
65
66 #define R1(A,B,C,D,E,F,G,H,TJ,Wi,Wj) \
67 RND(A,B,C,D,E,F,G,H,TJ,Wi,Wj,FF0,GG0)
68
69 #define R2(A,B,C,D,E,F,G,H,TJ,Wi,Wj) \
70 RND(A,B,C,D,E,F,G,H,TJ,Wi,Wj,FF1,GG1)
71
72 #define SM3_A 0x7380166fUL
73 #define SM3_B 0x4914b2b9UL
74 #define SM3_C 0x172442d7UL
75 #define SM3_D 0xda8a0600UL
76 #define SM3_E 0xa96f30bcUL
77 #define SM3_F 0x163138aaUL
78 #define SM3_G 0xe38dee4dUL
79 #define SM3_H 0xb0fb0e4eUL
sm3_local.h
文件sm3.c
1 /*
2 * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright 2017 Ribose Inc. All Rights Reserved.
4 * Ported from Ribose contributions from Botan.
5 *
6 * Licensed under the OpenSSL license (the "License"). You may not use
7 * this file except in compliance with the License. You can obtain a copy
8 * in the file LICENSE in the source distribution or at
9 * https://www.openssl.org/source/license.html
10 */
11
12 #include <openssl/e_os2.h>
13 #include "sm3_local.h"
14
15 int sm3_init(SM3_CTX *c)
16 {
17 memset(c, 0, sizeof(*c));
18 c->A = SM3_A;
19 c->B = SM3_B;
20 c->C = SM3_C;
21 c->D = SM3_D;
22 c->E = SM3_E;
23 c->F = SM3_F;
24 c->G = SM3_G;
25 c->H = SM3_H;
26 return 1;
27 }
28
29 void sm3_block_data_order(SM3_CTX *ctx, const void *p, size_t num)
30 {
31 const unsigned char *data = p;
32 register unsigned MD32_REG_T A, B, C, D, E, F, G, H;
33
34 unsigned MD32_REG_T W00, W01, W02, W03, W04, W05, W06, W07,
35 W08, W09, W10, W11, W12, W13, W14, W15;
36
37 for (; num--;) {
38
39 A = ctx->A;
40 B = ctx->B;
41 C = ctx->C;
42 D = ctx->D;
43 E = ctx->E;
44 F = ctx->F;
45 G = ctx->G;
46 H = ctx->H;
47
48 /*
49 * We have to load all message bytes immediately since SM3 reads
50 * them slightly out of order.
51 */
52 (void)HOST_c2l(data, W00);
53 (void)HOST_c2l(data, W01);
54 (void)HOST_c2l(data, W02);
55 (void)HOST_c2l(data, W03);
56 (void)HOST_c2l(data, W04);
57 (void)HOST_c2l(data, W05);
58 (void)HOST_c2l(data, W06);
59 (void)HOST_c2l(data, W07);
60 (void)HOST_c2l(data, W08);
61 (void)HOST_c2l(data, W09);
62 (void)HOST_c2l(data, W10);
63 (void)HOST_c2l(data, W11);
64 (void)HOST_c2l(data, W12);
65 (void)HOST_c2l(data, W13);
66 (void)HOST_c2l(data, W14);
67 (void)HOST_c2l(data, W15);
68
69 R1(A, B, C, D, E, F, G, H, 0x79CC4519, W00, W00 ^ W04);
70 W00 = EXPAND(W00, W07, W13, W03, W10);
71 R1(D, A, B, C, H, E, F, G, 0xF3988A32, W01, W01 ^ W05);
72 W01 = EXPAND(W01, W08, W14, W04, W11);
73 R1(C, D, A, B, G, H, E, F, 0xE7311465, W02, W02 ^ W06);
74 W02 = EXPAND(W02, W09, W15, W05, W12);
75 R1(B, C, D, A, F, G, H, E, 0xCE6228CB, W03, W03 ^ W07);
76 W03 = EXPAND(W03, W10, W00, W06, W13);
77 R1(A, B, C, D, E, F, G, H, 0x9CC45197, W04, W04 ^ W08);
78 W04 = EXPAND(W04, W11, W01, W07, W14);
79 R1(D, A, B, C, H, E, F, G, 0x3988A32F, W05, W05 ^ W09);
80 W05 = EXPAND(W05, W12, W02, W08, W15);
81 R1(C, D, A, B, G, H, E, F, 0x7311465E, W06, W06 ^ W10);
82 W06 = EXPAND(W06, W13, W03, W09, W00);
83 R1(B, C, D, A, F, G, H, E, 0xE6228CBC, W07, W07 ^ W11);
84 W07 = EXPAND(W07, W14, W04, W10, W01);
85 R1(A, B, C, D, E, F, G, H, 0xCC451979, W08, W08 ^ W12);
86 W08 = EXPAND(W08, W15, W05, W11, W02);
87 R1(D, A, B, C, H, E, F, G, 0x988A32F3, W09, W09 ^ W13);
88 W09 = EXPAND(W09, W00, W06, W12, W03);
89 R1(C, D, A, B, G, H, E, F, 0x311465E7, W10, W10 ^ W14);
90 W10 = EXPAND(W10, W01, W07, W13, W04);
91 R1(B, C, D, A, F, G, H, E, 0x6228CBCE, W11, W11 ^ W15);
92 W11 = EXPAND(W11, W02, W08, W14, W05);
93 R1(A, B, C, D, E, F, G, H, 0xC451979C, W12, W12 ^ W00);
94 W12 = EXPAND(W12, W03, W09, W15, W06);
95 R1(D, A, B, C, H, E, F, G, 0x88A32F39, W13, W13 ^ W01);
96 W13 = EXPAND(W13, W04, W10, W00, W07);
97 R1(C, D, A, B, G, H, E, F, 0x11465E73, W14, W14 ^ W02);
98 W14 = EXPAND(W14, W05, W11, W01, W08);
99 R1(B, C, D, A, F, G, H, E, 0x228CBCE6, W15, W15 ^ W03);
100 W15 = EXPAND(W15, W06, W12, W02, W09);
101 R2(A, B, C, D, E, F, G, H, 0x9D8A7A87, W00, W00 ^ W04);
102 W00 = EXPAND(W00, W07, W13, W03, W10);
103 R2(D, A, B, C, H, E, F, G, 0x3B14F50F, W01, W01 ^ W05);
104 W01 = EXPAND(W01, W08, W14, W04, W11);
105 R2(C, D, A, B, G, H, E, F, 0x7629EA1E, W02, W02 ^ W06);
106 W02 = EXPAND(W02, W09, W15, W05, W12);
107 R2(B, C, D, A, F, G, H, E, 0xEC53D43C, W03, W03 ^ W07);
108 W03 = EXPAND(W03, W10, W00, W06, W13);
109 R2(A, B, C, D, E, F, G, H, 0xD8A7A879, W04, W04 ^ W08);
110 W04 = EXPAND(W04, W11, W01, W07, W14);
111 R2(D, A, B, C, H, E, F, G, 0xB14F50F3, W05, W05 ^ W09);
112 W05 = EXPAND(W05, W12, W02, W08, W15);
113 R2(C, D, A, B, G, H, E, F, 0x629EA1E7, W06, W06 ^ W10);
114 W06 = EXPAND(W06, W13, W03, W09, W00);
115 R2(B, C, D, A, F, G, H, E, 0xC53D43CE, W07, W07 ^ W11);
116 W07 = EXPAND(W07, W14, W04, W10, W01);
117 R2(A, B, C, D, E, F, G, H, 0x8A7A879D, W08, W08 ^ W12);
118 W08 = EXPAND(W08, W15, W05, W11, W02);
119 R2(D, A, B, C, H, E, F, G, 0x14F50F3B, W09, W09 ^ W13);
120 W09 = EXPAND(W09, W00, W06, W12, W03);
121 R2(C, D, A, B, G, H, E, F, 0x29EA1E76, W10, W10 ^ W14);
122 W10 = EXPAND(W10, W01, W07, W13, W04);
123 R2(B, C, D, A, F, G, H, E, 0x53D43CEC, W11, W11 ^ W15);
124 W11 = EXPAND(W11, W02, W08, W14, W05);
125 R2(A, B, C, D, E, F, G, H, 0xA7A879D8, W12, W12 ^ W00);
126 W12 = EXPAND(W12, W03, W09, W15, W06);
127 R2(D, A, B, C, H, E, F, G, 0x4F50F3B1, W13, W13 ^ W01);
128 W13 = EXPAND(W13, W04, W10, W00, W07);
129 R2(C, D, A, B, G, H, E, F, 0x9EA1E762, W14, W14 ^ W02);
130 W14 = EXPAND(W14, W05, W11, W01, W08);
131 R2(B, C, D, A, F, G, H, E, 0x3D43CEC5, W15, W15 ^ W03);
132 W15 = EXPAND(W15, W06, W12, W02, W09);
133 R2(A, B, C, D, E, F, G, H, 0x7A879D8A, W00, W00 ^ W04);
134 W00 = EXPAND(W00, W07, W13, W03, W10);
135 R2(D, A, B, C, H, E, F, G, 0xF50F3B14, W01, W01 ^ W05);
136 W01 = EXPAND(W01, W08, W14, W04, W11);
137 R2(C, D, A, B, G, H, E, F, 0xEA1E7629, W02, W02 ^ W06);
138 W02 = EXPAND(W02, W09, W15, W05, W12);
139 R2(B, C, D, A, F, G, H, E, 0xD43CEC53, W03, W03 ^ W07);
140 W03 = EXPAND(W03, W10, W00, W06, W13);
141 R2(A, B, C, D, E, F, G, H, 0xA879D8A7, W04, W04 ^ W08);
142 W04 = EXPAND(W04, W11, W01, W07, W14);
143 R2(D, A, B, C, H, E, F, G, 0x50F3B14F, W05, W05 ^ W09);
144 W05 = EXPAND(W05, W12, W02, W08, W15);
145 R2(C, D, A, B, G, H, E, F, 0xA1E7629E, W06, W06 ^ W10);
146 W06 = EXPAND(W06, W13, W03, W09, W00);
147 R2(B, C, D, A, F, G, H, E, 0x43CEC53D, W07, W07 ^ W11);
148 W07 = EXPAND(W07, W14, W04, W10, W01);
149 R2(A, B, C, D, E, F, G, H, 0x879D8A7A, W08, W08 ^ W12);
150 W08 = EXPAND(W08, W15, W05, W11, W02);
151 R2(D, A, B, C, H, E, F, G, 0x0F3B14F5, W09, W09 ^ W13);
152 W09 = EXPAND(W09, W00, W06, W12, W03);
153 R2(C, D, A, B, G, H, E, F, 0x1E7629EA, W10, W10 ^ W14);
154 W10 = EXPAND(W10, W01, W07, W13, W04);
155 R2(B, C, D, A, F, G, H, E, 0x3CEC53D4, W11, W11 ^ W15);
156 W11 = EXPAND(W11, W02, W08, W14, W05);
157 R2(A, B, C, D, E, F, G, H, 0x79D8A7A8, W12, W12 ^ W00);
158 W12 = EXPAND(W12, W03, W09, W15, W06);
159 R2(D, A, B, C, H, E, F, G, 0xF3B14F50, W13, W13 ^ W01);
160 W13 = EXPAND(W13, W04, W10, W00, W07);
161 R2(C, D, A, B, G, H, E, F, 0xE7629EA1, W14, W14 ^ W02);
162 W14 = EXPAND(W14, W05, W11, W01, W08);
163 R2(B, C, D, A, F, G, H, E, 0xCEC53D43, W15, W15 ^ W03);
164 W15 = EXPAND(W15, W06, W12, W02, W09);
165 R2(A, B, C, D, E, F, G, H, 0x9D8A7A87, W00, W00 ^ W04);
166 W00 = EXPAND(W00, W07, W13, W03, W10);
167 R2(D, A, B, C, H, E, F, G, 0x3B14F50F, W01, W01 ^ W05);
168 W01 = EXPAND(W01, W08, W14, W04, W11);
169 R2(C, D, A, B, G, H, E, F, 0x7629EA1E, W02, W02 ^ W06);
170 W02 = EXPAND(W02, W09, W15, W05, W12);
171 R2(B, C, D, A, F, G, H, E, 0xEC53D43C, W03, W03 ^ W07);
172 W03 = EXPAND(W03, W10, W00, W06, W13);
173 R2(A, B, C, D, E, F, G, H, 0xD8A7A879, W04, W04 ^ W08);
174 R2(D, A, B, C, H, E, F, G, 0xB14F50F3, W05, W05 ^ W09);
175 R2(C, D, A, B, G, H, E, F, 0x629EA1E7, W06, W06 ^ W10);
176 R2(B, C, D, A, F, G, H, E, 0xC53D43CE, W07, W07 ^ W11);
177 R2(A, B, C, D, E, F, G, H, 0x8A7A879D, W08, W08 ^ W12);
178 R2(D, A, B, C, H, E, F, G, 0x14F50F3B, W09, W09 ^ W13);
179 R2(C, D, A, B, G, H, E, F, 0x29EA1E76, W10, W10 ^ W14);
180 R2(B, C, D, A, F, G, H, E, 0x53D43CEC, W11, W11 ^ W15);
181 R2(A, B, C, D, E, F, G, H, 0xA7A879D8, W12, W12 ^ W00);
182 R2(D, A, B, C, H, E, F, G, 0x4F50F3B1, W13, W13 ^ W01);
183 R2(C, D, A, B, G, H, E, F, 0x9EA1E762, W14, W14 ^ W02);
184 R2(B, C, D, A, F, G, H, E, 0x3D43CEC5, W15, W15 ^ W03);
185
186 ctx->A ^= A;
187 ctx->B ^= B;
188 ctx->C ^= C;
189 ctx->D ^= D;
190 ctx->E ^= E;
191 ctx->F ^= F;
192 ctx->G ^= G;
193 ctx->H ^= H;
194 }
195 }
sm3.c
文件md32_common.h
1 /*
2 * Copyright 1999-2018 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 /*-
11 * This is a generic 32 bit "collector" for message digest algorithms.
12 * Whenever needed it collects input character stream into chunks of
13 * 32 bit values and invokes a block function that performs actual hash
14 * calculations.
15 *
16 * Porting guide.
17 *
18 * Obligatory macros:
19 *
20 * DATA_ORDER_IS_BIG_ENDIAN or DATA_ORDER_IS_LITTLE_ENDIAN
21 * this macro defines byte order of input stream.
22 * HASH_CBLOCK
23 * size of a unit chunk HASH_BLOCK operates on.
24 * HASH_LONG
25 * has to be at least 32 bit wide.
26 * HASH_CTX
27 * context structure that at least contains following
28 * members:
29 * typedef struct {
30 * ...
31 * HASH_LONG Nl,Nh;
32 * either {
33 * HASH_LONG data[HASH_LBLOCK];
34 * unsigned char data[HASH_CBLOCK];
35 * };
36 * unsigned int num;
37 * ...
38 * } HASH_CTX;
39 * data[] vector is expected to be zeroed upon first call to
40 * HASH_UPDATE.
41 * HASH_UPDATE
42 * name of "Update" function, implemented here.
43 * HASH_TRANSFORM
44 * name of "Transform" function, implemented here.
45 * HASH_FINAL
46 * name of "Final" function, implemented here.
47 * HASH_BLOCK_DATA_ORDER
48 * name of "block" function capable of treating *unaligned* input
49 * message in original (data) byte order, implemented externally.
50 * HASH_MAKE_STRING
51 * macro converting context variables to an ASCII hash string.
52 *
53 * MD5 example:
54 *
55 * #define DATA_ORDER_IS_LITTLE_ENDIAN
56 *
57 * #define HASH_LONG MD5_LONG
58 * #define HASH_CTX MD5_CTX
59 * #define HASH_CBLOCK MD5_CBLOCK
60 * #define HASH_UPDATE MD5_Update
61 * #define HASH_TRANSFORM MD5_Transform
62 * #define HASH_FINAL MD5_Final
63 * #define HASH_BLOCK_DATA_ORDER md5_block_data_order
64 */
65
66 #include <openssl/crypto.h>
67
68 #if !defined(DATA_ORDER_IS_BIG_ENDIAN) && !defined(DATA_ORDER_IS_LITTLE_ENDIAN)
69 # error "DATA_ORDER must be defined!"
70 #endif
71
72 #ifndef HASH_CBLOCK
73 # error "HASH_CBLOCK must be defined!"
74 #endif
75 #ifndef HASH_LONG
76 # error "HASH_LONG must be defined!"
77 #endif
78 #ifndef HASH_CTX
79 # error "HASH_CTX must be defined!"
80 #endif
81
82 #ifndef HASH_UPDATE
83 # error "HASH_UPDATE must be defined!"
84 #endif
85 #ifndef HASH_TRANSFORM
86 # error "HASH_TRANSFORM must be defined!"
87 #endif
88 #ifndef HASH_FINAL
89 # error "HASH_FINAL must be defined!"
90 #endif
91
92 #ifndef HASH_BLOCK_DATA_ORDER
93 # error "HASH_BLOCK_DATA_ORDER must be defined!"
94 #endif
95
96 #define ROTATE(a,n) (((a)<<(n))|(((a)&0xffffffff)>>(32-(n))))
97
98 #if defined(DATA_ORDER_IS_BIG_ENDIAN)
99
100 # define HOST_c2l(c,l) (l =(((unsigned long)(*((c)++)))<<24), \
101 l|=(((unsigned long)(*((c)++)))<<16), \
102 l|=(((unsigned long)(*((c)++)))<< 8), \
103 l|=(((unsigned long)(*((c)++))) ) )
104 # define HOST_l2c(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \
105 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
106 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
107 *((c)++)=(unsigned char)(((l) )&0xff), \
108 l)
109
110 #elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
111
112 # define HOST_c2l(c,l) (l =(((unsigned long)(*((c)++))) ), \
113 l|=(((unsigned long)(*((c)++)))<< 8), \
114 l|=(((unsigned long)(*((c)++)))<<16), \
115 l|=(((unsigned long)(*((c)++)))<<24) )
116 # define HOST_l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \
117 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
118 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
119 *((c)++)=(unsigned char)(((l)>>24)&0xff), \
120 l)
121
122 #endif
123
124 /*
125 * Time for some action :-)
126 */
127
128 int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len)
129 {
130 const unsigned char *data = data_;
131 unsigned char *p;
132 HASH_LONG l;
133 size_t n;
134
135 if (len == 0)
136 return 1;
137
138 l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL;
139 if (l < c->Nl) /* overflow */
140 c->Nh++;
141 c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
142 * 16-bit */
143 c->Nl = l;
144
145 n = c->num;
146 if (n != 0) {
147 p = (unsigned char *)c->data;
148
149 if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) {
150 memcpy(p + n, data, HASH_CBLOCK - n);
151 HASH_BLOCK_DATA_ORDER(c, p, 1);
152 n = HASH_CBLOCK - n;
153 data += n;
154 len -= n;
155 c->num = 0;
156 /*
157 * We use memset rather than OPENSSL_cleanse() here deliberately.
158 * Using OPENSSL_cleanse() here could be a performance issue. It
159 * will get properly cleansed on finalisation so this isn't a
160 * security problem.
161 */
162 memset(p, 0, HASH_CBLOCK); /* keep it zeroed */
163 } else {
164 memcpy(p + n, data, len);
165 c->num += (unsigned int)len;
166 return 1;
167 }
168 }
169
170 n = len / HASH_CBLOCK;
171 if (n > 0) {
172 HASH_BLOCK_DATA_ORDER(c, data, n);
173 n *= HASH_CBLOCK;
174 data += n;
175 len -= n;
176 }
177
178 if (len != 0) {
179 p = (unsigned char *)c->data;
180 c->num = (unsigned int)len;
181 memcpy(p, data, len);
182 }
183 return 1;
184 }
185
186 void HASH_TRANSFORM(HASH_CTX *c, const unsigned char *data)
187 {
188 HASH_BLOCK_DATA_ORDER(c, data, 1);
189 }
190
191 int HASH_FINAL(unsigned char *md, HASH_CTX *c)
192 {
193 unsigned char *p = (unsigned char *)c->data;
194 size_t n = c->num;
195
196 p[n] = 0x80; /* there is always room for one */
197 n++;
198
199 if (n > (HASH_CBLOCK - 8)) {
200 memset(p + n, 0, HASH_CBLOCK - n);
201 n = 0;
202 HASH_BLOCK_DATA_ORDER(c, p, 1);
203 }
204 memset(p + n, 0, HASH_CBLOCK - 8 - n);
205
206 p += HASH_CBLOCK - 8;
207 #if defined(DATA_ORDER_IS_BIG_ENDIAN)
208 (void)HOST_l2c(c->Nh, p);
209 (void)HOST_l2c(c->Nl, p);
210 #elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
211 (void)HOST_l2c(c->Nl, p);
212 (void)HOST_l2c(c->Nh, p);
213 #endif
214 p -= HASH_CBLOCK;
215 HASH_BLOCK_DATA_ORDER(c, p, 1);
216 c->num = 0;
217 memset(p, 0, HASH_CBLOCK);
218
219 #ifndef HASH_MAKE_STRING
220 # error "HASH_MAKE_STRING must be defined!"
221 #else
222 HASH_MAKE_STRING(c, md);
223 #endif
224
225 return 1;
226 }
227
228 #ifndef MD32_REG_T
229 # if defined(__alpha) || defined(__sparcv9) || defined(__mips)
230 # define MD32_REG_T long
231 /*
232 * This comment was originally written for MD5, which is why it
233 * discusses A-D. But it basically applies to all 32-bit digests,
234 * which is why it was moved to common header file.
235 *
236 * In case you wonder why A-D are declared as long and not
237 * as MD5_LONG. Doing so results in slight performance
238 * boost on LP64 architectures. The catch is we don't
239 * really care if 32 MSBs of a 64-bit register get polluted
240 * with eventual overflows as we *save* only 32 LSBs in
241 * *either* case. Now declaring 'em long excuses the compiler
242 * from keeping 32 MSBs zeroed resulting in 13% performance
243 * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
244 * Well, to be honest it should say that this *prevents*
245 * performance degradation.
246 */
247 # else
248 /*
249 * Above is not absolute and there are LP64 compilers that
250 * generate better code if MD32_REG_T is defined int. The above
251 * pre-processor condition reflects the circumstances under which
252 * the conclusion was made and is subject to further extension.
253 */
254 # define MD32_REG_T int
255 # endif
256 #endif
md32_common.h
文件main.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <stdint.h>
4
5 #include "sm3.h"
6
7 void log_hex(uint8_t *data, size_t ndata, uint8_t *description){
8 printf("%s: ", description);
9 size_t i = 0;
10 for(i=0; i<ndata; i++){
11 printf("%02x", data[i]);
12 if(i && ((i+1)%4==0)){
13 printf(" ");
14 }
15 }
16 printf("\n");
17 }
18
19 static int test_sm3(){
20 uint8_t input[] = {0x61, 0x62, 0x63};
21 uint8_t degist[SM3_DIGEST_LENGTH] = {0};
22
23 SM3_CTX context;
24 sm3_init(&context);
25
26 sm3_update(&context, input, 3);
27 sm3_final(degist, &context);
28
29 printf("<GB_T 32905-2016 信息安全技术 SM3密码杂凑算法 A.1 示例1> :\n");
30 log_hex(input, 3, "输入十六进制数据");
31 log_hex(degist, SM3_DIGEST_LENGTH, "杂凑值");
32 return 0;
33 }
34
35 int main(){
36 return test_sm3();
37 }
main.c
文件Makefile
1 all: 2 gcc -c sm3.c -o sm3.o 3 gcc -c main.c -o main.o 4 gcc -o bin sm3.o main.oMakefile
运行程序
3.参考文献
1.《GB T 32905-2016 信息安全技术 SM3密码杂凑算法.pdf》
2.《密码编码学与网络安全—原理与实践 第五版》 3.1.3 Feistel密码, 11.5.1 SHA-512逻辑
3.登录
http://www.gmbz.org.cn/main/index.html
点击"标准查询入口"
