pypush-plus-plus/demo.py

180 lines
5.9 KiB
Python
Raw Normal View History

2023-05-02 07:39:11 -05:00
import json
2023-07-26 06:50:48 -05:00
import logging
2023-07-31 18:38:28 -05:00
import os
2023-07-26 06:50:48 -05:00
import threading
import time
from base64 import b64decode, b64encode
2023-05-09 16:03:27 -05:00
from getpass import getpass
2023-08-15 08:05:08 -05:00
from subprocess import PIPE, Popen
2023-05-02 07:39:11 -05:00
2023-07-23 17:55:13 -05:00
from rich.logging import RichHandler
2023-07-26 06:50:48 -05:00
import apns
import ids
2023-07-28 10:53:13 -05:00
import imessage
2023-07-26 06:50:48 -05:00
2023-08-19 10:27:44 -05:00
import trio
2023-07-23 17:55:13 -05:00
logging.basicConfig(
2023-07-26 17:49:41 -05:00
level=logging.NOTSET, format="%(message)s", datefmt="[%X]", handlers=[RichHandler()]
2023-07-23 17:55:13 -05:00
)
# Set sane log levels
logging.getLogger("urllib3").setLevel(logging.WARNING)
2023-08-15 08:05:08 -05:00
logging.getLogger("py.warnings").setLevel(logging.ERROR) # Ignore warnings from urllib3
2023-07-31 12:25:19 -05:00
logging.getLogger("asyncio").setLevel(logging.WARNING)
2023-07-23 17:55:13 -05:00
logging.getLogger("jelly").setLevel(logging.INFO)
logging.getLogger("nac").setLevel(logging.INFO)
2023-08-17 21:05:18 -05:00
logging.getLogger("apns").setLevel(logging.INFO)
2023-07-24 08:18:21 -05:00
logging.getLogger("albert").setLevel(logging.INFO)
logging.getLogger("ids").setLevel(logging.DEBUG)
2023-07-31 12:08:57 -05:00
logging.getLogger("bags").setLevel(logging.INFO)
2023-08-17 21:05:18 -05:00
logging.getLogger("imessage").setLevel(logging.INFO)
2023-05-02 19:53:18 -05:00
logging.captureWarnings(True)
2023-08-17 21:05:18 -05:00
process = Popen(["git", "rev-parse", "HEAD"], stdout=PIPE) # type: ignore
2023-08-15 08:05:08 -05:00
(commit_hash, err) = process.communicate()
exit_code = process.wait()
commit_hash = commit_hash.decode().strip()
2023-05-09 16:03:27 -05:00
# Try and load config.json
try:
with open("config.json", "r") as f:
CONFIG = json.load(f)
except FileNotFoundError:
CONFIG = {}
2023-05-02 07:39:11 -05:00
2023-08-15 08:05:08 -05:00
# Re-register if the commit hash has changed
2023-08-24 06:31:11 -05:00
if CONFIG.get("commit_hash") != commit_hash or True:
2023-08-15 08:05:08 -05:00
logging.warning("pypush commit is different, forcing re-registration...")
CONFIG["commit_hash"] = commit_hash
if "id" in CONFIG:
del CONFIG["id"]
2023-07-26 06:50:48 -05:00
2023-05-09 17:48:44 -05:00
def safe_b64decode(s):
try:
return b64decode(s)
except:
return None
2023-07-26 06:50:48 -05:00
2023-08-17 19:23:56 -05:00
async def main():
token = CONFIG.get("push", {}).get("token")
if token is not None:
token = b64decode(token)
else:
token = b""
2023-08-17 19:23:56 -05:00
push_creds = apns.PushCredentials(
CONFIG.get("push", {}).get("key", ""), CONFIG.get("push", {}).get("cert", ""), token)
2023-08-17 19:23:56 -05:00
async with apns.APNSConnection.start(push_creds) as conn:
await conn.set_state(1)
await conn.filter(["com.apple.madrid"])
2023-08-17 19:23:56 -05:00
user = ids.IDSUser(conn)
if CONFIG.get("auth", {}).get("cert") is not None:
auth_keypair = ids._helpers.KeyPair(CONFIG["auth"]["key"], CONFIG["auth"]["cert"])
user_id = CONFIG["auth"]["user_id"]
handles = CONFIG["auth"]["handles"]
user.restore_authentication(auth_keypair, user_id, handles)
2023-07-31 12:25:19 -05:00
else:
2023-08-17 19:23:56 -05:00
username = input("Username: ")
password = getpass("Password: ")
user.authenticate(username, password)
2023-08-24 06:31:11 -05:00
import sms_registration
phone_sig = safe_b64decode(CONFIG.get("phone", {}).get("sig"))
phone_number = CONFIG.get("phone", {}).get("number")
if phone_sig is None or phone_number is None:
print("Registering phone number...")
phone_number, phone_sig = sms_registration.register(user.push_connection.credentials.token)
CONFIG["phone"] = {
"number": phone_number,
"sig": b64encode(phone_sig).decode(),
}
if CONFIG.get("phone", {}).get("auth_key") is not None:
phone_auth_keypair = ids._helpers.KeyPair(CONFIG["phone"]["auth_key"], CONFIG["phone"]["auth_cert"])
else:
phone_auth_keypair = ids.profile.get_phone_cert(phone_number, user.push_connection.credentials.token, [phone_sig])
CONFIG["phone"]["auth_key"] = phone_auth_keypair.key
CONFIG["phone"]["auth_cert"] = phone_auth_keypair.cert
2023-08-17 19:23:56 -05:00
user.encryption_identity = ids.identity.IDSIdentity(
encryption_key=CONFIG.get("encryption", {}).get("rsa_key"),
signing_key=CONFIG.get("encryption", {}).get("ec_key"),
)
2023-08-24 06:31:11 -05:00
#user._auth_keypair = phone_auth_keypair
#user.handles = [f"tel:{phone_number}"]
#user.user_id = f"P:{phone_number}"
2023-08-17 19:23:56 -05:00
if (
CONFIG.get("id", {}).get("cert") is not None
and user.encryption_identity is not None
):
id_keypair = ids._helpers.KeyPair(CONFIG["id"]["key"], CONFIG["id"]["cert"])
user.restore_identity(id_keypair)
else:
logging.info("Registering new identity...")
import emulated.nac
vd = emulated.nac.generate_validation_data()
vd = b64encode(vd).decode()
2023-08-24 06:31:11 -05:00
user.register(vd, [("P:" + phone_number, phone_auth_keypair)], ["tel:" + phone_number, "tel:1"])
#user.register(vd)
print("Handles: ", user.handles)
2023-08-17 19:23:56 -05:00
# Write config.json
CONFIG["encryption"] = {
"rsa_key": user.encryption_identity.encryption_key,
"ec_key": user.encryption_identity.signing_key,
}
CONFIG["id"] = {
"key": user._id_keypair.key,
"cert": user._id_keypair.cert,
}
CONFIG["auth"] = {
"key": user._auth_keypair.key,
"cert": user._auth_keypair.cert,
"user_id": user.user_id,
"handles": user.handles,
}
CONFIG["push"] = {
"token": b64encode(user.push_connection.credentials.token).decode(),
"key": user.push_connection.credentials.private_key,
"cert": user.push_connection.credentials.cert,
}
with open("config.json", "w") as f:
json.dump(CONFIG, f, indent=4)
im = imessage.iMessageUser(conn, user)
# Send a message to myself
2023-08-19 10:27:44 -05:00
async with trio.open_nursery() as nursery:
nursery.start_soon(input_task, im)
nursery.start_soon(output_task, im)
async def input_task(im: imessage.iMessageUser):
while True:
cmd = await trio.to_thread.run_sync(input, "> ", cancellable=True)
if cmd != "":
await im.send(imessage.iMessage.create(im, cmd, [im.user.current_handle]))
async def output_task(im: imessage.iMessageUser):
while True:
msg = await im.receive()
print(str(msg))
if __name__ == "__main__":
trio.run(main)