#!/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())