求助，SHA256代码转换-y574924080的回答

求助，SHA256代码转换

2020-01-30 13:46发布

小弟一直只会汇编，C不是很懂，近期有个项目老板要用atmel的A88SA102S加密，atmel官方提供的SHA256算法是AVR的，我想用在51上（STC的89或者12系列都可以），但是一直不成功，网上关于SHA256的介绍很少，在论坛上也找到了win2kddk 大哥的帖子，但是里面是非标的，似乎不合用，下面贴上atmel给的AVR的源代码，求高手帮忙指点，不胜感激！

SHA256.H文件：
#ifndef SHA2_H
#define SHA2_H

#define SHA224_DIGEST_SIZE ( 224 / 8)
#define SHA256_DIGEST_SIZE ( 256 / 8)

#define SHA256_BLOCK_SIZE  ( 512 / 8)
#define SHA224_BLOCK_SIZE  SHA256_BLOCK_SIZE

#ifndef SHA2_TYPES
#define SHA2_TYPES
typedef unsigned char uint8;
typedef unsigned int  uint16;
typedef unsigned long uint32;
#endif

#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
uint32 tot_len;
uint32 len;
uint8 block[2 * SHA256_BLOCK_SIZE];
uint32 h[8];
} sha256_ctx;

void sha256_init(sha256_ctx * ctx);
void sha256_update(sha256_ctx *ctx, const uint8 *message, uint32 len);
void sha256_final(sha256_ctx *ctx, uint8 *digest);

void sha256_noPad(sha256_ctx *ctx, uint8 *digest);

void sha256(const uint8 *message, uint32 len, uint8 *digest);

#ifdef __cplusplus
}
#endif

#endif /* !SHA2_H */

SHA256.C 文件：
#if 0
#define UNROLL_LOOPS /* Enable loops unrolling */
#endif

#include <string.h>

#include "sha256.h"

#define SHFR(x, n) (x >> n)
#define ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))
#define ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n)))
#define CH(x, y, z)  ((x & y) ^ (~x & z))
#define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))

#define SHA256_F1(x) (ROTR(x,  2) ^ ROTR(x, 13) ^ ROTR(x, 22))
#define SHA256_F2(x) (ROTR(x,  6) ^ ROTR(x, 11) ^ ROTR(x, 25))
#define SHA256_F3(x) (ROTR(x,  7) ^ ROTR(x, 18) ^ SHFR(x,  3))
#define SHA256_F4(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10))

#define UNPACK32(x, str)
{
*((str) + 3) = (uint8) ((x)    );
*((str) + 2) = (uint8) ((x) >>  8);
*((str) + 1) = (uint8) ((x) >> 16);
*((str) + 0) = (uint8) ((x) >> 24);
}

#define PACK32(str, x)
{
*(x) = ((uint32) *((str) + 3)    )
         | ((uint32) *((str) + 2) <<  8)
         | ((uint32) *((str) + 1) << 16)
         | ((uint32) *((str) + 0) << 24);
}

/* Macros used for loops unrolling */

#define SHA256_SCR(i)
{
w =  SHA256_F4(w[i -  2]) + w[i -  7]
      + SHA256_F3(w[i - 15]) + w[i - 16];
}

#define SHA256_EXP(a, b, c, d, e, f, g, h, j)
{
t1 = wv[h] + SHA256_F2(wv[e]) + CH(wv[e], wv[f], wv[g])
      + sha256_k[j] + w[j];
t2 = SHA256_F1(wv[a]) + MAJ(wv[a], wv, wv[c]);
wv[d] += t1;
wv[h] = t1 + t2;
}

uint32 sha256_h0[8] =
         {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
         0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};

uint32 sha256_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, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
         0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
         0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
         0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
         0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
         0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};

/* SHA-256 functions */

void sha256_transf(sha256_ctx *ctx, const uint8 *message,
               uint32 block_nb)
{
uint32 w[64];
uint32 wv[8];

uint32 t1, t2;
const uint8 *sub_block;
int i;

#ifndef UNROLL_LOOPS
int j;
#endif

for (i = 0; i < (int) block_nb; i++) {
      sub_block = message + (i << 6);

#ifndef UNROLL_LOOPS
      for (j = 0; j < 16; j++) {
         PACK32(&sub_block[j << 2], &w[j]);
      }

      for (j = 16; j < 64; j++) {
         SHA256_SCR(j);
      }

      for (j = 0; j < 8; j++) {
         wv[j] = ctx->h[j];
      }

      for (j = 0; j < 64; j++) {
         t1 = wv[7] + SHA256_F2(wv[4]) + CH(wv[4], wv[5], wv[6])
            + sha256_k[j] + w[j];
         t2 = SHA256_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]);
         wv[7] = wv[6];
         wv[6] = wv[5];
         wv[5] = wv[4];
         wv[4] = wv[3] + t1;
         wv[3] = wv[2];
         wv[2] = wv[1];
         wv[1] = wv[0];
         wv[0] = t1 + t2;
      }

      for (j = 0; j < 8; j++) {
         ctx->h[j] += wv[j];
      }
#else
      PACK32(&sub_block[ 0], &w[ 0]); PACK32(&sub_block[ 4], &w[ 1]);
      PACK32(&sub_block[ 8], &w[ 2]); PACK32(&sub_block[12], &w[ 3]);
      PACK32(&sub_block[16], &w[ 4]); PACK32(&sub_block[20], &w[ 5]);
      PACK32(&sub_block[24], &w[ 6]); PACK32(&sub_block[28], &w[ 7]);
      PACK32(&sub_block[32], &w[ 8]); PACK32(&sub_block[36], &w[ 9]);
      PACK32(&sub_block[40], &w[10]); PACK32(&sub_block[44], &w[11]);
      PACK32(&sub_block[48], &w[12]); PACK32(&sub_block[52], &w[13]);
      PACK32(&sub_block[56], &w[14]); PACK32(&sub_block[60], &w[15]);

      SHA256_SCR(16); SHA256_SCR(17); SHA256_SCR(18); SHA256_SCR(19);
      SHA256_SCR(20); SHA256_SCR(21); SHA256_SCR(22); SHA256_SCR(23);
      SHA256_SCR(24); SHA256_SCR(25); SHA256_SCR(26); SHA256_SCR(27);
      SHA256_SCR(28); SHA256_SCR(29); SHA256_SCR(30); SHA256_SCR(31);
      SHA256_SCR(32); SHA256_SCR(33); SHA256_SCR(34); SHA256_SCR(35);
      SHA256_SCR(36); SHA256_SCR(37); SHA256_SCR(38); SHA256_SCR(39);
      SHA256_SCR(40); SHA256_SCR(41); SHA256_SCR(42); SHA256_SCR(43);
      SHA256_SCR(44); SHA256_SCR(45); SHA256_SCR(46); SHA256_SCR(47);
      SHA256_SCR(48); SHA256_SCR(49); SHA256_SCR(50); SHA256_SCR(51);
      SHA256_SCR(52); SHA256_SCR(53); SHA256_SCR(54); SHA256_SCR(55);
      SHA256_SCR(56); SHA256_SCR(57); SHA256_SCR(58); SHA256_SCR(59);
      SHA256_SCR(60); SHA256_SCR(61); SHA256_SCR(62); SHA256_SCR(63);

      wv[0] = ctx->h[0]; wv[1] = ctx->h[1];
      wv[2] = ctx->h[2]; wv[3] = ctx->h[3];
      wv[4] = ctx->h[4]; wv[5] = ctx->h[5];
      wv[6] = ctx->h[6]; wv[7] = ctx->h[7];

      SHA256_EXP(0,1,2,3,4,5,6,7, 0); SHA256_EXP(7,0,1,2,3,4,5,6, 1);
      SHA256_EXP(6,7,0,1,2,3,4,5, 2); SHA256_EXP(5,6,7,0,1,2,3,4, 3);
      SHA256_EXP(4,5,6,7,0,1,2,3, 4); SHA256_EXP(3,4,5,6,7,0,1,2, 5);
      SHA256_EXP(2,3,4,5,6,7,0,1, 6); SHA256_EXP(1,2,3,4,5,6,7,0, 7);
      SHA256_EXP(0,1,2,3,4,5,6,7, 8); SHA256_EXP(7,0,1,2,3,4,5,6, 9);
      SHA256_EXP(6,7,0,1,2,3,4,5,10); SHA256_EXP(5,6,7,0,1,2,3,4,11);
      SHA256_EXP(4,5,6,7,0,1,2,3,12); SHA256_EXP(3,4,5,6,7,0,1,2,13);
      SHA256_EXP(2,3,4,5,6,7,0,1,14); SHA256_EXP(1,2,3,4,5,6,7,0,15);
      SHA256_EXP(0,1,2,3,4,5,6,7,16); SHA256_EXP(7,0,1,2,3,4,5,6,17);
      SHA256_EXP(6,7,0,1,2,3,4,5,18); SHA256_EXP(5,6,7,0,1,2,3,4,19);
      SHA256_EXP(4,5,6,7,0,1,2,3,20); SHA256_EXP(3,4,5,6,7,0,1,2,21);
      SHA256_EXP(2,3,4,5,6,7,0,1,22); SHA256_EXP(1,2,3,4,5,6,7,0,23);
      SHA256_EXP(0,1,2,3,4,5,6,7,24); SHA256_EXP(7,0,1,2,3,4,5,6,25);
      SHA256_EXP(6,7,0,1,2,3,4,5,26); SHA256_EXP(5,6,7,0,1,2,3,4,27);
      SHA256_EXP(4,5,6,7,0,1,2,3,28); SHA256_EXP(3,4,5,6,7,0,1,2,29);
      SHA256_EXP(2,3,4,5,6,7,0,1,30); SHA256_EXP(1,2,3,4,5,6,7,0,31);
      SHA256_EXP(0,1,2,3,4,5,6,7,32); SHA256_EXP(7,0,1,2,3,4,5,6,33);
      SHA256_EXP(6,7,0,1,2,3,4,5,34); SHA256_EXP(5,6,7,0,1,2,3,4,35);
      SHA256_EXP(4,5,6,7,0,1,2,3,36); SHA256_EXP(3,4,5,6,7,0,1,2,37);
      SHA256_EXP(2,3,4,5,6,7,0,1,38); SHA256_EXP(1,2,3,4,5,6,7,0,39);
      SHA256_EXP(0,1,2,3,4,5,6,7,40); SHA256_EXP(7,0,1,2,3,4,5,6,41);
      SHA256_EXP(6,7,0,1,2,3,4,5,42); SHA256_EXP(5,6,7,0,1,2,3,4,43);
      SHA256_EXP(4,5,6,7,0,1,2,3,44); SHA256_EXP(3,4,5,6,7,0,1,2,45);
      SHA256_EXP(2,3,4,5,6,7,0,1,46); SHA256_EXP(1,2,3,4,5,6,7,0,47);
      SHA256_EXP(0,1,2,3,4,5,6,7,48); SHA256_EXP(7,0,1,2,3,4,5,6,49);
      SHA256_EXP(6,7,0,1,2,3,4,5,50); SHA256_EXP(5,6,7,0,1,2,3,4,51);
      SHA256_EXP(4,5,6,7,0,1,2,3,52); SHA256_EXP(3,4,5,6,7,0,1,2,53);
      SHA256_EXP(2,3,4,5,6,7,0,1,54); SHA256_EXP(1,2,3,4,5,6,7,0,55);
      SHA256_EXP(0,1,2,3,4,5,6,7,56); SHA256_EXP(7,0,1,2,3,4,5,6,57);
      SHA256_EXP(6,7,0,1,2,3,4,5,58); SHA256_EXP(5,6,7,0,1,2,3,4,59);
      SHA256_EXP(4,5,6,7,0,1,2,3,60); SHA256_EXP(3,4,5,6,7,0,1,2,61);
      SHA256_EXP(2,3,4,5,6,7,0,1,62); SHA256_EXP(1,2,3,4,5,6,7,0,63);

      ctx->h[0] += wv[0]; ctx->h[1] += wv[1];
      ctx->h[2] += wv[2]; ctx->h[3] += wv[3];
      ctx->h[4] += wv[4]; ctx->h[5] += wv[5];
      ctx->h[6] += wv[6]; ctx->h[7] += wv[7];
#endif /* !UNROLL_LOOPS */
}
}

void sha256(const uint8 *message, uint32 len, uint8 *digest)
{
sha256_ctx ctx;

sha256_init(&ctx);
sha256_update(&ctx, message, len);
sha256_final(&ctx, digest);
}

void sha256_init(sha256_ctx *ctx)
{
#ifndef UNROLL_LOOPS
int i;
for (i = 0; i < 8; i++) {
      ctx->h = sha256_h0;
}
#else
ctx->h[0] = sha256_h0[0]; ctx->h[1] = sha256_h0[1];
ctx->h[2] = sha256_h0[2]; ctx->h[3] = sha256_h0[3];
ctx->h[4] = sha256_h0[4]; ctx->h[5] = sha256_h0[5];
ctx->h[6] = sha256_h0[6]; ctx->h[7] = sha256_h0[7];
#endif /* !UNROLL_LOOPS */

ctx->len = 0;
ctx->tot_len = 0;
}

void sha256_update(sha256_ctx *ctx, const uint8 *message,
               uint32 len)
{
uint32 block_nb;
uint32 new_len, rem_len, tmp_len;
const uint8 *shifted_message;

tmp_len = SHA256_BLOCK_SIZE - ctx->len;
rem_len = len < tmp_len ? len : tmp_len;

memcpy(&ctx->block[ctx->len], message, rem_len);

if (ctx->len + len < SHA256_BLOCK_SIZE) {
      ctx->len += len;
      return;
}

new_len = len - rem_len;
block_nb = new_len / SHA256_BLOCK_SIZE;

shifted_message = message + rem_len;

sha256_transf(ctx, ctx->block, 1);
sha256_transf(ctx, shifted_message, block_nb);

rem_len = new_len % SHA256_BLOCK_SIZE;

memcpy(ctx->block, &shifted_message[block_nb << 6],
         rem_len);

ctx->len = rem_len;
ctx->tot_len += (block_nb + 1) << 6;
}

void sha256_final(sha256_ctx *ctx, uint8 *digest)
{
uint32 block_nb;
uint32 pm_len;
uint32 len_b;

#ifndef UNROLL_LOOPS
int i;
#endif

block_nb = (1 + ((SHA256_BLOCK_SIZE - 9)
                  < (ctx->len % SHA256_BLOCK_SIZE)));

len_b = (ctx->tot_len + ctx->len) << 3;
pm_len = block_nb << 6;

memset(ctx->block + ctx->len, 0, pm_len - ctx->len);
ctx->block[ctx->len] = 0x80;
UNPACK32(len_b, ctx->block + pm_len - 4);

sha256_transf(ctx, ctx->block, block_nb);

#ifndef UNROLL_LOOPS
for (i = 0 ; i < 8; i++) {
      UNPACK32(ctx->h, &digest[i << 2]);
}
#else
UNPACK32(ctx->h[0], &digest[ 0]);
UNPACK32(ctx->h[1], &digest[ 4]);
UNPACK32(ctx->h[2], &digest[ 8]);
UNPACK32(ctx->h[3], &digest[12]);
UNPACK32(ctx->h[4], &digest[16]);
UNPACK32(ctx->h[5], &digest[20]);
UNPACK32(ctx->h[6], &digest[24]);
UNPACK32(ctx->h[7], &digest[28]);
#endif /* !UNROLL_LOOPS */
}

void sha256_noPad(sha256_ctx *ctx, uint8 *digest)
{
int i;

for (i = 0 ; i < 8; i++) {
      UNPACK32(ctx->h, &digest[i << 2]);
}
}

跪求指点或发我邮箱279691233@qq.com

友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。

4条回答

y574924080
2020-01-30 20:16

未调用的子程序看这里

http://www.amobbs.com/thread-5090488-1-1.html

加载中...

查看其它4个回答

一周热门更多>

相关问题

【东软载波ESF0654 PDS开发板活动】开箱
1 个回答

东软载波ESF0654 PDS开发板外部中断
1 个回答

东软载波ESF0654 PDS开发板高级控制定时器AD16C4T
1 个回答

用串口调试助手为什么只能在hex模式接收发送而在文本模式不行
9 个回答

触摸芯片SC02B/SC04B在地砖灯的设计方案
1 个回答

相关文章

51单片机与蓝牙模块连接
0个评论

51单片机的硬件结构
0个评论

基于51单片机的无线遥控器制作
0个评论

51单片机 AD转换
0个评论

51单片机数码管递增显示
0个评论

如何实现对单片机寄存器的访问
0个评论

基于51单片机的指纹密码锁
0个评论

采纳回答

向帮助了您的知道网友说句感谢的话吧!

非常感谢!

编辑标签

最多设置5个标签!

51单片机

举报内容

检举类型

检举内容

检举用户

检举原因

广告推广

恶意灌水

回答内容与提问无关

抄袭答案

其他

检举说明(必填)

打开微信“扫一扫”，打开网页后点击屏幕右上角分享按钮

付费偷看金额在0.1-10元之间

您已邀请0人回答查看邀请

擅长该话题的人

回答过该话题的人

我关注的人

Copyright © 2024 平头弟京ICP备15032243号-1 投诉举报邮箱：nettui@qq.com

求助，SHA256代码转换

打开微信“扫一扫”，打开网页后点击屏幕右上角分享按钮

一周热门 更多>

相关问题

相关文章

采纳回答

编辑标签

举报内容

检举类型

检举原因

检举说明(必填)

打开微信“扫一扫”，打开网页后点击屏幕右上角分享按钮

付费偷看金额在0.1-10元之间

一周热门更多>