Tendokyu/docs
1
0
Fork 0
mirror of https://gitea.tendokyu.moe/eamuse/docs.git synced 2024-11-12 01:10:48 +01:00
Code Issues Packages Projects Releases Wiki Activity
master
docs/kcf_gen.py
Bottersnike cc9bc6b717
Lol
2023-04-25 18:09:31 +01:00

454 lines
12 KiB
Python
Raw Permalink Blame History

import struct
import zlib
import re
import io
import os
from dataclasses import dataclass
from Crypto.Cipher import AES
SOURCE = "./kcf"
OUT = "templates/pages/sega/software/security/"
APPDATA_BINARY_LEN = 288 # RingEdge
APPDATA_BINARY_LEN2 = 416 # RingEdge 2
APPDATA_NU_BINARY_LEN = 112 # Nu
FUNCTION_TYPE = {
1: "Server (SV)",
2: "Satellite (ST)",
3: "Live (LV)",
4: "Terminal (??)",
5: "UNKNOWN:5",
11: "UNKNOWN:11",
12: "UNKNOWN:12",
21: "UNKNOWN:21",
22: "UNKNOWN:22",
98: "Standalone (??)",
}
PLATFORM = {
"AAM": "RingWide",
"AAL": "RingEdge",
"AAS": "RingEdge 2",
"AAR": "ELEFUN",
"AAV": "Nu",
"AAZ": "Nu Lv 3.1",
"AAW": "Nu SX",
"ACA": "ALLS X",
"ACB": "ALLS X2",
}
SF_DEVELOP = 1 << 0
SF_ALL_NET = 1 << 2
SF_DELIVER = 1 << 3
SF_BINDING = 1 << 4
SF_BILLING = 1 << 5
SF_RENTAL = 1 << 6
class Stream:
def __init__(self, stream):
self.stream = stream
def read(self, n):
return self.stream.read(n)
def seek(self, n):
self.stream.seek(n)
def crc32(self, nbytes):
start = self.stream.tell()
data = self.stream.read(nbytes)
self.stream.seek(start)
return zlib.crc32(data) & 0xffffffff
def skip(self, n):
self.read(n)
def unpack(self, fmt):
return struct.unpack("<" + fmt, self.stream.read(struct.calcsize(fmt)))
def u8(self):
return self.unpack("B")[0]
def u16(self):
return self.unpack("H")[0]
def u32(self):
return self.unpack("I")[0]
def ipv4(self):
return self.unpack("4B")
def ipv6(self):
return self.unpack("8H")
def str(self, n):
return self.unpack(f"{n}s")[0].decode("latin-1")
class AppData:
system_flag: int
function_type: int
region: int
platform_id: str
def parse_region(self):
if self.region == 0xFF:
return "ALL"
regions = []
if self.region & 1:
regions.append("JPN")
if self.region & 2:
regions.append("USA")
if self.region & 4:
regions.append("EXP")
if self.region & 8:
regions.append("CHN")
if self.region & ~(1 | 2 | 4 | 8):
regions.append(f"ex:{self.region}")
return "/".join(regions)
def parse_system_flag(self):
"""
[bit 0] Develop:
1: Key chip for development
0: Key chip for mass production
[bit 2] ALL.Net:
1: ON (use)
0: OFF (do not use)
[bit 3] Deliver (LAN installation):
1: Local FDC Server
0: Client
Ethernet network: Used & Mode: 1 only when server
[bit 4] Binding:
1: ON
0: OFF
* Not used in ELEFUN (= 0) (cannot be set as = 1)
[bit 5] Billing:
Requires ALL.Net to be ON
1: ON
0: OFF (no charge)
* Not used in ELEFUN (= 0) (cannot be set as = 1)
[bit 6] Rental (P-ras charging):
Requires ALL.Net to be ON
Requires Billing to be ON
* Not used in ELEFUN (= 0) (cannot be set as = 1)
1: P-ras billing (rental billing)
0: pay-as-you-go billing (net billing)
"""
parsed = []
if self.system_flag & 1:
parsed.append("Develop")
if self.system_flag & 2:
parsed.append("2")
if self.system_flag & 4:
parsed.append("ALL.Net")
if self.system_flag & 8:
parsed.append("Deliver")
if self.system_flag & 16:
parsed.append("Binding")
if self.system_flag & 32:
parsed.append("Billing")
if self.system_flag & 64:
parsed.append("Rental")
if self.system_flag & 128:
parsed.append("128")
return ",".join(parsed)
def parse_function_type(self):
return FUNCTION_TYPE[self.function_type]
def parse_platform_id(self):
return f"{PLATFORM[self.platform_id]} ({self.platform_id})"
@dataclass
class AppDataRing(AppData):
# Appboot
format_type: int
game_id: str
region: int
function_type: int
system_flag: int
platform_id: str
dvd_flag: int
network_addr: tuple[int]
# Misc
app_data: bytes
# Crypto
key: bytes
iv: bytes
seed: bytes
keyfile: bytes
# Misc (2)
extra: bytes
@dataclass
class AppDataNu(AppData):
# Appboot
format_type: int
game_id: str
region: int
function_type: int
system_flag: int
billing_form: int
platform_id: str
network_addr: tuple[int]
network_addr_6: tuple[int]
# Crypto
gkey: bytes
giv: bytes
okey: bytes
oiv: bytes
def scramble(val, a, b, c, d):
ret = bytearray(val)
ret[a], ret[b] = ret[b], ret[a]
ret[c], ret[d] = ret[d], ret[c]
return bytes(ret)
def parse_appdata_ring(stream: Stream):
crc = stream.u32() # idk how to make this pass. it doesn't match?
format_type = stream.u8()
stream.skip(3)
game_id = stream.str(4)
region = stream.u8()
function_type = stream.u8()
system_flag = stream.u8()
stream.skip(1)
platform_id = stream.str(3)
dvd_flag = stream.u8()
network_addr = stream.ipv4()
app_data = stream.read(216)
seed = scramble(stream.read(16), 1, 8, 12, 15)
key = scramble(stream.read(16), 0, 4, 2, 14)
iv = scramble(stream.read(16), 0, 11, 5, 15)
# AAL, AAS, AAR has:
extra = stream.read(128)
# For AAR, extra=FF....FF
# if extra and platform_id != 'AAR':
# print(extra[:64].hex(), platform_id, game_id, function_type)
cipher = AES.new(key, AES.MODE_CBC, iv)
keyfile = cipher.encrypt(seed)
return AppDataRing(
format_type, game_id, region, function_type, system_flag,
platform_id, dvd_flag, network_addr, app_data,
key, iv, seed, keyfile, extra
)
def parse_appdata_nu(stream: Stream):
crc = stream.u32()
format_type = stream.u8()
stream.skip(3)
game_id = stream.str(4)
region = stream.u8()
function_type = stream.u8()
system_flag = stream.u8()
billing_form = stream.u8()
platform_id = stream.str(3)
stream.skip(1)
network_addr = stream.ipv4()
stream.skip(8)
ipv6_addr = stream.ipv6()
gkey = stream.read(16)
giv = stream.read(16)
okey = stream.read(16)
oiv = stream.read(16)
return AppDataNu(
format_type, game_id, region, function_type, system_flag,
billing_form, platform_id, network_addr, ipv6_addr,
gkey, giv, okey, oiv
)
def format_row(*values, elem="td"):
return "<tr>" + "".join(f"<{elem}>{i}</{elem}>" for i in values) + "</tr>"
def format_code(code):
return f"<code>{code}</code>"
def parse_kcf(data):
kcf = io.BytesIO(data)
nbytes = len(data)
if nbytes == APPDATA_BINARY_LEN:
return parse_appdata_ring(Stream(kcf)), None
elif nbytes == APPDATA_BINARY_LEN2:
return parse_appdata_ring(Stream(kcf)), None
elif nbytes == APPDATA_NU_BINARY_LEN:
return None, parse_appdata_nu(Stream(kcf))
else:
raise ValueError
STYLES = """
<style>
body {
font-family: sans-serif;
}
table {
white-space: nowrap;
overflow-x: auto;
border-collapse: collapse;
}
th {
border-bottom: 3px solid #000;
position: sticky;
top: 0;
text-align: left;
background: #fff;
}
td {
border-bottom: 1px solid #ddd;
}
th, td {
border-left: 1px solid #ddd;
}
th:last-child, td:last-child {
border-right: 1px solid #ddd;
}
th, td {
margin: 0;
padding: 2px 4px;
}
</style>
"""
def gen_file_ring(path: str, platform: str, appdata: list[AppDataRing]):
with open(path, "w") as kcf_html:
print(STYLES, file=kcf_html)
print("<table><thead>", file=kcf_html)
print(format_row(
"Game ID", "Region", "Model Type",
"Develop Flag", "ALL.Net", "Deliver", "Binding", "Billing", "Rental",
"DVD Enabled", "Platform ID", "IPv4 Subnet",
"AES Key", "AES IV", "AppBoot Seed", "Keyfile",
"App Data", "Trailing Data",
elem="th"
), file=kcf_html)
print("</thead></tbody>", file=kcf_html)
appdata.sort(key=lambda x: (x.platform_id, x.network_addr, x.game_id, x.format_type, x.system_flag))
for i in appdata:
if i.platform_id != platform:
continue
print(format_row(
i.game_id,
i.parse_region(),
i.parse_function_type(),
"X" if i.system_flag & SF_DEVELOP else "",
"X" if i.system_flag & SF_ALL_NET else "",
"X" if i.system_flag & SF_DELIVER else "",
"X" if i.system_flag & SF_BINDING else "",
"X" if i.system_flag & SF_BILLING else "",
"X" if i.system_flag & SF_RENTAL else "",
"X" if i.dvd_flag else "",
i.parse_platform_id(),
".".join(map(str, i.network_addr)),
format_code(i.key.hex().upper()),
format_code(i.iv.hex().upper()),
format_code(i.seed.hex().upper()),
format_code(i.keyfile.hex().upper()),
""
if all(j == 0 for j in i.app_data)
else format_code(i.app_data.hex().upper()),
format_code(i.extra.hex().upper()),
), file=kcf_html)
print("</tbody></table>", file=kcf_html)
def main():
appdata_ring: list[AppDataRing] = []
appdata_nu: list[AppDataNu] = []
raw = set()
for i in os.listdir(SOURCE):
raw.add(open(os.path.join(SOURCE, i), "rb").read())
for i in raw:
ring, nu = parse_kcf(i)
if ring:
appdata_ring.append(ring)
if nu:
appdata_nu.append(nu)
gen_file_ring(OUT + "kcf-ringedge.html", "AAL", appdata_ring)
gen_file_ring(OUT + "kcf-ringwide.html", "AAM", appdata_ring)
gen_file_ring(OUT + "kcf-ringedge2.html", "AAS", appdata_ring)
gen_file_ring(OUT + "kcf-elefun.html", "AAR", appdata_ring)
with open(OUT + "kcf-nu.html", "w") as kcf_nu:
print(STYLES, file=kcf_nu)
print("<table><thead>", file=kcf_nu)
print(format_row(
"Game ID", "Region", "Model Type",
"Develop Flag", "ALL.Net", "Deliver", "Binding", "Billing", "Rental",
"Billing Form", "Platform ID",
"IPv4 Subnet", "IPv6 Subnet",
"Game Key", "Game IV", "Opt Key", "Opt IV",
elem="th"
), file=kcf_nu)
print("</thead></tbody>", file=kcf_nu)
appdata_nu.sort(key=lambda x: (x.platform_id, x.network_addr, x.game_id, x.format_type, x.system_flag))
for i in appdata_nu:
ipv6 = ":".join(f"{j:04x}" for j in i.network_addr_6)
ipv6 = re.sub(r"/(^(0000:?)+)|(:(0000:)+)|((:0000)+$)/", "::", ipv6)
print(format_row(
i.game_id,
i.parse_region(),
i.parse_function_type(),
"X" if i.system_flag & SF_DEVELOP else "",
"X" if i.system_flag & SF_ALL_NET else "",
"X" if i.system_flag & SF_DELIVER else "",
"X" if i.system_flag & SF_BINDING else "",
"X" if i.system_flag & SF_BILLING else "",
"X" if i.system_flag & SF_RENTAL else "",
i.billing_form,
i.parse_platform_id(),
".".join(map(str, i.network_addr)),
ipv6,
format_code(i.gkey.hex().upper()),
format_code(i.giv.hex().upper()),
format_code(i.okey.hex().upper()),
format_code(i.oiv.hex().upper()),
), file=kcf_nu)
print("</tbody></table>", file=kcf_nu)
if __name__ == "__main__":
main()
Reference in New Issue View Git Blame Copy Permalink