#!/usr/bin/python3
# Centre KemmOS 1.8.0 — assistant « Je viens de Windows » : ouvre la partition Windows EN LECTURE SEULE pour
# l'utilisateur qui a lancé l'assistant. Lancé par pkexec (action org.kemmos.centre.windows).
#   windows ouvrir <périphérique>    clé BitLocker (si besoin) lue sur l'entrée standard, une ligne
# Partition BitLocker : cryptsetup open --type bitlk --readonly → /dev/mapper/kemmos-windows (clé de
# récupération de 48 chiffres, tirets facultatifs, ou mot de passe BitLocker). Montage ntfs3 en lecture seule
# (ntfs-3g en secours, Windows en veille prolongée ou « démarrage rapide ») dans /run/kemmos-windows, fichiers
# au nom de l'utilisateur (PKEXEC_UID), invisibles des autres comptes. Partition déjà montée (Fichiers) :
# son point de montage est réutilisé tel quel. Rien n'est jamais écrit sur le disque Windows.
# Sortie : le point de montage. Codes : 0 = fait, 1 = échec, 2 = usage, 3 = clé refusée, 4 = clé nécessaire.
# Fermeture : windows-fermer (sans mot de passe).
import json
import os
import pwd
import re
import subprocess
import sys

POINT = "/run/kemmos-windows"
NOM_DM = "kemmos-windows"


def usage(msg="usage : windows ouvrir /dev/<partition>"):
    print(msg, file=sys.stderr)
    sys.exit(2)


def echec(msg, code=1):
    print(msg, file=sys.stderr, flush=True)
    sys.exit(code)


def lsblk(dev):
    r = subprocess.run(["lsblk", "-J", "-b", "-o", "PATH,TYPE,FSTYPE,MOUNTPOINTS", dev],
                       capture_output=True, text=True)
    if r.returncode != 0:
        echec(f"{dev} : périphérique introuvable")
    return json.loads(r.stdout)["blockdevices"][0]


def point_existant(b):
    # point de montage déjà en place (partition ouverte dans Fichiers, ou assistant relancé)
    for p in b.get("mountpoints") or []:
        if p:
            return p
    for enfant in b.get("children") or []:
        p = point_existant(enfant)
        if p:
            return p
    return None


def cle_bitlocker(texte):
    # clé de récupération : 48 chiffres, à donner à cryptsetup en 8 blocs de 6 séparés par des tirets
    # chaque bloc est un multiple de 11 inférieur à 720896 : sinon c'est une faute de frappe
    chiffres = re.sub(r"[\s-]", "", texte)
    if re.fullmatch(r"\d{48}", chiffres):
        blocs = [chiffres[i:i + 6] for i in range(0, 48, 6)]
        if any(int(b) % 11 or int(b) // 11 > 0xFFFF for b in blocs):
            echec("clé de récupération incorrecte (faute de frappe)", 3)
        return "-".join(blocs)
    return texte


def monter(source, uid, gid, ouvert_ici=False):
    os.makedirs(POINT, mode=0o755, exist_ok=True)
    if os.path.ismount(POINT):
        subprocess.run(["umount", POINT])
    erreurs = []
    for typ, opts in (("ntfs3", f"ro,uid={uid},gid={gid},umask=077"),
                      ("ntfs-3g", f"ro,uid={uid},gid={gid},umask=077")):
        r = subprocess.run(["mount", "-t", typ, "-o", opts, source, POINT], capture_output=True, text=True)
        if r.returncode == 0:
            return POINT
        erreurs.append(f"{typ} : {(r.stderr or r.stdout).strip()}")
    if ouvert_ici:
        # disque BitLocker déverrouillé pour rien : on le referme (la clé sera redemandée)
        subprocess.run(["cryptsetup", "close", NOM_DM])
    echec("lecture du disque Windows impossible\n" + "\n".join(erreurs))


a = sys.argv[1:]
if len(a) != 2 or a[0] != "ouvrir" or not re.fullmatch(r"/dev/[A-Za-z0-9/_.-]+", a[1]) or ".." in a[1]:
    usage()
uid = os.environ.get("PKEXEC_UID", "")
if not uid.isdigit():
    echec("à lancer par pkexec depuis l'assistant")
gid = str(pwd.getpwuid(int(uid)).pw_gid)

b = lsblk(a[1])
if b["type"] not in ("part", "disk") or b["fstype"] not in ("ntfs", "BitLocker"):
    echec(f"{a[1]} n'est pas une partition Windows (NTFS ou BitLocker)")

deja = point_existant(b)
if deja:
    print(deja, flush=True)
    sys.exit(0)

source, ouvert_ici = a[1], False
if b["fstype"] == "BitLocker":
    if not os.path.exists(f"/dev/mapper/{NOM_DM}"):
        texte = sys.stdin.readline().strip()
        if not texte:
            echec("clé BitLocker nécessaire", 4)
        r = subprocess.run(["cryptsetup", "open", "--type", "bitlk", "--readonly", "--key-file", "-",
                            a[1], NOM_DM], input=cle_bitlocker(texte).encode(), capture_output=True)
        if r.returncode != 0:
            # clé incorrecte : code 2 pour un mot de passe, mais code 1 (« paramètres incorrects ») pour une clé
            # de récupération fausse (cryptsetup 2.8.8)
            recuperation = re.fullmatch(r"\d{48}", re.sub(r"[\s-]", "", texte)) is not None
            if r.returncode == 2 or (r.returncode == 1 and recuperation):
                echec("clé refusée", 3)
            echec((r.stderr or r.stdout).decode(errors="replace").strip() or "échec de cryptsetup")
        ouvert_ici = True
    source = f"/dev/mapper/{NOM_DM}"

print(monter(source, uid, gid, ouvert_ici), flush=True)
