1 /* 2 * sha256.c --- The sh256 algorithm 3 * 4 * Copyright (C) 2004 Sam Hocevar <sam (at) hocevar.net> 5 * (copied from libtomcrypt and then relicensed under GPLv2) 6 * 7 * %Begin-Header% 8 * This file may be redistributed under the terms of the GNU Library 9 * General Public License, version 2. 10 * %End-Header% 11 */ 12 13 14 #include "config.h" 15 #if HAVE_SYS_TYPES_H 16 #include <sys/types.h> 17 #endif 18 #include "ext2fs.h" 19 20 static const __u32 K[64] = { 21 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL, 22 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL, 23 0x243185beUL, 0x550c7dc3UL, 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 24 0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL, 25 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 0x983e5152UL, 26 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL, 27 0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 28 0x53380d13UL, 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL, 29 0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL, 30 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL, 31 0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 32 0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL, 33 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL 34 }; 35 36 /* Various logical functions */ 37 #define Ch(x,y,z) (z ^ (x & (y ^ z))) 38 #define Maj(x,y,z) (((x | y) & z) | (x & y)) 39 #define S(x, n) RORc((x),(n)) 40 #define R(x, n) (((x)&0xFFFFFFFFUL)>>(n)) 41 #define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22)) 42 #define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25)) 43 #define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3)) 44 #define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10)) 45 #define RORc(x, y) ( ((((__u32)(x)&0xFFFFFFFFUL)>>(__u32)((y)&31)) | ((__u32)(x)<<(__u32)(32-((y)&31)))) & 0xFFFFFFFFUL) 46 47 #define RND(a,b,c,d,e,f,g,h,i) \ 48 t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \ 49 t1 = Sigma0(a) + Maj(a, b, c); \ 50 d += t0; \ 51 h = t0 + t1; 52 53 #define STORE64H(x, y) \ 54 do { \ 55 (y)[0] = (unsigned char)(((x)>>56)&255);\ 56 (y)[1] = (unsigned char)(((x)>>48)&255);\ 57 (y)[2] = (unsigned char)(((x)>>40)&255);\ 58 (y)[3] = (unsigned char)(((x)>>32)&255);\ 59 (y)[4] = (unsigned char)(((x)>>24)&255);\ 60 (y)[5] = (unsigned char)(((x)>>16)&255);\ 61 (y)[6] = (unsigned char)(((x)>>8)&255);\ 62 (y)[7] = (unsigned char)((x)&255); } while(0) 63 64 #define STORE32H(x, y) \ 65 do { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \ 66 (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); } while(0) 67 68 #define LOAD32H(x, y) \ 69 do { x = ((__u32)((y)[0] & 255)<<24) | \ 70 ((__u32)((y)[1] & 255)<<16) | \ 71 ((__u32)((y)[2] & 255)<<8) | \ 72 ((__u32)((y)[3] & 255)); } while(0) 73 74 struct sha256_state { 75 __u64 length; 76 __u32 state[8], curlen; 77 unsigned char buf[64]; 78 }; 79 80 /* This is a highly simplified version from libtomcrypt */ 81 struct hash_state { 82 struct sha256_state sha256; 83 }; 84 85 static void sha256_compress(struct hash_state * md, const unsigned char *buf) 86 { 87 __u32 S[8], W[64], t0, t1; 88 __u32 t; 89 int i; 90 91 /* copy state into S */ 92 for (i = 0; i < 8; i++) { 93 S[i] = md->sha256.state[i]; 94 } 95 96 /* copy the state into 512-bits into W[0..15] */ 97 for (i = 0; i < 16; i++) { 98 LOAD32H(W[i], buf + (4*i)); 99 } 100 101 /* fill W[16..63] */ 102 for (i = 16; i < 64; i++) { 103 W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]; 104 } 105 106 /* Compress */ 107 for (i = 0; i < 64; ++i) { 108 RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],i); 109 t = S[7]; S[7] = S[6]; S[6] = S[5]; S[5] = S[4]; 110 S[4] = S[3]; S[3] = S[2]; S[2] = S[1]; S[1] = S[0]; S[0] = t; 111 } 112 113 /* feedback */ 114 for (i = 0; i < 8; i++) { 115 md->sha256.state[i] = md->sha256.state[i] + S[i]; 116 } 117 } 118 119 static void sha256_init(struct hash_state * md) 120 { 121 md->sha256.curlen = 0; 122 md->sha256.length = 0; 123 md->sha256.state[0] = 0x6A09E667UL; 124 md->sha256.state[1] = 0xBB67AE85UL; 125 md->sha256.state[2] = 0x3C6EF372UL; 126 md->sha256.state[3] = 0xA54FF53AUL; 127 md->sha256.state[4] = 0x510E527FUL; 128 md->sha256.state[5] = 0x9B05688CUL; 129 md->sha256.state[6] = 0x1F83D9ABUL; 130 md->sha256.state[7] = 0x5BE0CD19UL; 131 } 132 133 #define MIN(x, y) ( ((x)<(y))?(x):(y) ) 134 #define SHA256_BLOCKSIZE 64 135 static void sha256_process(struct hash_state * md, const unsigned char *in, unsigned long inlen) 136 { 137 unsigned long n; 138 139 while (inlen > 0) { 140 if (md->sha256.curlen == 0 && inlen >= SHA256_BLOCKSIZE) { 141 sha256_compress(md, in); 142 md->sha256.length += SHA256_BLOCKSIZE * 8; 143 in += SHA256_BLOCKSIZE; 144 inlen -= SHA256_BLOCKSIZE; 145 } else { 146 n = MIN(inlen, (SHA256_BLOCKSIZE - md->sha256.curlen)); 147 memcpy(md->sha256.buf + md->sha256.curlen, in, (size_t)n); 148 md->sha256.curlen += n; 149 in += n; 150 inlen -= n; 151 if (md->sha256.curlen == SHA256_BLOCKSIZE) { 152 sha256_compress(md, md->sha256.buf); 153 md->sha256.length += 8*SHA256_BLOCKSIZE; 154 md->sha256.curlen = 0; 155 } 156 } 157 } 158 } 159 160 161 static void sha256_done(struct hash_state * md, unsigned char *out) 162 { 163 int i; 164 165 /* increase the length of the message */ 166 md->sha256.length += md->sha256.curlen * 8; 167 168 /* append the '1' bit */ 169 md->sha256.buf[md->sha256.curlen++] = (unsigned char)0x80; 170 171 /* if the length is currently above 56 bytes we append zeros 172 * then compress. Then we can fall back to padding zeros and length 173 * encoding like normal. 174 */ 175 if (md->sha256.curlen > 56) { 176 while (md->sha256.curlen < 64) { 177 md->sha256.buf[md->sha256.curlen++] = (unsigned char)0; 178 } 179 sha256_compress(md, md->sha256.buf); 180 md->sha256.curlen = 0; 181 } 182 183 /* pad upto 56 bytes of zeroes */ 184 while (md->sha256.curlen < 56) { 185 md->sha256.buf[md->sha256.curlen++] = (unsigned char)0; 186 } 187 188 /* store length */ 189 STORE64H(md->sha256.length, md->sha256.buf+56); 190 sha256_compress(md, md->sha256.buf); 191 192 /* copy output */ 193 for (i = 0; i < 8; i++) { 194 STORE32H(md->sha256.state[i], out+(4*i)); 195 } 196 } 197 198 void ext2fs_sha256(const unsigned char *in, unsigned long in_size, 199 unsigned char out[EXT2FS_SHA256_LENGTH]) 200 { 201 struct hash_state md; 202 203 sha256_init(&md); 204 sha256_process(&md, in, in_size); 205 sha256_done(&md, out); 206 } 207 208 #ifdef UNITTEST 209 static const struct { 210 char *msg; 211 unsigned char hash[32]; 212 } tests[] = { 213 { "", 214 { 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 215 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 216 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 217 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55 } 218 }, 219 { "abc", 220 { 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 221 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, 222 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 223 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad } 224 }, 225 { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 226 { 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 227 0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39, 228 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67, 229 0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1 } 230 }, 231 }; 232 233 int main(int argc, char **argv) 234 { 235 int i; 236 int errors = 0; 237 unsigned char tmp[32]; 238 struct hash_state md; 239 240 for (i = 0; i < (int)(sizeof(tests) / sizeof(tests[0])); i++) { 241 unsigned char *msg = (unsigned char *) tests[i].msg; 242 int len = strlen(tests[i].msg); 243 244 ext2fs_sha256(msg, len, tmp); 245 printf("SHA256 test message %d: ", i); 246 if (memcmp(tmp, tests[i].hash, 32) != 0) { 247 printf("FAILED\n"); 248 errors++; 249 } else 250 printf("OK\n"); 251 } 252 return errors; 253 } 254 255 #endif /* UNITTEST */ 256
