← Kod źródłowyantykradziez.py 632 linii⬇ Pobierz
#!/usr/bin/env python3# Anty-kradzież - Jabłoński KOMPUTERY - www.k.j.pl"""Ochrona przed kradzieżą dla Debiana i systemów pochodnych (Ubuntu, Linux Mint…) – z dowolnympulpitem (GNOME, Cinnamon, XFCE, MATE, KDE…) albo bez pulpitu. Nic nie instaluje i nic nieoptymalizuje: sprawdza licencję (kod aktywacyjny z pakietem „J.K. Anty-Kradzież”), pyta o zgodęi dodaje tylko ochronę.Jak działa: przy starcie (jeszcze przed ekranem logowania) i co 10 minut komputer pyta serwerJabłoński KOMPUTERY, czy nie został zgłoszony jako skradziony / zgubiony. Gdy tak:  • wszystkie konta (także root) są blokowane – bez logowania na ekranie, w konsoli, przez su i SSH,  • ekran logowania (GDM, LightDM, SDDM…) nie startuje; zamiast niego jest tylko wiadomość dla    znalazcy i „naciśnij W, aby wyłączyć komputer” (konsola tekstowa – działa z każdym pulpitem),  • otwarte sesje zostają zamknięte.Odblokowanie przywraca DOKŁADNIE stan sprzed blokady (hasła, daty ważności kont, ekran logowania, SSH).Bez internetu albo gdy serwer nie działa – nic się nie zmienia.Użycie (jako root; najprościej przez skrypt startowy):  wget -qO- https://linux.k.j.pl/antykradziez.sh | sh  python3 antykradziez.py               – włączenie (albo wyłączenie) ochrony, z pytaniem o zgodę  python3 antykradziez.py --odinstaluj  – wyłączenie i usunięcie ochrony"""import argparseimport base64import globimport hashlibimport jsonimport osimport pwdimport reimport selectimport shutilimport signalimport socketimport subprocessimport sysimport timeimport urllib.errorimport urllib.parseimport urllib.requestfrom typing import Dict, List, Optional, TupleWERSJA = "AK-1.0"NAZWA = "J.K. Anty-Kradzież - Jabłoński KOMPUTERY"USER_AGENT = f"Mozilla/5.0 (X11; Linux) AntykradziezJK/{WERSJA}"AKTYWACJA_URL = "https://linux.k.j.pl/aktywacja.php"ZGLOSZENIE_URL = "https://linux.k.j.pl/antykradziez.php"KATALOG_PROGRAMU = "/usr/local/lib/jablonski-komputery"SKRYPT = KATALOG_PROGRAMU + "/antykradziez.py"OPTYMALIZATOR = KATALOG_PROGRAMU + "/optymalizator_jk.py"      # pełny program (Debian 13 KDE)PLIK_LICENCJI = "/etc/jablonski-komputery/licencja.json"PLIK_ZGODY = "/etc/jablonski-komputery/antykradziez.json"KATALOG_STANU = "/var/lib/jablonski-komputery"PLIK_BLOKADY = KATALOG_STANU + "/blokada.json"                  # 0600 – zapisane wpisy /etc/shadowSSH_BLOKADA = "/etc/ssh/sshd_config.d/zz-jablonski-zgubiony.conf"NAZWA_DROPIN = "zz-jablonski-blokada.conf"USLUGA_STANU = "jablonski-antykradziez.service"ZEGAR_STANU = "jablonski-antykradziez.timer"USLUGA_EKRANU = "jablonski-ekran-blokady.service"KATALOG_SYSTEMD = "/etc/systemd/system"WZORZEC_KLUCZA = re.compile(r"[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}")DOMYSLNY_KOMUNIKAT = ("Ten komputer został zgłoszony jako zgubiony lub skradziony.\n"                      "Jeśli go znalazłeś, skontaktuj się z Jabłoński KOMPUTERY – www.k.j.pl")TEKST_INNY_SYSTEM = """\Przykro nam – ten system ({system}) nie jest jeszcze obsługiwany.J.K. Anty-Kradzież działa na Debianie i systemach, które na nim bazują:Ubuntu, Linux Mint, Pop!_OS, Zorin OS, elementary OS, MX Linux i podobnych.Prace nad obsługą innych dystrybucji trwają – zajrzyj do nas niedługo: www.k.j.pl"""TEKST_ZGODY = """\J.K. Anty-Kradzież – zalecamy włączyć.Jeśli komputer zostanie skradziony albo go zgubisz, zablokujesz go na stronie  {zgloszenie}(J.K. Anty-Kradzież) albo u nas w firmie. Przy najbliższym połączeniu z internetem komputer się zablokuje:nikt nie zaloguje się na żadne konto, a na ekranie zobaczy tylko Twoją wiadomość dlaznalazcy (np. numer telefonu) i informację, jak wyłączyć komputer. Złodziej nie zalogujesię do Twojego komputera.Gdy komputer się odnajdzie – odblokujesz go na tej samej stronie i wszystko wrócidokładnie do stanu sprzed blokady (te same hasła, pliki i programy).Blokada działa wyłącznie po Twoim zgłoszeniu. Nie śledzimy komputera i nie widzimy Twoichplików – komputer co 10 minut tylko pyta nasz serwer, czy nie został zgłoszony (serwerwidzi przy tym adres internetowy, co może pomóc w odnalezieniu). Zdanie możesz zmienićw każdej chwili, uruchamiając ten program ponownie."""# --- Narzędzia ---------------------------------------------------------------------------------def czytaj(sciezka: str) -> str:    try:        with open(sciezka, encoding="utf-8", errors="replace") as f:            return f.read()    except OSError:        return ""def zapisz(sciezka: str, tresc: str, tryb: int = 0o644) -> None:    os.makedirs(os.path.dirname(sciezka), exist_ok=True)    tymczasowy = sciezka + ".tmp"    with open(tymczasowy, "w", encoding="utf-8") as f:        f.write(tresc)    os.chmod(tymczasowy, tryb)    os.replace(tymczasowy, sciezka)def usun(sciezka: str) -> None:    try:        if os.path.isdir(sciezka) and not os.path.islink(sciezka):            shutil.rmtree(sciezka)        elif os.path.lexists(sciezka):            os.remove(sciezka)    except OSError:        passdef uruchom(polecenie: List[str]) -> Tuple[int, str]:    try:        w = subprocess.run(polecenie, capture_output=True, text=True, timeout=120)        return w.returncode, (w.stdout + w.stderr).strip()    except (OSError, subprocess.SubprocessError) as e:        return 1, str(e)def wynik(polecenie: List[str]) -> str:    """Tylko standardowe wyjście (jak w Optymalizatorze – identyfikator sprzętu musi się zgadzać)."""    try:        return subprocess.run(polecenie, capture_output=True, text=True, timeout=10).stdout    except (OSError, subprocess.SubprocessError):        return ""def normalizuj_klucz(tekst: str) -> str:    znaki = re.sub(r"[^A-Za-z0-9]", "", tekst or "").upper()    return f"{znaki[:4]}-{znaki[4:8]}-{znaki[8:]}" if len(znaki) == 12 else ""def nazwa_komputera() -> str:    m = re.search(r'^PRETTY_HOSTNAME="?([^"\n]*)"?', czytaj("/etc/machine-info"), re.M)    return (m.group(1).strip() if m else "") or socket.gethostname()def wczytaj_json(sciezka: str) -> dict:    try:        dane = json.loads(czytaj(sciezka) or "{}")    except ValueError:        return {}    return dane if isinstance(dane, dict) else {}# --- Identyfikator sprzętu – identyczny jak w Optymalizatorze (panel rozpoznaje komputer) ------def _dysk_systemowy() -> List[str]:    zrodlo = re.sub(r"\[.*\]$", "", wynik(["findmnt", "-no", "SOURCE", "/"]).strip())    if not zrodlo:        return []    numery = []    for linia in wynik(["lsblk", "-sPno", "TYPE,TRAN,SERIAL", zrodlo]).splitlines():        pola = dict(re.findall(r'(\w+)="([^"]*)"', linia))        if pola.get("TYPE") == "disk" and pola.get("SERIAL") and pola.get("TRAN") != "usb":            numery.append(pola["SERIAL"].strip())    return sorted(set(numery))def _adresy_mac_wbudowane() -> List[str]:    adresy = []    for katalog in sorted(glob.glob("/sys/class/net/*")):        urzadzenie = os.path.join(katalog, "device")        if (not os.path.exists(urzadzenie) or os.path.exists(os.path.join(katalog, "wireless"))                or "/usb" in os.path.realpath(urzadzenie)):            continue        nazwa = os.path.basename(katalog)        m = re.search(r"permaddr ([0-9a-f:]{17})", wynik(["ip", "-o", "link", "show", "dev", nazwa]))        adres = m.group(1) if m else czytaj(os.path.join(katalog, "address")).strip()        if adres and adres != "00:00:00:00:00:00":            adresy.append(adres.lower())    return sorted(set(adresy))def identyfikator_sprzetu() -> Tuple[str, str]:    def dmi(pole: str) -> str:        wartosc = czytaj(f"/sys/class/dmi/id/{pole}").strip()        puste = ("", "to be filled by o.e.m.", "system product name", "default string", "none")        return "" if wartosc.lower() in puste else wartosc    skladniki = ["dmi:" + "|".join(dmi(p) for p in ("sys_vendor", "product_name",                                                     "board_vendor", "board_name"))]    skladniki += ["dysk:" + s for s in _dysk_systemowy()]    skladniki += ["mac:" + a for a in _adresy_mac_wbudowane()]    if len(skladniki) == 1:        skladniki.append("machine-id:" + czytaj("/etc/machine-id").strip())    skrot = hashlib.sha256("\n".join(skladniki).encode()).hexdigest().upper()[:16]    identyfikator = "-".join(skrot[i:i + 4] for i in range(0, 16, 4))    opis = " ".join(x for x in (dmi("sys_vendor"), dmi("product_name")) if x) or "nieznany model"    return identyfikator, opis[:100]# --- Serwer licencji ---------------------------------------------------------------------------def zapytaj_serwer(parametry: Dict[str, str], czas: float = 15) -> str:    url = AKTYWACJA_URL + "?" + urllib.parse.urlencode(parametry)    zadanie = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})    with urllib.request.urlopen(zadanie, timeout=czas) as odp:        return odp.read(4096).decode("utf-8", "replace").strip()def aktywuj(klucz: str) -> Tuple[bool, str, List[str]]:    sprzet, opis = identyfikator_sprzetu()    try:        odpowiedz = zapytaj_serwer({"klucz-id": klucz, "host": nazwa_komputera(), "sprzet": sprzet,                                    "sprzet-opis": opis, "wersja": WERSJA})    except (urllib.error.URLError, OSError, ValueError) as e:        return False, f"Nie udało się połączyć z serwerem licencji ({e}). Sprawdź internet.", []    if "LICENCJA OK" in odpowiedz:        m = re.search(r"^OPCJE:\s*(.*)$", odpowiedz, re.M)        opcje = [o.strip() for o in m.group(1).split(",") if o.strip()] if m else ["antykradziez"]        return True, "Licencja aktywna.", opcje    if "LIMIT" in odpowiedz.upper():        return False, ("Ten kod jest już wykorzystany na innym komputerze (limit komputerów). "                       f"Identyfikator tego komputera: {sprzet}"), []    return False, "Kod aktywacyjny jest nieprawidłowy.", []def parametry_stanu(zgoda: bool) -> Optional[Dict[str, str]]:    klucz = normalizuj_klucz(wczytaj_json(PLIK_LICENCJI).get("klucz", ""))    if not klucz:        return None    sprzet, _ = identyfikator_sprzetu()    return {"stan": "1", "antykradziez": "1" if zgoda else "0", "klucz": klucz, "sprzet": sprzet,            "host": nazwa_komputera()}# --- Blokada -----------------------------------------------------------------------------------def konta_do_blokady() -> List[str]:    konta = ["root"]    for p in pwd.getpwall():        if 1000 <= p.pw_uid < 60000 and not p.pw_shell.endswith(("nologin", "false")):            konta.append(p.pw_name)    return kontadef wpisy_shadow() -> Dict[str, Dict[str, str]]:    wynik_ = {}    for linia in czytaj("/etc/shadow").splitlines():        pola = linia.split(":")        if len(pola) >= 8:            wynik_[pola[0]] = {"haslo": pola[1], "zmiana": pola[2], "wygasa": pola[7]}    return wynik_def menedzer_logowania() -> str:    """Prawdziwa nazwa usługi ekranu logowania (gdm.service, lightdm.service, sddm.service…)."""    nazwa = wynik(["systemctl", "show", "-p", "Id", "--value", "display-manager.service"]).strip()    stan = wynik(["systemctl", "show", "-p", "LoadState", "--value", "display-manager.service"]).strip()    return nazwa if stan == "loaded" and nazwa.endswith(".service") else ""def zakoncz_sesje() -> None:    for linia in wynik(["loginctl", "list-users", "--no-legend"]).splitlines():        pola = linia.split()        if pola and pola[0].isdigit() and int(pola[0]) >= 1000:            uruchom(["loginctl", "terminate-user", pola[0]])def wlacz_blokade(tresc: str) -> None:    stan = wczytaj_json(PLIK_BLOKADY)    tresc = tresc.strip() or DOMYSLNY_KOMUNIKAT    pierwszy_raz = "konta" not in stan    if pierwszy_raz:        cienie = wpisy_shadow()        stan = {"od": time.strftime("%Y-%m-%d %H:%M:%S"), "tresc": tresc,                "konta": {k: cienie[k] for k in konta_do_blokady() if k in cienie},                "ssh": False, "dm": menedzer_logowania()}        zapisz(PLIK_BLOKADY, json.dumps(stan, ensure_ascii=False) + "\n", 0o600)   # najpierw zapis        for konto in stan["konta"]:            uruchom(["usermod", "-L", konto])            if konto != "root":                       # root: tylko hasło (cron, usługi)                uruchom(["chage", "-E", "1", konto])        if os.path.isdir(os.path.dirname(SSH_BLOKADA)):            zapisz(SSH_BLOKADA, "# Jabłoński KOMPUTERY – komputer zablokowany\nDenyUsers *\n")            stan["ssh"] = True            uruchom(["systemctl", "try-reload-or-restart", "ssh.service"])        if stan["dm"]:                                # ekran logowania nie startuje, dopóki jest blokada            zapisz(f"{KATALOG_SYSTEMD}/{stan['dm']}.d/{NAZWA_DROPIN}",                   f"# Jabłoński KOMPUTERY – komputer zablokowany\n[Unit]\nConditionPathExists=!{PLIK_BLOKADY}\n")            uruchom(["systemctl", "daemon-reload"])    zmiana = pierwszy_raz or stan.get("tresc") != tresc    stan["tresc"] = tresc    zapisz(PLIK_BLOKADY, json.dumps(stan, ensure_ascii=False) + "\n", 0o600)    if pierwszy_raz and not przy_starcie():           # komputer już działa – zamykamy wszystko        if stan["dm"]:            uruchom(["systemctl", "stop", stan["dm"]])        zakoncz_sesje()    if zmiana and not przy_starcie():        uruchom(["systemctl", "restart", USLUGA_EKRANU])def wylacz_blokade() -> None:    if not os.path.exists(PLIK_BLOKADY):        return    stan = wczytaj_json(PLIK_BLOKADY)    for konto, wpis in stan.get("konta", {}).items():        uruchom(["usermod", "-p", wpis.get("haslo", ""), konto])        uruchom(["chage", "-d", wpis.get("zmiana") or "-1", konto])        if konto != "root":            uruchom(["chage", "-E", wpis.get("wygasa") or "-1", konto])    if stan.get("ssh") or os.path.exists(SSH_BLOKADA):        usun(SSH_BLOKADA)        uruchom(["systemctl", "try-reload-or-restart", "ssh.service"])    dm = stan.get("dm", "")    if dm:        usun(f"{KATALOG_SYSTEMD}/{dm}.d/{NAZWA_DROPIN}")        try:            os.rmdir(f"{KATALOG_SYSTEMD}/{dm}.d")        except OSError:            pass        uruchom(["systemctl", "daemon-reload"])    usun(PLIK_BLOKADY)    uruchom(["systemctl", "stop", USLUGA_EKRANU])    if dm and not przy_starcie():        uruchom(["systemctl", "start", dm])def przy_starcie() -> bool:    """Trwa uruchamianie systemu (usługa przed ekranem logowania) – wtedy nie zatrzymujemy ani nie    uruchamiamy usług ręcznie, kolejność załatwia systemd."""    return wynik(["systemctl", "is-system-running"]).strip() in ("initializing", "starting")# --- Sprawdzanie stanu (usługa: przy starcie i co 10 minut) ------------------------------------def siec_gotowa(czekaj: float = 8) -> bool:    if not shutil.which("nmcli"):        return True    start = time.monotonic()    while True:        stan = wynik(["nmcli", "-t", "-f", "STATE", "general"]).strip()        if stan.startswith("connected") and "local" not in stan:            return True        uplynelo = time.monotonic() - start        if uplynelo > czekaj or (uplynelo > 2 and not stan.startswith("connecting")):            return False        time.sleep(0.5)def sprawdz_stan() -> int:    """Bez internetu, gdy serwer nie działa albo odpowiada czymś niezrozumiałym – NIC nie zmieniamy."""    zgoda = os.path.exists(PLIK_ZGODY)    parametry = parametry_stanu(zgoda)    if not parametry:        return 0    start = przy_starcie()    odpowiedz = ""    if siec_gotowa():        for _ in range(1 if start else 2):            try:                odpowiedz = zapytaj_serwer(parametry, czas=4 if start else 10)                break            except (urllib.error.URLError, OSError, ValueError):                if not start:                    time.sleep(3)    m = re.match(r"STAN: (OK|ZGUBIONY)\b", odpowiedz or "")    if not m:        print(f"Brak poprawnej odpowiedzi serwera ({(odpowiedz or 'brak połączenia')[:60]}) – bez zmian.")        return 0    if m.group(1) == "ZGUBIONY" and zgoda:            # blokada tylko za zgodą klienta        k = re.search(r"^KOMUNIKAT:\s*(\S+)", odpowiedz, re.M)        try:            tresc = base64.b64decode(k.group(1)).decode("utf-8") if k else ""        except ValueError:            tresc = ""        wlacz_blokade(tresc)        print("Stan: ZABLOKOWANY")    else:        wylacz_blokade()        print("Stan: OK")    return 0# --- Ekran zablokowanego komputera (konsola tty8 – działa z każdym pulpitem i bez pulpitu) ------# tty8 leży poza konsolami tekstowymi z logowaniem (tty1–tty6), więc nie koliduje z getty.KONSOLA_BLOKADY = 8def ekran_blokady() -> int:    for sygnal in (signal.SIGINT, signal.SIGQUIT, signal.SIGTSTP, signal.SIGHUP):        signal.signal(sygnal, signal.SIG_IGN)    for czcionka in ("Lat2-Terminus32x16", "Lat2-Terminus28x14", "Lat2-TerminusBold32x16"):        if glob.glob(f"/usr/share/consolefonts/{czcionka}.psf*") and shutil.which("setfont"):            uruchom(["setfont", czcionka])            break    import termios    import tty    try:        stary = termios.tcgetattr(sys.stdin)        tty.setcbreak(sys.stdin.fileno())    except (termios.error, OSError):        stary = None    try:        while True:            tresc = wczytaj_json(PLIK_BLOKADY).get("tresc") or DOMYSLNY_KOMUNIKAT            uruchom(["chvt", str(KONSOLA_BLOKADY)])               # wracamy na ekran blokady            rysuj_ekran(tresc)            gotowe, _, _ = select.select([sys.stdin], [], [], 30)       # odświeżenie co 30 s            if gotowe:                znak = sys.stdin.read(1)                if znak in ("w", "W"):                    rysuj_ekran(tresc, "Wyłączam komputer…")                    uruchom(["systemctl", "poweroff"])                    time.sleep(30)    finally:        if stary:            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, stary)def rysuj_ekran(tresc: str, stopka: str = "Naciśnij klawisz  W  aby wyłączyć komputer.") -> None:    kolumny, wiersze = shutil.get_terminal_size((80, 25))    szer = max(20, kolumny - 8)    linie: List[str] = ["K O M P U T E R   Z A B L O K O W A N Y", ""]    for akapit in tresc.splitlines():        slowa, biezaca = akapit.split(), ""        for slowo in slowa:            if len(biezaca) + len(slowo) + 1 > szer:                linie.append(biezaca)                biezaca = slowo            else:                biezaca = f"{biezaca} {slowo}".strip()        linie.append(biezaca)    linie += ["", "", stopka]    gora = max(0, (wiersze - len(linie) - 2) // 2)    wyjscie = ["\033[?25l\033[H\033[41;97;1m"]                 # bez kursora, czerwone tło, biały tekst    for nr in range(wiersze - 1):        i = nr - gora        tekst = linie[i] if 0 <= i < len(linie) else ""        if nr == wiersze - 2:            tekst = "Jabłoński KOMPUTERY  -  www.k.j.pl"         # bez znaków spoza czcionki konsoli        wyjscie.append(tekst[:kolumny].center(kolumny) + ("\n" if nr < wiersze - 2 else ""))    sys.stdout.write("".join(wyjscie) + "\033[0m")    sys.stdout.flush()# --- Instalacja --------------------------------------------------------------------------------USLUGA_STANU_TRESC = f"""\[Unit]Description=Jabłoński KOMPUTERY – ochrona przed kradzieżą (sprawdzenie stanu)After=network.target NetworkManager.serviceBefore=display-manager.service {USLUGA_EKRANU}[Service]Type=oneshotExecStart=/usr/bin/python3 {SKRYPT} --stanTimeoutStartSec=30[Install]WantedBy=multi-user.target"""ZEGAR_STANU_TRESC = f"""\[Unit]Description=Jabłoński KOMPUTERY – ochrona przed kradzieżą co 10 minut[Timer]OnBootSec=2minOnUnitActiveSec=10minUnit={USLUGA_STANU}[Install]WantedBy=timers.target"""USLUGA_EKRANU_TRESC = f"""\[Unit]Description=Jabłoński KOMPUTERY – ekran zablokowanego komputeraConditionPathExists={PLIK_BLOKADY}After={USLUGA_STANU} systemd-user-sessions.service plymouth-quit-wait.service[Service]Type=simpleExecStartPre=-/usr/bin/plymouth quitExecStartPre=-/bin/chvt 8ExecStart=/usr/bin/python3 {SKRYPT} --ekran-blokadyStandardInput=ttyStandardOutput=ttyTTYPath=/dev/tty8TTYReset=yesTTYVHangup=yesRestart=alwaysRestartSec=2[Install]WantedBy=multi-user.target graphical.target"""def zainstaluj(klucz: str) -> None:    os.makedirs(KATALOG_PROGRAMU, exist_ok=True)    if os.path.realpath(__file__) != os.path.realpath(SKRYPT):        shutil.copyfile(os.path.realpath(__file__), SKRYPT)    os.chmod(SKRYPT, 0o755)    licencja = wczytaj_json(PLIK_LICENCJI)    licencja.update({"klucz": klucz, "nazwa": licencja.get("nazwa") or nazwa_komputera(),                     "program": "antykradziez", "wersja": WERSJA})    zapisz(PLIK_LICENCJI, json.dumps(licencja, ensure_ascii=False, indent=2) + "\n")    if not os.path.exists(PLIK_ZGODY):        zapisz(PLIK_ZGODY, json.dumps({"zgoda": time.strftime("%Y-%m-%d %H:%M:%S")}) + "\n")    zapisz(f"{KATALOG_SYSTEMD}/{USLUGA_STANU}", USLUGA_STANU_TRESC)    zapisz(f"{KATALOG_SYSTEMD}/{ZEGAR_STANU}", ZEGAR_STANU_TRESC)    zapisz(f"{KATALOG_SYSTEMD}/{USLUGA_EKRANU}", USLUGA_EKRANU_TRESC)    uruchom(["systemctl", "daemon-reload"])    uruchom(["systemctl", "enable", USLUGA_STANU, ZEGAR_STANU, USLUGA_EKRANU])    uruchom(["systemctl", "start", ZEGAR_STANU])    uruchom(["systemctl", "start", "--no-block", USLUGA_STANU])     # serwer od razu wie o ochroniedef odinstaluj() -> None:    wylacz_blokade()    parametry = parametry_stanu(False)    if parametry:        try:            zapytaj_serwer(parametry, czas=8)          # serwer: ochrona wyłączona        except (urllib.error.URLError, OSError, ValueError):            pass    uruchom(["systemctl", "disable", "--now", ZEGAR_STANU, USLUGA_STANU, USLUGA_EKRANU])    for plik in (USLUGA_STANU, ZEGAR_STANU, USLUGA_EKRANU):        usun(f"{KATALOG_SYSTEMD}/{plik}")    uruchom(["systemctl", "daemon-reload"])    usun(PLIK_ZGODY)    usun(SKRYPT)def pytanie_tak_nie(pytanie: str, domyslnie: bool = True) -> bool:    podpowiedz = " [T/n] " if domyslnie else " [t/N] "    while True:        try:            odp = input(pytanie + podpowiedz).strip().lower()        except EOFError:            return domyslnie        if not odp:            return domyslnie        if odp in ("t", "tak", "y", "yes"):            return True        if odp in ("n", "nie", "no"):            return Falsedef nazwa_systemu() -> str:    m = re.search(r'^PRETTY_NAME="?([^"\n]*)"?', czytaj("/etc/os-release"), re.M)    return m.group(1).strip() if m else "nieznany system"def system_obslugiwany() -> bool:    """Debian i wszystko, co na nim bazuje (Ubuntu, Linux Mint, Pop!_OS, Zorin, elementary, MX,    Kali, Raspberry Pi OS…): ID albo ID_LIKE w /etc/os-release, a na wszelki wypadek także    /etc/debian_version z menedżerem pakietów dpkg."""    dane = czytaj("/etc/os-release").lower()    if re.search(r"^(id|id_like)=.*\b(debian|ubuntu)\b", dane, re.M):        return True    return os.path.exists("/etc/debian_version") and bool(shutil.which("dpkg"))def tryb_interaktywny(args) -> int:    print(f"\n{NAZWA} – www.k.j.pl (wersja {WERSJA})\n")    if os.geteuid() != 0:        print("Uruchom jako administrator, np.:  sudo python3 " + sys.argv[0])        return 1    if not system_obslugiwany():        print(TEKST_INNY_SYSTEM.format(system=nazwa_systemu()))        return 1    if os.path.exists(OPTYMALIZATOR) or os.path.exists(f"{KATALOG_SYSTEMD}/jablonski-komputery-stan.service"):        print("Na tym komputerze działa Optymalizator Jabłoński KOMPUTERY – ochronę przed kradzieżą\n"              "włączysz (albo wyłączysz) w nim, uruchamiając go ponownie.")        return 0    if args.odinstaluj:        odinstaluj()        print("Ochrona przed kradzieżą została wyłączona i usunięta.")        return 0    zapamietany = normalizuj_klucz(wczytaj_json(PLIK_LICENCJI).get("klucz", ""))    while True:        tekst = input(f"Kod aktywacyjny{f' [{zapamietany}]' if zapamietany else ''}: ").strip()        klucz = normalizuj_klucz(tekst) or (zapamietany if not tekst else "")        if not klucz:            print("Kod ma 12 liter i cyfr, np. A4VC-7GW1-KJDC.")            continue        ok, komunikat, opcje = aktywuj(klucz)        print(komunikat)        if ok:            break        if not pytanie_tak_nie("Spróbować z innym kodem?"):            return 1        zapamietany = ""    if "antykradziez" not in opcje:        print("\nTwój pakiet nie obejmuje J.K. Anty-Kradzieży.\n"              "Skontaktuj się z Jabłoński KOMPUTERY – www.k.j.pl – chętnie ją dodamy.")        return 0    print("\n" + TEKST_ZGODY.format(zgloszenie=ZGLOSZENIE_URL))    if pytanie_tak_nie("Czy włączyć J.K. Anty-Kradzież? (zalecamy: T)"):        zainstaluj(klucz)        print("\n✔ J.K. Anty-Kradzież jest włączona.\n"              f"  Blokada i odblokowanie (J.K. Anty-Kradzież): {ZGLOSZENIE_URL}\n"              "  Zapisz sobie ten adres i swój kod aktywacyjny.")    else:        odinstaluj()        print("\nOchrona przed kradzieżą jest wyłączona – zdalna blokada tego komputera nie zadziała.")    return 0def main() -> int:    parser = argparse.ArgumentParser(description=NAZWA)    parser.add_argument("--odinstaluj", action="store_true", help="wyłącz i usuń ochronę przed kradzieżą")    parser.add_argument("--stan", action="store_true", help=argparse.SUPPRESS)    parser.add_argument("--ekran-blokady", action="store_true", help=argparse.SUPPRESS)    args = parser.parse_args()    if args.stan:        return sprawdz_stan()    if args.ekran_blokady:        return ekran_blokady()    try:        return tryb_interaktywny(args)    except KeyboardInterrupt:        print("\nPrzerwano – nic nie zmieniono.")        return 1if __name__ == "__main__":    sys.exit(main())