Mercurial > repos > blastem

comparison hash.c @ 1305:5ceb316c479a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
author Michael Pavone <pavone@retrodev.com>
date Wed, 29 Mar 2017 00:29:44 -0700
parents
children 0111c8344477
comparison
equal deleted inserted replaced
1304:5b90d7669eee 1305:5ceb316c479a
1 #include <stdint.h>
2 #include <string.h>
3
4 //NOTE: This is only intended for use in file identification
5 //Please do not use this in a cryptographic setting as no attempts have been
6 //made at avoiding side channel attacks
7
8 static uint32_t rotleft(uint32_t val, uint32_t shift)
9 {
10 return val << shift | val >> (32-shift);
11 }
12
13 static void sha1_step(uint32_t *state, uint32_t f, uint32_t k, uint32_t w)
14 {
15 uint32_t tmp = rotleft(state[0], 5) + f + state[4] + k + w;
16 state[4] = state[3];
17 state[3] = state[2];
18 state[2] = rotleft(state[1], 30);
19 state[1] = state[0];
20 state[0] = tmp;
21 }
22
23 static void sha1_chunk(uint8_t *chunk, uint32_t *hash)
24 {
25 uint32_t state[5], w[80];
26 memcpy(state, hash, sizeof(state));
27 for (uint32_t src = 0; src < 64; src += 4)
28 {
29 w[src >> 2] = chunk[src] << 24 | chunk[src+1] << 16 | chunk[src+2] << 8 | chunk[src+3];
30 }
31 for (uint32_t cur = 16; cur < 80; cur++)
32 {
33 w[cur] = rotleft(w[cur-3] ^ w[cur-8] ^ w[cur-14] ^ w[cur-16], 1);
34 }
35 for (uint32_t cur = 0; cur < 20; cur++)
36 {
37 sha1_step(state, (state[1] & state[2]) | ((~state[1]) & state[3]), 0x5A827999, w[cur]);
38 }
39 for (uint32_t cur = 20; cur < 40; cur++)
40 {
41 sha1_step(state, state[1] ^ state[2] ^ state[3], 0x6ED9EBA1, w[cur]);
42 }
43 for (uint32_t cur = 40; cur < 60; cur++)
44 {
45 sha1_step(state, (state[1] & state[2]) | (state[1] & state[3]) | (state[2] & state[3]), 0x8F1BBCDC, w[cur]);
46 }
47 for (uint32_t cur = 60; cur < 80; cur++)
48 {
49 sha1_step(state, state[1] ^ state[2] ^ state[3], 0xCA62C1D6, w[cur]);
50 }
51 for (uint32_t i = 0; i < 5; i++)
52 {
53 hash[i] += state[i];
54 }
55 }
56
57 void sha1(uint8_t *data, uint64_t size, uint8_t *out)
58 {
59 uint32_t hash[5] = {0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0};
60 uint8_t last[128];
61 uint32_t last_size = 0;
62 if ((size & 63) != 0) {
63 for (uint32_t src = size - (size & 63); src < size; src++)
64 {
65 last[last_size++] = data[src];
66 }
67 }
68 uint64_t bitsize = size * 8;
69 size -= last_size;
70 last[last_size++] = 0x80;
71 while ((last_size & 63) != 56)
72 {
73 last[last_size++] = 0;
74 }
75
76 last[last_size++] = bitsize >> 56;
77 last[last_size++] = bitsize >> 48;
78 last[last_size++] = bitsize >> 40;
79 last[last_size++] = bitsize >> 32;
80 last[last_size++] = bitsize >> 24;
81 last[last_size++] = bitsize >> 16;
82 last[last_size++] = bitsize >> 8;
83 last[last_size++] = bitsize;
84
85 for (uint64_t cur = 0; cur < size; cur += 64)
86 {
87 sha1_chunk(data + cur, hash);
88 }
89 for (uint64_t cur = 0; cur < last_size; cur += 64)
90 {
91 sha1_chunk(last + cur, hash);
92 }
93 for (uint32_t cur = 0; cur < 20; cur += 4)
94 {
95 uint32_t val = hash[cur >> 2];
96 out[cur] = val >> 24;
97 out[cur+1] = val >> 16;
98 out[cur+2] = val >> 8;
99 out[cur+3] = val;
100 }
101 }