hashbro
120 lines
4.2 KiB
Python
120 lines
4.2 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
tglib_to_tdata.py — Convert tglib.js JSON payload to a Telegram Desktop tdata zip.
|
|
|
|
Usage:
|
|
python tglib_to_tdata.py <input.json> <output.zip>
|
|
|
|
Reads the tglib.js JSON (state + db_sqlite), extracts the master MTProto auth
|
|
key + DC id, builds a Telethon SQLite session, and uses opentele-ng to write a
|
|
tdata folder, then zips it.
|
|
|
|
Works fully offline — no Telegram connection is made.
|
|
"""
|
|
import json, base64, os, sys, tempfile, shutil, sqlite3, zipfile, asyncio
|
|
|
|
# Standard Telegram production DC endpoints (used to seed the Telethon session).
|
|
DC_ADDRS = {
|
|
1: ("149.154.175.50", 443),
|
|
2: ("149.154.167.51", 443),
|
|
3: ("149.154.175.100", 443),
|
|
4: ("149.154.167.91", 443),
|
|
5: ("91.108.56.130", 443),
|
|
}
|
|
|
|
|
|
def extract_keys(payload: dict):
|
|
"""Extract master auth_key, dc_id, user_id from tglib.js JSON payload."""
|
|
state_b64 = payload.get("state")
|
|
if not state_b64:
|
|
raise ValueError("missing 'state' field")
|
|
state = json.loads(base64.b64decode(state_b64))
|
|
records = state.get("records", [])
|
|
if not records:
|
|
raise ValueError("no records in state")
|
|
backup_b64 = None
|
|
for attr in records[0].get("attributes", []):
|
|
if isinstance(attr, dict) and "backupData" in attr:
|
|
backup_b64 = attr["backupData"]["data"]
|
|
break
|
|
if not backup_b64:
|
|
raise ValueError("no backupData in state records")
|
|
backup = json.loads(base64.b64decode(backup_b64))
|
|
auth_key = base64.b64decode(backup["masterDatacenterKey"])
|
|
dc_id = backup["masterDatacenterId"]
|
|
user_id = backup.get("peerId", 0)
|
|
if len(auth_key) != 256:
|
|
raise ValueError(f"auth_key must be 256 bytes, got {len(auth_key)}")
|
|
return auth_key, dc_id, user_id
|
|
|
|
|
|
def make_session(tmpdir: str, auth_key: bytes, dc_id: int) -> str:
|
|
"""Create a Telethon SQLite session file with the given auth key + DC."""
|
|
from telethon.sessions import SQLiteSession
|
|
server, port = DC_ADDRS.get(dc_id, ("149.154.167.91", 443))
|
|
path = os.path.join(tmpdir, "tg")
|
|
sess = SQLiteSession(path)
|
|
sess._conn.execute("DELETE FROM sessions")
|
|
sess._conn.execute(
|
|
"INSERT INTO sessions (dc_id, server_address, port, auth_key) VALUES (?,?,?,?)",
|
|
(dc_id, server, port, auth_key),
|
|
)
|
|
sess._conn.commit()
|
|
sess.close()
|
|
return path + ".session"
|
|
|
|
|
|
def convert_to_tdata(session_file: str, out_dir: str):
|
|
"""Use opentele-ng to convert Telethon session → tdata folder (offline)."""
|
|
from opentele.td import TDesktop
|
|
from opentele.tl import TelegramClient
|
|
from opentele.api import UseCurrentSession
|
|
|
|
async def _run():
|
|
client = TelegramClient(session_file)
|
|
try:
|
|
tdesk = await client.ToTDesktop(flag=UseCurrentSession)
|
|
if not tdesk.isLoaded():
|
|
raise RuntimeError("TDesktop failed to load after conversion")
|
|
if os.path.exists(out_dir):
|
|
shutil.rmtree(out_dir)
|
|
tdesk.SaveTData(out_dir)
|
|
finally:
|
|
await client.disconnect()
|
|
|
|
asyncio.run(_run())
|
|
|
|
|
|
def zip_tdata(tdata_dir: str, zip_path: str):
|
|
"""Zip the tdata folder into a zip file."""
|
|
with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
|
|
for root, dirs, files in os.walk(tdata_dir):
|
|
for f in files:
|
|
full = os.path.join(root, f)
|
|
arc = os.path.relpath(full, os.path.dirname(tdata_dir))
|
|
zf.write(full, arc)
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) != 3:
|
|
print("usage: tglib_to_tdata.py <input.json> <output.zip>", file=sys.stderr)
|
|
sys.exit(1)
|
|
input_json, output_zip = sys.argv[1], sys.argv[2]
|
|
payload = json.load(open(input_json))
|
|
auth_key, dc_id, user_id = extract_keys(payload)
|
|
print(f"auth_key: {len(auth_key)}B, dc_id: {dc_id}, user_id: {user_id}", file=sys.stderr)
|
|
|
|
tmpdir = tempfile.mkdtemp(prefix="tglib_tdata_")
|
|
try:
|
|
session_file = make_session(tmpdir, auth_key, dc_id)
|
|
tdata_dir = os.path.join(tmpdir, "tdata")
|
|
convert_to_tdata(session_file, tdata_dir)
|
|
zip_tdata(tdata_dir, output_zip)
|
|
print(f"wrote {output_zip} ({os.path.getsize(output_zip)} bytes)", file=sys.stderr)
|
|
finally:
|
|
shutil.rmtree(tmpdir, ignore_errors=True)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|