1 /***************************************************************************
2
3 "Kabuki" Z80 encryption
4
5
6 The "Kabuki" is a custom Z80 module which runs encrypted code. The encryption
7 key is stored in some battery-backed RAM, therefore the chip has the annoying
8 habit of stopping working every few years, when the battery dies.
9 Check at the bottom of this text to see a list of all the known games which
10 use this chip.
11
12
13 How it works:
14 The base operation is a bit swap which affects couples of adjacent bits.
15 Each of the 4 couples may or may not be swapped, depending on the address of
16 the byte and on whether it is an opcode or data.
17 The decryption consists of these steps:
18 - bitswap
19 - ROL
20 - bitswap
21 - XOR with a key
22 - ROL
23 - bitswap
24 - ROL
25 - bitswap
26
27 To know how to apply the bit swap, take the address of the byte to decode and:
28 - if the byte is an opcode, add addr_key to the address
29 - if the byte is data, XOR the address with 1FC0, add 1, and then add addr_key
30 You'll get a 16-bit word. The first two bitswaps depend on bits 0-7 of that
31 word, while the second two on bits 8-15. When a bit in the word is 1, swap the
32 two bits, oherwise don't. The exact couple of bits affected depends on the
33 game and is identified in this file with two keys: swap_key1 and swap_key2
34 (which are just permutations of the numbers 0-7, not full 32-bit integers).
35
36
37 Key space size:
38 - swap_key1 8! = 40320
39 - swap_key2 8! = 40320
40 - addr_key 2^16 = 65536
41 - xor_key 2^8 = 256
42 - total 2.7274 * 10^16
43
44
45 Weaknesses:
46 - 0x00 and 0xff, having all the bits set to the same value, are not affected
47 by bit permutations after the XOR. Therefore, their encryption is the same
48 regardless of the high 8 bits of the address, and of the value of
49 swap_key2. If there is a long stream of 0x00 or 0xff in the original data,
50 this can be used to find by brute force all the candidates for swap_key1,
51 xor_key, and for the low 8 bits of addr_key. This is a serious weakness
52 which dramatically reduces the security of the encryption.
53 - A 0x00 is always encrypted as a byte with as many 1s as xor_key; a 0xff is
54 always encrypted as a byte with as many 0s as xor_key has 1s. So you just
55 need to know one 0x00 or 0xff in the unencrypted data to know how many 1s
56 there are in xor_key.
57 - Once you have restricted the range for swap_key1 and you know the number of
58 1s in the xor_key, you can easily use known plaintext attacks and brute
59 force to find the remaining keys. Long strings like THIS GAME IS FOR USE IN
60 and ABCDEFGHIJKLMNOPQRSTUVWXYZ can be found by comparing the number of 1s
61 in the clear and encrypted data, taking xor_key into account. When you have
62 found where the string is, use brute force to reduce the key space.
63
64
65 Known games:
66 swap_key1 swap_key2 addr_key xor_key
67 Mahjong Gakuen 2 Gakuen-chou no Fukushuu 76543210 01234567 aa55 a5
68 Poker Ladies " " " " "" ""
69 Dokaben " " " " "" ""
70 Dokaben 2 unknown
71 Pang / Buster Bros / Pomping World 01234567 76543210 6548 24
72 Capcom Baseball " " " " "" ""
73 Capcom World 04152637 40516273 5751 43
74 Adventure Quiz 2 Hatena ? no Dai-Bouken 45670123 45670123 5751 43
75 Super Pang 45670123 45670123 5852 43
76 Super Buster Bros 45670123 45670123 2130 12
77 Super Marukin-Ban 54321076 54321076 4854 4f
78 Quiz Tonosama no Yabou 12345670 12345670 1111 11
79 Ashita Tenki ni Naare unknown
80 Quiz Sangokushi 23456701 23456701 1828 18
81 Block Block 02461357 64207531 0002 01
82
83 Warriors of Fate 01234567 54163072 5151 51
84 Cadillacs and Dinosaurs 76543210 24601357 4343 43
85 Punisher 67452103 75316024 2222 22
86 Slam Masters 54321076 65432107 3131 19
87
88 ***************************************************************************/
89
90 #include "cpuintrf.h"
91
bitswap1(int src,int key,int sel)92 static int bitswap1(int src,int key,int sel)
93 {
94 if (sel & (1 << ((key >> 0) & 7)))
95 src = (src & 0xfc) | ((src & 0x01) << 1) | ((src & 0x02) >> 1);
96 if (sel & (1 << ((key >> 4) & 7)))
97 src = (src & 0xf3) | ((src & 0x04) << 1) | ((src & 0x08) >> 1);
98 if (sel & (1 << ((key >> 8) & 7)))
99 src = (src & 0xcf) | ((src & 0x10) << 1) | ((src & 0x20) >> 1);
100 if (sel & (1 << ((key >>12) & 7)))
101 src = (src & 0x3f) | ((src & 0x40) << 1) | ((src & 0x80) >> 1);
102
103 return src;
104 }
105
bitswap2(int src,int key,int sel)106 static int bitswap2(int src,int key,int sel)
107 {
108 if (sel & (1 << ((key >>12) & 7)))
109 src = (src & 0xfc) | ((src & 0x01) << 1) | ((src & 0x02) >> 1);
110 if (sel & (1 << ((key >> 8) & 7)))
111 src = (src & 0xf3) | ((src & 0x04) << 1) | ((src & 0x08) >> 1);
112 if (sel & (1 << ((key >> 4) & 7)))
113 src = (src & 0xcf) | ((src & 0x10) << 1) | ((src & 0x20) >> 1);
114 if (sel & (1 << ((key >> 0) & 7)))
115 src = (src & 0x3f) | ((src & 0x40) << 1) | ((src & 0x80) >> 1);
116
117 return src;
118 }
119
bytedecode(int src,int swap_key1,int swap_key2,int xor_key,int sel)120 static int bytedecode(int src,int swap_key1,int swap_key2,int xor_key,int sel)
121 {
122 src = bitswap1(src,swap_key1 & 0xffff,sel & 0xff);
123 src = ((src & 0x7f) << 1) | ((src & 0x80) >> 7);
124 src = bitswap2(src,swap_key1 >> 16,sel & 0xff);
125 src ^= xor_key;
126 src = ((src & 0x7f) << 1) | ((src & 0x80) >> 7);
127 src = bitswap2(src,swap_key2 & 0xffff,sel >> 8);
128 src = ((src & 0x7f) << 1) | ((src & 0x80) >> 7);
129 src = bitswap1(src,swap_key2 >> 16,sel >> 8);
130 return src;
131 }
132
kabuki_decode(unsigned char * src,unsigned char * dest_op,unsigned char * dest_data,int base_addr,int length,int swap_key1,int swap_key2,int addr_key,int xor_key)133 static void kabuki_decode(unsigned char *src,unsigned char *dest_op,unsigned char *dest_data,
134 int base_addr,int length,int swap_key1,int swap_key2,int addr_key,int xor_key)
135 {
136 int A;
137 int sel;
138
139 for (A = 0; A < length; A++)
140 {
141 /* decode opcodes */
142 sel = (A + base_addr) + addr_key;
143 dest_op[A] = bytedecode(src[A],swap_key1,swap_key2,xor_key,sel);
144
145 /* decode data */
146 sel = ((A + base_addr) ^ 0x1fc0) + addr_key + 1;
147 dest_data[A] = bytedecode(src[A],swap_key1,swap_key2,xor_key,sel);
148 }
149 }
150
cps1_decode(unsigned char * rom,int swap_key1,int swap_key2,int addr_key,int xor_key)151 void cps1_decode(unsigned char *rom, int swap_key1,int swap_key2,int addr_key,int xor_key)
152 {
153 int diff = (512*1024)/2;
154
155 kabuki_decode(rom, rom+diff, rom, 0x0000, 0x8000, swap_key1, swap_key2, addr_key, xor_key);
156 }
157