Cool_Tools/bemaniutils
1
0
Fork 0
mirror of synced 2024-11-24 14:30:11 +01:00
Code Releases Activity
d6cddebe88
bemaniutils/bemani/common/card.py

542 lines
21 KiB
Python
Raw Normal View History

Fix compatibility with python < 3.8 by switching from typing.Final to typing_extensions.Final
2021-06-07 07:46:39 +02:00
from typing import Dict, List
from typing_extensions import Final
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
class CardCipherException(Exception):
pass
class CardCipher:
"""
Algorithm for converting between the Card ID as stored in an
eAmusement card and the 16 character card string as shown on
the back of a card and in-game. All of this was kindly RE'd by
Tau and converted ham-fistedly to Python.
"""
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
KEY: Final[List[int]] = [
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
0x20d0d03c, 0x868ecb41, 0xbcd89c84, 0x4c0e0d0d,
0x84fc30ac, 0x4cc1890e, 0xfc5418a4, 0x02c50f44,
0x68acb4e0, 0x06cd4a4e, 0xcc28906c, 0x4f0c8ac0,
0xb03ca468, 0x884ac7c4, 0x389490d8, 0xcf80c6c2,
0x58d87404, 0xc48ec444, 0xb4e83c50, 0x498d0147,
0x64f454c0, 0x4c4701c8, 0xec302cc4, 0xc6c949c1,
0xc84c00f0, 0xcdcc49cc, 0x883c5cf4, 0x8b0fcb80,
0x703cc0b0, 0xcb820a8d, 0x78804c8c, 0x4fca830e,
0x80d0f03c, 0x8ec84f8c, 0x98c89c4c, 0xc80d878f,
0x54bc949c, 0xc801c5ce, 0x749078dc, 0xc3c80d46,
0x2c8070f0, 0x0cce4dcf, 0x8c3874e4, 0x8d448ac3,
0x987cac70, 0xc0c20ac5, 0x288cfc78, 0xc28543c8,
0x4c8c7434, 0xc50e4f8d, 0x8468f4b4, 0xcb4a0307,
0x2854dc98, 0x48430b45, 0x6858fce8, 0x4681cd49,
0xd04808ec, 0x458d0fcb, 0xe0a48ce4, 0x880f8fce,
0x7434b8fc, 0xce080a8e, 0x5860fc6c, 0x46c886cc,
0xd01098a4, 0xce090b8c, 0x1044cc2c, 0x86898e0f,
0xd0809c3c, 0x4a05860f, 0x54b4f80c, 0x4008870e,
0x1480b88c, 0x0ac8854f, 0x1c9034cc, 0x08444c4e,
0x0cb83c64, 0x41c08cc6, 0x1c083460, 0xc0c603ce,
0x2ca0645c, 0x818246cb, 0x0408e454, 0xc5464487,
0x88607c18, 0xc1424187, 0x284c7c90, 0xc1030509,
0x40486c94, 0x4603494b, 0xe0404ce4, 0x4109094d,
0x60443ce4, 0x4c0b8b8d, 0xe054e8bc, 0x02008e89,
]
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
LUT_A0: Final[List[int]] = [
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
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,
]
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
LUT_A1: Final[List[int]] = [
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
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,
]
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
LUT_A2: Final[List[int]] = [
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
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,
]
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
LUT_A3: Final[List[int]] = [
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
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,
]
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
LUT_B0: Final[List[int]] = [
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
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,
]
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
LUT_B1: Final[List[int]] = [
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
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,
]
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
LUT_B2: Final[List[int]] = [
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
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,
]
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
LUT_B3: Final[List[int]] = [
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
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,
]
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
VALID_CHARS: Final[str] = "0123456789ABCDEFGHJKLMNPRSTUWXYZ"
CONV_CHARS: Final[Dict[str, str]] = {
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
"I": "1",
"O": "0",
}
@staticmethod
def __type_from_cardid(cardid: str) -> int:
if cardid[:2].upper() == 'E0':
return 1
if cardid[:2].upper() == '01':
return 2
raise CardCipherException('Unrecognized card type')
@staticmethod
def encode(cardid: str) -> str:
"""
Given a card ID as stored on a card (Usually starting with E004), convert
it to the card string as shown on the back of the card.
Parameters:
cardid - 16 digit card ID (hex values stored as string).
Returns:
String representation of the card string.
"""
if len(cardid) != 16:
raise CardCipherException(
Convert most of the format() string calls to f-strings using libcst. Exact commands run were: python3 -m libcst.tool codemod convert_format_to_fstring.ConvertFormatStringCommand . --no-format python3 setup.py build_ext --inplace
2020-01-07 22:29:07 +01:00
f'Expected 16-character card ID, got {len(cardid)}',
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
)
cardint = [int(cardid[i:(i + 2)], 16) for i in range(0, len(cardid), 2)]
# Reverse bytes
reverse = [0] * 8
for i in range(0, 8):
reverse[7 - i] = cardint[i]
# Encipher
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
ciphered = CardCipher._encode(bytes(reverse))
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
# Convert 8 x 8 bit bytes into 13 x 5 bit groups (sort of)
bits = [0] * 65
for i in range(0, 64):
bits[i] = (ciphered[i >> 3] >> (~i & 7)) & 1
groups = [0] * 16
for i in range(0, 13):
groups[i] = (
(bits[i * 5 + 0] << 4) |
(bits[i * 5 + 1] << 3) |
(bits[i * 5 + 2] << 2) |
(bits[i * 5 + 3] << 1) |
(bits[i * 5 + 4] << 0)
)
# Smear 13 groups out into 14 groups
groups[13] = 1
groups[0] ^= CardCipher.__type_from_cardid(cardid)
for i in range(0, 14):
groups[i] ^= groups[i - 1]
# Scheme field is 1 for old-style, 2 for felica cards
groups[14] = CardCipher.__type_from_cardid(cardid)
groups[15] = CardCipher.__checksum(groups)
# Convert to chars and return
return ''.join([CardCipher.VALID_CHARS[i] for i in groups])
@staticmethod
def decode(cardid: str) -> str:
"""
Given a card string as shown on the back of the card, return the card ID
as stored on the card itself. Does some sanitization to remove dashes,
spaces and convert confusing characters (1, L and 0, O) before converting.
Parameters:
cardid - String representation of the card string.
Returns:
16 digit card ID (hex values stored as string).
"""
# First sanitize the input
cardid = cardid.replace(' ', '')
cardid = cardid.replace('-', '')
cardid = cardid.upper()
for c in CardCipher.CONV_CHARS:
cardid = cardid.replace(c, CardCipher.CONV_CHARS[c])
if len(cardid) != 16:
raise CardCipherException(
Convert most of the format() string calls to f-strings using libcst. Exact commands run were: python3 -m libcst.tool codemod convert_format_to_fstring.ConvertFormatStringCommand . --no-format python3 setup.py build_ext --inplace
2020-01-07 22:29:07 +01:00
f'Expected 16-character card ID, got {len(cardid)}',
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
)
for c in cardid:
if c not in CardCipher.VALID_CHARS:
raise CardCipherException(
Convert most of the format() string calls to f-strings using libcst. Exact commands run were: python3 -m libcst.tool codemod convert_format_to_fstring.ConvertFormatStringCommand . --no-format python3 setup.py build_ext --inplace
2020-01-07 22:29:07 +01:00
f'Got unexpected character {c} in card ID',
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
)
# Convert chars to groups
groups = [0] * 16
for i in range(0, 16):
for j in range(0, 32):
if cardid[i] == CardCipher.VALID_CHARS[j]:
groups[i] = j
break
# Verify scheme and checksum
if (groups[14] != 1 and groups[14] != 2):
raise CardCipherException(
"Unrecognized card type"
)
if groups[15] != CardCipher.__checksum(groups):
raise CardCipherException(
"Bad card number"
)
# Un-smear 14 fields back into 13
for i in range(13, 0, -1):
groups[i] ^= groups[i - 1]
groups[0] ^= groups[14]
# Explode groups into bits
bits = [0] * 64
for i in range(0, 64):
bits[i] = (groups[int(i / 5)] >> (4 - (i % 5))) & 1
# Re-pack bits into eight bytes
ciphered = [0] * 8
for i in range(0, 64):
ciphered[int(i / 8)] |= bits[i] << (~i & 7)
# Decipher and reverse
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
deciphered = CardCipher._decode(bytes(ciphered))
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
reverse = [0] * 8
for i in range(0, 8):
reverse[i] = deciphered[7 - i]
def tohex(x: int) -> str:
h = hex(x)[2:]
while len(h) < 2:
h = '0' + h
return h.upper()
# Convert to a string, verify we have the same type
finalvalue = ''.join([tohex(v) for v in reverse])
if groups[14] != CardCipher.__type_from_cardid(finalvalue):
raise CardCipherException(
"Card type mismatch"
)
return finalvalue
@staticmethod
def __checksum(data: List[int]) -> int:
checksum = 0
for i in range(0, 15):
checksum += (i % 3 + 1) * data[i]
while checksum >= 0x20:
checksum = (checksum & 0x1F) + (checksum >> 5)
return checksum
@staticmethod
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
def _encode(inbytes: bytes) -> bytes:
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
if len(inbytes) != 8:
raise CardCipherException(
Convert most of the format() string calls to f-strings using libcst. Exact commands run were: python3 -m libcst.tool codemod convert_format_to_fstring.ConvertFormatStringCommand . --no-format python3 setup.py build_ext --inplace
2020-01-07 22:29:07 +01:00
f'Expected 8-byte input, got {len(inbytes)}',
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
)
inp = [b for b in inbytes]
out = [0] * 8
CardCipher.__from_int(out, CardCipher.__operatorA(0x00, CardCipher.__to_int(inp)))
CardCipher.__from_int(out, CardCipher.__operatorB(0x20, CardCipher.__to_int(out)))
CardCipher.__from_int(out, CardCipher.__operatorA(0x40, CardCipher.__to_int(out)))
return bytes(out)
@staticmethod
Additional typing fixes for safety and to be able to compile more code with mypyc.
2021-05-31 20:09:40 +02:00
def _decode(inbytes: bytes) -> bytes:
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
if len(inbytes) != 8:
raise CardCipherException(
Convert most of the format() string calls to f-strings using libcst. Exact commands run were: python3 -m libcst.tool codemod convert_format_to_fstring.ConvertFormatStringCommand . --no-format python3 setup.py build_ext --inplace
2020-01-07 22:29:07 +01:00
f'Expected 8-byte input, got {len(inbytes)}',
Initial commit of BEMANI Utilities to GitHub.
2019-12-08 22:43:49 +01:00
)
inp = [b for b in inbytes]
out = [0] * 8
CardCipher.__from_int(out, CardCipher.__operatorB(0x40, CardCipher.__to_int(inp)))
CardCipher.__from_int(out, CardCipher.__operatorA(0x20, CardCipher.__to_int(out)))
CardCipher.__from_int(out, CardCipher.__operatorB(0x00, CardCipher.__to_int(out)))
return bytes(out)
@staticmethod
def __to_int(data: List[int]) -> int:
inX = (
(data[0] & 0xFF) |
((data[1] & 0xFF) << 8) |
((data[2] & 0xFF) << 16) |
((data[3] & 0xFF) << 24)
)
inY = (
(data[4] & 0xFF) |
((data[5] & 0xFF) << 8) |
((data[6] & 0xFF) << 16) |
((data[7] & 0xFF) << 24)
)
v7 = ((((inX ^ (inY >> 4)) & 0xF0F0F0F) << 4) ^ inY) & 0xFFFFFFFF
v8 = (((inX ^ (inY >> 4)) & 0xF0F0F0F) ^ inX) & 0xFFFFFFFF
v9 = ((v7 ^ (v8 >> 16))) & 0x0000FFFF
v10 = (((v7 ^ (v8 >> 16)) << 16) ^ v8) & 0xFFFFFFFF
v11 = (v9 ^ v7) & 0xFFFFFFFF
v12 = (v10 ^ (v11 >> 2)) & 0x33333333
v13 = (v11 ^ (v12 << 2)) & 0xFFFFFFFF
v14 = (v12 ^ v10) & 0xFFFFFFFF
v15 = (v13 ^ (v14 >> 8)) & 0x00FF00FF
v16 = (v14 ^ (v15 << 8)) & 0xFFFFFFFF
v17 = CardCipher.__ror(v15 ^ v13, 1)
v18 = (v16 ^ v17) & 0x55555555
v3 = CardCipher.__ror(v18 ^ v16, 1)
v4 = (v18 ^ v17) & 0xFFFFFFFF
return ((v3 & 0xFFFFFFFF) << 32) | (v4 & 0xFFFFFFFF)
@staticmethod
def __from_int(data: List[int], state: int) -> None:
v3 = (state >> 32) & 0xFFFFFFFF
v4 = state & 0xFFFFFFFF
v22 = CardCipher.__ror(v4, 31)
v23 = (v3 ^ v22) & 0x55555555
v24 = (v23 ^ v22) & 0xFFFFFFFF
v25 = CardCipher.__ror(v23 ^ v3, 31)
v26 = (v25 ^ (v24 >> 8)) & 0x00FF00FF
v27 = (v24 ^ (v26 << 8)) & 0xFFFFFFFF
v28 = (v26 ^ v25) & 0xFFFFFFFF
v29 = ((v28 >> 2) ^ v27) & 0x33333333
v30 = ((v29 << 2) ^ v28) & 0xFFFFFFFF
v31 = (v29 ^ v27) & 0xFFFFFFFF
v32 = (v30 ^ (v31 >> 16)) & 0x0000FFFF
v33 = (v31 ^ (v32 << 16)) & 0xFFFFFFFF
v34 = (v32 ^ v30) & 0xFFFFFFFF
v35 = (v33 ^ (v34 >> 4)) & 0xF0F0F0F
outY = ((v35 << 4) ^ v34) & 0xFFFFFFFF
outX = (v35 ^ v33) & 0xFFFFFFFF
data[0] = outX & 0xFF
data[1] = (outX >> 8) & 0xFF
data[2] = (outX >> 16) & 0xFF
data[3] = (outX >> 24) & 0xFF
data[4] = outY & 0xFF
data[5] = (outY >> 8) & 0xFF
data[6] = (outY >> 16) & 0xFF
data[7] = (outY >> 24) & 0xFF
@staticmethod
def __operatorA(off: int, state: int) -> int:
v3 = (state >> 32) & 0xFFFFFFFF
v4 = state & 0xFFFFFFFF
for i in range(0, 32, 4):
v20 = CardCipher.__ror(v3 ^ CardCipher.KEY[off + i + 1], 28)
v4 ^= (
CardCipher.LUT_B0[(v20 >> 26) & 0x3F] ^
CardCipher.LUT_B1[(v20 >> 18) & 0x3F] ^
CardCipher.LUT_B2[(v20 >> 10) & 0x3F] ^
CardCipher.LUT_B3[(v20 >> 2) & 0x3F] ^
CardCipher.LUT_A0[((v3 ^ CardCipher.KEY[off + i]) >> 26) & 0x3F] ^
CardCipher.LUT_A1[((v3 ^ CardCipher.KEY[off + i]) >> 18) & 0x3F] ^
CardCipher.LUT_A2[((v3 ^ CardCipher.KEY[off + i]) >> 10) & 0x3F] ^
CardCipher.LUT_A3[((v3 ^ CardCipher.KEY[off + i]) >> 2) & 0x3F]
)
v21 = CardCipher.__ror(v4 ^ CardCipher.KEY[off + i + 3], 28)
v3 ^= (
CardCipher.LUT_B0[(v21 >> 26) & 0x3F] ^
CardCipher.LUT_B1[(v21 >> 18) & 0x3F] ^
CardCipher.LUT_B2[(v21 >> 10) & 0x3F] ^
CardCipher.LUT_B3[(v21 >> 2) & 0x3F] ^
CardCipher.LUT_A0[((v4 ^ CardCipher.KEY[off + i + 2]) >> 26) & 0x3F] ^
CardCipher.LUT_A1[((v4 ^ CardCipher.KEY[off + i + 2]) >> 18) & 0x3F] ^
CardCipher.LUT_A2[((v4 ^ CardCipher.KEY[off + i + 2]) >> 10) & 0x3F] ^
CardCipher.LUT_A3[((v4 ^ CardCipher.KEY[off + i + 2]) >> 2) & 0x3F]
)
return ((v3 & 0xFFFFFFFF) << 32) | (v4 & 0xFFFFFFFF)
@staticmethod
def __operatorB(off: int, state: int) -> int:
v3 = (state >> 32) & 0xFFFFFFFF
v4 = state & 0xFFFFFFFF
for i in range(0, 32, 4):
v20 = CardCipher.__ror(v3 ^ CardCipher.KEY[off + 31 - i], 28)
v4 ^= (
CardCipher.LUT_A0[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 26) & 0x3F] ^
CardCipher.LUT_A1[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 18) & 0x3F] ^
CardCipher.LUT_A2[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 10) & 0x3F] ^
CardCipher.LUT_A3[((v3 ^ CardCipher.KEY[off + 30 - i]) >> 2) & 0x3F] ^
CardCipher.LUT_B0[(v20 >> 26) & 0x3F] ^
CardCipher.LUT_B1[(v20 >> 18) & 0x3F] ^
CardCipher.LUT_B2[(v20 >> 10) & 0x3F] ^
CardCipher.LUT_B3[(v20 >> 2) & 0x3F]
)
v21 = CardCipher.__ror(v4 ^ CardCipher.KEY[off + 29 - i], 28)
v3 ^= (
CardCipher.LUT_A0[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 26) & 0x3F] ^
CardCipher.LUT_A1[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 18) & 0x3F] ^
CardCipher.LUT_A2[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 10) & 0x3F] ^
CardCipher.LUT_A3[((v4 ^ CardCipher.KEY[off + 28 - i]) >> 2) & 0x3F] ^
CardCipher.LUT_B0[(v21 >> 26) & 0x3F] ^
CardCipher.LUT_B1[(v21 >> 18) & 0x3F] ^
CardCipher.LUT_B2[(v21 >> 10) & 0x3F] ^
CardCipher.LUT_B3[(v21 >> 2) & 0x3F]
)
return ((v3 & 0xFFFFFFFF) << 32) | (v4 & 0xFFFFFFFF)
@staticmethod
def __ror(val: int, amount: int) -> int:
return ((val << (32 - amount)) & 0xFFFFFFFF) | ((val >> amount) & 0xFFFFFFFF)
Copy Permalink