468 lines
28 KiB
HTML
468 lines
28 KiB
HTML
{% extends "base.html" %}
|
|
{% block title %}Card IDs{% endblock %}
|
|
{% block body %}
|
|
<h1>Card ID generation</h1>
|
|
<details>
|
|
<summary>I'm just here for code.</summary>
|
|
<p>Fair. My intent with these pages is to describe things in enough detail that they should be simple to
|
|
implement yourself, but this is one of those things that's quite easy to just drop in some pre-made code
|
|
for. My local implementation is in python, so that's all you're getting :). As a free bonus, have some test
|
|
cases too. It's not great code by any stretch, and it liberally uses assertions rather than proper
|
|
exceptions, but it should be a good enough starting point for your own version.</p>
|
|
<pre></pre>{% highlight 'python' %}
|
|
import binascii
|
|
from Crypto.Cipher import DES3
|
|
|
|
|
|
KEY = b"" # Check the DES section for this
|
|
_KEY = bytes(i * 2 for i in KEY) # Preprocess the key
|
|
|
|
ALPHABET = "0123456789ABCDEFGHJKLMNPRSTUWXYZ"
|
|
|
|
|
|
def enc_des(uid):
|
|
cipher = DES3.new(_KEY, DES3.MODE_CBC, iv=b'\0' * 8)
|
|
return cipher.encrypt(uid)
|
|
|
|
|
|
def dec_des(uid):
|
|
cipher = DES3.new(_KEY, DES3.MODE_CBC, iv=b'\0' * 8)
|
|
return cipher.decrypt(uid)
|
|
|
|
|
|
def checksum(data):
|
|
chk = sum(data[i] * (i % 3 + 1) for i in range(15))
|
|
|
|
while chk > 31:
|
|
chk = (chk >> 5) + (chk & 31)
|
|
|
|
return chk
|
|
|
|
|
|
def pack_5(data):
|
|
data = "".join(f"{i:05b}" for i in data)
|
|
if len(data) % 8 != 0:
|
|
data += "0" * (8 - (len(data) % 8))
|
|
return bytes(int(data[i:i+8], 2) for i in range(0, len(data), 8))
|
|
|
|
|
|
def unpack_5(data):
|
|
data = "".join(f"{i:08b}" for i in data)
|
|
if len(data) % 5 != 0:
|
|
data += "0" * (5 - (len(data) % 5))
|
|
return bytes(int(data[i:i+5], 2) for i in range(0, len(data), 5))
|
|
|
|
|
|
def to_konami_id(uid):
|
|
assert len(uid) == 16, "UID must be 16 bytes"
|
|
|
|
if uid.upper().startswith("E004"):
|
|
card_type = 1
|
|
elif uid.upper().startswith("0"):
|
|
card_type = 2
|
|
else:
|
|
raise ValueError("Invalid UID prefix")
|
|
|
|
kid = binascii.unhexlify(uid)
|
|
assert len(kid) == 8, "ID must be 8 bytes"
|
|
|
|
out = bytearray(unpack_5(enc_des(kid[::-1]))[:13]) + b'\0\0\0'
|
|
|
|
out[0] ^= card_type
|
|
out[13] = 1
|
|
for i in range(1, 14):
|
|
out[i] ^= out[i - 1]
|
|
out[14] = card_type
|
|
out[15] = checksum(out)
|
|
|
|
return "".join(ALPHABET[i] for i in out)
|
|
|
|
|
|
def to_uid(konami_id):
|
|
if konami_id[14] == "1":
|
|
card_type = 1
|
|
elif konami_id[14] == "2":
|
|
card_type = 2
|
|
else:
|
|
raise ValueError("Invalid ID")
|
|
|
|
assert len(konami_id) == 16, f"ID must be 16 characters"
|
|
assert all(i in ALPHABET for i in konami_id), "ID contains invalid characters"
|
|
card = [ALPHABET.index(i) for i in konami_id]
|
|
assert card[11] % 2 == card[12] % 2, "Parity check failed"
|
|
assert card[13] == card[12] ^ 1, "Card invalid"
|
|
assert card[15] == checksum(card), "Checksum failed"
|
|
|
|
for i in range(13, 0, -1):
|
|
card[i] ^= card[i - 1]
|
|
|
|
card[0] ^= card_type
|
|
|
|
card_id = dec_des(pack_5(card[:13])[:8])[::-1]
|
|
card_id = binascii.hexlify(card_id).decode().upper()
|
|
|
|
if card_type == 1:
|
|
assert card_id[:4] == "E004", "Invalid card type"
|
|
elif card_type == 2:
|
|
assert card_id[0] == "0", "Invalid card type"
|
|
return card_id
|
|
|
|
|
|
if __name__ == "__main__":
|
|
assert to_konami_id("0000000000000000") == "007TUT8XJNSSPN2P", "To KID failed"
|
|
assert to_uid("007TUT8XJNSSPN2P") == "0000000000000000", "From KID failed"
|
|
assert to_uid(to_konami_id("000000100200F000")) == "000000100200F000", "Roundtrip failed"
|
|
{% endhighlight %}</pre>
|
|
</details>
|
|
<p>e-Amusement cards use 16 digit IDs. KONAMI IDs are also 16 digits. Are they related? Yes! In fact, KONAMI IDs are
|
|
derived from the ID stored on the e-Amusement card.</p>
|
|
<p>KONAMI IDs have an alphabet of <code>0123456789ABCDEFGHJKLMNPRSTUWXYZ</code> (note that <code>IOQV</code> are
|
|
absent), whereas e-A IDs (yeah I'm not typing that out every time) have an alphabet of
|
|
<code>0123456789ABCDEF</code> (hex). It stands to reason then that there's additional information present in
|
|
KONAMI IDs, as they are the same length, but can hold a greater density of information. That intuition would be
|
|
correct.
|
|
</p>
|
|
<h2 id="konami">Converting KONAMI IDs to e-Amusement IDs</h2>
|
|
<p>Let's take a look at the format of KONAMI IDs. The first step before we can do anything is to convert it from a
|
|
string to a series of integers. Each byte is replaced with its index in the alphabet, giving us 16 values
|
|
ranging from 0 through 31. These bytes has the following meanings:</p>
|
|
<table class="code">
|
|
<thead>
|
|
<tr>
|
|
<td>0</td>
|
|
<td>1</td>
|
|
<td>2</td>
|
|
<td>3</td>
|
|
<td>4</td>
|
|
<td>5</td>
|
|
<td>6</td>
|
|
<td>7</td>
|
|
<td>8</td>
|
|
<td>9</td>
|
|
<td>10</td>
|
|
<td>11</td>
|
|
<td>12</td>
|
|
<td>13</td>
|
|
<td>14</td>
|
|
<td>15</td>
|
|
</tr>
|
|
</thead>
|
|
<tr>
|
|
<td colspan="13">e-Amusement ID</td>
|
|
<td>Check byte</td>
|
|
<td>Card type</td>
|
|
<td>Checksum</td>
|
|
</tr>
|
|
</table>
|
|
|
|
<p>Due to how IDs are constructed, there are a number of checks we can perform to validate an ID:</p>
|
|
<ul>
|
|
<li>Parity check: <code>[11] % 2 == [12] % 2</code></li>
|
|
<li>Encoding check: <code>[13] == [12] ^ 1</code></li>
|
|
<li>Checksum: <code>[15] == <a href="#checksum">checksum([0..14])</a></code></li>
|
|
<li>Post-decoding, FeliCa cards start with <code>0</code> and magnetic strip cards start with <code>E004</code>.
|
|
</li>
|
|
<li>Card type: <code>[14] == 1</code> (magnetic stripe) or <code>[14] == 2</code> (FeliCa)</li>
|
|
</ul>
|
|
|
|
<p>To decrypt a KONAMI ID, at a high level we must:</p>
|
|
<ul>
|
|
<li>Remove the XOR encoding</li>
|
|
<li>5-pack the ID</li>
|
|
<li>Decrypt the packed ID</li>
|
|
<li>Reverse the bytes</li>
|
|
<li>Convert to upper-case hex</li>
|
|
</ul>
|
|
<p>As we'll see in the next section, card IDs have an XOR pass performed. This is what allows for the above encoding
|
|
check, but we must remove it before we can begin decoding. A line of code speaks a thousand words, so have
|
|
three:</p>
|
|
<pre><code>for i from 13 to 1 inclusive:
|
|
card[i] ^= card[i - 1]
|
|
card[0] ^= card_type</code></pre>
|
|
<p id="packing">The values in the <code>e-Amusement ID</code> field above will all maximally be 31
|
|
(<code>0b11111</code>) therefore before we perform the decryption step we first densly pack these 5-bit
|
|
integers. That is, <code>0b11111 0b00000 0b11111</code> would be packed to <code>0b11111000 0b00111110</code>.
|
|
This value will be 8 bytes long. We can now <a href="#des">decrypt it</a>, reverse it, and convert to hex.
|
|
</p>
|
|
<details>
|
|
<summary>Implementing 5-bit packing</summary>
|
|
<p>In most languages, implementing a packer can be done one of two ways. The approach chosen by Bemani is to
|
|
first create a table of every individual bit (each stored in a whole byte!), then iterate through the bits
|
|
ORing them together. This is a simple but wasteful implementation. The other approach is to use a buffer
|
|
byte and slowly shift values in, tracking how many bits are stored in the buffer byte, and performing
|
|
different actions depending on how many bits this is. For both packing and unpacking this requires three
|
|
cases. It's somewhat more complex, but less wasteful in terms of memory usage. Pick your poison I suppose.
|
|
</p>
|
|
<details>
|
|
<summary>In <i>most</i> languages?</summary>
|
|
<p>Haha well you see we can actually cheat and use string manipulation. Wasteful? Incredibly. Efficient? Not
|
|
at all. Quick and easy? Yup!</p>
|
|
<pre>{% highlight "python" %}def pack_5(data):
|
|
data = "".join(f"{i:05b}" for i in data)
|
|
if len(data) % 8 != 0:
|
|
data += "0" * (8 - (len(data) % 8))
|
|
return bytes(int(data[i:i+8], 2) for i in range(0, len(data), 8))
|
|
|
|
def unpack_5(data):
|
|
data = "".join(f"{i:08b}" for i in data)
|
|
if len(data) % 5 != 0:
|
|
data += "0" * (5 - (len(data) % 5))
|
|
return bytes(int(data[i:i+5], 2) for i in range(0, len(data), 5)){% endhighlight %}</pre>
|
|
<p>If your language of choice allows this, and you don't care for efficiency, this can be a great time-saver
|
|
towards get something working. Truth be told my local implementation originally used the Bemani method
|
|
(it was a line-for-line port, after all), switched to the second method, then I opted for this hacky
|
|
string method in the name of code clarity.</p>
|
|
</details>
|
|
</details>
|
|
|
|
<h2 id="eaid">Converting e-Amusement IDs to KONAMI IDs</h2>
|
|
<p>This is mostly the above process, in reverse, but we need to make sure to populate some of the extra check bytes.
|
|
</p>
|
|
<p>Before we start, we need to make sure we have a valid card! FeliCa cards (type <code>2</code>) will begin with a
|
|
single null nibble, and magnetic stripe cards (type <code>1</code>) with the word <code>E004</code>. We then
|
|
parse the entire ID as a hex string, giving us an 8-byte value.</p>
|
|
<p>This value is reversed, and <a href="#des">encrypted</a>. After encryption, we need to unpack it from it's
|
|
5-packed format. This is the same process as <a href="#packing">unpacking</a>, but reversed. The unpacked data
|
|
can be ambiguous in length. It's 13 bytes. If your unpacker produces a 14th byte, it'll be null and can be
|
|
discarded.</p>
|
|
<p>We pad the 13 bytes with 3 extra null bytes, then apply our checks to the ID:</p>
|
|
<pre><code>card[0] ^= card_type
|
|
card[13] = 1
|
|
for i from 0 to 13 inclusive:
|
|
card[i + 1] ^= card[i]
|
|
card[14] = card_type
|
|
card[15] = <a href="#checksum">checksum(card)</a></code></pre>
|
|
|
|
<p>This leaves us with 16 values ranging from 0 to 31, which we apply as indecies to our alphabet to produce the
|
|
final ID.</p>
|
|
|
|
<h2 id="checksum">Checksums</h2>
|
|
<p>As if the encryption and XOR wasn't enough, card IDs also contain a checksum to make <i>absolutely</i> sure the
|
|
card is valid. I could explain in words how the checksum works, but that's probably not very useful. Have a
|
|
pseudocode snippet instead:</p>
|
|
<pre><code>checksum(bytes):
|
|
chk = 0
|
|
for i from 0 to 14 inclusive:
|
|
chk += bytes[i] * (i % 3 + 1)
|
|
|
|
while chk > 31:
|
|
chk = (chk >> 5) + (chk & 31)
|
|
|
|
return chk</code></pre>
|
|
|
|
<h2 id="des">The DES scheme used</h2>
|
|
<p>For whatever reason, Bemani decided that IDs should be encrypted. Thankfully however they used triple DES, which
|
|
almost certainly has an existing implementation in your language of choice. It is triple DES, in CBC mode, with
|
|
a totally null <code>IV</code>. The key is quite easy to find if you hit the right binaries with
|
|
<code>strings</code>. <span style="color: white">Alternatively, check the source of this page.</span> The key
|
|
contains characters that are all within the ASCII range. Before we can use it with DES, the value of every byte
|
|
needs doubled. This was presumably done to give the values more range, but I sincerely doubt it adds any
|
|
additional security.
|
|
</p>
|
|
<!-- soundvoltex.dll:0x102d3e2d -->
|
|
<details>
|
|
<summary>I'm curious how Bemani implemented this in their own code!</summary>
|
|
<p>Curiosity is a great thing. Unfortunately, this is code that is implement within the game specific DLL files.
|
|
If you happen to have SDXV 4 in front of you too, head over over to <code>soundvoltex.dll:0x1027316f</code>
|
|
and you should see everything you need.
|
|
</p>
|
|
<p>As part of breaking down how this all works, I produced a more or less line-for-line Python port of the game
|
|
code, for testing, validation, etc.. It's not especially pretty, but should give you an idea of how it works
|
|
under the hood. One interesting observation is that it looks like the initial and final permutation steps
|
|
were inlined. It's also possible that they did the whole thing with macros rather than inline functions.
|
|
Either way, my python port didn't do any cleaning up, because we can just use a DES library.</p>
|
|
<details>
|
|
<summary>Show me that!</summary>
|
|
<pre>{% highlight "python" %}DES_KEYMAP = [
|
|
[0x02080008, 0x02082000, 0x00002008, 0x00000000, 0x02002000, 0x00080008, 0x02080000, 0x02082008, 0x00000008, 0x02000000, 0x00082000, 0x00002008, 0x00082008, 0x02002008, 0x02000008, 0x02080000, 0x00002000, 0x00082008, 0x00080008, 0x02002000, 0x02082008, 0x02000008, 0x00000000, 0x00082000, 0x02000000, 0x00080000, 0x02002008, 0x02080008, 0x00080000, 0x00002000, 0x02082000, 0x00000008, 0x00080000, 0x00002000, 0x02000008, 0x02082008, 0x00002008, 0x02000000, 0x00000000, 0x00082000, 0x02080008, 0x02002008, 0x02002000, 0x00080008, 0x02082000, 0x00000008, 0x00080008, 0x02002000, 0x02082008, 0x00080000, 0x02080000, 0x02000008, 0x00082000, 0x00002008, 0x02002008, 0x02080000, 0x00000008, 0x02082000, 0x00082008, 0x00000000, 0x02000000, 0x02080008, 0x00002000, 0x00082008],
|
|
[0x08000004, 0x00020004, 0x00000000, 0x08020200, 0x00020004, 0x00000200, 0x08000204, 0x00020000, 0x00000204, 0x08020204, 0x00020200, 0x08000000, 0x08000200, 0x08000004, 0x08020000, 0x00020204, 0x00020000, 0x08000204, 0x08020004, 0x00000000, 0x00000200, 0x00000004, 0x08020200, 0x08020004, 0x08020204, 0x08020000, 0x08000000, 0x00000204, 0x00000004, 0x00020200, 0x00020204, 0x08000200, 0x00000204, 0x08000000, 0x08000200, 0x00020204, 0x08020200, 0x00020004, 0x00000000, 0x08000200, 0x08000000, 0x00000200, 0x08020004, 0x00020000, 0x00020004, 0x08020204, 0x00020200, 0x00000004, 0x08020204, 0x00020200, 0x00020000, 0x08000204, 0x08000004, 0x08020000, 0x00020204, 0x00000000, 0x00000200, 0x08000004, 0x08000204, 0x08020200, 0x08020000, 0x00000204, 0x00000004, 0x08020004],
|
|
[0x80040100, 0x01000100, 0x80000000, 0x81040100, 0x00000000, 0x01040000, 0x81000100, 0x80040000, 0x01040100, 0x81000000, 0x01000000, 0x80000100, 0x81000000, 0x80040100, 0x00040000, 0x01000000, 0x81040000, 0x00040100, 0x00000100, 0x80000000, 0x00040100, 0x81000100, 0x01040000, 0x00000100, 0x80000100, 0x00000000, 0x80040000, 0x01040100, 0x01000100, 0x81040000, 0x81040100, 0x00040000, 0x81040000, 0x80000100, 0x00040000, 0x81000000, 0x00040100, 0x01000100, 0x80000000, 0x01040000, 0x81000100, 0x00000000, 0x00000100, 0x80040000, 0x00000000, 0x81040000, 0x01040100, 0x00000100, 0x01000000, 0x81040100, 0x80040100, 0x00040000, 0x81040100, 0x80000000, 0x01000100, 0x80040100, 0x80040000, 0x00040100, 0x01040000, 0x81000100, 0x80000100, 0x01000000, 0x81000000, 0x01040100],
|
|
[0x04010801, 0x00000000, 0x00010800, 0x04010000, 0x04000001, 0x00000801, 0x04000800, 0x00010800, 0x00000800, 0x04010001, 0x00000001, 0x04000800, 0x00010001, 0x04010800, 0x04010000, 0x00000001, 0x00010000, 0x04000801, 0x04010001, 0x00000800, 0x00010801, 0x04000000, 0x00000000, 0x00010001, 0x04000801, 0x00010801, 0x04010800, 0x04000001, 0x04000000, 0x00010000, 0x00000801, 0x04010801, 0x00010001, 0x04010800, 0x04000800, 0x00010801, 0x04010801, 0x00010001, 0x04000001, 0x00000000, 0x04000000, 0x00000801, 0x00010000, 0x04010001, 0x00000800, 0x04000000, 0x00010801, 0x04000801, 0x04010800, 0x00000800, 0x00000000, 0x04000001, 0x00000001, 0x04010801, 0x00010800, 0x04010000, 0x04010001, 0x00010000, 0x00000801, 0x04000800, 0x04000801, 0x00000001, 0x04010000, 0x00010800],
|
|
[0x00000400, 0x00000020, 0x00100020, 0x40100000, 0x40100420, 0x40000400, 0x00000420, 0x00000000, 0x00100000, 0x40100020, 0x40000020, 0x00100400, 0x40000000, 0x00100420, 0x00100400, 0x40000020, 0x40100020, 0x00000400, 0x40000400, 0x40100420, 0x00000000, 0x00100020, 0x40100000, 0x00000420, 0x40100400, 0x40000420, 0x00100420, 0x40000000, 0x40000420, 0x40100400, 0x00000020, 0x00100000, 0x40000420, 0x00100400, 0x40100400, 0x40000020, 0x00000400, 0x00000020, 0x00100000, 0x40100400, 0x40100020, 0x40000420, 0x00000420, 0x00000000, 0x00000020, 0x40100000, 0x40000000, 0x00100020, 0x00000000, 0x40100020, 0x00100020, 0x00000420, 0x40000020, 0x00000400, 0x40100420, 0x00100000, 0x00100420, 0x40000000, 0x40000400, 0x40100420, 0x40100000, 0x00100420, 0x00100400, 0x40000400],
|
|
[0x00800000, 0x00001000, 0x00000040, 0x00801042, 0x00801002, 0x00800040, 0x00001042, 0x00801000, 0x00001000, 0x00000002, 0x00800002, 0x00001040, 0x00800042, 0x00801002, 0x00801040, 0x00000000, 0x00001040, 0x00800000, 0x00001002, 0x00000042, 0x00800040, 0x00001042, 0x00000000, 0x00800002, 0x00000002, 0x00800042, 0x00801042, 0x00001002, 0x00801000, 0x00000040, 0x00000042, 0x00801040, 0x00801040, 0x00800042, 0x00001002, 0x00801000, 0x00001000, 0x00000002, 0x00800002, 0x00800040, 0x00800000, 0x00001040, 0x00801042, 0x00000000, 0x00001042, 0x00800000, 0x00000040, 0x00001002, 0x00800042, 0x00000040, 0x00000000, 0x00801042, 0x00801002, 0x00801040, 0x00000042, 0x00001000, 0x00001040, 0x00801002, 0x00800040, 0x00000042, 0x00000002, 0x00001042, 0x00801000, 0x00800002],
|
|
[0x10400000, 0x00404010, 0x00000010, 0x10400010, 0x10004000, 0x00400000, 0x10400010, 0x00004010, 0x00400010, 0x00004000, 0x00404000, 0x10000000, 0x10404010, 0x10000010, 0x10000000, 0x10404000, 0x00000000, 0x10004000, 0x00404010, 0x00000010, 0x10000010, 0x10404010, 0x00004000, 0x10400000, 0x10404000, 0x00400010, 0x10004010, 0x00404000, 0x00004010, 0x00000000, 0x00400000, 0x10004010, 0x00404010, 0x00000010, 0x10000000, 0x00004000, 0x10000010, 0x10004000, 0x00404000, 0x10400010, 0x00000000, 0x00404010, 0x00004010, 0x10404000, 0x10004000, 0x00400000, 0x10404010, 0x10000000, 0x10004010, 0x10400000, 0x00400000, 0x10404010, 0x00004000, 0x00400010, 0x10400010, 0x00004010, 0x00400010, 0x00000000, 0x10404000, 0x10000010, 0x10400000, 0x10004010, 0x00000010, 0x00404000],
|
|
[0x00208080, 0x00008000, 0x20200000, 0x20208080, 0x00200000, 0x20008080, 0x20008000, 0x20200000, 0x20008080, 0x00208080, 0x00208000, 0x20000080, 0x20200080, 0x00200000, 0x00000000, 0x20008000, 0x00008000, 0x20000000, 0x00200080, 0x00008080, 0x20208080, 0x00208000, 0x20000080, 0x00200080, 0x20000000, 0x00000080, 0x00008080, 0x20208000, 0x00000080, 0x20200080, 0x20208000, 0x00000000, 0x00000000, 0x20208080, 0x00200080, 0x20008000, 0x00208080, 0x00008000, 0x20000080, 0x00200080, 0x20208000, 0x00000080, 0x00008080, 0x20200000, 0x20008080, 0x20000000, 0x20200000, 0x00208000, 0x20208080, 0x00008080, 0x00208000, 0x20200080, 0x00200000, 0x20000080, 0x20008000, 0x00000000, 0x00008000, 0x00200000, 0x20200080, 0x00208080, 0x20000000, 0x20208000, 0x00000080, 0x20008080]
|
|
]
|
|
|
|
DES_ROTORS = [0x22, 0x0D, 0x05, 0x2E, 0x2F, 0x12, 0x20, 0x29, 0x0B, 0x35, 0x21, 0x14, 0x0E, 0x24, 0x1E, 0x18, 0x31, 0x02, 0x0F, 0x25, 0x2A, 0x32, 0x00, 0x15, 0x26, 0x30, 0x06, 0x1A, 0x27, 0x04, 0x34, 0x19, 0x0C, 0x1B, 0x1F, 0x28, 0x01, 0x11, 0x1C, 0x1D, 0x17, 0x33, 0x23, 0x07, 0x03, 0x16, 0x09, 0x2B, 0x29, 0x14, 0x0C, 0x35, 0x36, 0x19, 0x27, 0x30, 0x12, 0x1F, 0x28, 0x1B, 0x15, 0x2B, 0x25, 0x00, 0x01, 0x09, 0x16, 0x2C, 0x31, 0x02, 0x07, 0x1C, 0x2D, 0x37, 0x0D, 0x21, 0x2E, 0x0B, 0x06, 0x20, 0x13, 0x22, 0x26, 0x2F, 0x08, 0x18, 0x23, 0x24, 0x1E, 0x03, 0x2A, 0x0E, 0x0A, 0x1D, 0x10, 0x32, 0x37, 0x22, 0x1A, 0x26, 0x0B, 0x27, 0x35, 0x05, 0x20, 0x2D, 0x36, 0x29, 0x23, 0x02, 0x33, 0x0E, 0x0F, 0x17, 0x24, 0x03, 0x08, 0x10, 0x15, 0x2A, 0x06, 0x0C, 0x1B, 0x2F, 0x1F, 0x19, 0x14, 0x2E, 0x21, 0x30, 0x34, 0x04, 0x16, 0x07, 0x31, 0x32, 0x2C, 0x11, 0x01, 0x1C, 0x18, 0x2B, 0x1E, 0x09, 0x0C, 0x30, 0x28, 0x34, 0x19, 0x35, 0x26, 0x13, 0x2E, 0x06, 0x0B, 0x37, 0x31, 0x10, 0x0A, 0x1C, 0x1D, 0x25, 0x32, 0x11, 0x16, 0x1E, 0x23, 0x01, 0x14, 0x1A, 0x29, 0x04, 0x2D, 0x27, 0x22, 0x1F, 0x2F, 0x05, 0x0D, 0x12, 0x24, 0x15, 0x08, 0x09, 0x03, 0x00, 0x0F, 0x2A, 0x07, 0x02, 0x2C, 0x17, 0x1A, 0x05, 0x36, 0x0D, 0x27, 0x26, 0x34, 0x21, 0x1F, 0x14, 0x19, 0x0C, 0x08, 0x1E, 0x18, 0x2A, 0x2B, 0x33, 0x09, 0x00, 0x24, 0x2C, 0x31, 0x0F, 0x22, 0x28, 0x37, 0x12, 0x06, 0x35, 0x30, 0x2D, 0x04, 0x13, 0x1B, 0x20, 0x32, 0x23, 0x16, 0x17, 0x11, 0x0E, 0x1D, 0x01, 0x15, 0x10, 0x03, 0x25, 0x28, 0x13, 0x0B, 0x1B, 0x35, 0x34, 0x0D, 0x2F, 0x2D, 0x22, 0x27, 0x1A, 0x16, 0x2C, 0x07, 0x01, 0x02, 0x0A, 0x17, 0x0E, 0x32, 0x03, 0x08, 0x1D, 0x30, 0x36, 0x0C, 0x20, 0x14, 0x26, 0x05, 0x06, 0x12, 0x21, 0x29, 0x2E, 0x09, 0x31, 0x24, 0x25, 0x00, 0x1C, 0x2B, 0x0F, 0x23, 0x1E, 0x11, 0x33, 0x36, 0x21, 0x19, 0x29, 0x26, 0x0D, 0x1B, 0x04, 0x06, 0x30, 0x35, 0x28, 0x24, 0x03, 0x15, 0x0F, 0x10, 0x18, 0x25, 0x1C, 0x09, 0x11, 0x16, 0x2B, 0x05, 0x0B, 0x1A, 0x2E, 0x22, 0x34, 0x13, 0x14, 0x20, 0x2F, 0x37, 0x1F, 0x17, 0x08, 0x32, 0x33, 0x0E, 0x2A, 0x02, 0x1D, 0x31, 0x2C, 0x00, 0x0A, 0x0B, 0x2F, 0x27, 0x37, 0x34, 0x1B, 0x29, 0x12, 0x14, 0x05, 0x26, 0x36, 0x32, 0x11, 0x23, 0x1D, 0x1E, 0x07, 0x33, 0x2A, 0x17, 0x00, 0x24, 0x02, 0x13, 0x19, 0x28, 0x1F, 0x30, 0x0D, 0x21, 0x22, 0x2E, 0x04, 0x0C, 0x2D, 0x25, 0x16, 0x09, 0x0A, 0x1C, 0x01, 0x10, 0x2B, 0x08, 0x03, 0x0E, 0x18, 0x12, 0x36, 0x2E, 0x05, 0x06, 0x22, 0x30, 0x19, 0x1B, 0x0C, 0x2D, 0x04, 0x02, 0x18, 0x2A, 0x24, 0x25, 0x0E, 0x03, 0x31, 0x1E, 0x07, 0x2B, 0x09, 0x1A, 0x20, 0x2F, 0x26, 0x37, 0x14, 0x28, 0x29, 0x35, 0x0B, 0x13, 0x34, 0x2C, 0x1D, 0x10, 0x11, 0x23, 0x08, 0x17, 0x32, 0x0F, 0x0A, 0x15, 0x00, 0x20, 0x0B, 0x1F, 0x13, 0x14, 0x30, 0x05, 0x27, 0x29, 0x1A, 0x06, 0x12, 0x10, 0x07, 0x01, 0x32, 0x33, 0x1C, 0x11, 0x08, 0x2C, 0x15, 0x02, 0x17, 0x28, 0x2E, 0x04, 0x34, 0x0C, 0x22, 0x36, 0x37, 0x26, 0x19, 0x21, 0x0D, 0x03, 0x2B, 0x1E, 0x00, 0x31, 0x16, 0x25, 0x09, 0x1D, 0x18, 0x23, 0x0E, 0x2E, 0x19, 0x2D, 0x21, 0x22, 0x05, 0x13, 0x35, 0x37, 0x28, 0x14, 0x20, 0x1E, 0x15, 0x0F, 0x09, 0x0A, 0x2A, 0x00, 0x16, 0x03, 0x23, 0x10, 0x25, 0x36, 0x1F, 0x12, 0x0D, 0x1A, 0x30, 0x0B, 0x0C, 0x34, 0x27, 0x2F, 0x1B, 0x11, 0x02, 0x2C, 0x0E, 0x08, 0x24, 0x33, 0x17, 0x2B, 0x07, 0x31, 0x1C, 0x1F, 0x27, 0x06, 0x2F, 0x30, 0x13, 0x21, 0x26, 0x0C, 0x36, 0x22, 0x2E, 0x2C, 0x23, 0x1D, 0x17, 0x18, 0x01, 0x0E, 0x24, 0x11, 0x31, 0x1E, 0x33, 0x0B, 0x2D, 0x20, 0x1B, 0x28, 0x05, 0x19, 0x1A, 0x0D, 0x35, 0x04, 0x29, 0x00, 0x10, 0x03, 0x1C, 0x16, 0x32, 0x0A, 0x25, 0x02, 0x15, 0x08, 0x2A, 0x2D, 0x35, 0x14, 0x04, 0x05, 0x21, 0x2F, 0x34, 0x1A, 0x0B, 0x30, 0x1F, 0x03, 0x31, 0x2B, 0x25, 0x07, 0x0F, 0x1C, 0x32, 0x00, 0x08, 0x2C, 0x0A, 0x19, 0x06, 0x2E, 0x29, 0x36, 0x13, 0x27, 0x28, 0x1B, 0x26, 0x12, 0x37, 0x0E, 0x1E, 0x11, 0x2A, 0x24, 0x09, 0x18, 0x33, 0x10, 0x23, 0x16, 0x01, 0x06, 0x26, 0x22, 0x12, 0x13, 0x2F, 0x04, 0x0D, 0x28, 0x19, 0x05, 0x2D, 0x11, 0x08, 0x02, 0x33, 0x15, 0x1D, 0x2A, 0x09, 0x0E, 0x16, 0x03, 0x18, 0x27, 0x14, 0x1F, 0x37, 0x0B, 0x21, 0x35, 0x36, 0x29, 0x34, 0x20, 0x0C, 0x1C, 0x2C, 0x00, 0x01, 0x32, 0x17, 0x07, 0x0A, 0x1E, 0x31, 0x24, 0x0F, 0x14, 0x34, 0x30, 0x20, 0x21, 0x04, 0x12, 0x1B, 0x36, 0x27, 0x13, 0x06, 0x00, 0x16, 0x10, 0x0A, 0x23, 0x2B, 0x01, 0x17, 0x1C, 0x24, 0x11, 0x07, 0x35, 0x22, 0x2D, 0x0C, 0x19, 0x2F, 0x26, 0x0B, 0x37, 0x0D, 0x2E, 0x1A, 0x2A, 0x03, 0x0E, 0x0F, 0x09, 0x25, 0x15, 0x18, 0x2C, 0x08, 0x32, 0x1D, 0x1B, 0x06, 0x37, 0x27, 0x28, 0x0B, 0x19, 0x22, 0x04, 0x2E, 0x1A, 0x0D, 0x07, 0x1D, 0x17, 0x11, 0x2A, 0x32, 0x08, 0x1E, 0x23, 0x2B, 0x18, 0x0E, 0x1F, 0x29, 0x34, 0x13, 0x20, 0x36, 0x2D, 0x12, 0x05, 0x14, 0x35, 0x21, 0x31, 0x0A, 0x15, 0x16, 0x10, 0x2C, 0x1C, 0x00, 0x33, 0x0F, 0x02, 0x24]
|
|
byte_102D4AA0 = [0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x1B, 0x1A, 0x19, 0x18, 0x17, 0x16, 0x13, 0x12, 0x11, 0x10, 0x0F, 0x0E, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x03, 0x02, 0x01, 0x00, 0x1F, 0x1E]
|
|
|
|
KEY_DATA = [0] * 96
|
|
|
|
|
|
def roll_right(arg2, arg3):
|
|
return (arg2 << 32 - arg3 | (arg2 >> arg3)) & 0xffffffff
|
|
|
|
|
|
def des_small_flips_encrypt(key, output, uid):
|
|
v3 = uid[0] | (uid[1] << 8) | (uid[2] << 16) | (uid[3] << 24)
|
|
v0 = uid[4] | (uid[5] << 8) | (uid[6] << 16) | (uid[7] << 24)
|
|
v4 = (16 * ((v3 ^ (v0 >> 4)) & 0xF0F0F0F)) ^ v0
|
|
v5 = (v3 ^ (v0 >> 4)) & 0xF0F0F0F ^ v3
|
|
v6 = (v4 ^ (v5 >> 16)) & 0xffff
|
|
v7 = (v6 << 16) ^ v5
|
|
v8 = v6 ^ v4
|
|
v9 = (v7 ^ (v8 >> 2)) & 0x33333333
|
|
v10 = (4 * v9) ^ v8
|
|
v11 = v9 ^ v7
|
|
v12 = (v10 ^ (v11 >> 8)) & 0xFF00FF
|
|
v13 = (v12 << 8) ^ v11
|
|
v14 = roll_right(v12 ^ v10, 1)
|
|
v15 = (v13 ^ v14) & 0x55555555
|
|
v16 = v15 ^ v14
|
|
v17 = roll_right(v15 ^ v13, 1)
|
|
|
|
for i in range(0, 32, 4):
|
|
v19 = roll_right(v17 ^ key[i + 1], 28)
|
|
v16 ^= (0
|
|
^ DES_KEYMAP[0][((v17 ^ key[i]) >> 26) & 0x3f]
|
|
^ DES_KEYMAP[1][((v17 ^ key[i]) >> 18) & 0x3f]
|
|
^ DES_KEYMAP[2][(((v17 ^ key[i]) >> 8) >> 2) & 0x3f]
|
|
^ DES_KEYMAP[3][((v17 ^ key[i]) >> 2) & 0x3f]
|
|
^ DES_KEYMAP[4][(v19 >> 26) & 0x3f]
|
|
^ DES_KEYMAP[5][(v19 >> 18) & 0x3f]
|
|
^ DES_KEYMAP[6][(v19 >> 10) & 0x3f]
|
|
^ DES_KEYMAP[7][(v19 >> 2) & 0x3f]
|
|
)
|
|
v20 = roll_right(v16 ^ key[i + 3], 28)
|
|
v17 ^= (0
|
|
^ DES_KEYMAP[0][((v16 ^ key[i + 2]) >> 26) & 0x3f]
|
|
^ DES_KEYMAP[1][((v16 ^ key[i + 2]) >> 18) & 0x3F]
|
|
^ DES_KEYMAP[2][(((v16 ^ key[i + 2]) >> 8) >> 2) & 0x3f]
|
|
^ DES_KEYMAP[3][((v16 ^ key[i + 2]) >> 2) & 0x3F]
|
|
^ DES_KEYMAP[4][(v20 >> 26) & 0x3f]
|
|
^ DES_KEYMAP[5][(v20 >> 18) & 0x3F]
|
|
^ DES_KEYMAP[6][(v20 >> 10) & 0x3f]
|
|
^ DES_KEYMAP[7][(v20 >> 2) & 0x3f]
|
|
)
|
|
v21 = roll_right(v16, 31)
|
|
v22 = (v17 ^ v21) & 0x55555555
|
|
v23 = v22 ^ v21
|
|
v24 = roll_right(v22 ^ v17, 31)
|
|
v25 = (v24 ^ (v23 >> 8)) & 0xFF00FF
|
|
v26 = (v25 << 8) ^ v23
|
|
v27 = v25 ^ v24
|
|
v28 = (v26 ^ ((v25 ^ v24) >> 2)) & 0x33333333
|
|
v29 = (4 * v28) ^ v27
|
|
v30 = v28 ^ v26
|
|
v31 = (v29 ^ (v30 >> 16)) & 0xffff
|
|
v32 = ((v31 << 16) & 0xffffffff) ^ v30
|
|
v33 = v31 ^ v29
|
|
v34 = (v32 ^ (v33 >> 4)) & 0xF0F0F0F
|
|
v35 = (v34 << 4) ^ v33
|
|
v34 = v34 ^ v32
|
|
|
|
output[0] = v34 & 0xff
|
|
output[1] = (v34 >> 8) & 0xff
|
|
output[2] = (v34 >> 16) & 0xff
|
|
output[3] = (v34 >> 24) & 0xff
|
|
output[4] = v35 & 0xff
|
|
output[5] = (v35 >> 8) & 0xff
|
|
output[6] = (v35 >> 16) & 0xff
|
|
output[7] = (v35 >> 24) & 0xff
|
|
|
|
|
|
def des_small_flips_decrypt(key, output, uid):
|
|
v3 = uid[0] | (uid[1] << 8) | (uid[2] << 16) | (uid[3] << 24)
|
|
v0 = uid[4] | (uid[5] << 8) | (uid[6] << 16) | (uid[7] << 24)
|
|
v4 = (16 * ((v3 ^ (v0 >> 4)) & 0xF0F0F0F)) ^ v0
|
|
v5 = (v3 ^ (v0 >> 4)) & 0xF0F0F0F ^ v3
|
|
v6 = (v4 ^ (v5 >> 16)) & 0xffff
|
|
v7 = (v6 << 16) ^ v5
|
|
v8 = v6 ^ v4
|
|
v9 = (v7 ^ (v8 >> 2)) & 0x33333333
|
|
v10 = (4 * v9) ^ v8
|
|
v11 = v9 ^ v7
|
|
v12 = (v10 ^ (v11 >> 8)) & 0xFF00FF
|
|
v13 = (v12 << 8) ^ v11
|
|
v14 = roll_right(v12 ^ v10, 1)
|
|
v15 = (v13 ^ v14) & 0x55555555
|
|
v16 = v15 ^ v14
|
|
v17 = roll_right(v15 ^ v13, 1)
|
|
|
|
for i in range(0, 32, 4):
|
|
v19 = roll_right(v17 ^ key[(31 - i)], 28)
|
|
v16 ^= (0
|
|
^ DES_KEYMAP[0][((v17 ^ key[(30 - i)]) >> 26) & 0x3f]
|
|
^ DES_KEYMAP[1][((v17 ^ key[(30 - i)]) >> 18) & 0x3F]
|
|
^ DES_KEYMAP[2][(((v17 ^ key[(30 - i)]) >> 8) >> 2) & 0x3f]
|
|
^ DES_KEYMAP[3][((v17 ^ key[(30 - i)]) >> 2) & 0x3F]
|
|
^ DES_KEYMAP[4][(v19 >> 26) & 0x3f]
|
|
^ DES_KEYMAP[5][(v19 >> 18) & 0x3F]
|
|
^ DES_KEYMAP[6][(v19 >> 10) & 0x3f]
|
|
^ DES_KEYMAP[7][(v19 >> 2) & 0x3f]
|
|
)
|
|
v20 = roll_right(v16 ^ key[(29 - i)], 28)
|
|
v17 ^= (0
|
|
^ DES_KEYMAP[0][((v16 ^ key[(28 - i)]) >> 26) & 0x3f]
|
|
^ DES_KEYMAP[1][((v16 ^ key[(28 - i)]) >> 18) & 0x3F]
|
|
^ DES_KEYMAP[2][(((v16 ^ key[(28 - i)]) >> 8) >> 2) & 0x3f]
|
|
^ DES_KEYMAP[3][((v16 ^ key[(28 - i)]) >> 2) & 0x3F]
|
|
^ DES_KEYMAP[4][(v20 >> 26) & 0x3f]
|
|
^ DES_KEYMAP[5][(v20 >> 18) & 0x3f]
|
|
^ DES_KEYMAP[6][(v20 >> 10) & 0x3f]
|
|
^ DES_KEYMAP[7][(v20 >> 2) & 0x3f]
|
|
)
|
|
|
|
v21 = roll_right(v16, 31)
|
|
v22 = (v17 ^ v21) & 0x55555555
|
|
v23 = v22 ^ v21
|
|
v24 = roll_right(v22 ^ v17, 31)
|
|
v25 = (v24 ^ (v23 >> 8)) & 0xFF00FF
|
|
v26 = (v25 << 8) ^ v23
|
|
v27 = v25 ^ v24
|
|
v28 = (v26 ^ ((v25 ^ v24) >> 2)) & 0x33333333
|
|
v29 = (4 * v28) ^ v27
|
|
v30 = v28 ^ v26
|
|
v31 = (v29 ^ (v30 >> 16)) & 0xffff
|
|
v32 = (v31 << 16) ^ v30
|
|
v33 = v31 ^ v29
|
|
v34 = (v32 ^ (v33 >> 4)) & 0xF0F0F0F
|
|
v35 = (v34 << 4) ^ v33
|
|
v34 = v34 ^ v32
|
|
|
|
output[0] = v34 & 0xff
|
|
output[1] = (v34 >> 8) & 0xff
|
|
output[2] = (v34 >> 16) & 0xff
|
|
output[3] = (v34 >> 24) & 0xff
|
|
output[4] = v35 & 0xff
|
|
output[5] = (v35 >> 8) & 0xff
|
|
output[6] = (v35 >> 16) & 0xff
|
|
output[7] = (v35 >> 24) & 0xff
|
|
|
|
|
|
def des3_encryption(key, kid_out, uid):
|
|
des_small_flips_encrypt(key, kid_out, uid)
|
|
des_small_flips_decrypt(key[32:], kid_out, kid_out)
|
|
des_small_flips_encrypt(key[64:], kid_out, kid_out)
|
|
|
|
|
|
def des_setkey(key, offset, out):
|
|
b1 = bytearray(56);
|
|
|
|
for i in range(8):
|
|
v3 = out[i]
|
|
for j in range(7):
|
|
b1[-7 * i - j + 55] = (v3 >> (j + 1)) & 1
|
|
|
|
for i in range(32):
|
|
v5 = 0
|
|
for j in range(24):
|
|
v5 |= b1[DES_ROTORS[24 * i + j]] << byte_102D4AA0[24 * (i & 1) + j]
|
|
|
|
key[offset + i] = v5
|
|
|
|
|
|
def des3_setkey(key, out):
|
|
for i in range(3):
|
|
des_setkey(key, 32 * i, out[8 * i:])
|
|
|
|
|
|
def load_key(key):
|
|
key_data = bytearray(24)
|
|
for i in range(24):
|
|
key_data[i] = 2 * key[i % len(key)]
|
|
des3_setkey(KEY_DATA, key_data){% endhighlight %}</pre>
|
|
</details>
|
|
</details>
|
|
{% endblock %} |