1、单向散列算法

单向散列算法，又称hash函数，Hash哈希函数（也称杂凑算法）就是把任意长的输入消息串变化成固定长的输出串的一种函数，该过程是不可逆的。Hash函数可用于数字签名、消息的完整性检测、消息起源的认证检测等。较为常用的方法包括MD算法和SHA算法。

1.1 MD（Message Digest）消息摘要算法

MD系列算法分为MD2、MD4、MD5三种算法，最常用的是MD5版本算法，用来把不同长度的数据块进行暗码运算成一个128位的散列值（hash value），用于确保信息传输完整一致。

应用场景：嵌入式系统开发中，MD5一般用于校验文件的完整性，如通过网络下载的文件，可能缺少部分或者被篡改，通过计算实际接收文件的MD5码，与原始MD5比较，判断文件是否正确。在密码存储方面，将用户输入的明文密码转成MD5码保存，后期应用只匹配比较MD5码，这样即使后台管理员也无法查看到真实密码。
具体算法可以参考 嵌入式算法9—MD5的应用与实现

1.2 SHA（Secure Hash Algorithm）安全散列算法

SHA是一个密码散列函数家族，SHA算法主要分为SHA-1、SHA-2、SHA-3 三大类，一般使用SHA-2算法，主要有SHA-256、SHA-512、SHA-224、SHA-384四种，对于嵌入式一般选择SHA256，将任意长度的输入压缩成256位，且哈希碰撞的概率近乎为0。

应用场景：数字签名、数字时间戳、数字证书。

1.3 MAC（Message Authentication Code）消息认证码

对称加密算法是为了保证数据的机密性，hash算法是为了验证数据的完整性，而MAC算法既可以验证数据的完整性，又可以验证数据是否被篡改。似乎嵌入式开发种少见。

2、SHA256

一般嵌入式系统签名或者校验复杂版使用SHA256，也就是长度小于2^64字节的任意数据，经过哈希运算得到256比特的消息摘要。

2.1 源码

SHA256源码如下：

#include "stdlib.h"

//sha256.h
#define SHA256_BLOCK_SIZE 32 //SHA 256bits = 32Bytes

typedef unsigned char uint8_t; 
typedef unsigned int  uint32_t;

typedef struct
{
    uint8_t data[64];
    uint32_t datalen;
    unsigned long long bitlen;
    uint32_t state[8];
} sha256_ctx_t;

//api
extern void sha256_init(sha256_ctx_t *ctx);
extern void sha256_update(sha256_ctx_t *ctx, const uint8_t data[], uint32_t len);
extern void sha256_final(sha256_ctx_t *ctx, uint8_t hash[]);

//sha256.c
/****************************** MACROS ******************************/
#define ROTLEFT(a,b) (((a) << (b)) | ((a) >> (32-(b))))
#define ROTRIGHT(a,b) (((a) >> (b)) | ((a) << (32-(b))))

#define CH(x,y,z) (((x) & (y)) ^ (~(x) & (z)))
#define MAJ(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#define EP0(x) (ROTRIGHT(x,2) ^ ROTRIGHT(x,13) ^ ROTRIGHT(x,22))
#define EP1(x) (ROTRIGHT(x,6) ^ ROTRIGHT(x,11) ^ ROTRIGHT(x,25))
#define SIG0(x) (ROTRIGHT(x,7) ^ ROTRIGHT(x,18) ^ ((x) >> 3))
#define SIG1(x) (ROTRIGHT(x,17) ^ ROTRIGHT(x,19) ^ ((x) >> 10))

/**************************** VARIABLES *****************************/
static const uint32_t 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
};


static void sha256_transform(sha256_ctx_t *ctx, const uint8_t data[])
{
    uint32_t a, b, c, d, e, f, g, h, i, j, t1, t2, m[64];

    for(i = 0, j = 0; i < 16; ++i, j += 4)
    {
        m[i] = (data[j] << 24) | (data[j + 1] << 16) | (data[j + 2] << 8) | (data[j + 3]);
    }
    for(; i < 64; ++i)
    {
        m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
    }

    a = ctx->state[0];
    b = ctx->state[1];
    c = ctx->state[2];
    d = ctx->state[3];
    e = ctx->state[4];
    f = ctx->state[5];
    g = ctx->state[6];
    h = ctx->state[7];

    for(i = 0; i < 64; ++i)
    {
        t1 = h + EP1(e) + CH(e, f, g) + k[i] + m[i];
        t2 = EP0(a) + MAJ(a, b, c);
        h = g;
        g = f;
        f = e;
        e = d + t1;
        d = c;
        c = b;
        b = a;
        a = t1 + t2;
    }

    ctx->state[0] += a;
    ctx->state[1] += b;
    ctx->state[2] += c;
    ctx->state[3] += d;
    ctx->state[4] += e;
    ctx->state[5] += f;
    ctx->state[6] += g;
    ctx->state[7] += h;
}

void sha256_init(sha256_ctx_t *ctx)
{
    ctx->datalen = 0;
    ctx->bitlen = 0;
    ctx->state[0] = 0x6a09e667;
    ctx->state[1] = 0xbb67ae85;
    ctx->state[2] = 0x3c6ef372;
    ctx->state[3] = 0xa54ff53a;
    ctx->state[4] = 0x510e527f;
    ctx->state[5] = 0x9b05688c;
    ctx->state[6] = 0x1f83d9ab;
    ctx->state[7] = 0x5be0cd19;
}

void sha256_update(sha256_ctx_t *ctx, const uint8_t data[], uint32_t len)
{
    uint32_t i;

    for(i = 0; i < len; ++i)
    {
        ctx->data[ctx->datalen] = data[i];
        ctx->datalen++;
        if(ctx->datalen == 64)
        {
            sha256_transform(ctx, ctx->data);
            ctx->bitlen += 512;
            ctx->datalen = 0;
        }
    }
}

void sha256_final(sha256_ctx_t *ctx, uint8_t hash[])
{
    uint32_t i;

    i = ctx->datalen;

    // Pad whatever data is left in the buffer.
    if(ctx->datalen < 56)
    {
        ctx->data[i++] = 0x80;
        while(i < 56)
        {
            ctx->data[i++] = 0x00;
        }
    }
    else
    {
        ctx->data[i++] = 0x80;
        while(i < 64)
        {
            ctx->data[i++] = 0x00;
        }
        sha256_transform(ctx, ctx->data);
        memset(ctx->data, 0, 56);
    }

    // Append to the padding the total message's length in bits and transform.
    ctx->bitlen += ctx->datalen * 8;
    ctx->data[63] = ctx->bitlen;
    ctx->data[62] = ctx->bitlen >> 8;
    ctx->data[61] = ctx->bitlen >> 16;
    ctx->data[60] = ctx->bitlen >> 24;
    ctx->data[59] = ctx->bitlen >> 32;
    ctx->data[58] = ctx->bitlen >> 40;
    ctx->data[57] = ctx->bitlen >> 48;
    ctx->data[56] = ctx->bitlen >> 56;
    sha256_transform(ctx, ctx->data);

    // Since this implementation uses little endian byte ordering and SHA uses big endian,
    // reverse all the bytes when copying the final state to the output hash.
    for(i = 0; i < 4; ++i)
    {
        hash[i]      = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff;
        hash[i + 4]  = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff;
        hash[i + 8]  = (ctx->state[2] >> (24 - i * 8)) & 0x000000ff;
        hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0x000000ff;
        hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0x000000ff;
        hash[i + 20] = (ctx->state[5] >> (24 - i * 8)) & 0x000000ff;
        hash[i + 24] = (ctx->state[6] >> (24 - i * 8)) & 0x000000ff;
        hash[i + 28] = (ctx->state[7] >> (24 - i * 8)) & 0x000000ff;
    }
}
/***********************************************************************/
//test
void log(char *head, uint8_t *data, uint8_t len)
{
    uint8_t i;
    printf("%s:", head);
    for(i = 0; i < len; i++)
    {
        printf("%02X ", data[i]);
    }
    printf("\r\n");
}

int main(int argc, char *argv[])
{
    uint8_t buff1[] = {"embedded-system"};
    uint8_t buff2[] = {0x00, 0x65, 0x00, 0x6D, 0x00, 0x62, 0x00, 0x65, 0x00, 0x64, 0x00, 0x64, 0x00, 0x65, \
                       0x00, 0x64, 0x00, 0x2D, 0x00, 0x73, 0x00, 0x79, 0x00, 0x73, 0x00, 0x74, 0x00, 0x65, 0x00, 0x6D
                      };
    uint8_t sha256_result[32] = {0};

    sha256_ctx_t sha;
    sha256_init(&sha);
    sha256_update(&sha, buff1, strlen(buff1));
    sha256_final(&sha, sha256_result);
    log("buff1   sha256", sha256_result, 32);

    sha256_init(&sha);
    sha256_update(&sha, buff2, sizeof(buff2));
    sha256_final(&sha, sha256_result);
    log("buff2   sha256", sha256_result, 32);

    sha256_init(&sha);
    sha256_update(&sha, buff1, strlen(buff1));
    sha256_update(&sha, buff1, strlen(buff1));
    sha256_update(&sha, buff1, strlen(buff1));
    sha256_final(&sha, sha256_result);
    log("buff1*3 sha256", sha256_result, 32);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

2.2 应用

对嵌入式系统，在RAM空间有限的情况下，对较长的数据进行运算，SHA256是可以分段多次传入数据的。如上使用范例第3段所示。一般用于校验密钥或者文件是否传输错误或者被篡改。

3、 SHA256与MD5比较

一般嵌入式系统使用的单向散列函数是MD5和SHA256。两者都是实现对任意长度输入，经运算输出固定长度的摘要数据。

无限多可能的输入数据转换成了数量有限的输出值，理论上是会出现两个不同的输入值运算结果相同，这种情况称为碰撞，即不同的消息产生同一个散列值的情况。

MD5是输出128比特的散列值，而SHA256是256比特；可见SHA256的安全性略高，但其运算耗时也多。

具体应用选择哪种并没太严格的标准。