V1.1.01

README.md

@@ -1,70 +1,80 @@
 # yd_crypto
 
-## 最新版本：V1.0.02
+## 最新版本：V1.1.01
 
 ***
 
 ### 1、文件简介
 
 > 演示(demo)
+>> aes_demo.c---AES各种加密模式示例
+>>
 >> des_demo.c---DES各种加密模式示例
 >>
 >> tdes_demo.c---TDES各种加密模式示例
 >>
->> aes_demo.c---AES各种加密模式示例
->>
 >> md5_demo.c---MD5示例
 >>
 >> sha_demo.c---HASH系列示例
 >>
 >> sm3_demo.c---国密SM3示例
 >>
->源代码(src)
->>yd_aes_base.c---AES算法核心
+> 源代码(src)
+>> yd_aes_base.c---AES算法核心
 >>
->>yd_aes_cbc.c---AES-CBC模式加解密API
+>> yd_aes_cbc.c---AES-CBC模式加解密API
 >>
->>yd_aes_cfb.c---AES-CFB模式及不同位数加解密API
+>> yd_aes_cbc_cs.c---AES-CBC-CS模式三种变体加解密API
 >>
->>yd_aes_ecb.c---AES-ECB模式加解密API
+>> yd_aes_cfb.c---AES-CFB模式及不同位数加解密API
 >>
->>yd_aes_ofb.c---AES-OFB模式加(解)密API
+>> yd_aes_ecb.c---AES-ECB模式加解密API
 >>
->>yd_des_base.c---DES算法核心
+>> yd_aes_ofb.c---AES-OFB模式加(解)密API
 >>
->>yd_des_cbc.c---DES-CBC模式加解密API
+>> yd_des_base.c---DES算法核心
 >>
->>yd_des_cfb.c---DES-CFB模式及不同位数加解密API
+>> yd_des_cbc.c---DES-CBC模式加解密API
 >>
->>yd_des_ecb.c---DES-ECB模式加解密API
+>> yd_des_cfb.c---DES-CFB模式及不同位数加解密API
 >>
->>yd_des_ofb.c---DES-OFB模式及不同位数加(解)密API
+>> yd_des_ecb.c---DES-ECB模式加解密API
 >>
->>yd_tdes_cbc.c---TDES-CBC模式加解密API
+>> yd_des_ofb.c---DES-OFB模式及不同位数加(解)密API
 >>
->>yd_tdes_cfb.c---TDES-CFB模式及不同位数加解密API
+>> yd_tdes_cbc.c---TDES-CBC模式加解密API
 >>
->>yd_tdes_ecb.c---TDES-ECB模式加解密API
+>> yd_tdes_cfb.c---TDES-CFB模式及不同位数加解密API
 >>
->>yd_tdes_ofb.c---TDES-OFB模式加(解)密API
+>> yd_tdes_ecb.c---TDES-ECB模式加解密API
 >>
->>yd_md5.c---MD5算法核心及API
+>> yd_tdes_ofb.c---TDES-OFB模式加(解)密API
 >>
->>yd_sha1.c---SHA1算法核心及API
+>> yd_md5.c---MD5算法核心及API
 >>
->>yd_sha224.c---SHA224算法核心及API
+>> yd_sha1.c---SHA1算法核心及API
 >>
->>yd_sha256.c---SHA256算法核心及API
+>> yd_sha224.c---SHA224算法核心及API
 >>
->>yd_sm3.c---国密SM3算法核心及API
+>> yd_sha256.c---SHA256算法核心及API
+>>
+>> yd_sm3.c---国密SM3算法核心及API
 
 ### 2、更新记录
 
->2020-4-11
->>第一次发布
+> 2020-4-11
+>> 第一次发布
+>>
+> 2020-6-29
+>> 加入国密SM3算法及示例
+>>
+> 2020-8-27
+>> 注释更新为UTF8编码
+>>
+> 2020-9-3
+>> 修改MD5、SHA、SM3中的全局变量，解决多任务同时调用需要互斥的问题
 >>
->2020-6-29
->>加入国密SM3算法及示例
+> 2020-9-17
+>> 增加AES CBC-CS三种变体算法及示例，可以加密任意长度字节，不需要是
 >>
->2020-8-27
->>注释更新为UTF8编码
+>> 16字节的整数倍。

demo/aes_demo.c

@@ -1,9 +1,11 @@
 
 #include "demo.h"
+#include "yd_aes_base.h"
 #include "yd_aes_ecb.h"
 #include "yd_aes_cbc.h"
 #include "yd_aes_cfb.h"
 #include "yd_aes_ofb.h"
+#include "yd_aes_cbc_cs.h"
 
 
 static uint8_t str[64]={0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
@@ -15,17 +17,20 @@ static uint8_t str[64]={0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
 						0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
 						0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10};
 
+#if	AES_NK == 4
 static uint8_t key4[16]={0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
 						 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
 
-//static uint8_t key6[24]={0x8e, 0x73, 0xb0, 0xf7, 0xda, 0x0e, 0x64, 0x52,
-//						 0xc8, 0x10, 0xf3, 0x2b, 0x80, 0x90, 0x79, 0xe5,
-//						 0x62, 0xf8, 0xea, 0xd2, 0x52, 0x2c, 0x6b, 0x7b};
-
-//static uint8_t key8[32]={0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
-//						 0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
-//						 0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
-//						 0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4};
+#elif AES_NK == 6
+static uint8_t key6[24]={0x8e, 0x73, 0xb0, 0xf7, 0xda, 0x0e, 0x64, 0x52,
+						 0xc8, 0x10, 0xf3, 0x2b, 0x80, 0x90, 0x79, 0xe5,
+						 0x62, 0xf8, 0xea, 0xd2, 0x52, 0x2c, 0x6b, 0x7b};
+#else
+static uint8_t key8[32]={0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
+						 0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
+						 0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
+						 0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4};
+#endif
 
 static uint8_t iv[16]= {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 						0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
@@ -36,17 +41,19 @@ void aes_ecb_demo(void)
 {
 	uint8_t enc[64], dec[64];
 	
+#if	AES_NK == 4
 	/* yd_aes_base.h中定义AES_NK=4 */
 	yd_aes_ecb_encrypt(str, enc, key4, 4);
 	yd_aes_ecb_decrypt(enc, dec, key4, 4);
-	
+#elif AES_NK == 6
 	/* yd_aes_base.h中定义AES_NK=6 */
-//	yd_aes_ecb_encrypt(str, enc, key6, 4);
-//	yd_aes_ecb_decrypt(enc, dec, key6, 4);
-	
+	yd_aes_ecb_encrypt(str, enc, key6, 4);
+	yd_aes_ecb_decrypt(enc, dec, key6, 4);
+#else
 	/* yd_aes_base.h中定义AES_NK=8 */
-//	yd_aes_ecb_encrypt(str, enc, key8, 4);
-//	yd_aes_ecb_decrypt(enc, dec, key8, 4);
+	yd_aes_ecb_encrypt(str, enc, key8, 4);
+	yd_aes_ecb_decrypt(enc, dec, key8, 4);
+#endif
 }
 
 /* CBC模式 */
@@ -54,17 +61,19 @@ void aes_cbc_demo(void)
 {
 	uint8_t enc[64], dec[64];
 	
+#if	AES_NK == 4
 	/* yd_aes_base.h中定义AES_NK=4 */
 	yd_aes_cbc_encrypt(str, enc, key4, iv, 4);
 	yd_aes_cbc_decrypt(enc, dec, key4, iv, 4);
-	
+#elif AES_NK == 6
 	/* yd_aes_base.h中定义AES_NK=6 */
-//	yd_aes_cbc_encrypt(str, enc, key6, iv, 4);
-//	yd_aes_cbc_decrypt(enc, dec, key6, iv, 4);
-	
+	yd_aes_cbc_encrypt(str, enc, key6, iv, 4);
+	yd_aes_cbc_decrypt(enc, dec, key6, iv, 4);
+#else
 	/* yd_aes_base.h中定义AES_NK=8 */	
-//	yd_aes_cbc_encrypt(str, enc, key8, iv, 4);
-//	yd_aes_cbc_decrypt(enc, dec, key8, iv, 4);
+	yd_aes_cbc_encrypt(str, enc, key8, iv, 4);
+	yd_aes_cbc_decrypt(enc, dec, key8, iv, 4);
+#endif
 }
 
 /* CFB模式 */
@@ -73,26 +82,28 @@ void aes_cfb_demo(void)
 	uint8_t enc8[18], dec8[18];
 	uint8_t enc128[64], dec128[64];
 	
+#if	AES_NK == 4
 	/* yd_aes_base.h中定义AES_NK=4 */
 	yd_aes_cfb8_encrypt(str, enc8, key4, iv, 18);
 	yd_aes_cfb8_decrypt(enc8, dec8, key4, iv, 18);
 	
 	yd_aes_cfb128_encrypt(str, enc128, key4, iv, 4);
 	yd_aes_cfb128_decrypt(enc128, dec128, key4, iv, 4);
-	
+#elif AES_NK == 6
 	/* yd_aes_base.h中定义AES_NK=6 */
-//	yd_aes_cfb8_encrypt(str, enc8, key6, iv, 18);
-//	yd_aes_cfb8_decrypt(enc8, dec8, key6, iv, 18);
-//	
-//	yd_aes_cfb128_encrypt(str, enc128, key6, iv, 4);
-//	yd_aes_cfb128_decrypt(enc128, dec128, key6, iv, 4);
+	yd_aes_cfb8_encrypt(str, enc8, key6, iv, 18);
+	yd_aes_cfb8_decrypt(enc8, dec8, key6, iv, 18);
 	
+	yd_aes_cfb128_encrypt(str, enc128, key6, iv, 4);
+	yd_aes_cfb128_decrypt(enc128, dec128, key6, iv, 4);
+#else
 	/* yd_aes_base.h中定义AES_NK=8 */
-//	yd_aes_cfb8_encrypt(str, enc8, key8, iv, 18);
-//	yd_aes_cfb8_decrypt(enc8, dec8, key8, iv, 18);
-//	
-//	yd_aes_cfb128_encrypt(str, enc128, key8, iv, 4);
-//	yd_aes_cfb128_decrypt(enc128, dec128, key8, iv, 4);
+	yd_aes_cfb8_encrypt(str, enc8, key8, iv, 18);
+	yd_aes_cfb8_decrypt(enc8, dec8, key8, iv, 18);
+	
+	yd_aes_cfb128_encrypt(str, enc128, key8, iv, 4);
+	yd_aes_cfb128_decrypt(enc128, dec128, key8, iv, 4);
+#endif
 }
 
 /* OFB模式 */
@@ -100,15 +111,77 @@ void aes_ofb_demo(void)
 {
 	uint8_t enc[64], dec[64];
 	
+#if	AES_NK == 4
 	/* yd_aes_base.h中定义AES_NK=4 */
 	yd_aes_ofb_enc_dec_crypto(str, enc, key4, iv, 4);
 	yd_aes_ofb_enc_dec_crypto(enc, dec, key4, iv, 4);
+#elif AES_NK == 6
+	/* yd_aes_base.h中定义AES_NK=6 */
+	yd_aes_ofb_enc_dec_crypto(str, enc, key6, iv, 4);
+	yd_aes_ofb_enc_dec_crypto(enc, dec, key6, iv, 4);
+#else
+	/* yd_aes_base.h中定义AES_NK=8 */	
+	yd_aes_ofb_enc_dec_crypto(str, enc, key8, iv, 4);
+	yd_aes_ofb_enc_dec_crypto(enc, dec, key8, iv, 4);
+#endif
+}
+
+/* CBC-CS1模式 */
+void aes_cbc_cs1_demo(void)
+{
+	uint8_t enc[64], dec[64];
 	
+#if	AES_NK == 4
+	/* yd_aes_base.h中定义AES_NK=4 */
+	yd_aes_cbc_cs1_encrypt(str, enc, key4, iv, 42); //可加密不同字节长度.
+	yd_aes_cbc_cs1_decrypt(enc, dec, key4, iv, 42);
+#elif AES_NK == 6
 	/* yd_aes_base.h中定义AES_NK=6 */
-//	yd_aes_ofb_enc_dec_crypto(str, enc, key6, iv, 4);
-//	yd_aes_ofb_enc_dec_crypto(enc, dec, key6, iv, 4);
+	yd_aes_cbc_cs1_encrypt(str, enc, key6, iv, 32);
+	yd_aes_cbc_cs1_decrypt(enc, dec, key6, iv, 32);
+#else
+	/* yd_aes_base.h中定义AES_NK=8 */	
+	yd_aes_cbc_cs1_encrypt(str, enc, key8, iv, 26);
+	yd_aes_cbc_cs1_decrypt(enc, dec, key8, iv, 26);
+#endif
+}
+
+/* CBC-CS2模式 */
+void aes_cbc_cs2_demo(void)
+{
+	uint8_t enc[64], dec[64];
+	
+#if	AES_NK == 4
+	/* yd_aes_base.h中定义AES_NK=4 */
+	yd_aes_cbc_cs2_encrypt(str, enc, key4, iv, 42); //可加密不同字节长度.
+	yd_aes_cbc_cs2_decrypt(enc, dec, key4, iv, 42);
+#elif AES_NK == 6
+	/* yd_aes_base.h中定义AES_NK=6 */
+	yd_aes_cbc_cs2_encrypt(str, enc, key6, iv, 32);
+	yd_aes_cbc_cs2_decrypt(enc, dec, key6, iv, 32);
+#else
+	/* yd_aes_base.h中定义AES_NK=8 */	
+	yd_aes_cbc_cs2_encrypt(str, enc, key8, iv, 26);
+	yd_aes_cbc_cs2_decrypt(enc, dec, key8, iv, 26);
+#endif
+}
+
+/* CBC-CS3模式 */
+void aes_cbc_cs3_demo(void)
+{
+	uint8_t enc[64], dec[64];
 	
+#if	AES_NK == 4
+	/* yd_aes_base.h中定义AES_NK=4 */
+	yd_aes_cbc_cs3_encrypt(str, enc, key4, iv, 42); //可加密不同字节长度.
+	yd_aes_cbc_cs3_decrypt(enc, dec, key4, iv, 42);
+#elif AES_NK == 6
+	/* yd_aes_base.h中定义AES_NK=6 */
+	yd_aes_cbc_cs3_encrypt(str, enc, key6, iv, 32);
+	yd_aes_cbc_cs3_decrypt(enc, dec, key6, iv, 32);
+#else
 	/* yd_aes_base.h中定义AES_NK=8 */	
-//	yd_aes_ofb_enc_dec_crypto(str, enc, key8, iv, 4);
-//	yd_aes_ofb_enc_dec_crypto(enc, dec, key8, iv, 4);
+	yd_aes_cbc_cs3_encrypt(str, enc, key8, iv, 26);
+	yd_aes_cbc_cs3_decrypt(enc, dec, key8, iv, 26);
+#endif
 }

demo/demo.h

@@ -5,6 +5,14 @@
 #include <stdint.h>
 
 
+void aes_ecb_demo(void);
+void aes_cbc_demo(void);
+void aes_cfb_demo(void);
+void aes_ofb_demo(void);
+void aes_cbc_cs1_demo(void);
+void aes_cbc_cs2_demo(void);
+void aes_cbc_cs3_demo(void);
+
 void des_ecb_cbc_demo(void);
 void des_cfb_demo(void);
 void des_ofb_demo(void);
@@ -15,11 +23,6 @@ void tdes_cfb8_demo(void);
 void tdes_cfb64_demo(void);
 void tdes_ofb_demo(void);
 
-void aes_ecb_demo(void);
-void aes_cbc_demo(void);
-void aes_cfb_demo(void);
-void aes_ofb_demo(void);
-
 void md5_demo(void);
 
 void sha1_demo(void);

demo/md5_demo.c

@@ -11,11 +11,11 @@ void md5_demo(void)
 	uint8_t str4[]="12345678901234567890123456789012345678901234567890123456789012345678901234567890";
 	uint8_t md5[16];
 	
-	yd_md5(str1, md5); //空.
+	yd_md5(str1, 0, md5); //空.
 	
-	yd_md5(str2, md5); //14字符.
+	yd_md5(str2, 14, md5); //14字符.
 	
-	yd_md5(str3, md5); //62字符.
+	yd_md5(str3, 62, md5); //62字符.
 	
-	yd_md5(str4, md5); //80字符.
+	yd_md5(str4, 80, md5); //80字符.
 }

demo/sha_demo.c

@@ -14,8 +14,8 @@ void sha1_demo(void)
 {
 	uint32_t s1[5], s2[5];
 	
-	yd_sha1(str1, s1);
-	yd_sha1(str2, s2);
+	yd_sha1(str1, 3, s1);
+	yd_sha1(str2, 56, s2);
 }
 
 /* SHA224 */
@@ -23,8 +23,8 @@ void sha224_demo(void)
 {
 	uint32_t s1[7], s2[7];
 	
-	yd_sha224(str1, s1);
-	yd_sha224(str2, s2);
+	yd_sha224(str1, 3, s1);
+	yd_sha224(str2, 56, s2);
 }
 
 /* SHA256 */
@@ -32,6 +32,6 @@ void sha256_demo(void)
 {
 	uint32_t s1[8], s2[8];
 	
-	yd_sha256(str1, s1);
-	yd_sha256(str2, s2);
+	yd_sha256(str1, 3, s1);
+	yd_sha256(str2, 56, s2);
 }

demo/sm3_demo.c

@@ -9,6 +9,6 @@ void sm3_demo(void)
 	uint8_t str2[]="abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd";
 	uint32_t sm3_1[8], sm3_2[8];
 	
-	yd_sm3(str1, sm3_1);
-	yd_sm3(str2, sm3_2);
+	yd_sm3(str1, 3, sm3_1);
+	yd_sm3(str2, 64, sm3_2);
 }

inc/yd_md5.h

@@ -20,7 +20,7 @@
 #include <stdbool.h>
 
 
-bool yd_md5(uint8_t *message, uint8_t *md5);
+bool yd_md5(uint8_t *msg, uint32_t msg_length, uint8_t *md5);
 
 #ifdef __cplusplus
 }

inc/yd_sha1.h

@@ -20,7 +20,7 @@
 #include <stdbool.h>
 
 
-bool yd_sha1(uint8_t *message, uint32_t *sha1);
+bool yd_sha1(uint8_t *message, uint32_t msg_length, uint32_t *sha1);
 
 #ifdef __cplusplus
 }

inc/yd_sha224.h

@@ -20,7 +20,7 @@
 #include <stdbool.h>
 
 
-bool yd_sha224(uint8_t *message, uint32_t *sha224);
+bool yd_sha224(uint8_t *msg, uint32_t msg_length, uint32_t *sha224);
 
 #ifdef __cplusplus
 }

inc/yd_sha256.h

@@ -20,7 +20,7 @@
 #include <stdbool.h>
 
 
-bool yd_sha256(uint8_t *message, uint32_t *sha256);
+bool yd_sha256(uint8_t *msg, uint32_t msg_length, uint32_t *sha256);
 
 #ifdef __cplusplus
 }

inc/yd_sm3.h

@@ -20,7 +20,7 @@
 #include <stdbool.h>
 
 
-bool yd_sm3(uint8_t *message, uint32_t *sm3);
+bool yd_sm3(uint8_t *msg, uint32_t msg_length, uint32_t *sm3);
 
 #ifdef __cplusplus
 }

src/hash/yd_sha1.c

@@ -12,56 +12,33 @@
 #include "yd_sha1.h"
 
 
-static uint32_t hash_message_length=0, hash_message_length_tmp=0; //要计算消息长度.
-
-
-/* 统计消息长度 */
-static bool count_hash_message_length(uint8_t *message)
-{
-	uint32_t tmp;
-	
-	tmp = 0;
-	while(message[tmp] != '\0')
-	{
-		tmp++;
-		/* 限制：最大计算(0xffffffff >> 3) = 536870911字节 */
-		if(tmp > 536870911)
-		{
-			return false;
-		}
-	}
-	
-	hash_message_length = tmp;
-	hash_message_length_tmp = tmp; //消息长度.
-	
-	return true;
-}
-
 /*
  *	数据填充
- *	false=数据没有填充完；true=数据填充完成
+ *	返回值：false=数据没有填充完；true=数据填充完成
  */
-static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
+static bool padding_bits(uint8_t *msg,
+						 uint32_t msg_length,
+						 uint32_t *msg_length_remain,
+						 uint8_t *m_8bit)
 {
 	uint8_t i;
-	uint32_t tmp;
 	
-	if(hash_message_length >= 64)
+	if(*msg_length_remain >= 64)
 	{
 		for(i=0; i<64; i++)
 		{
-			m_8bit[i] = message[i];
+			m_8bit[i] = msg[i];
 		}
 		
-		hash_message_length -= 64;
+		*msg_length_remain -= 64;
 	}
 	else //小于64字节.
 	{
-		if(hash_message_length >= 56) //56-63字节之间，一个块填充不完，还需要填充1次.
+		if(*msg_length_remain >= 56) //56-63字节之间，一个块填充不完，还需要填充1次.
 		{
-			for(i=0; i<hash_message_length; i++)
+			for(i=0; i<*msg_length_remain; i++)
 			{
-				m_8bit[i] = message[i];
+				m_8bit[i] = msg[i];
 			}
 			m_8bit[i++] = 0x80;
 			while(i < 64)
@@ -69,17 +46,17 @@ static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
 				m_8bit[i++] = 0;
 			}
 			
-			hash_message_length = 0;
+			*msg_length_remain = 0;
 		}
 		else //小于等于56字节.
 		{
-			for(i=0; i<hash_message_length; i++)
+			for(i=0; i<*msg_length_remain; i++)
 			{
-				m_8bit[i] = message[i];
+				m_8bit[i] = msg[i];
 			}
 			
 			/* 消息小于56字节时或者消息是64的倍数时，‘1’没有填充 */
-			if(hash_message_length != 0 || hash_message_length_tmp % 64 == 0)
+			if(*msg_length_remain != 0 || msg_length % 64 == 0)
 			{
 				m_8bit[i++] = 0x80;
 			}
@@ -94,11 +71,11 @@ static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
 				m_8bit[i++] = 0;
 			}
 			
-			tmp = hash_message_length_tmp * 8;
-			m_8bit[60] = tmp >> 24;
-			m_8bit[61] = tmp >> 16;
-			m_8bit[62] = tmp >> 8;
-			m_8bit[63] = tmp;
+			msg_length <<= 3; //乘8转为位长度.
+			m_8bit[60] = msg_length >> 24;
+			m_8bit[61] = msg_length >> 16;
+			m_8bit[62] = msg_length >> 8;
+			m_8bit[63] = msg_length;
 			
 			return true;
 		}
@@ -190,18 +167,22 @@ static void compute_hash_value(uint32_t *wt, uint32_t *H)
 
 /*
  *	产生安全散列值SHA1
- *	message：参与计算的数据
- *	sha1：	 计算得到的散列值(160位)
+ *	msg：		参与计算的数据
+ *	msg_length	参与计算的数据长度
+ *	sha1：	 	计算得到的散列值(160位)
  */
-bool yd_sha1(uint8_t *message, uint32_t *sha1)
+bool yd_sha1(uint8_t *msg, uint32_t msg_length, uint32_t *sha1)
 {
 	uint8_t flag, m_8bit[64];
-	uint32_t i, wt[80], H[5];
+	uint32_t i, msg_length_remain;
+	uint32_t wt[80], H[5];
 	
-	if(false == count_hash_message_length(message))
+	/* 限制：最大计算0xffffffff / 8 = 536870911字节 */
+	if(msg_length > 536870911)
 	{
 		return false;
 	}
+	msg_length_remain = msg_length;
 	
 	H[0] = 0x67452301;
 	H[1] = 0xefcdab89;
@@ -210,11 +191,14 @@ bool yd_sha1(uint8_t *message, uint32_t *sha1)
 	H[4] = 0xc3d2e1f0;
 	
 	flag = 1;
-	while(flag == 1)
+	do
 	{
 		/* 0步------------------------------------------------------------ */
-		i = hash_message_length_tmp - hash_message_length; //定位要计算的消息.
-		if(true == padding_bits(&message[i], m_8bit))
+		i = msg_length - msg_length_remain; //定位要计算的消息.
+		if(true == padding_bits(&msg[i],
+								msg_length,
+								&msg_length_remain,
+								m_8bit))
 		{
 			flag = 0;
 		}
@@ -224,7 +208,7 @@ bool yd_sha1(uint8_t *message, uint32_t *sha1)
 		
 		/* 2-4步---------------------------------------------------------- */
 		compute_hash_value(wt, H);
-	}
+	}while(flag == 1);
 	
 	sha1[0] = H[0];
 	sha1[1] = H[1];

src/hash/yd_sha224.c

@@ -12,7 +12,6 @@
 #include "yd_sha224.h"
 
 
-static uint32_t hash_message_length=0, hash_message_length_tmp=0; //要计算消息长度.
 static uint32_t k_table[64] =
 {	/* 下面数据由前64个质数开3次方的前32位小数部分(转二进制，乘2取整)得到 */
 	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
@@ -25,54 +24,33 @@ static uint32_t k_table[64] =
 	0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
 };
 
-
-/* 统计消息长度 */
-static bool count_hash_message_length(uint8_t *message)
-{
-	uint32_t tmp;
-	
-	tmp = 0;
-	while(message[tmp] != '\0')
-	{
-		tmp++;
-		/* 限制：最大计算(0xffffffff >> 3) = 536870911字节 */
-		if(tmp > 536870911)
-		{
-			return false;
-		}
-	}
-	
-	hash_message_length = tmp;
-	hash_message_length_tmp = tmp; //消息长度.
-	
-	return true;
-}
-
 /*
  *	数据填充
- *	false=数据没有填充完；true=数据填充完成
+ *	返回值：false=数据没有填充完；true=数据填充完成
  */
-static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
+static bool padding_bits(uint8_t *msg,
+						 uint32_t msg_length,
+						 uint32_t *msg_length_remain,
+						 uint8_t *m_8bit)
 {
 	uint8_t i;
-	uint32_t tmp;
 	
-	if(hash_message_length >= 64)
+	if(*msg_length_remain >= 64)
 	{
 		for(i=0; i<64; i++)
 		{
-			m_8bit[i] = message[i];
+			m_8bit[i] = msg[i];
 		}
 		
-		hash_message_length -= 64;
+		*msg_length_remain -= 64;
 	}
 	else //小于64字节.
 	{
-		if(hash_message_length >= 56) //56-63字节之间，一个块填充不完，还需要填充1次.
+		if(*msg_length_remain >= 56) //56-63字节之间，一个块填充不完，还需要填充1次.
 		{
-			for(i=0; i<hash_message_length; i++)
+			for(i=0; i<*msg_length_remain; i++)
 			{
-				m_8bit[i] = message[i];
+				m_8bit[i] = msg[i];
 			}
 			m_8bit[i++] = 0x80;
 			while(i < 64)
@@ -80,17 +58,17 @@ static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
 				m_8bit[i++] = 0;
 			}
 			
-			hash_message_length = 0;
+			*msg_length_remain = 0;
 		}
 		else //小于等于56字节.
 		{
-			for(i=0; i<hash_message_length; i++)
+			for(i=0; i<*msg_length_remain; i++)
 			{
-				m_8bit[i] = message[i];
+				m_8bit[i] = msg[i];
 			}
 			
 			/* 消息小于56字节时或者消息是64的倍数时，‘1’没有填充 */
-			if(hash_message_length != 0 || hash_message_length_tmp % 64 == 0)
+			if(*msg_length_remain != 0 || msg_length % 64 == 0)
 			{
 				m_8bit[i++] = 0x80;
 			}
@@ -105,11 +83,11 @@ static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
 				m_8bit[i++] = 0;
 			}
 			
-			tmp = hash_message_length_tmp * 8;
-			m_8bit[60] = tmp >> 24;
-			m_8bit[61] = tmp >> 16;
-			m_8bit[62] = tmp >> 8;
-			m_8bit[63] = tmp;
+			msg_length <<= 3; //乘8转为位长度.
+			m_8bit[60] = msg_length >> 24;
+			m_8bit[61] = msg_length >> 16;
+			m_8bit[62] = msg_length >> 8;
+			m_8bit[63] = msg_length;
 			
 			return true;
 		}
@@ -242,18 +220,22 @@ static void compute_hash_value(uint32_t *wt, uint32_t *H)
 
 /*
  *	产生安全散列值SHA224
- *	message：参与计算的数据
- *	sha224： 计算得到的散列值(224位)
+ *	msg：		参与计算的数据
+ *	msg_length：参与计算的数据长度
+ *	sha224： 	计算得到的散列值(224位)
  */
-bool yd_sha224(uint8_t *message, uint32_t *sha224)
+bool yd_sha224(uint8_t *msg, uint32_t msg_length, uint32_t *sha224)
 {
 	uint8_t flag, m_8bit[64];
-	uint32_t i, wt[64], H[8];
+	uint32_t i, msg_length_remain;
+	uint32_t wt[64], H[8];
 	
-	if(false == count_hash_message_length(message))
+	/* 限制：最大计算0xffffffff / 8 = 536870911字节 */
+	if(msg_length > 536870911)
 	{
 		return false;
 	}
+	msg_length_remain = msg_length;
 	
 	H[0] = 0xc1059ed8;
 	H[1] = 0x367cd507;
@@ -268,8 +250,11 @@ bool yd_sha224(uint8_t *message, uint32_t *sha224)
 	while(flag == 1)
 	{
 		/* 0步------------------------------------------------------------ */
-		i = hash_message_length_tmp - hash_message_length; //定位要计算的消息.
-		if(true == padding_bits(&message[i], m_8bit))
+		i = msg_length - msg_length_remain; //定位要计算的消息.
+		if(true == padding_bits(&msg[i],
+								msg_length,
+								&msg_length_remain,
+								m_8bit))
 		{
 			flag = 0;
 		}

src/hash/yd_sha256.c

@@ -12,7 +12,6 @@
 #include "yd_sha256.h"
 
 
-static uint32_t hash_message_length=0, hash_message_length_tmp=0; //要计算消息长度.
 static uint32_t k_table[64] =
 {	/* 下面数据由前64个质数开3次方的前32位小数部分(转二进制，乘2取整)得到 */
 	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
@@ -25,54 +24,33 @@ static uint32_t k_table[64] =
 	0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
 };
 
-
-/* 统计消息长度 */
-static bool count_hash_message_length(uint8_t *message)
-{
-	uint32_t tmp;
-	
-	tmp = 0;
-	while(message[tmp] != '\0')
-	{
-		tmp++;
-		/* 限制：最大计算(0xffffffff >> 3) = 536870911字节 */
-		if(tmp > 536870911)
-		{
-			return false;
-		}
-	}
-	
-	hash_message_length = tmp;
-	hash_message_length_tmp = tmp; //消息长度.
-	
-	return true;
-}
-
 /*
  *	数据填充
- *	false=数据没有填充完；true=数据填充完成
+ *	返回值：false=数据没有填充完；true=数据填充完成
  */
-static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
+static bool padding_bits(uint8_t *msg,
+						 uint32_t msg_length,
+						 uint32_t *msg_length_remain,
+						 uint8_t *m_8bit)
 {
 	uint8_t i;
-	uint32_t tmp;
 	
-	if(hash_message_length >= 64)
+	if(*msg_length_remain >= 64)
 	{
 		for(i=0; i<64; i++)
 		{
-			m_8bit[i] = message[i];
+			m_8bit[i] = msg[i];
 		}
 		
-		hash_message_length -= 64;
+		*msg_length_remain -= 64;
 	}
 	else //小于64字节.
 	{
-		if(hash_message_length >= 56) //56-63字节之间，一个块填充不完，还需要填充1次.
+		if(*msg_length_remain >= 56) //56-63字节之间，一个块填充不完，还需要填充1次.
 		{
-			for(i=0; i<hash_message_length; i++)
+			for(i=0; i<*msg_length_remain; i++)
 			{
-				m_8bit[i] = message[i];
+				m_8bit[i] = msg[i];
 			}
 			m_8bit[i++] = 0x80;
 			while(i < 64)
@@ -80,17 +58,17 @@ static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
 				m_8bit[i++] = 0;
 			}
 			
-			hash_message_length = 0;
+			*msg_length_remain = 0;
 		}
 		else //小于等于56字节.
 		{
-			for(i=0; i<hash_message_length; i++)
+			for(i=0; i<*msg_length_remain; i++)
 			{
-				m_8bit[i] = message[i];
+				m_8bit[i] = msg[i];
 			}
 			
 			/* 消息小于56字节时或者消息是64的倍数时，‘1’没有填充 */
-			if(hash_message_length != 0 || hash_message_length_tmp % 64 == 0)
+			if(*msg_length_remain != 0 || msg_length % 64 == 0)
 			{
 				m_8bit[i++] = 0x80;
 			}
@@ -105,11 +83,11 @@ static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
 				m_8bit[i++] = 0;
 			}
 			
-			tmp = hash_message_length_tmp * 8;
-			m_8bit[60] = tmp >> 24;
-			m_8bit[61] = tmp >> 16;
-			m_8bit[62] = tmp >> 8;
-			m_8bit[63] = tmp;
+			msg_length <<= 3; //乘8转为位长度.
+			m_8bit[60] = msg_length >> 24;
+			m_8bit[61] = msg_length >> 16;
+			m_8bit[62] = msg_length >> 8;
+			m_8bit[63] = msg_length;
 			
 			return true;
 		}
@@ -242,18 +220,22 @@ static void compute_hash_value(uint32_t *wt, uint32_t *H)
 
 /*
  *	产生安全散列值SHA256
- *	message：参与计算的数据
- *	sha256： 计算得到的散列值(256位)
+ *	msg：		参与计算的数据
+ *	msg_length：参与计算的数据长度
+ *	sha256： 	计算得到的散列值(256位)
  */
-bool yd_sha256(uint8_t *message, uint32_t *sha256)
+bool yd_sha256(uint8_t *msg, uint32_t msg_length, uint32_t *sha256)
 {
 	uint8_t flag, m_8bit[64];
-	uint32_t i, wt[64], H[8];
+	uint32_t i, msg_length_remain;
+	uint32_t wt[64], H[8];
 	
-	if(false == count_hash_message_length(message))
+	/* 限制：最大计算0xffffffff / 8 = 536870911字节 */
+	if(msg_length > 536870911)
 	{
 		return false;
 	}
+	msg_length_remain = msg_length;
 	
 	H[0] = 0x6a09e667;
 	H[1] = 0xbb67ae85;
@@ -265,11 +247,14 @@ bool yd_sha256(uint8_t *message, uint32_t *sha256)
 	H[7] = 0x5be0cd19;
 	
 	flag = 1;
-	while(flag == 1)
+	do
 	{
 		/* 0步------------------------------------------------------------ */
-		i = hash_message_length_tmp - hash_message_length; //定位要计算的消息.
-		if(true == padding_bits(&message[i], m_8bit))
+		i = msg_length - msg_length_remain; //定位要计算的消息.
+		if(true == padding_bits(&msg[i],
+								msg_length,
+								&msg_length_remain,
+								m_8bit))
 		{
 			flag = 0;
 		}
@@ -279,7 +264,7 @@ bool yd_sha256(uint8_t *message, uint32_t *sha256)
 		
 		/* 2-4步------------------------------------------------------------ */
 		compute_hash_value(wt, H);
-	}
+	}while(flag == 1);
 	
 	sha256[0] = H[0];
 	sha256[1] = H[1];

src/md5/yd_md5.c

@@ -12,7 +12,6 @@
 #include "yd_md5.h"
 
 
-static uint32_t md5_message_length=0, md5_message_length_tmp=0; //要计算消息长度.
 static uint32_t t_table[64] =
 {	/* 下面值由4294967296*abs(sin(i))得到，i=1~64，i是弧度，4294967296=0xffffffff+1 */
 	0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
@@ -25,54 +24,34 @@ static uint32_t t_table[64] =
 	0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
 };
 
-
-/* 统计消息长度 */
-static bool count_hash_message_length(uint8_t *message)
-{
-	uint32_t tmp;
-	
-	tmp = 0;
-	while(message[tmp] != '\0')
-	{
-		tmp++;
-		/* 限制：最大计算(0xffffffff >> 3) = 536870911字节 */
-		if(tmp > 536870911)
-		{
-			return false;
-		}
-	}
-	
-	md5_message_length = tmp;
-	md5_message_length_tmp = tmp; //消息长度.
-	
-	return true;
-}
-
 /*
  *	数据填充
- *	false=数据没有填充完；true=数据填充完成
+ *	返回值：false=数据没有填充完；true=数据填充完成
  */
-static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
+static bool padding_bits(uint8_t *msg,
+						 uint32_t msg_length,
+						 uint32_t *msg_length_remain,
+						 uint8_t *m_8bit)
 {
 	uint8_t i;
-	uint32_t tmp;
 	
-	if(md5_message_length >= 64)
+	if(*msg_length_remain >= 64)
 	{
 		for(i=0; i<64; i++)
 		{
-			m_8bit[i] = message[i];
+			m_8bit[i] = msg[i];
 		}
 		
-		md5_message_length -= 64;
+		*msg_length_remain -= 64;
 	}
 	else //小于64字节.
 	{
-		if(md5_message_length >= 56) //56-63字节之间，一个块填充不完，还需要填充1次.
+		/* 56-63字节之间，一个块填充不完，还需要填充1次 */
+		if(*msg_length_remain >= 56)
 		{
-			for(i=0; i<md5_message_length; i++)
+			for(i=0; i<*msg_length_remain; i++)
 			{
-				m_8bit[i] = message[i];
+				m_8bit[i] = msg[i];
 			}
 			m_8bit[i++] = 0x80;
 			while(i < 64)
@@ -80,17 +59,17 @@ static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
 				m_8bit[i++] = 0;
 			}
 			
-			md5_message_length = 0;
+			*msg_length_remain = 0;
 		}
 		else //小于等于56字节.
 		{
-			for(i=0; i<md5_message_length; i++)
+			for(i=0; i<*msg_length_remain; i++)
 			{
-				m_8bit[i] = message[i];
+				m_8bit[i] = msg[i];
 			}
 			
 			/* 消息小于56字节时或者消息是64的倍数时，‘1’没有填充 */
-			if(md5_message_length != 0 || md5_message_length_tmp % 64 == 0)
+			if(*msg_length_remain != 0 || msg_length % 64 == 0)
 			{
 				m_8bit[i++] = 0x80;
 			}
@@ -100,11 +79,11 @@ static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
 				m_8bit[i++] = 0;
 			}
 			
-			tmp = md5_message_length_tmp * 8;
-			m_8bit[56] = tmp;
-			m_8bit[57] = tmp >> 8;
-			m_8bit[58] = tmp >> 16;
-			m_8bit[59] = tmp >> 24;
+			msg_length <<= 3; //乘8转为位长度.
+			m_8bit[56] = msg_length;
+			m_8bit[57] = msg_length >> 8;
+			m_8bit[58] = msg_length >> 16;
+			m_8bit[59] = msg_length >> 24;
 			
 			i = 60;
 			while(i < 64) //最大计算数据长度限制到32位，所以这4字节填0.
@@ -252,18 +231,23 @@ static void compute_md5_value(uint32_t *X, uint32_t *abcd)
 
 /*
  *	产生MD5
- *	message：参与计算的数据(字符串)
- *	md5：	 计算得到的值(128位)
+ *	msg：		参与计算的数据(字符串)
+ *	msg_length：参与计算的数据长度
+ *	md5：	 	计算得到的值(128位)
  */
-bool yd_md5(uint8_t *message, uint8_t *md5)
+bool yd_md5(uint8_t *msg, uint32_t msg_length, uint8_t *md5)
 {
-	uint8_t k, k_tmp, flag, m_8bit[64];
-	uint32_t i, X[16], abcd[4];
+	uint8_t k, k_tmp;
+	uint8_t flag, m_8bit[64];
+	uint32_t i, msg_length_remain;
+	uint32_t X[16], abcd[4];
 	
-	if(false == count_hash_message_length(message)) //字符串长度统计.
+	/* 限制：最大计算0xffffffff / 8 = 536870911字节 */
+	if(msg_length > 536870911)
 	{
 		return false;
 	}
+	msg_length_remain = msg_length;
 	
 	abcd[0] = 0x67452301; //初始化MD缓冲器.
 	abcd[1] = 0xefcdab89;
@@ -271,22 +255,28 @@ bool yd_md5(uint8_t *message, uint8_t *md5)
 	abcd[3] = 0x10325476;
 	
 	flag = 1;
-	while(flag == 1)
+	do
 	{
-		i = md5_message_length_tmp - md5_message_length; //定位要计算的消息.
-		if(true == padding_bits(&message[i], m_8bit))
+		i = msg_length - msg_length_remain; //定位要计算的消息.
+		if(true == padding_bits(&msg[i],
+								msg_length,
+								&msg_length_remain,
+								m_8bit))
 		{
 			flag = 0; //完成最后填充，结束循环.
 		}
 		
 		for(k=0; k<16; k++)
 		{
-			k_tmp = k << 2; //k<<2=k*4.
-			X[k] = m_8bit[k_tmp+3]<<24 | m_8bit[k_tmp+2]<<16 | m_8bit[k_tmp+1]<<8 | m_8bit[k_tmp];
+			k_tmp = k << 2; //k*4.
+			X[k] = m_8bit[k_tmp+3] << 24 |
+				   m_8bit[k_tmp+2] << 16 |
+				   m_8bit[k_tmp+1] << 8  |
+				   m_8bit[k_tmp];
 		}
 		
 		compute_md5_value(X, abcd);
-	}
+	}while(flag == 1);
 	
 	/* 显示转换 */
 	md5[0] = abcd[0];

src/sm3/yd_sm3.c

@@ -11,56 +11,34 @@
 
 #include "yd_sm3.h"
 
-static uint32_t sm3_message_length=0, sm3_message_length_tmp=0; //要计算消息长度.
-
-
-/* 统计消息长度 */
-static bool count_sm3_message_length(uint8_t *message)
-{
-	uint32_t tmp;
-	
-	tmp = 0;
-	while(message[tmp] != '\0')
-	{
-		tmp++;
-		/* 限制：最大计算(0xffffffff >> 3) = 536870911字节 */
-		if(tmp > 536870911)
-		{
-			return false;
-		}
-	}
-	
-	sm3_message_length = tmp;
-	sm3_message_length_tmp = tmp; //消息长度.
-	
-	return true;
-}
 
 /*
  *	数据填充
- *	false=数据没有填充完；true=数据填充完成
+ *	返回值：false=数据没有填充完；true=数据填充完成
  */
-static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
+static bool padding_bits(uint8_t *msg,
+						 uint32_t msg_length,
+						 uint32_t *msg_length_remain,
+						 uint8_t *m_8bit)
 {
 	uint8_t i;
-	uint32_t tmp;
 	
-	if(sm3_message_length >= 64)
+	if(*msg_length_remain >= 64)
 	{
 		for(i=0; i<64; i++)
 		{
-			m_8bit[i] = message[i];
+			m_8bit[i] = msg[i];
 		}
 		
-		sm3_message_length -= 64;
+		*msg_length_remain -= 64;
 	}
 	else //小于64字节.
 	{
-		if(sm3_message_length >= 56) //56-63字节之间，一个块填充不完，还需要填充1次.
+		if(*msg_length_remain >= 56) //56-63字节之间，一个块填充不完，还需要填充1次.
 		{
-			for(i=0; i<sm3_message_length; i++)
+			for(i=0; i<*msg_length_remain; i++)
 			{
-				m_8bit[i] = message[i];
+				m_8bit[i] = msg[i];
 			}
 			m_8bit[i++] = 0x80;
 			while(i < 64)
@@ -68,17 +46,17 @@ static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
 				m_8bit[i++] = 0;
 			}
 			
-			sm3_message_length = 0;
+			*msg_length_remain = 0;
 		}
 		else //小于等于56字节.
 		{
-			for(i=0; i<sm3_message_length; i++)
+			for(i=0; i<*msg_length_remain; i++)
 			{
-				m_8bit[i] = message[i];
+				m_8bit[i] = msg[i];
 			}
 			
 			/* 消息小于56字节时或者消息是64的倍数时，‘1’没有填充 */
-			if(sm3_message_length != 0 || sm3_message_length_tmp % 64 == 0)
+			if(*msg_length_remain != 0 || msg_length % 64 == 0)
 			{
 				m_8bit[i++] = 0x80;
 			}
@@ -93,11 +71,11 @@ static bool padding_bits(uint8_t *message, uint8_t *m_8bit)
 				m_8bit[i++] = 0;
 			}
 			
-			tmp = sm3_message_length_tmp * 8;
-			m_8bit[60] = tmp >> 24;
-			m_8bit[61] = tmp >> 16;
-			m_8bit[62] = tmp >> 8;
-			m_8bit[63] = tmp;
+			msg_length <<= 3; //乘8转为位长度.
+			m_8bit[60] = msg_length >> 24;
+			m_8bit[61] = msg_length >> 16;
+			m_8bit[62] = msg_length >> 8;
+			m_8bit[63] = msg_length;
 			
 			return true;
 		}
@@ -252,18 +230,22 @@ static void compute_sm3_value(uint32_t *w, uint32_t *wt, uint32_t *V)
 
 /*
  *	产生SM3杂凑值(密码)
- *	message：参与计算的数据
- *	sm3： 计算得到的杂凑值(256位)
+ *	msg：		参与计算的数据(字符串)
+ *	msg_length：参与计算的数据长度
+ *	sm3： 		计算得到的杂凑值(256位)
  */
-bool yd_sm3(uint8_t *message, uint32_t *sm3)
+bool yd_sm3(uint8_t *msg, uint32_t msg_length, uint32_t *sm3)
 {
 	uint8_t flag, m_8bit[64];
-	uint32_t i, w[68], wt[64], V[8];
+	uint32_t i, msg_length_remain;
+	uint32_t w[68], wt[64], V[8];
 	
-	if(false == count_sm3_message_length(message))
+	/* 限制：最大计算0xffffffff / 8 = 536870911字节 */
+	if(msg_length > 536870911)
 	{
 		return false;
 	}
+	msg_length_remain = msg_length;
 	
 	V[0] = 0x7380166f;
 	V[1] = 0x4914b2b9;
@@ -277,8 +259,11 @@ bool yd_sm3(uint8_t *message, uint32_t *sm3)
 	flag = 1;
 	while(flag == 1)
 	{
-		i = sm3_message_length_tmp - sm3_message_length; //定位要计算的消息.
-		if(true == padding_bits(&message[i], m_8bit))
+		i = msg_length - msg_length_remain; //定位要计算的消息.
+		if(true == padding_bits(&msg[i],
+								msg_length,
+								&msg_length_remain,
+								m_8bit))
 		{
 			flag = 0;
 		}