Perfil pagador nível 3: consistência de device, clock drift e reparo fino

pkg install -y ntp
ntpdate -q pool.ntp.org   # mostra offset em segundos
# saida tipica: "server x.x.x.x, stratum 2, offset -0.043s"
# se |offset| > 2s, reparar antes de pagar

pkg update -y
pkg install -y python ntp tzdata
pip install requests rich ntplib

#!/usr/bin/env python3
"""
payer_consistency.py — nivel 3 da trilha de pagamentos.
Mede CONSISTENCIA entre IP/fuso/locale/UA/clock e propoe reparos.
"""
from __future__ import annotations
import os, sys, json, time, locale, hashlib, subprocess
from datetime import datetime, timezone
import requests, ntplib
from rich.console import Console
from rich.table import Table

console = Console()
TIMEOUT = 8

# mapa simplificado: pais -> fusos esperados
COUNTRY_TZ = {
    "BR": ["America/Sao_Paulo","America/Bahia","America/Fortaleza",
           "America/Manaus","America/Belem","America/Recife"],
    "US": ["America/New_York","America/Chicago","America/Denver",
           "America/Los_Angeles","America/Phoenix"],
    "PT": ["Europe/Lisbon"], "ES": ["Europe/Madrid"],
    "AR": ["America/Argentina/Buenos_Aires"],
}

COUNTRY_LANG = {
    "BR": ("pt", "pt_BR"), "PT": ("pt", "pt_PT"),
    "US": ("en", "en_US"), "GB": ("en", "en_GB"),
    "AR": ("es", "es_AR"), "ES": ("es", "es_ES"),
}

def get_ip_country() -> str | None:
    try:
        r = requests.get("https://ipwho.is/", timeout=TIMEOUT).json()
        return r.get("country_code")
    except Exception:
        return None

def get_device_tz() -> str:
    # Termux/Android expoe via getprop; fallback para /etc/timezone
    try:
        out = subprocess.check_output(["getprop","persist.sys.timezone"],
                                       timeout=2).decode().strip()
        if out: return out
    except Exception:
        pass
    if os.path.exists("/etc/timezone"):
        return open("/etc/timezone").read().strip()
    return time.strftime("%Z")

def get_locale() -> str:
    try:
        return locale.getlocale()[0] or os.environ.get("LANG","")
    except Exception:
        return os.environ.get("LANG","")

def get_clock_drift() -> float | None:
    """Offset em segundos entre relogio local e NTP pool."""
    try:
        c = ntplib.NTPClient()
        r = c.request("pool.ntp.org", version=3, timeout=TIMEOUT)
        return float(r.offset)
    except Exception:
        return None

def expected_ua_hint() -> dict:
    """User-Agent + Client Hints que um Chrome Android real envia,
    derivados do que o device declara via env. Usado so para
    voce comparar com o que o browser de pagamento envia."""
    return {
        "platform": "Android" if os.environ.get("TERMUX_VERSION") else "Linux",
        "mobile": bool(os.environ.get("TERMUX_VERSION")),
        "arch": os.uname().machine,
    }

def fp_hash(parts: list[str]) -> str:
    return hashlib.sha256("|".join(parts).encode()).hexdigest()[:16]

# -------------------- analise -------------------- #

def analyse(country, dev_tz, loc, drift):
    issues = []
    fixes  = []

    # 1. timezone vs IP
    if country and country in COUNTRY_TZ:
        if dev_tz not in COUNTRY_TZ[country]:
            issues.append(f"Timezone {dev_tz} nao bate com pais do IP ({country}).")
            fixes.append(
                f"No Android: Ajustes > Sistema > Data e Hora > Fuso "
                f"-> {COUNTRY_TZ[country][0]}. Reabra o Chrome depois."
            )

    # 2. locale vs IP
    if country and country in COUNTRY_LANG:
        lang_pref, full = COUNTRY_LANG[country]
        if not (loc or "").lower().startswith(lang_pref):
            issues.append(f"Locale '{loc}' divergente do esperado ({full}).")
            fixes.append(
                f"Android: Ajustes > Sistema > Idiomas -> coloque "
                f"{full.replace('_','-')} no TOPO. No Chrome: chrome://settings/languages."
            )

    # 3. clock drift
    if drift is None:
        issues.append("Nao foi possivel medir drift NTP (sem rede?).")
    elif abs(drift) > 2:
        issues.append(f"Clock drift {drift:+.2f}s (limite saudavel: +-2s).")
        fixes.append(
            "Ative 'Data e hora automatica' (NTP do sistema). Em Termux: "
            "pkg install ntp && sudo ntpdate -u pool.ntp.org (root) "
            "ou apenas ative o toggle nas Configuracoes do Android."
        )
    elif abs(drift) > 0.5:
        issues.append(f"Clock drift {drift:+.2f}s (aceitavel, mas monitorar).")

    # 4. fingerprint hash (so para voce notar mudancas entre execucoes)
    fp = fp_hash([dev_tz, str(loc), str(os.uname().machine),
                  str(os.environ.get("TERMUX_VERSION",""))])

    return issues, fixes, fp

# -------------------- main -------------------- #

def main():
    country = (sys.argv[1] if len(sys.argv) > 1 else "").upper() or get_ip_country() or "BR"
    dev_tz  = get_device_tz()
    loc     = get_locale()
    console.rule("[bold cyan]Medindo consistencia")
    with console.status("consultando NTP..."):
        drift = get_clock_drift()

    t = Table(title="Sinais coletados", show_lines=True)
    t.add_column("Campo"); t.add_column("Valor")
    t.add_row("country (IP)", str(country))
    t.add_row("device timezone", dev_tz)
    t.add_row("locale", str(loc))
    t.add_row("clock drift (s)", f"{drift:+.3f}" if drift is not None else "n/a")
    t.add_row("ua hints (esperado)", json.dumps(expected_ua_hint()))
    console.print(t)

    issues, fixes, fp = analyse(country, dev_tz, loc, drift)

    console.rule("[bold yellow]Inconsistencias")
    if issues:
        for i in issues: console.print(f"  ! {i}")
    else:
        console.print("  [green]Nenhuma. Perfil coerente para 3DS frictionless.[/]")

    console.rule("[bold green]Reparos sugeridos")
    if fixes:
        for f in fixes: console.print(f"  -> {f}")
    else:
        console.print("  Nada a reparar agora.")

    console.print(f"\n[dim]fingerprint estavel: {fp}[/dim]")
    out = {"ts": datetime.now(timezone.utc).isoformat(),
           "country": country, "timezone": dev_tz, "locale": loc,
           "clock_drift_s": drift, "fingerprint": fp,
           "issues": issues, "fixes": fixes}
    p = os.path.expanduser("~/payer_consistency_report.json")
    json.dump(out, open(p,"w"), indent=2, ensure_ascii=False)
    console.print(f"[dim]Relatorio salvo em {p}[/dim]")

if __name__ == "__main__":
    main()

python ~/payer_consistency.py BR