Mercurial > repos > blastem
comparison hash.c @ 1305:5ceb316c479a
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 } |