#!/usr/bin/env python3
"""Controlla una copia del sito. Solo Python, nessuna dipendenza: leggilo, sono poche righe.

  python3 verifica.py                    dentro la cartella: ogni file contro SHA256SUMS, poi la firma in firma.json
  python3 verifica.py file evento.json   un file qualsiasi contro un evento Nostr firmato (per esempio lo zip)

Dice che i byte sono quelli firmati da quella chiave. Non dice che quello che c'è scritto sia vero.
La firma BIP-340 è l'algoritmo di riferimento, riga per riga; l'evento è NIP-01, il tipo 1063 è NIP-94.
"""
import sys

# Con «python3 verifica.py» Python cerca i moduli prima nella cartella dello script: un hashlib.py o un json.py
# aggiunto alla copia, o lasciato tra i download, girerebbe al posto di quello vero, e potrebbe dire «Firma valida».
# Con -I o -P la cartella non c'è già.
if __name__ == "__main__" and not sys.flags.isolated and not getattr(sys.flags, "safe_path", False):
    del sys.path[0]

import hashlib  # noqa: E402
import json  # noqa: E402
import pathlib  # noqa: E402

# Li lascia il sistema in una cartella aperta o copiata su una chiavetta (Finder, Esplora risorse; i ._ di un Mac su FAT)
DI_SISTEMA = {".DS_Store", "Thumbs.db", "desktop.ini"}
P = 2**256 - 2**32 - 977
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
G = (0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
     0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)


def somma(a, b):
    if a is None:
        return b
    if b is None:
        return a
    if a[0] == b[0] and a[1] != b[1]:
        return None
    pendenza = (3 * a[0] * a[0] * pow(2 * a[1], P - 2, P)) % P if a == b else ((b[1] - a[1]) * pow(b[0] - a[0], P - 2, P)) % P
    x = (pendenza * pendenza - a[0] - b[0]) % P
    return x, (pendenza * (a[0] - x) - a[1]) % P


def per(punto, volte):
    esito = None
    while volte:
        if volte & 1:
            esito = somma(esito, punto)
        punto = somma(punto, punto)
        volte >>= 1
    return esito


def sha(dati):
    return hashlib.sha256(dati).digest()


def da_x(x):
    if x >= P:
        return None
    quadrato = (pow(x, 3, P) + 7) % P
    y = pow(quadrato, (P + 1) // 4, P)
    if pow(y, 2, P) != quadrato:
        return None
    return x, y if y % 2 == 0 else P - y


def firma_valida(messaggio, chiave, firma):
    if len(chiave) != 32 or len(firma) != 64:
        return False
    punto = da_x(int.from_bytes(chiave, "big"))
    r, s = int.from_bytes(firma[:32], "big"), int.from_bytes(firma[32:], "big")
    if punto is None or r >= P or s >= N:
        return False
    etichetta = sha(b"BIP0340/challenge")
    e = int.from_bytes(sha(etichetta + etichetta + firma[:32] + chiave + messaggio), "big") % N
    esito = somma(per(G, s), per(punto, N - e))
    return esito is not None and esito[1] % 2 == 0 and esito[0] == r


def evento_valido(evento):
    corpo = json.dumps([0, evento["pubkey"], evento["created_at"], evento["kind"], evento["tags"], evento["content"]],
                       separators=(",", ":"), ensure_ascii=False).encode()
    return sha(corpo).hex() == evento["id"] and firma_valida(bytes.fromhex(evento["id"]), bytes.fromhex(evento["pubkey"]), bytes.fromhex(evento["sig"]))


def impronta(percorso):
    digest = hashlib.sha256()
    with open(percorso, "rb") as file:
        while blocco := file.read(1 << 20):
            digest.update(blocco)
    return digest.hexdigest()


def controlla(percorso, evento):
    if not evento_valido(evento):
        sys.exit("FIRMA NON VALIDA: l'evento è stato cambiato, oppure non è di questa chiave.")
    atteso = dict(tag[:2] for tag in evento["tags"]).get("x")
    if impronta(percorso) != atteso:
        sys.exit(f"DIVERSO: {percorso} non è il file firmato.")
    print(f"Firma valida. {percorso} è il file firmato da questa chiave:\n{evento['pubkey']}")
    print("Confrontala con la chiave che conosci da un'altra parte: una copia rifatta può avere una firma nuova, con un'altra chiave.")


def main():
    if len(sys.argv) == 3:
        controlla(sys.argv[1], json.loads(pathlib.Path(sys.argv[2]).read_text()))
        return
    cartella = pathlib.Path(__file__).resolve().parent
    cattivi = conti = 0
    elencati = {"SHA256SUMS", "firma.json"}
    for riga in (cartella / "SHA256SUMS").read_text().splitlines():
        atteso, nome = riga.split("  ", 1)
        conti += 1
        elencati.add(nome)
        file = cartella / nome
        if not file.exists() or impronta(file) != atteso:
            print(f"DIVERSO: {nome}")
            cattivi += 1
    # Un file aggiunto non cambia SHA256SUMS: una pagina o uno script in più passerebbero per firmati
    in_piu = sorted(via for file in cartella.rglob("*") if file.is_file() and file.name not in DI_SISTEMA
                    and not file.name.startswith("._") and (via := file.relative_to(cartella).as_posix()) not in elencati)
    for nome in in_piu:
        print(f"IN PIÙ: {nome}")
    if cattivi or in_piu:
        sys.exit(" ".join(([f"{cattivi} file su {conti} non tornano."] if cattivi else [])
                          + ([f"{len(in_piu)} file in più, che SHA256SUMS non elenca: la firma non li copre."] if in_piu else [])))
    print(f"{conti} file uguali a SHA256SUMS.")
    controlla(cartella / "SHA256SUMS", json.loads((cartella / "firma.json").read_text()))


if __name__ == "__main__":
    main()
