1 /* Copyright (C) 2010-2020 The RetroArch team
3 * ---------------------------------------------------------------------------------------
4 * The following license statement only applies to this file (lrc_hash.c).
5 * ---------------------------------------------------------------------------------------
7 * Permission is hereby granted, free of charge,
8 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation the rights to
10 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
11 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
16 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
19 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 #include <retro_miscellaneous.h>
32 #include <retro_endianness.h>
33 #include <streams/file_stream.h>
35 #define LSL32(x, n) ((uint32_t)(x) << (n))
36 #define LSR32(x, n) ((uint32_t)(x) >> (n))
37 #define ROR32(x, n) (LSR32(x, n) | LSL32(x, 32 - (n)))
39 /* First 32 bits of the fractional parts of the square roots of the first 8 primes 2..19 */
40 static const uint32_t T_H[8] = {
41 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
44 /* First 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311 */
45 static const uint32_t T_K[64] = {
46 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
47 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
48 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
49 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
50 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
51 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
52 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
53 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
56 /* SHA256 implementation from bSNES. Written by valditx. */
72 static void sha256_init(struct sha256_ctx *p)
74 memset(p, 0, sizeof(struct sha256_ctx));
75 memcpy(p->h, T_H, sizeof(T_H));
78 static void sha256_block(struct sha256_ctx *p)
82 uint32_t a, b, c, d, e, f, g, h;
84 for (i = 0; i < 16; i++)
85 p->w[i] = load32be(p->in.u32 + i);
87 for (i = 16; i < 64; i++)
89 s0 = ROR32(p->w[i - 15], 7) ^ ROR32(p->w[i - 15], 18) ^ LSR32(p->w[i - 15], 3);
90 s1 = ROR32(p->w[i - 2], 17) ^ ROR32(p->w[i - 2], 19) ^ LSR32(p->w[i - 2], 10);
91 p->w[i] = p->w[i - 16] + s0 + p->w[i - 7] + s1;
94 a = p->h[0]; b = p->h[1]; c = p->h[2]; d = p->h[3];
95 e = p->h[4]; f = p->h[5]; g = p->h[6]; h = p->h[7];
97 for (i = 0; i < 64; i++)
99 uint32_t t1, t2, maj, ch;
101 s0 = ROR32(a, 2) ^ ROR32(a, 13) ^ ROR32(a, 22);
102 maj = (a & b) ^ (a & c) ^ (b & c);
104 s1 = ROR32(e, 6) ^ ROR32(e, 11) ^ ROR32(e, 25);
105 ch = (e & f) ^ (~e & g);
106 t1 = h + s1 + ch + T_K[i] + p->w[i];
118 p->h[0] += a; p->h[1] += b; p->h[2] += c; p->h[3] += d;
119 p->h[4] += e; p->h[5] += f; p->h[6] += g; p->h[7] += h;
125 static void sha256_chunk(struct sha256_ctx *p,
126 const uint8_t *s, unsigned len)
132 unsigned l = 64 - p->inlen;
137 memcpy(p->in.u8 + p->inlen, s, l);
148 static void sha256_final(struct sha256_ctx *p)
151 p->in.u8[p->inlen++] = 0x80;
155 memset(p->in.u8 + p->inlen, 0, 64 - p->inlen);
159 memset(p->in.u8 + p->inlen, 0, 56 - p->inlen);
162 store32be(p->in.u32 + 14, (uint32_t)(len >> 32));
163 store32be(p->in.u32 + 15, (uint32_t)len);
167 static void sha256_subhash(struct sha256_ctx *p, uint32_t *t)
170 for (i = 0; i < 8; i++)
171 store32be(t++, p->h[i]);
178 * @size : Size of @s.
180 * Hashes SHA256 and outputs a human readable string.
182 void sha256_hash(char *s, const uint8_t *in, size_t size)
185 struct sha256_ctx sha;
194 sha256_chunk(&sha, in, (unsigned)size);
196 sha256_subhash(&sha, shahash.u32);
198 for (i = 0; i < 32; i++)
199 snprintf(s + 2 * i, 3, "%02x", (unsigned)shahash.u8[i]);
204 static const uint32_t crc32_hash_table[256] = {
205 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
206 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
207 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
208 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
209 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
210 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
211 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
212 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
213 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
214 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
215 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
216 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
217 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
218 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
219 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
220 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
221 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
222 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
223 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
224 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
225 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
226 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
227 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
228 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
229 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
230 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
231 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
232 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
233 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
234 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
235 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
236 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
237 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
238 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
239 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
240 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
241 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
242 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
243 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
244 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
245 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
246 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
247 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
250 uint32_t crc32_adjust(uint32_t checksum, uint8_t input)
252 return ((checksum >> 8) & 0x00ffffff) ^ crc32_hash_table[(checksum ^ input) & 0xff];
255 uint32_t crc32_calculate(const uint8_t *data, size_t length)
258 uint32_t checksum = ~0;
259 for (i = 0; i < length; i++)
260 checksum = crc32_adjust(checksum, data[i]);
265 /* SHA-1 implementation. */
270 * Copyright (C) 1998, 2009
271 * Paul E. Jones <paulej@packetizer.com>
272 * All Rights Reserved
274 *****************************************************************************
275 * $Id: sha1.c 12 2009-06-22 19:34:25Z paulej $
276 *****************************************************************************
279 * This file implements the Secure Hashing Standard as defined
280 * in FIPS PUB 180-1 published April 17, 1995.
282 * The Secure Hashing Standard, which uses the Secure Hashing
283 * Algorithm (SHA), produces a 160-bit message digest for a
284 * given data stream. In theory, it is highly improbable that
285 * two messages will produce the same message digest. Therefore,
286 * this algorithm can serve as a means of providing a "fingerprint"
289 * Portability Issues:
290 * SHA-1 is defined in terms of 32-bit "words". This code was
291 * written with the expectation that the processor has at least
292 * a 32-bit machine word size. If the machine word size is larger,
293 * the code should still function properly. One caveat to that
294 * is that the input functions taking characters and character
295 * arrays assume that only 8 bits of information are stored in each
299 * SHA-1 is designed to work with messages less than 2^64 bits
300 * long. Although SHA-1 allows a message digest to be generated for
301 * messages of any number of bits less than 2^64, this
302 * implementation only works with messages with a length that is a
303 * multiple of the size of an 8-bit character.
307 /* Define the circular shift macro */
308 #define SHA1CircularShift(bits,word) ((((word) << (bits)) & 0xFFFFFFFF) | ((word) >> (32-(bits))))
312 unsigned Message_Digest[5]; /* Message Digest (output) */
314 unsigned Length_Low; /* Message length in bits */
315 unsigned Length_High; /* Message length in bits */
317 unsigned char Message_Block[64]; /* 512-bit message blocks */
318 int Message_Block_Index; /* Index into message block array */
320 int Computed; /* Is the digest computed? */
321 int Corrupted; /* Is the message digest corruped? */
325 static void SHA1Reset(struct sha1_context *context)
330 context->Length_Low = 0;
331 context->Length_High = 0;
332 context->Message_Block_Index = 0;
334 context->Message_Digest[0] = 0x67452301;
335 context->Message_Digest[1] = 0xEFCDAB89;
336 context->Message_Digest[2] = 0x98BADCFE;
337 context->Message_Digest[3] = 0x10325476;
338 context->Message_Digest[4] = 0xC3D2E1F0;
340 context->Computed = 0;
341 context->Corrupted = 0;
344 static void SHA1ProcessMessageBlock(struct sha1_context *context)
346 const unsigned K[] = /* Constants defined in SHA-1 */
353 int t; /* Loop counter */
354 unsigned temp; /* Temporary word value */
355 unsigned W[80]; /* Word sequence */
356 unsigned A, B, C, D, E; /* Word buffers */
358 /* Initialize the first 16 words in the array W */
359 for (t = 0; t < 16; t++)
361 W[t] = ((unsigned) context->Message_Block[t * 4]) << 24;
362 W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16;
363 W[t] |= ((unsigned) context->Message_Block[t * 4 + 2]) << 8;
364 W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]);
367 for (t = 16; t < 80; t++)
368 W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
370 A = context->Message_Digest[0];
371 B = context->Message_Digest[1];
372 C = context->Message_Digest[2];
373 D = context->Message_Digest[3];
374 E = context->Message_Digest[4];
376 for (t = 0; t < 20; t++)
378 temp = SHA1CircularShift(5,A) +
379 ((B & C) | ((~B) & D)) + E + W[t] + K[0];
383 C = SHA1CircularShift(30,B);
388 for (t = 20; t < 40; t++)
390 temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
394 C = SHA1CircularShift(30,B);
399 for (t = 40; t < 60; t++)
401 temp = SHA1CircularShift(5,A) +
402 ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
406 C = SHA1CircularShift(30,B);
411 for (t = 60; t < 80; t++)
413 temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
417 C = SHA1CircularShift(30,B);
422 context->Message_Digest[0] =
423 (context->Message_Digest[0] + A) & 0xFFFFFFFF;
424 context->Message_Digest[1] =
425 (context->Message_Digest[1] + B) & 0xFFFFFFFF;
426 context->Message_Digest[2] =
427 (context->Message_Digest[2] + C) & 0xFFFFFFFF;
428 context->Message_Digest[3] =
429 (context->Message_Digest[3] + D) & 0xFFFFFFFF;
430 context->Message_Digest[4] =
431 (context->Message_Digest[4] + E) & 0xFFFFFFFF;
433 context->Message_Block_Index = 0;
436 static void SHA1PadMessage(struct sha1_context *context)
442 * Check to see if the current message block is too small to hold
443 * the initial padding bits and length. If so, we will pad the
444 * block, process it, and then continue padding into a second
447 context->Message_Block[context->Message_Block_Index++] = 0x80;
449 if (context->Message_Block_Index > 55)
451 while (context->Message_Block_Index < 64)
452 context->Message_Block[context->Message_Block_Index++] = 0;
454 SHA1ProcessMessageBlock(context);
457 while (context->Message_Block_Index < 56)
458 context->Message_Block[context->Message_Block_Index++] = 0;
460 /* Store the message length as the last 8 octets */
461 context->Message_Block[56] = (context->Length_High >> 24) & 0xFF;
462 context->Message_Block[57] = (context->Length_High >> 16) & 0xFF;
463 context->Message_Block[58] = (context->Length_High >> 8) & 0xFF;
464 context->Message_Block[59] = (context->Length_High) & 0xFF;
465 context->Message_Block[60] = (context->Length_Low >> 24) & 0xFF;
466 context->Message_Block[61] = (context->Length_Low >> 16) & 0xFF;
467 context->Message_Block[62] = (context->Length_Low >> 8) & 0xFF;
468 context->Message_Block[63] = (context->Length_Low) & 0xFF;
470 SHA1ProcessMessageBlock(context);
473 static int SHA1Result(struct sha1_context *context)
475 if (context->Corrupted)
478 if (!context->Computed)
480 SHA1PadMessage(context);
481 context->Computed = 1;
487 static void SHA1Input(struct sha1_context *context,
488 const unsigned char *message_array,
494 if (context->Computed || context->Corrupted)
496 context->Corrupted = 1;
500 while (length-- && !context->Corrupted)
502 context->Message_Block[context->Message_Block_Index++] =
503 (*message_array & 0xFF);
505 context->Length_Low += 8;
506 /* Force it to 32 bits */
507 context->Length_Low &= 0xFFFFFFFF;
508 if (context->Length_Low == 0)
510 context->Length_High++;
511 /* Force it to 32 bits */
512 context->Length_High &= 0xFFFFFFFF;
513 if (context->Length_High == 0)
514 context->Corrupted = 1; /* Message is too long */
517 if (context->Message_Block_Index == 64)
518 SHA1ProcessMessageBlock(context);
524 int sha1_calculate(const char *path, char *result)
526 struct sha1_context sha;
527 unsigned char buff[4096];
529 RFILE *fd = filestream_open(path,
530 RETRO_VFS_FILE_ACCESS_READ,
531 RETRO_VFS_FILE_ACCESS_HINT_NONE);
542 rv = (int)filestream_read(fd, buff, 4096);
546 SHA1Input(&sha, buff, rv);
549 if (!SHA1Result(&sha))
552 sprintf(result, "%08X%08X%08X%08X%08X",
553 sha.Message_Digest[0],
554 sha.Message_Digest[1],
555 sha.Message_Digest[2],
556 sha.Message_Digest[3], sha.Message_Digest[4]);
558 filestream_close(fd);
563 filestream_close(fd);
567 uint32_t djb2_calculate(const char *str)
569 const unsigned char *aux = (const unsigned char*)str;
570 uint32_t hash = 5381;
573 hash = ( hash << 5 ) + hash + *aux++;