ramips: add switch port index for I-O DATA WN-GX300GR
[openwrt/openwrt.git] / scripts / mkhash.c
1 /*
2 * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 *
16 * -- MD5 code:
17 *
18 * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
19 * MD5 Message-Digest Algorithm (RFC 1321).
20 *
21 * Homepage:
22 * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
23 *
24 * Author:
25 * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
26 *
27 * This software was written by Alexander Peslyak in 2001. No copyright is
28 * claimed, and the software is hereby placed in the public domain.
29 * In case this attempt to disclaim copyright and place the software in the
30 * public domain is deemed null and void, then the software is
31 * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
32 * general public under the following terms:
33 *
34 * Redistribution and use in source and binary forms, with or without
35 * modification, are permitted.
36 *
37 * There's ABSOLUTELY NO WARRANTY, express or implied.
38 *
39 * (This is a heavily cut-down "BSD license".)
40 *
41 * This differs from Colin Plumb's older public domain implementation in that
42 * no exactly 32-bit integer data type is required (any 32-bit or wider
43 * unsigned integer data type will do), there's no compile-time endianness
44 * configuration, and the function prototypes match OpenSSL's. No code from
45 * Colin Plumb's implementation has been reused; this comment merely compares
46 * the properties of the two independent implementations.
47 *
48 * The primary goals of this implementation are portability and ease of use.
49 * It is meant to be fast, but not as fast as possible. Some known
50 * optimizations are not included to reduce source code size and avoid
51 * compile-time configuration.
52 *
53 * -- SHA256 Code:
54 *
55 * Copyright 2005 Colin Percival
56 * All rights reserved.
57 *
58 * Redistribution and use in source and binary forms, with or without
59 * modification, are permitted provided that the following conditions
60 * are met:
61 * 1. Redistributions of source code must retain the above copyright
62 * notice, this list of conditions and the following disclaimer.
63 * 2. Redistributions in binary form must reproduce the above copyright
64 * notice, this list of conditions and the following disclaimer in the
65 * documentation and/or other materials provided with the distribution.
66 *
67 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
68 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
69 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
70 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
71 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
72 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
73 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
74 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
75 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
76 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
77 * SUCH DAMAGE.
78 */
79
80
81
82 #include <endian.h>
83 #include <stdio.h>
84 #include <string.h>
85 #include <stdint.h>
86 #include <stdbool.h>
87 #include <unistd.h>
88
89 #define ARRAY_SIZE(_n) (sizeof(_n) / sizeof((_n)[0]))
90
91 static void
92 be32enc(void *buf, uint32_t u)
93 {
94 uint8_t *p = buf;
95
96 p[0] = ((uint8_t) ((u >> 24) & 0xff));
97 p[1] = ((uint8_t) ((u >> 16) & 0xff));
98 p[2] = ((uint8_t) ((u >> 8) & 0xff));
99 p[3] = ((uint8_t) (u & 0xff));
100 }
101
102 static void
103 be64enc(void *buf, uint64_t u)
104 {
105 uint8_t *p = buf;
106
107 be32enc(p, ((uint32_t) (u >> 32)));
108 be32enc(p + 4, ((uint32_t) (u & 0xffffffffULL)));
109 }
110
111
112 static uint16_t
113 be16dec(const void *buf)
114 {
115 const uint8_t *p = buf;
116
117 return (((uint16_t) p[0]) << 8) | p[1];
118 }
119
120 static uint32_t
121 be32dec(const void *buf)
122 {
123 const uint8_t *p = buf;
124
125 return (((uint32_t) be16dec(p)) << 16) | be16dec(p + 2);
126 }
127
128 #define MD5_DIGEST_LENGTH 16
129
130 typedef struct MD5_CTX {
131 uint32_t lo, hi;
132 uint32_t a, b, c, d;
133 unsigned char buffer[64];
134 } MD5_CTX;
135
136 /*
137 * The basic MD5 functions.
138 *
139 * F and G are optimized compared to their RFC 1321 definitions for
140 * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
141 * implementation.
142 */
143 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
144 #define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
145 #define H(x, y, z) (((x) ^ (y)) ^ (z))
146 #define H2(x, y, z) ((x) ^ ((y) ^ (z)))
147 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
148
149 /*
150 * The MD5 transformation for all four rounds.
151 */
152 #define STEP(f, a, b, c, d, x, t, s) \
153 (a) += f((b), (c), (d)) + (x) + (t); \
154 (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
155 (a) += (b);
156
157 /*
158 * SET reads 4 input bytes in little-endian byte order and stores them
159 * in a properly aligned word in host byte order.
160 */
161 #if __BYTE_ORDER == __LITTLE_ENDIAN
162 #define SET(n) \
163 (*(uint32_t *)&ptr[(n) * 4])
164 #define GET(n) \
165 SET(n)
166 #else
167 #define SET(n) \
168 (block[(n)] = \
169 (uint32_t)ptr[(n) * 4] | \
170 ((uint32_t)ptr[(n) * 4 + 1] << 8) | \
171 ((uint32_t)ptr[(n) * 4 + 2] << 16) | \
172 ((uint32_t)ptr[(n) * 4 + 3] << 24))
173 #define GET(n) \
174 (block[(n)])
175 #endif
176
177 /*
178 * This processes one or more 64-byte data blocks, but does NOT update
179 * the bit counters. There are no alignment requirements.
180 */
181 static const void *MD5_body(MD5_CTX *ctx, const void *data, unsigned long size)
182 {
183 const unsigned char *ptr;
184 uint32_t a, b, c, d;
185 uint32_t saved_a, saved_b, saved_c, saved_d;
186 #if __BYTE_ORDER != __LITTLE_ENDIAN
187 uint32_t block[16];
188 #endif
189
190 ptr = (const unsigned char *)data;
191
192 a = ctx->a;
193 b = ctx->b;
194 c = ctx->c;
195 d = ctx->d;
196
197 do {
198 saved_a = a;
199 saved_b = b;
200 saved_c = c;
201 saved_d = d;
202
203 /* Round 1 */
204 STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
205 STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
206 STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
207 STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
208 STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
209 STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
210 STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
211 STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
212 STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
213 STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
214 STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
215 STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
216 STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
217 STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
218 STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
219 STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
220
221 /* Round 2 */
222 STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
223 STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
224 STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
225 STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
226 STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
227 STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
228 STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
229 STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
230 STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
231 STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
232 STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
233 STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
234 STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
235 STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
236 STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
237 STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
238
239 /* Round 3 */
240 STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
241 STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
242 STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
243 STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
244 STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
245 STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
246 STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
247 STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
248 STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
249 STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
250 STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
251 STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
252 STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
253 STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
254 STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
255 STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
256
257 /* Round 4 */
258 STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
259 STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
260 STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
261 STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
262 STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
263 STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
264 STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
265 STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
266 STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
267 STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
268 STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
269 STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
270 STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
271 STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
272 STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
273 STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
274
275 a += saved_a;
276 b += saved_b;
277 c += saved_c;
278 d += saved_d;
279
280 ptr += 64;
281 } while (size -= 64);
282
283 ctx->a = a;
284 ctx->b = b;
285 ctx->c = c;
286 ctx->d = d;
287
288 return ptr;
289 }
290
291 void MD5_begin(MD5_CTX *ctx)
292 {
293 ctx->a = 0x67452301;
294 ctx->b = 0xefcdab89;
295 ctx->c = 0x98badcfe;
296 ctx->d = 0x10325476;
297
298 ctx->lo = 0;
299 ctx->hi = 0;
300 }
301
302 static void
303 MD5_hash(const void *data, size_t size, MD5_CTX *ctx)
304 {
305 uint32_t saved_lo;
306 unsigned long used, available;
307
308 saved_lo = ctx->lo;
309 if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
310 ctx->hi++;
311 ctx->hi += size >> 29;
312
313 used = saved_lo & 0x3f;
314
315 if (used) {
316 available = 64 - used;
317
318 if (size < available) {
319 memcpy(&ctx->buffer[used], data, size);
320 return;
321 }
322
323 memcpy(&ctx->buffer[used], data, available);
324 data = (const unsigned char *)data + available;
325 size -= available;
326 MD5_body(ctx, ctx->buffer, 64);
327 }
328
329 if (size >= 64) {
330 data = MD5_body(ctx, data, size & ~((size_t) 0x3f));
331 size &= 0x3f;
332 }
333
334 memcpy(ctx->buffer, data, size);
335 }
336
337 static void
338 MD5_end(void *resbuf, MD5_CTX *ctx)
339 {
340 unsigned char *result = resbuf;
341 unsigned long used, available;
342
343 used = ctx->lo & 0x3f;
344
345 ctx->buffer[used++] = 0x80;
346
347 available = 64 - used;
348
349 if (available < 8) {
350 memset(&ctx->buffer[used], 0, available);
351 MD5_body(ctx, ctx->buffer, 64);
352 used = 0;
353 available = 64;
354 }
355
356 memset(&ctx->buffer[used], 0, available - 8);
357
358 ctx->lo <<= 3;
359 ctx->buffer[56] = ctx->lo;
360 ctx->buffer[57] = ctx->lo >> 8;
361 ctx->buffer[58] = ctx->lo >> 16;
362 ctx->buffer[59] = ctx->lo >> 24;
363 ctx->buffer[60] = ctx->hi;
364 ctx->buffer[61] = ctx->hi >> 8;
365 ctx->buffer[62] = ctx->hi >> 16;
366 ctx->buffer[63] = ctx->hi >> 24;
367
368 MD5_body(ctx, ctx->buffer, 64);
369
370 result[0] = ctx->a;
371 result[1] = ctx->a >> 8;
372 result[2] = ctx->a >> 16;
373 result[3] = ctx->a >> 24;
374 result[4] = ctx->b;
375 result[5] = ctx->b >> 8;
376 result[6] = ctx->b >> 16;
377 result[7] = ctx->b >> 24;
378 result[8] = ctx->c;
379 result[9] = ctx->c >> 8;
380 result[10] = ctx->c >> 16;
381 result[11] = ctx->c >> 24;
382 result[12] = ctx->d;
383 result[13] = ctx->d >> 8;
384 result[14] = ctx->d >> 16;
385 result[15] = ctx->d >> 24;
386
387 memset(ctx, 0, sizeof(*ctx));
388 }
389
390 #define SHA256_BLOCK_LENGTH 64
391 #define SHA256_DIGEST_LENGTH 32
392 #define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1)
393
394 typedef struct SHA256Context {
395 uint32_t state[8];
396 uint64_t count;
397 uint8_t buf[SHA256_BLOCK_LENGTH];
398 } SHA256_CTX;
399
400 #if BYTE_ORDER == BIG_ENDIAN
401
402 /* Copy a vector of big-endian uint32_t into a vector of bytes */
403 #define be32enc_vect(dst, src, len) \
404 memcpy((void *)dst, (const void *)src, (size_t)len)
405
406 /* Copy a vector of bytes into a vector of big-endian uint32_t */
407 #define be32dec_vect(dst, src, len) \
408 memcpy((void *)dst, (const void *)src, (size_t)len)
409
410 #else /* BYTE_ORDER != BIG_ENDIAN */
411
412 /*
413 * Encode a length len/4 vector of (uint32_t) into a length len vector of
414 * (unsigned char) in big-endian form. Assumes len is a multiple of 4.
415 */
416 static void
417 be32enc_vect(unsigned char *dst, const uint32_t *src, size_t len)
418 {
419 size_t i;
420
421 for (i = 0; i < len / 4; i++)
422 be32enc(dst + i * 4, src[i]);
423 }
424
425 /*
426 * Decode a big-endian length len vector of (unsigned char) into a length
427 * len/4 vector of (uint32_t). Assumes len is a multiple of 4.
428 */
429 static void
430 be32dec_vect(uint32_t *dst, const unsigned char *src, size_t len)
431 {
432 size_t i;
433
434 for (i = 0; i < len / 4; i++)
435 dst[i] = be32dec(src + i * 4);
436 }
437
438 #endif /* BYTE_ORDER != BIG_ENDIAN */
439
440
441 /* Elementary functions used by SHA256 */
442 #define Ch(x, y, z) ((x & (y ^ z)) ^ z)
443 #define Maj(x, y, z) ((x & (y | z)) | (y & z))
444 #define ROTR(x, n) ((x >> n) | (x << (32 - n)))
445
446 /*
447 * SHA256 block compression function. The 256-bit state is transformed via
448 * the 512-bit input block to produce a new state.
449 */
450 static void
451 SHA256_Transform(uint32_t * state, const unsigned char block[64])
452 {
453 /* SHA256 round constants. */
454 static const uint32_t K[64] = {
455 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
456 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
457 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
458 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
459 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
460 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
461 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
462 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
463 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
464 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
465 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
466 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
467 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
468 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
469 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
470 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
471 };
472 uint32_t W[64];
473 uint32_t S[8];
474 int i;
475
476 #define S0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
477 #define S1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
478 #define s0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ (x >> 3))
479 #define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ (x >> 10))
480
481 /* SHA256 round function */
482 #define RND(a, b, c, d, e, f, g, h, k) \
483 h += S1(e) + Ch(e, f, g) + k; \
484 d += h; \
485 h += S0(a) + Maj(a, b, c);
486
487 /* Adjusted round function for rotating state */
488 #define RNDr(S, W, i, ii) \
489 RND(S[(64 - i) % 8], S[(65 - i) % 8], \
490 S[(66 - i) % 8], S[(67 - i) % 8], \
491 S[(68 - i) % 8], S[(69 - i) % 8], \
492 S[(70 - i) % 8], S[(71 - i) % 8], \
493 W[i + ii] + K[i + ii])
494
495 /* Message schedule computation */
496 #define MSCH(W, ii, i) \
497 W[i + ii + 16] = s1(W[i + ii + 14]) + W[i + ii + 9] + s0(W[i + ii + 1]) + W[i + ii]
498
499 /* 1. Prepare the first part of the message schedule W. */
500 be32dec_vect(W, block, 64);
501
502 /* 2. Initialize working variables. */
503 memcpy(S, state, 32);
504
505 /* 3. Mix. */
506 for (i = 0; i < 64; i += 16) {
507 RNDr(S, W, 0, i);
508 RNDr(S, W, 1, i);
509 RNDr(S, W, 2, i);
510 RNDr(S, W, 3, i);
511 RNDr(S, W, 4, i);
512 RNDr(S, W, 5, i);
513 RNDr(S, W, 6, i);
514 RNDr(S, W, 7, i);
515 RNDr(S, W, 8, i);
516 RNDr(S, W, 9, i);
517 RNDr(S, W, 10, i);
518 RNDr(S, W, 11, i);
519 RNDr(S, W, 12, i);
520 RNDr(S, W, 13, i);
521 RNDr(S, W, 14, i);
522 RNDr(S, W, 15, i);
523
524 if (i == 48)
525 break;
526 MSCH(W, 0, i);
527 MSCH(W, 1, i);
528 MSCH(W, 2, i);
529 MSCH(W, 3, i);
530 MSCH(W, 4, i);
531 MSCH(W, 5, i);
532 MSCH(W, 6, i);
533 MSCH(W, 7, i);
534 MSCH(W, 8, i);
535 MSCH(W, 9, i);
536 MSCH(W, 10, i);
537 MSCH(W, 11, i);
538 MSCH(W, 12, i);
539 MSCH(W, 13, i);
540 MSCH(W, 14, i);
541 MSCH(W, 15, i);
542 }
543
544 #undef S0
545 #undef s0
546 #undef S1
547 #undef s1
548 #undef RND
549 #undef RNDr
550 #undef MSCH
551
552 /* 4. Mix local working variables into global state */
553 for (i = 0; i < 8; i++)
554 state[i] += S[i];
555 }
556
557 static unsigned char PAD[64] = {
558 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
559 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
560 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
561 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
562 };
563
564 /* Add padding and terminating bit-count. */
565 static void
566 SHA256_Pad(SHA256_CTX * ctx)
567 {
568 size_t r;
569
570 /* Figure out how many bytes we have buffered. */
571 r = (ctx->count >> 3) & 0x3f;
572
573 /* Pad to 56 mod 64, transforming if we finish a block en route. */
574 if (r < 56) {
575 /* Pad to 56 mod 64. */
576 memcpy(&ctx->buf[r], PAD, 56 - r);
577 } else {
578 /* Finish the current block and mix. */
579 memcpy(&ctx->buf[r], PAD, 64 - r);
580 SHA256_Transform(ctx->state, ctx->buf);
581
582 /* The start of the final block is all zeroes. */
583 memset(&ctx->buf[0], 0, 56);
584 }
585
586 /* Add the terminating bit-count. */
587 be64enc(&ctx->buf[56], ctx->count);
588
589 /* Mix in the final block. */
590 SHA256_Transform(ctx->state, ctx->buf);
591 }
592
593 /* SHA-256 initialization. Begins a SHA-256 operation. */
594 static void
595 SHA256_Init(SHA256_CTX * ctx)
596 {
597
598 /* Zero bits processed so far */
599 ctx->count = 0;
600
601 /* Magic initialization constants */
602 ctx->state[0] = 0x6A09E667;
603 ctx->state[1] = 0xBB67AE85;
604 ctx->state[2] = 0x3C6EF372;
605 ctx->state[3] = 0xA54FF53A;
606 ctx->state[4] = 0x510E527F;
607 ctx->state[5] = 0x9B05688C;
608 ctx->state[6] = 0x1F83D9AB;
609 ctx->state[7] = 0x5BE0CD19;
610 }
611
612 /* Add bytes into the hash */
613 static void
614 SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len)
615 {
616 uint64_t bitlen;
617 uint32_t r;
618 const unsigned char *src = in;
619
620 /* Number of bytes left in the buffer from previous updates */
621 r = (ctx->count >> 3) & 0x3f;
622
623 /* Convert the length into a number of bits */
624 bitlen = len << 3;
625
626 /* Update number of bits */
627 ctx->count += bitlen;
628
629 /* Handle the case where we don't need to perform any transforms */
630 if (len < 64 - r) {
631 memcpy(&ctx->buf[r], src, len);
632 return;
633 }
634
635 /* Finish the current block */
636 memcpy(&ctx->buf[r], src, 64 - r);
637 SHA256_Transform(ctx->state, ctx->buf);
638 src += 64 - r;
639 len -= 64 - r;
640
641 /* Perform complete blocks */
642 while (len >= 64) {
643 SHA256_Transform(ctx->state, src);
644 src += 64;
645 len -= 64;
646 }
647
648 /* Copy left over data into buffer */
649 memcpy(ctx->buf, src, len);
650 }
651
652 /*
653 * SHA-256 finalization. Pads the input data, exports the hash value,
654 * and clears the context state.
655 */
656 static void
657 SHA256_Final(unsigned char digest[static SHA256_DIGEST_LENGTH], SHA256_CTX *ctx)
658 {
659 /* Add padding */
660 SHA256_Pad(ctx);
661
662 /* Write the hash */
663 be32enc_vect(digest, ctx->state, SHA256_DIGEST_LENGTH);
664
665 /* Clear the context state */
666 memset(ctx, 0, sizeof(*ctx));
667 }
668
669 static void *hash_buf(FILE *f, int *len)
670 {
671 static char buf[1024];
672
673 *len = fread(buf, 1, sizeof(buf), f);
674
675 return *len > 0 ? buf : NULL;
676 }
677
678 static char *hash_string(unsigned char *buf, int len)
679 {
680 static char str[SHA256_DIGEST_LENGTH * 2 + 1];
681 int i;
682
683 if (len * 2 + 1 > sizeof(str))
684 return NULL;
685
686 for (i = 0; i < len; i++)
687 sprintf(&str[i * 2], "%02x", buf[i]);
688
689 return str;
690 }
691
692 static const char *md5_hash(FILE *f)
693 {
694 MD5_CTX ctx;
695 unsigned char val[MD5_DIGEST_LENGTH];
696 void *buf;
697 int len;
698
699 MD5_begin(&ctx);
700 while ((buf = hash_buf(f, &len)) != NULL)
701 MD5_hash(buf, len, &ctx);
702 MD5_end(val, &ctx);
703
704 return hash_string(val, MD5_DIGEST_LENGTH);
705 }
706
707 static const char *sha256_hash(FILE *f)
708 {
709 SHA256_CTX ctx;
710 unsigned char val[SHA256_DIGEST_LENGTH];
711 void *buf;
712 int len;
713
714 SHA256_Init(&ctx);
715 while ((buf = hash_buf(f, &len)) != NULL)
716 SHA256_Update(&ctx, buf, len);
717 SHA256_Final(val, &ctx);
718
719 return hash_string(val, SHA256_DIGEST_LENGTH);
720 }
721
722
723 struct hash_type {
724 const char *name;
725 const char *(*func)(FILE *f);
726 int len;
727 };
728
729 struct hash_type types[] = {
730 { "md5", md5_hash, MD5_DIGEST_LENGTH },
731 { "sha256", sha256_hash, SHA256_DIGEST_LENGTH },
732 };
733
734
735 static int usage(const char *progname)
736 {
737 int i;
738
739 fprintf(stderr, "Usage: %s <hash type> [<file>...]\n"
740 "Supported hash types:", progname);
741
742 for (i = 0; i < ARRAY_SIZE(types); i++)
743 fprintf(stderr, "%s %s", i ? "," : "", types[i].name);
744
745 fprintf(stderr, "\n");
746 return 1;
747 }
748
749 static struct hash_type *get_hash_type(const char *name)
750 {
751 int i;
752
753 for (i = 0; i < ARRAY_SIZE(types); i++) {
754 struct hash_type *t = &types[i];
755
756 if (!strcmp(t->name, name))
757 return t;
758 }
759 return NULL;
760 }
761
762
763 static int hash_file(struct hash_type *t, const char *filename, bool add_filename)
764 {
765 const char *str;
766
767 if (!filename || !strcmp(filename, "-")) {
768 str = t->func(stdin);
769 } else {
770 FILE *f = fopen(filename, "r");
771
772 if (!f) {
773 fprintf(stderr, "Failed to open '%s'\n", filename);
774 return 1;
775 }
776 str = t->func(f);
777 fclose(f);
778 }
779
780 if (!str) {
781 fprintf(stderr, "Failed to generate hash\n");
782 return 1;
783 }
784
785 if (add_filename)
786 printf("%s %s\n", str, filename ? filename : "-");
787 else
788 printf("%s\n", str);
789 return 0;
790 }
791
792
793 int main(int argc, char **argv)
794 {
795 struct hash_type *t;
796 const char *progname = argv[0];
797 int i, ch;
798 bool add_filename = false;
799
800 while ((ch = getopt(argc, argv, "n")) != -1) {
801 switch (ch) {
802 case 'n':
803 add_filename = true;
804 break;
805 default:
806 return usage(progname);
807 }
808 }
809
810 argc -= optind;
811 argv += optind;
812
813 if (argc < 1)
814 return usage(progname);
815
816 t = get_hash_type(argv[0]);
817 if (!t)
818 return usage(progname);
819
820 if (argc < 2)
821 return hash_file(t, NULL, add_filename);
822
823 for (i = 0; i < argc - 1; i++)
824 hash_file(t, argv[1 + i], add_filename);
825
826 return 0;
827 }