SHA224SHA256算法.docx

《SHA224SHA256算法.docx》由会员分享，可在线阅读，更多相关《SHA224SHA256算法.docx（21页珍藏版）》请在三一办公上搜索。

1、SHA224SHA256算法SHA224_SHA256算法实现 源码文件：main.c，SHA224_SHA256.h，SHA224_SHA256.c加入工程编译即可 说明：该SHA224_SHA256算法是8位单片机(51内核)Keil C51纯软件实现 目 录 1 SHA224_SHA256算法说明 . 3 1.1. 源码算法使用方法 . 3 2 数据类型定义 . 3 3函数接口说明 . 3 初始化SHA224模块 . 4 3.2 分步对SHA224消息进行计算 . 4 3.3 完成杂凑计算，取SHA224结果 . 5 3.4 一次性输入，计算，取SHA224结果 . 5 3.5 初始化S

2、HA256模块 . 6 3.6 分步对SHA256消息进行计算 . 6 3.7 完成杂凑计算，取SHA256结果 . 6 3.8 一次性输入，计算，取SHA256结果 . 7 源码算法例程 . 7 3.1 1 SHA224_SHA256算法说明 1.1. 源码算法使用方法 算法使用方法如下： 将main.c和SHA224_SHA256.c，SHA224_SHA256.h加入工程编译即可； 1、 2 数据类型定义 typedef unsigned char typedef singed char U8; S8; typedef unsigned int U16; typedef signed i

3、nt S16; U32; typedef unsigned long typedef signed long S32; typedef struct U32 count2; U32 hash8; U32 wbuf16; SHA256_Ctx; typedef SHA256_Ctx SHA224_Ctx; 3函数接口说明 SHA224_SHA256算法包含的函数列表如下： 表 3-1 SHA224_SHA256算法库函数表 函数 void SHA224_Init(SHA224_Ctx * ctx) void SHA224_Process(SHA224_Ctx * ctx, U8 * messag

4、e, U32 byteLen) 描述 初始化SHA224模块 分步对SHA224消息进行计算 完成杂凑计算，取SHA224void SHA224_Done(SHA224_Ctx * ctx, U8 * digest) 结果 一次性输入，计算，取void SHA224_Hash(U8 * message, U32 byteLen, U8 * digest) SHA224结果 void SHA256_Init(SHA256_Ctx * ctx) 初始化SHA256模块 void SHA256_Process(SHA256_Ctx * ctx, U8 * message, U32 分步对SHA256

5、消息进行byteLen) 计算 完成杂凑计算，取SHA256void SHA256_Done(SHA256_Ctx * ctx, U8 * digest) 结果 一次性输入，计算，取void SHA256_Hash(U8 * message, U32 byteLen, U8 * digest) SHA256结果 3.1 初始化SHA224模块 SHA224_Init 初始化SHA224模块 函数原型 void SHA224_Init(SHA224_Ctx * ctx) 参数说明 ctx 注意事项 例程 输入，分步计算的SHA224_Ctx结构体指针 对一较长消息进行分步杂凑计算时都要首先调用本

6、函数 见源码。 3.2 分步对SHA224消息进行计算 SHA224_Process 分步对SHA224消息进行计算 函数原型 参数说明 ctx 输入，分步计算的SHA224_Ctx结构体指针 输入，当前处理消息的指针 输入，当前处理消息的字节长度 void SHA224_Process(SHA224_Ctx * ctx, U8 * message, U32 byteLen) message byteLen 注意事项 可以将很长的待杂凑消息分成几部分，依次循环调用此函数，每次调用时message取当前部分的起始地址 例程 见源码。 3.3 完成杂凑计算，取SHA224结果 SHA224_Don

7、e 完成杂凑计算，取结果 函数原型 参数说明 void SHA224_Done(SHA224_Ctx * ctx, U8 * digest) ctx 输入，分步计算的SHA224_Ctx结构体指针 输出，杂凑的结果 digest 注意事项 1. 在调用SHA224_Process函数将待杂凑数据输入完毕后，调用本函数计算最终的杂凑结果 2. 由于SHA224的结果是224比特，即28字节，因此digest指向的空间至少应是28字节 例程 见源码。 3.4 一次性输入，计算，取SHA224结果 SHA224_Hash 一次性输入，计算，取结果 函数原型 参数说明 void SHA224_Hash

8、(U8 * message, U32 byteLen, U8 * digest) message byteLen digest 注意事项 输入，待处理消息的指针 输入，待处理消息的字节长度 输出，杂凑的结果 1. 调用本函数进行一次性杂凑计算，效果与完整的调用一次“初始化-分步输入杂凑数据计算-完成杂凑计算”相同 2. 由于SHA224的结果是224比特，即28字节，因此digest指向的空间至少应是28字节 例程 见源码。 3.5 初始化SHA256模块 SHA256_Init 初始化SHA256模块 函数原型 void SHA256_Init(SHA256_Ctx * ctx) 参数说明

9、ctx 注意事项 例程 输入，分步计算的SHA256_Ctx结构体指针 对一较长消息进行分步杂凑计算时都要首先调用本函数 见源码。 3.6 分步对SHA256消息进行计算 SHA256_Process 分步对SHA256消息进行计算 函数原型 参数说明 ctx 输入，分步计算的SHA256_Ctx结构体指针 输入，当前处理消息的指针 输入，当前处理消息的字节长度 void SHA256_Process(SHA256_Ctx * ctx, U8 * message, U32byteLen) message byteLen 注意事项 可以将很长的待杂凑消息分成几部分，依次循环调用此函数，每次调用时

10、message取当前部分的起始地址 例程 见源码。 3.7 完成杂凑计算，取SHA256结果 SHA256_Done 完成杂凑计算，取结果 函数原型 参数说明 void SHA256_Done(SHA256_Ctx * ctx, U8 * digest) ctx 输入，分步计算的SHA256_Ctx结构体指针 输出，杂凑的结果 digest 注意事项 1. 在调用SHA256_Process函数将待杂凑数据输入完毕后，调用本函数计算最终的杂凑结果 2. 由于SHA256的结果是256比特，即32字节，因此digest指向的空间至少应是32字节 例程 见源码。 3.8 一次性输入，计算，取SHA

11、256结果 SHA256_Hash 一次性输入，计算，取结果 函数原型 参数说明 void SHA256_Hash(U8 * message, U32 byteLen, U8 * digest) message byteLen digest 注意事项 输入，待处理消息的指针 输入，待处理消息的字节长度 输出，杂凑的结果 1. 调用本函数进行一次性杂凑计算，效果与完整的调用一次“初始化-分步输入杂凑数据计算-完成杂凑计算”相同 2. 由于SHA256的结果是256比特，即32字节，因此digest指向的空间至少应是32字节 例程 见源码 源码算法例程 SHA224_SHA256.h #ifnde

12、f SHA224_SHA256_H #define SHA224_SHA256_H typedef unsigned char typedef unsigned int typedef unsigned long typedef unsigned short typedef unsigned char typedef unsigned int typedef unsigned long typedef char UCHAR; UINT; ULONG; USHORT; U8; U16; U32; S8 ; typedef int S16; typedef long S32; /* type to

13、 hold the SHA256 context */ typedef struct U32 count2; U32 hash8; U32 wbuf16; SHA256_Ctx; /* type to hold the SHA224 context */ typedef SHA256_Ctx SHA224_Ctx; void SHA256_Init(SHA256_Ctx * ctx); void SHA256_Process(SHA256_Ctx * ctx, U8 * message, U32 len); void SHA256_Done(SHA256_Ctx * ctx, U8 * dig

14、est); void SHA256_Hash(U8 * message, U32 len, U8 * digest); void SHA224_Init(SHA224_Ctx * ctx); void SHA224_Process(SHA224_Ctx * ctx, U8 * message, U32 len); void SHA224_Done(SHA224_Ctx * ctx, U8 * digest); void SHA224_Hash(U8 * message, U32 len, U8 * digest); #endif Main.c #include #include #includ

15、e #include SHA224_SHA256.h /void printbuf(U8 * buf, U32 len) / / int i; / printf(rn); / for(i=0;ilen;i+) / printf(%02bx,bufi); /说明：print_buf函数需要根据所用单片机来实现，主要是观察数据使用，不影响算法，故注释掉。 void main U8 xdata InBuff1024; U8 xdata OutBuff64; SHA256_Ctx xdata ctx; U32 xdata i; printf(rn SHA1 Test Demo rn); for(i=0

16、; i1024; i+) InBuffi = 0x5a; /*SHA224 Speed Test */ / the message consists of 0x5a, SHA224_Init(&ctx); /printf( rn SHA224 Speed Test Begin!); for(i=0; i30; i+) SHA224_Process(&ctx, InBuff, 1024); /printf( rn SHA224 Speed Test Finished!); SHA224_Done(&ctx, OutBuff); /printbuf(OutBuff, 28); /the resul

17、t should be 5f30cbe95d45c15c71d8ee1f24af113980aad24f241d24c60e43a9e7 /* SHA256 Speed Test */ / the message consists of 0x5a, its byte length is 30KB SHA256_Init(&ctx); printf( rnrn SHA256 Speed Test Begin!); for(i=0; i30; i+) SHA256_Process(&ctx, InBuff, 1024); printf( rn SHA256 Speed Test Finished!

18、); SHA256_Done(&ctx, OutBuff); /printbuf(OutBuff, 32); /the result should be 0bfa0d07af40713eacec4dddd713a2224d66937c82b93dd09057f246676b01dd /* SHA224 Validity Test 1 */ / the messages all consist of 0x5a, its byte length are from 1 to 136 /printf(rnrn SHA224 Validity Test 1 rn); for(i=1; i137; i+)

19、 SHA224_Hash(InBuff, i, OutBuff); /printbuf(OutBuff, 28); /* SHA256 Validity Test 1 */ / the messages all consist of 0x5a /printf(rnrn SHA256 Validity Test 1 rn); for(i=1; i137; i+) SHA256_Hash(InBuff, i, OutBuff); /printbuf(OutBuff, 32); /* SHA224 Validity Test 2 */ /The message consists of 0x5a, i

20、ts byte length is 132, just for example, here are 4 cases to /compute its message digest, /and the results all should be /026678D14A6289E3C1FD772D05931834D5B74FA1498899141DF7693C /printf(rnrn SHA224 Validity Test 2 ); /case 1 SHA224_Hash(InBuff, 132, OutBuff); /printf(rn SHA224 Case 1: ); / printbuf

21、(OutBuff, 28); /case 2 SHA224_Init(&ctx); SHA224_Process(&ctx, InBuff, 1); SHA224_Process(&ctx, InBuff+1, 2); SHA224_Process(&ctx, InBuff+3, 61); SHA224_Process(&ctx, InBuff+64, 3); SHA224_Process(&ctx, InBuff+67, 65); SHA224_Done(&ctx, OutBuff); /printf(rn SHA224 Case 2: ); /printbuf(OutBuff, 28);

22、/case 3 SHA224_Init(&ctx); SHA224_Process(&ctx, InBuff, 12); SHA224_Process(&ctx, InBuff+12, 43); SHA224_Process(&ctx, InBuff+55, 2); SHA224_Process(&ctx, InBuff+57, 3); SHA224_Process(&ctx, InBuff+60, 71); SHA224_Process(&ctx, InBuff+131, 1); SHA224_Done(&ctx, OutBuff); /printf(rn SHA224 Case 3: );

23、 /printbuf(OutBuff, 28); /case 4 SHA224_Init(&ctx); SHA224_Process(&ctx, InBuff, 66); SHA224_Process(&ctx, InBuff+66, 11); SHA224_Process(&ctx, InBuff+77, 47); SHA224_Process(&ctx, InBuff+124, 8); SHA224_Done(&ctx, OutBuff); /printf(rn SHA224 Case 4: ); /printbuf(OutBuff, 28); /*/ /* SHA256 Validity

24、 Test 2 */ /The message consists of 0x5a, its byte length is 132, just for example, here are 4 cases to /compute its message digest, /and the results all should be /e9483323f0c36c8a3eb4c5eb4e8f0820ff021e95ce40d030a579a1ae15331397 /printf(rnrn SHA256 Validity Test 2 ); /case 1 SHA256_Hash(InBuff, 132

25、, OutBuff); /printf(rn SHA256 Case 1: ); /printbuf(OutBuff, 32); /case 2 SHA256_Init(&ctx); SHA256_Process(&ctx, InBuff, 1); SHA256_Process(&ctx, InBuff+1, 2); SHA256_Process(&ctx, InBuff+3, 61); SHA256_Process(&ctx, InBuff+64, 3); SHA256_Process(&ctx, InBuff+67, 65); SHA256_Done(&ctx, OutBuff); /pr

26、intf(rn SHA256 Case 2: ); /printbuf(OutBuff, 32); /case 3 SHA256_Init(&ctx); SHA256_Process(&ctx, InBuff, 12); SHA256_Process(&ctx, InBuff+12, 43); SHA256_Process(&ctx, InBuff+55, 2); SHA256_Process(&ctx, InBuff+57, 3); SHA256_Process(&ctx, InBuff+60, 71); SHA256_Process(&ctx, InBuff+131, 1); SHA256

27、_Done(&ctx, OutBuff); /printf(rn SHA256 Case 3: ); /printbuf(OutBuff, 32); /case 4 SHA256_Init(&ctx); SHA256_Process(&ctx, InBuff, 66); SHA256_Process(&ctx, InBuff+66, 11); SHA256_Process(&ctx, InBuff+77, 47); SHA256_Process(&ctx, InBuff+124, 8); SHA256_Done(&ctx, OutBuff); /printf(rn SHA256 Case 4:

28、 ); /printbuf(OutBuff, 32); /*/ while(1); SHA224_SHA256.c #include #include #include SHA224_SHA256.h U32 code SHA224_H08= 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4; U32 code SHA256_H08= 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0

29、x9b05688c, 0x1f83d9ab, 0x5be0cd19; U32 code SHA256_K64= 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2d

30、e92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6

31、990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2; /对32比特的变量x循环右移n比特( 该芯片是大端顺序，因此可直接用 U32 类型处理 ) U32 SHA256_ROTR(U32 * x, U8 n)

32、 return (*x)n)|(*x)n; /U64类型的大数a = a + len*8; 即a表示消息的比特长度, 这里参数len = 64 void SHA256_len_add(U32 * a, U16 len) a1 += (len3); if(a1 (lencount13) & 0x3f; /每64字节的消息分组，计算最终得到的 abcdefgh void SHA256_block(SHA256_Ctx * ctx) S8 data i,j; U32 xdata SHA256_abcdefgh8, *W, *T; /initialize abcdefgh memcpy(SHA256_

33、abcdefgh, ctx-hash, 32); for(i=0; iwbuf + (i&15); if(i15) W = ctx-wbuf + (i&15); T = ctx-wbuf + (i-2)&15); (*W) += (SHA256_ROTR(T, 17) SHA256_ROTR(T, 19) SHA256_SHR(T, 10); T = ctx-wbuf + (i-15)&15); (*W) += (SHA256_ROTR(T, 7) SHA256_ROTR(T, 18) SHA256_SHR(T, 3); (*W) += ctx-wbuf(i-7)&15; j=7-(i&7);

34、 /注意: (i%8) = (i&7) /compute T1 SHA256_abcdefghj += (SHA256_abcdefgh(j+5)&7)&(SHA256_abcdefgh(j+6)&7) (SHA256_abcdefgh(j+5)&7)&(SHA256_abcdefgh(j+7)&7); /与上面一起 SHA256_abcdefghj += (*W) + SHA256_Ki); SHA256_abcdefghj += (SHA256_ROTR(SHA256_abcdefgh+(j+5)&7), 6) SHA256_ROTR(SHA256_abcdefgh+(j+5)&7), 11) SHA256_ROTR(SHA256_abcdefgh+(j+5)&7), 25); /与上面一起 / e=d+T1 SHA256_abcdefgh(j+4)&7 += SHA256_abcdefghj; / a=T1+T2 SHA256_abcdefghj += (SHA256_abcdefgh(j+1)&7)&(SHA256_abcdefgh(j+2)&7) (SHA256_abcdefgh(j+1)&7)&(SHA256_abcdefgh(j+3)&7) (SHA256_abcd