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 <u-boot/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 }