SHA224SHA256算法.docx
《SHA224SHA256算法.docx》由会员分享，可在线阅读，更多相关《SHA224SHA256算法.docx（16页珍藏版）》请在冰豆网上搜索。
SHA224SHA256算法
SHA224_SHA256算法实现
源码文件：
main.c，SHA224_SHA256.h，SHA224_SHA256.c加入工程编译即可
说明：
该SHA224_SHA256算法是8位单片机（51内核）KeilC51纯软件实现
1SHA224_SHA256算法说明
1.1.源码算法使用方法
算法使用方法如下：
1、将main.c和SHA224_SHA256.c，SHA224_SHA256.h加入工程编译即可；
2数据类型定义
typedefunsignedcharU8;
typedefsingedcharS8;
typedefunsignedintU16;
typedefsignedintS16;
typedefunsignedlongU32;
typedefsignedlongS32;
typedefstruct
{U32count[2];
U32hash[8];
U32wbuf[16];
}SHA256_Ctx;
typedefSHA256_CtxSHA224_Ctx;
3函数接口说明
SHA224_SHA256算法包含的函数列表如下：
表31SHA224_SHA256算法库函数表
函数
描述
voidSHA224_Init（SHA224_Ctx*ctx）
初始化SHA224模块
voidSHA224_Process（SHA224_Ctx*ctx,U8*message,U32byteLen）
分步对SHA224消息进行计算
voidSHA224_Done（SHA224_Ctx*ctx,U8*digest）
完成杂凑计算，取SHA224结果
voidSHA224_Hash（U8*message,U32byteLen,U8*digest）
一次性输入，计算，取SHA224结果
voidSHA256_Init（SHA256_Ctx*ctx）
初始化SHA256模块
voidSHA256_Process（SHA256_Ctx*ctx,U8*message,U32byteLen）
分步对SHA256消息进行计算
voidSHA256_Done（SHA256_Ctx*ctx,U8*digest）
完成杂凑计算，取SHA256结果
voidSHA256_Hash（U8*message,U32byteLen,U8*digest）
一次性输入，计算，取SHA256结果
3.1初始化SHA224模块
SHA224_Init初始化SHA224模块
函数原型voidSHA224_Init（SHA224_Ctx*ctx）
参数说明
ctx输入，分步计算的SHA224_Ctx结构体指针
注意事项对一较长消息进行分步杂凑计算时都要首先调用本函数
例程见源码。
3.2分步对SHA224消息进行计算
SHA224_Process分步对SHA224消息进行计算
函数原型voidSHA224_Process（SHA224_Ctx*ctx,U8*message,U32byteLen）
参数说明
ctx输入，分步计算的SHA224_Ctx结构体指针
message输入，当前处理消息的指针
byteLen输入，当前处理消息的字节长度
注意事项可以将很长的待杂凑消息分成几部分，依次循环调用此函数，每次调用时message取当前部分的起始地址
例程见源码。
3.3完成杂凑计算，取SHA224结果
SHA224_Done完成杂凑计算，取结果
函数原型voidSHA224_Done（SHA224_Ctx*ctx,U8*digest）
参数说明
ctx输入，分步计算的SHA224_Ctx结构体指针
digest输出，杂凑的结果
注意事项1.在调用SHA224_Process函数将待杂凑数据输入完毕后，调用本函数计算最终的杂凑结果
2.由于SHA224的结果是224比特，即28字节，因此digest指向的空间至少应是28字节
例程见源码。
3.4一次性输入，计算，取SHA224结果
SHA224_Hash一次性输入，计算，取结果
函数原型voidSHA224_Hash（U8*message,U32byteLen,U8*digest）
参数说明
message输入，待处理消息的指针
byteLen输入，待处理消息的字节长度
digest输出，杂凑的结果
注意事项1.调用本函数进行一次性杂凑计算，效果与完整的调用一次“初始化->分步输入杂凑数据计算->完成杂凑计算”相同
2.由于SHA224的结果是224比特，即28字节，因此digest指向的空间至少应是28字节
例程见源码。
3.5初始化SHA256模块
SHA256_Init初始化SHA256模块
函数原型voidSHA256_Init（SHA256_Ctx*ctx）
参数说明
ctx输入，分步计算的SHA256_Ctx结构体指针
注意事项对一较长消息进行分步杂凑计算时都要首先调用本函数
例程见源码。
3.6分步对SHA256消息进行计算
SHA256_Process分步对SHA256消息进行计算
函数原型voidSHA256_Process（SHA256_Ctx*ctx,U8*message,U32byteLen）
参数说明
ctx输入，分步计算的SHA256_Ctx结构体指针
message输入，当前处理消息的指针
byteLen输入，当前处理消息的字节长度
注意事项可以将很长的待杂凑消息分成几部分，依次循环调用此函数，每次调用时message取当前部分的起始地址
例程见源码。
3.7完成杂凑计算，取SHA256结果
SHA256_Done完成杂凑计算，取结果
函数原型voidSHA256_Done（SHA256_Ctx*ctx,U8*digest）
参数说明
ctx输入，分步计算的SHA256_Ctx结构体指针
digest输出，杂凑的结果
注意事项1.在调用SHA256_Process函数将待杂凑数据输入完毕后，调用本函数计算最终的杂凑结果
2.由于SHA256的结果是256比特，即32字节，因此digest指向的空间至少应是32字节
例程见源码。
3.8一次性输入，计算，取SHA256结果
SHA256_Hash一次性输入，计算，取结果
函数原型voidSHA256_Hash（U8*message,U32byteLen,U8*digest）
参数说明
message输入，待处理消息的指针
byteLen输入，待处理消息的字节长度
digest输出，杂凑的结果
注意事项1.调用本函数进行一次性杂凑计算，效果与完整的调用一次“初始化->分步输入杂凑数据计算->完成杂凑计算”相同
2.由于SHA256的结果是256比特，即32字节，因此digest指向的空间至少应是32字节
例程见源码
源码算法例程（main.c,SHA224_SHA256.h,SHA224_SHA256.c）
SHA224_SHA256.h
#ifndefSHA224_SHA256_H
#defineSHA224_SHA256_H
typedefunsignedcharUCHAR;
typedefunsignedintUINT;
typedefunsignedlongULONG;
typedefunsignedshortUSHORT;
typedefunsignedcharU8;
typedefunsignedintU16;
typedefunsignedlongU32;
typedefcharS8;
typedefintS16;
typedeflongS32;
/*typetoholdtheSHA256context*/
typedefstruct
{U32count[2];
U32hash[8];
U32wbuf[16];
}SHA256_Ctx;
/*typetoholdtheSHA224context*/
typedefSHA256_CtxSHA224_Ctx;
voidSHA256_Init（SHA256_Ctx*ctx）;
voidSHA256_Process（SHA256_Ctx*ctx,U8*message,U32len）;
voidSHA256_Done（SHA256_Ctx*ctx,U8*digest）;
voidSHA256_Hash（U8*message,U32len,U8*digest）;
voidSHA224_Init（SHA224_Ctx*ctx）;
voidSHA224_Process（SHA224_Ctx*ctx,U8*message,U32len）;
voidSHA224_Done（SHA224_Ctx*ctx,U8*digest）;
voidSHA224_Hash（U8*message,U32len,U8*digest）;
#endif
Main.c
#include
#include
#include
#include"SHA224_SHA256.h"
//voidprintbuf（U8*buf,U32len）
//{
//inti;
//printf（"\r\n"）;
//for（i=0;i//printf（"%02bx",buf[i]）;
}//说明：
print_buf函数需要根据所用单片机来实现，主要是观察数据使用，不影响算法，故注释掉。
voidmain（）
{
U8xdataInBuff[1024];
U8xdataOutBuff[64];
SHA256_Ctxxdatactx;
U32xdatai;
printf（"\r\nSHA1TestDemo\r\n"）;
for（i=0;i<1024;i++）
InBuff[i]=0x5a;
//****************************SHA224SpeedTest*********************************/
//themessageconsistsof"0x5a",
SHA224_Init（&ctx）;
//printf（"\r\nSHA224SpeedTestBegin!
"）;
for（i=0;i<30;i++）
SHA224_Process（&ctx,InBuff,1024）;
//printf（"\r\nSHA224SpeedTestFinished!
"）;
SHA224_Done（&ctx,OutBuff）;
//printbuf（OutBuff,28）;
//theresultshouldbe5f30cbe95d45c15c71d8ee1f24af113980aad24f241d24c60e43a9e7
//***************************SHA256SpeedTest*********************************/
//themessageconsistsof"0x5a",itsbytelengthis30KB
SHA256_Init（&ctx）;
printf（"\r\n\r\nSHA256SpeedTestBegin!
"）;
for（i=0;i<30;i++）
SHA256_Process（&ctx,InBuff,1024）;
printf（"\r\nSHA256SpeedTestFinished!
"）;
SHA256_Done（&ctx,OutBuff）;
//printbuf（OutBuff,32）;
//theresultshouldbe0bfa0d07af40713eacec4dddd713a2224d66937c82b93dd09057f246676b01dd
//*************************SHA224ValidityTest1********************************/
//themessagesallconsistof"0x5a",itsbytelengtharefrom1to136
//printf（"\r\n\r\nSHA224ValidityTest1\r\n"）;
for（i=1;i<137;i++）
{
SHA224_Hash（InBuff,i,OutBuff）;
//printbuf（OutBuff,28）;
}
//**************************SHA256ValidityTest1********************************/
//themessagesallconsistof"0x5a"
//printf（"\r\n\r\nSHA256ValidityTest1\r\n"）;
for（i=1;i<137;i++）
{
SHA256_Hash（InBuff,i,OutBuff）;
//printbuf（OutBuff,32）;
}
//****************************SHA224ValidityTest2********************************/
//Themessageconsistsof"0x5a",itsbytelengthis132,justforexample,hereare4casesto//computeitsmessagedigest,
//andtheresultsallshouldbe//026678D14A6289E3C1FD772D05931834D5B74FA1498899141DF7693C
//printf（"\r\n\r\nSHA224ValidityTest2"）;
//case1
SHA224_Hash（InBuff,132,OutBuff）;
//printf（"\r\nSHA224Case1:
"）;
//printbuf（OutBuff,28）;
//case2
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（"\r\nSHA224Case2:
"）;
//printbuf（OutBuff,28）;
//case3
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（"\r\nSHA224Case3:
"）;
//printbuf（OutBuff,28）;
//case4
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（"\r\nSHA224Case4:
"）;
//printbuf（OutBuff,28）;
//**************************/
//****************************SHA256ValidityTest2********************************/
//Themessageconsistsof"0x5a",itsbytelengthis132,justforexample,hereare4casesto//computeitsmessagedigest,
//andtheresultsallshouldbe//e9483323f0c36c8a3eb4c5eb4e8f0820ff021e95ce40d030a579a1ae15331397
//printf（"\r\n\r\nSHA256ValidityTest2"）;
//case1
SHA256_Hash（InBuff,132,OutBuff）;
//printf（"\r\nSHA256Case1:
"）;
//printbuf（OutBuff,32）;
//case2
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）;
//printf（"\r\nSHA256Case2:
"）;
//printbuf（OutBuff,32）;
//case3
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_Done（&ctx,OutBuff）;
//printf（"\r\nSHA256Case3:
"）;
//printbuf（OutBuff,32）;
//case4
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（"\r\nSHA256Case4:
"）;
//printbuf（OutBuff,32）;
//**************************/
while
（1）;
}
SHA224_SHA256.c
#include
#include
#include"SHA224_SHA256.h"
U32codeSHA224_H0[8]={0xc1059ed8,0x367cd507,0x3070dd17,0xf70e5939,0xffc00b31,0x68581511,0x64f98fa7,0xbefa4fa4};
U32codeSHA256_H0[8]={0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19};
U32codeSHA256_K[64]={0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
0xa2bfe8a1
升级会员 