import httpx
import secrets
import hashlib
import time
import json

def enc_int(value):
    out = bytearray()
    while value > 0x7f:
        out.append((value & 0x7f) | 0x80)
        value >>= 7
    out.append(value)
    return bytes(out)

def decode_varint(data, offset):
    value = 0
    shift = 0
    while True:
        byte = data[offset]
        value |= (byte & 0x7f) << shift
        shift += 7
        offset += 1
        if not (byte & 0x80):
            break
    return value, offset

def decode_response(data):
    if isinstance(data, str):
        data = data.encode('utf-8', errors='ignore')
    offset = 5
    result = {}
    
    while offset < len(data):
        tag = data[offset]
        field_num = tag >> 3
        wire_type = tag & 0x07
        offset += 1
        
        if wire_type == 0:
            value, offset = decode_varint(data, offset)
            result[field_num] = value
        elif wire_type == 2:
            length, offset = decode_varint(data, offset)
            value = data[offset:offset+length]
            offset += length
            try:
                result[field_num] = value.decode('utf-8')
            except:
                result[field_num] = value.hex()
    
    return result

def extract_token(raw_str):
    if raw_str.startswith("0a") and len(raw_str) > 2:
        raw_str = raw_str[2:]
    if raw_str.startswith("40") and len(raw_str) > 2:
        raw_str = raw_str[2:]
    if len(raw_str) > 2:
        length = int(raw_str[:2], 16)
        if length <= len(raw_str[2:]):
            raw_str = raw_str[2 + length:]
    return raw_str[:64] if len(raw_str) >= 64 else raw_str

def build_req(phone, pwd_hash, country):
    phone_b = phone.encode()
    pwd_b = pwd_hash.encode()
    country_b = country.encode()
    nested = b"\x08" + enc_int(418) + b"\x12" + enc_int(2) + b"05" + b"\x1a" + enc_int(2) + b"IQ" + b"\x22" + enc_int(8) + b"Asiacell" + b"\x2a" + enc_int(8) + b"Asiacell"
    proto = b"\x0a" + enc_int(len(phone_b)) + phone_b + b"\x12" + enc_int(len(pwd_b)) + pwd_b + b"\x2a" + enc_int(len(country_b)) + country_b + b"\x32" + enc_int(len(nested)) + nested
    return b"\x00" + len(proto).to_bytes(4, "big") + proto

phone = input("Phone: ").strip()
pwd = input("Password: ").strip()
country = input("Country: ").strip().upper()

pwd_hash = hashlib.md5(pwd.encode()).hexdigest()
payload = build_req(phone, pwd_hash, country)

headers = {
    "User-Agent": "grpc-java-okhttp/1.61.0",
    "content-type": "application/grpc",
    "te": "trailers",
    "lang": "ar",
    "version": "2004000",
    "vc": "2004000",
    "vn": "2.4.0.0",
    "os": "android",
    "sys_version": "android-15",
    "model": "TECNO+LJ9",
    "mcc": "418",
    "locale": "ar_EG",
    "net_type": "4",
    "pkg": "com.xparty.androidapp",
    "issue_channel": "1",
    "did": secrets.token_hex(8),
    "timezone": "3",
    "device_level": "HIGH",
    "x-sign-version": "v1",
    "x-timestamp": str(int(time.time())),
    "grpc-timeout": "14999175u",
}

url = "https://rpc-hw.xenalive.me/grpc.login.LoginService/PhoneLogin"

with httpx.Client(http2=True, timeout=30.0) as client:
    res = client.post(url, content=payload, headers=headers)
    decoded = decode_response(res.content)
    
    message = ""
    for field_num, value in decoded.items():
        if isinstance(value, str) and len(value) > 5 and not all(c in '0123456789abcdef' for c in value.lower()):
            message = value
            break
    
    if message:
        print(json.dumps({
            "error": message,
            "status": 0,
        }, indent=4, ensure_ascii=False))
    else:
        token_field = decoded.get(3, "")
        token = extract_token(token_field) if isinstance(token_field, str) else ""
        
        signed_token_field = decoded.get(4, "")
        signed_token = extract_token(signed_token_field) if isinstance(signed_token_field, str) else ""
        
        print(json.dumps({
            "token": token,
            "expiry_time": decoded.get(2, 0),
            "signed_token": signed_token,
            "status": decoded.get(7, 0),
            "country": decoded.get(8, ""),
            "currency": decoded.get(9, ""),
            "user_id": decoded.get(10, ""),
        }, indent=4, ensure_ascii=False))

import base64
import json
import secrets
import time
import uuid
import requests
from Crypto.Cipher import AES, PKCS1_v1_5
from Crypto.PublicKey import RSA
from Crypto.Util.Padding import pad, unpad
API = "https://api.yallabaloot.com/account/v2/passwordLogin"
IV = b"8460257940005478"
PUCK3 = (
    "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw4tQ9I7GINCnxfxoHF4vLe15fyYzGI/mNoXTRG3P"
    "xOtcHZ0oNW5oGcGqCBw4Zw8e/bcgfhn5tWTmfEJPnVny+hmF+Jj6KHpD4mbefHXCnrDs6Zeu/Nh3gjj/M/LXt"
    "9z1zs5Rt6WG1XQw00fJ9xmm3dBvTRn7f7S4kXLyhhwu3GW0iWdCK2Srrw6KlJ5kOrV9/dEFgF/OYCowU0w46"
    "SVki8VCbS7UZb0yIZAcpHOSXlU3UAKKuUDgldNfaMYtInmSqhAAghHptRZziLhMmnUS+gqtdw8nDItwQQEsv"
    "FLe0sftAo/iJPHdIY3RS6sWpHvy/dBhyzUIzEtN6CvKw6hoewIDAQAB"
)

phone = input("Phone : ").strip()
password = input("Password: ").strip()

try:
    device_id = open(".yalla_device").read().strip()
except Exception:
    device_id = uuid.uuid4().hex
    open(".yalla_device", "w").write(device_id)

uu = "".join(secrets.choice("0123456789abcdef") for _ in range(4)) * 8
key_bytes = uu.encode("utf-8")

body_obj = {"phone": phone, "password": password, "nationalityId": 8}
head = {
    "deviceId": device_id,
    "deviceCode": "BRP-N21",
    "osType": "6",
    "osVersion": "1.5.2.1",
    "osVersionCode": "15200",
    "userAgent": "edge",
    "platform": "6",
    "timestamp": str(int(time.time() * 1000)),
    "uuId": uu,
    "osInfo": "16",
    "sign": "sign",
    "netWork": "WIFI",
}

c1 = AES.new(key_bytes, AES.MODE_CBC, IV)
data_b64 = base64.b64encode(c1.encrypt(pad(json.dumps(body_obj, separators=(",", ":")).encode(), 16))).decode()

c2 = AES.new(key_bytes, AES.MODE_CBC, IV)
head_b64 = base64.b64encode(c2.encrypt(pad(json.dumps(head, separators=(",", ":")).encode(), 16))).decode()

pub = RSA.import_key(base64.b64decode(PUCK3))
key_b64 = base64.b64encode(PKCS1_v1_5.new(pub).encrypt(key_bytes)).decode()

payload = {"data": data_b64}
headers = {
    "User-Agent": "Dalvik/2.1.0 (Linux; U; Android 16; BRP-NX1 Build/HONORBRP-N21)",
    "Connection": "Keep-Alive",
    "Accept-Encoding": "identity",
    "HeadContent": head_b64,
    "Key": key_b64,
    "ApiVersion": "",
    "Content-Type": "application/json; charset=UTF-8;",
}
r = requests.post(API, json=payload, headers=headers, timeout=25)

rkey = r.headers.get("key") or r.headers.get("Key")
if not rkey:
    print(r.text[:2000])
else:
    j = json.loads(r.text)
    if j.get("data") and j["data"] != "{}":
        c3 = AES.new(rkey.encode("utf-8"), AES.MODE_CBC, IV)
        plain = unpad(c3.decrypt(base64.b64decode(j["data"])), 16).decode("utf-8", "replace")
        j["data"] = json.loads(plain)
    print(json.dumps(j, indent=2, ensure_ascii=False))

Source code available for TikTok user verification. Features: 1. No ban, uses proxy. 2. No sessions or fake accounts. 3. No bans. 4. Fast, single connection only. Notes: 1. The feature detects the user. 2. I don't sell activations. To purchase the code, contact @P_W_7