← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/lib/sha256.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/lib/sha256.c
 
1
/*
 
2
 * FIPS-180-2 compliant SHA-256 implementation
 
3
 *
 
4
 * Copyright (C) 2001-2003  Christophe Devine
 
5
 *
 
6
 * SPDX-License-Identifier:     GPL-2.0+
 
7
 */
 
8
 
 
9
#ifndef USE_HOSTCC
 
10
#include <common.h>
 
11
#include <linux/string.h>
 
12
#else
 
13
#include <string.h>
 
14
#endif /* USE_HOSTCC */
 
15
#include <watchdog.h>
 
16
#include <sha256.h>
 
17
 
 
18
/*
 
19
 * 32-bit integer manipulation macros (big endian)
 
20
 */
 
21
#ifndef GET_UINT32_BE
 
22
#define GET_UINT32_BE(n,b,i) {                          \
 
23
        (n) = ( (unsigned long) (b)[(i)    ] << 24 )    \
 
24
            | ( (unsigned long) (b)[(i) + 1] << 16 )    \
 
25
            | ( (unsigned long) (b)[(i) + 2] <<  8 )    \
 
26
            | ( (unsigned long) (b)[(i) + 3]       );   \
 
27
}
 
28
#endif
 
29
#ifndef PUT_UINT32_BE
 
30
#define PUT_UINT32_BE(n,b,i) {                          \
 
31
        (b)[(i)    ] = (unsigned char) ( (n) >> 24 );   \
 
32
        (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );   \
 
33
        (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );   \
 
34
        (b)[(i) + 3] = (unsigned char) ( (n)       );   \
 
35
}
 
36
#endif
 
37
 
 
38
void sha256_starts(sha256_context * ctx)
 
39
{
 
40
        ctx->total[0] = 0;
 
41
        ctx->total[1] = 0;
 
42
 
 
43
        ctx->state[0] = 0x6A09E667;
 
44
        ctx->state[1] = 0xBB67AE85;
 
45
        ctx->state[2] = 0x3C6EF372;
 
46
        ctx->state[3] = 0xA54FF53A;
 
47
        ctx->state[4] = 0x510E527F;
 
48
        ctx->state[5] = 0x9B05688C;
 
49
        ctx->state[6] = 0x1F83D9AB;
 
50
        ctx->state[7] = 0x5BE0CD19;
 
51
}
 
52
 
 
53
static void sha256_process(sha256_context *ctx, const uint8_t data[64])
 
54
{
 
55
        uint32_t temp1, temp2;
 
56
        uint32_t W[64];
 
57
        uint32_t A, B, C, D, E, F, G, H;
 
58
 
 
59
        GET_UINT32_BE(W[0], data, 0);
 
60
        GET_UINT32_BE(W[1], data, 4);
 
61
        GET_UINT32_BE(W[2], data, 8);
 
62
        GET_UINT32_BE(W[3], data, 12);
 
63
        GET_UINT32_BE(W[4], data, 16);
 
64
        GET_UINT32_BE(W[5], data, 20);
 
65
        GET_UINT32_BE(W[6], data, 24);
 
66
        GET_UINT32_BE(W[7], data, 28);
 
67
        GET_UINT32_BE(W[8], data, 32);
 
68
        GET_UINT32_BE(W[9], data, 36);
 
69
        GET_UINT32_BE(W[10], data, 40);
 
70
        GET_UINT32_BE(W[11], data, 44);
 
71
        GET_UINT32_BE(W[12], data, 48);
 
72
        GET_UINT32_BE(W[13], data, 52);
 
73
        GET_UINT32_BE(W[14], data, 56);
 
74
        GET_UINT32_BE(W[15], data, 60);
 
75
 
 
76
#define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
 
77
#define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))
 
78
 
 
79
#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^ SHR(x, 3))
 
80
#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^ SHR(x,10))
 
81
 
 
82
#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
 
83
#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))
 
84
 
 
85
#define F0(x,y,z) ((x & y) | (z & (x | y)))
 
86
#define F1(x,y,z) (z ^ (x & (y ^ z)))
 
87
 
 
88
#define R(t)                                    \
 
89
(                                               \
 
90
        W[t] = S1(W[t - 2]) + W[t - 7] +        \
 
91
                S0(W[t - 15]) + W[t - 16]       \
 
92
)
 
93
 
 
94
#define P(a,b,c,d,e,f,g,h,x,K) {                \
 
95
        temp1 = h + S3(e) + F1(e,f,g) + K + x;  \
 
96
        temp2 = S2(a) + F0(a,b,c);              \
 
97
        d += temp1; h = temp1 + temp2;          \
 
98
}
 
99
 
 
100
        A = ctx->state[0];
 
101
        B = ctx->state[1];
 
102
        C = ctx->state[2];
 
103
        D = ctx->state[3];
 
104
        E = ctx->state[4];
 
105
        F = ctx->state[5];
 
106
        G = ctx->state[6];
 
107
        H = ctx->state[7];
 
108
 
 
109
        P(A, B, C, D, E, F, G, H, W[0], 0x428A2F98);
 
110
        P(H, A, B, C, D, E, F, G, W[1], 0x71374491);
 
111
        P(G, H, A, B, C, D, E, F, W[2], 0xB5C0FBCF);
 
112
        P(F, G, H, A, B, C, D, E, W[3], 0xE9B5DBA5);
 
113
        P(E, F, G, H, A, B, C, D, W[4], 0x3956C25B);
 
114
        P(D, E, F, G, H, A, B, C, W[5], 0x59F111F1);
 
115
        P(C, D, E, F, G, H, A, B, W[6], 0x923F82A4);
 
116
        P(B, C, D, E, F, G, H, A, W[7], 0xAB1C5ED5);
 
117
        P(A, B, C, D, E, F, G, H, W[8], 0xD807AA98);
 
118
        P(H, A, B, C, D, E, F, G, W[9], 0x12835B01);
 
119
        P(G, H, A, B, C, D, E, F, W[10], 0x243185BE);
 
120
        P(F, G, H, A, B, C, D, E, W[11], 0x550C7DC3);
 
121
        P(E, F, G, H, A, B, C, D, W[12], 0x72BE5D74);
 
122
        P(D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE);
 
123
        P(C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7);
 
124
        P(B, C, D, E, F, G, H, A, W[15], 0xC19BF174);
 
125
        P(A, B, C, D, E, F, G, H, R(16), 0xE49B69C1);
 
126
        P(H, A, B, C, D, E, F, G, R(17), 0xEFBE4786);
 
127
        P(G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6);
 
128
        P(F, G, H, A, B, C, D, E, R(19), 0x240CA1CC);
 
129
        P(E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F);
 
130
        P(D, E, F, G, H, A, B, C, R(21), 0x4A7484AA);
 
131
        P(C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC);
 
132
        P(B, C, D, E, F, G, H, A, R(23), 0x76F988DA);
 
133
        P(A, B, C, D, E, F, G, H, R(24), 0x983E5152);
 
134
        P(H, A, B, C, D, E, F, G, R(25), 0xA831C66D);
 
135
        P(G, H, A, B, C, D, E, F, R(26), 0xB00327C8);
 
136
        P(F, G, H, A, B, C, D, E, R(27), 0xBF597FC7);
 
137
        P(E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3);
 
138
        P(D, E, F, G, H, A, B, C, R(29), 0xD5A79147);
 
139
        P(C, D, E, F, G, H, A, B, R(30), 0x06CA6351);
 
140
        P(B, C, D, E, F, G, H, A, R(31), 0x14292967);
 
141
        P(A, B, C, D, E, F, G, H, R(32), 0x27B70A85);
 
142
        P(H, A, B, C, D, E, F, G, R(33), 0x2E1B2138);
 
143
        P(G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC);
 
144
        P(F, G, H, A, B, C, D, E, R(35), 0x53380D13);
 
145
        P(E, F, G, H, A, B, C, D, R(36), 0x650A7354);
 
146
        P(D, E, F, G, H, A, B, C, R(37), 0x766A0ABB);
 
147
        P(C, D, E, F, G, H, A, B, R(38), 0x81C2C92E);
 
148
        P(B, C, D, E, F, G, H, A, R(39), 0x92722C85);
 
149
        P(A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1);
 
150
        P(H, A, B, C, D, E, F, G, R(41), 0xA81A664B);
 
151
        P(G, H, A, B, C, D, E, F, R(42), 0xC24B8B70);
 
152
        P(F, G, H, A, B, C, D, E, R(43), 0xC76C51A3);
 
153
        P(E, F, G, H, A, B, C, D, R(44), 0xD192E819);
 
154
        P(D, E, F, G, H, A, B, C, R(45), 0xD6990624);
 
155
        P(C, D, E, F, G, H, A, B, R(46), 0xF40E3585);
 
156
        P(B, C, D, E, F, G, H, A, R(47), 0x106AA070);
 
157
        P(A, B, C, D, E, F, G, H, R(48), 0x19A4C116);
 
158
        P(H, A, B, C, D, E, F, G, R(49), 0x1E376C08);
 
159
        P(G, H, A, B, C, D, E, F, R(50), 0x2748774C);
 
160
        P(F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5);
 
161
        P(E, F, G, H, A, B, C, D, R(52), 0x391C0CB3);
 
162
        P(D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A);
 
163
        P(C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F);
 
164
        P(B, C, D, E, F, G, H, A, R(55), 0x682E6FF3);
 
165
        P(A, B, C, D, E, F, G, H, R(56), 0x748F82EE);
 
166
        P(H, A, B, C, D, E, F, G, R(57), 0x78A5636F);
 
167
        P(G, H, A, B, C, D, E, F, R(58), 0x84C87814);
 
168
        P(F, G, H, A, B, C, D, E, R(59), 0x8CC70208);
 
169
        P(E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA);
 
170
        P(D, E, F, G, H, A, B, C, R(61), 0xA4506CEB);
 
171
        P(C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7);
 
172
        P(B, C, D, E, F, G, H, A, R(63), 0xC67178F2);
 
173
 
 
174
        ctx->state[0] += A;
 
175
        ctx->state[1] += B;
 
176
        ctx->state[2] += C;
 
177
        ctx->state[3] += D;
 
178
        ctx->state[4] += E;
 
179
        ctx->state[5] += F;
 
180
        ctx->state[6] += G;
 
181
        ctx->state[7] += H;
 
182
}
 
183
 
 
184
void sha256_update(sha256_context *ctx, const uint8_t *input, uint32_t length)
 
185
{
 
186
        uint32_t left, fill;
 
187
 
 
188
        if (!length)
 
189
                return;
 
190
 
 
191
        left = ctx->total[0] & 0x3F;
 
192
        fill = 64 - left;
 
193
 
 
194
        ctx->total[0] += length;
 
195
        ctx->total[0] &= 0xFFFFFFFF;
 
196
 
 
197
        if (ctx->total[0] < length)
 
198
                ctx->total[1]++;
 
199
 
 
200
        if (left && length >= fill) {
 
201
                memcpy((void *) (ctx->buffer + left), (void *) input, fill);
 
202
                sha256_process(ctx, ctx->buffer);
 
203
                length -= fill;
 
204
                input += fill;
 
205
                left = 0;
 
206
        }
 
207
 
 
208
        while (length >= 64) {
 
209
                sha256_process(ctx, input);
 
210
                length -= 64;
 
211
                input += 64;
 
212
        }
 
213
 
 
214
        if (length)
 
215
                memcpy((void *) (ctx->buffer + left), (void *) input, length);
 
216
}
 
217
 
 
218
static uint8_t sha256_padding[64] = {
 
219
        0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
220
           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
221
           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
222
           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 
223
};
 
224
 
 
225
void sha256_finish(sha256_context * ctx, uint8_t digest[32])
 
226
{
 
227
        uint32_t last, padn;
 
228
        uint32_t high, low;
 
229
        uint8_t msglen[8];
 
230
 
 
231
        high = ((ctx->total[0] >> 29)
 
232
                | (ctx->total[1] << 3));
 
233
        low = (ctx->total[0] << 3);
 
234
 
 
235
        PUT_UINT32_BE(high, msglen, 0);
 
236
        PUT_UINT32_BE(low, msglen, 4);
 
237
 
 
238
        last = ctx->total[0] & 0x3F;
 
239
        padn = (last < 56) ? (56 - last) : (120 - last);
 
240
 
 
241
        sha256_update(ctx, sha256_padding, padn);
 
242
        sha256_update(ctx, msglen, 8);
 
243
 
 
244
        PUT_UINT32_BE(ctx->state[0], digest, 0);
 
245
        PUT_UINT32_BE(ctx->state[1], digest, 4);
 
246
        PUT_UINT32_BE(ctx->state[2], digest, 8);
 
247
        PUT_UINT32_BE(ctx->state[3], digest, 12);
 
248
        PUT_UINT32_BE(ctx->state[4], digest, 16);
 
249
        PUT_UINT32_BE(ctx->state[5], digest, 20);
 
250
        PUT_UINT32_BE(ctx->state[6], digest, 24);
 
251
        PUT_UINT32_BE(ctx->state[7], digest, 28);
 
252
}
 
253
 
 
254
/*
 
255
 * Output = SHA-256( input buffer ). Trigger the watchdog every 'chunk_sz'
 
256
 * bytes of input processed.
 
257
 */
 
258
void sha256_csum_wd(const unsigned char *input, unsigned int ilen,
 
259
                unsigned char *output, unsigned int chunk_sz)
 
260
{
 
261
        sha256_context ctx;
 
262
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
 
263
        const unsigned char *end;
 
264
        unsigned char *curr;
 
265
        int chunk;
 
266
#endif
 
267
 
 
268
        sha256_starts(&ctx);
 
269
 
 
270
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
 
271
        curr = (unsigned char *)input;
 
272
        end = input + ilen;
 
273
        while (curr < end) {
 
274
                chunk = end - curr;
 
275
                if (chunk > chunk_sz)
 
276
                        chunk = chunk_sz;
 
277
                sha256_update(&ctx, curr, chunk);
 
278
                curr += chunk;
 
279
                WATCHDOG_RESET();
 
280
        }
 
281
#else
 
282
        sha256_update(&ctx, input, ilen);
 
283
#endif
 
284
 
 
285
        sha256_finish(&ctx, output);
 
286
}