369 lines
12 KiB
Python
369 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""
|
||
AzA Aktivierungsschlüssel-System.
|
||
|
||
Erzeugt, prüft und persistiert Aktivierungsschlüssel.
|
||
|
||
Schlüssel-Format
|
||
----------------
|
||
|
||
Kanonisch:
|
||
|
||
AZA-YYYYMMDD-<hmac_hex[:12]>
|
||
|
||
Beispiel: ``AZA-20271231-1a2b3c4d5e6f``
|
||
|
||
Damit ältere oder von Hand abgetippte Schlüssel nicht unnötig am
|
||
Format scheitern, akzeptiert der Validator ausserdem:
|
||
|
||
* gross-/kleingeschrieben (``aza-...`` ist gleichwertig zu ``AZA-...``);
|
||
* Whitespace, Tabulatoren, Zeilenumbrüche im / vor / nach dem Schlüssel;
|
||
* Unicode-Bindestriche (en-dash, em-dash, geschützter Bindestrich);
|
||
* Datum mit Trennzeichen (``YYYY-MM-DD``, ``YYYY.MM.DD``, ``YYYY/MM/DD``);
|
||
* Signatur-Längen 8, 12 oder 16 (frühere Builds).
|
||
|
||
Damit funktioniert ein bereits einmal vergebener Schlüssel auf
|
||
demselben Computer auch dann weiter, wenn er kopierte Leerzeichen,
|
||
PDF-Bindestriche oder leichte Schreibvarianten enthält.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import hmac
|
||
import hashlib
|
||
import json
|
||
import os
|
||
import re
|
||
import time
|
||
import unicodedata
|
||
from datetime import datetime, date, timedelta
|
||
from typing import Optional, Tuple
|
||
|
||
from aza_config import (
|
||
get_writable_data_dir,
|
||
ACTIVATION_CONFIG_FILENAME,
|
||
ACTIVATION_HMAC_SECRET,
|
||
APP_HARD_EXPIRY,
|
||
APP_TRIAL_DAYS,
|
||
)
|
||
|
||
|
||
# ── Pfade ─────────────────────────────────────────────────────────────
|
||
|
||
def _activation_path() -> str:
|
||
return os.path.join(get_writable_data_dir(), ACTIVATION_CONFIG_FILENAME)
|
||
|
||
|
||
# ── Signatur ──────────────────────────────────────────────────────────
|
||
|
||
def _sign(expiry_compact: str, length: int = 12) -> str:
|
||
"""HMAC-Hex-Signatur über das Ablaufdatum (compact ``YYYYMMDD``)."""
|
||
sig = hmac.new(
|
||
ACTIVATION_HMAC_SECRET.encode("utf-8"),
|
||
expiry_compact.encode("utf-8"),
|
||
hashlib.sha256,
|
||
).hexdigest()
|
||
if length <= 0:
|
||
return sig
|
||
return sig[:length]
|
||
|
||
|
||
# ── Schlüssel generieren ──────────────────────────────────────────────
|
||
|
||
def generate_key(expiry_date: str) -> str:
|
||
"""Erzeugt einen kanonischen Aktivierungsschlüssel ``AZA-YYYYMMDD-<sig12>``."""
|
||
dt = datetime.strptime(expiry_date, "%Y-%m-%d")
|
||
tag = dt.strftime("%Y%m%d")
|
||
return f"AZA-{tag}-{_sign(tag, 12)}"
|
||
|
||
|
||
# ── Normalisierung ───────────────────────────────────────────────────
|
||
|
||
# Alle Zeichen, die wir wie einen ASCII-Bindestrich behandeln.
|
||
_DASH_CHARS = (
|
||
"-", # ASCII
|
||
"\u2010", # hyphen
|
||
"\u2011", # non-breaking hyphen
|
||
"\u2012", # figure dash
|
||
"\u2013", # en dash
|
||
"\u2014", # em dash
|
||
"\u2015", # horizontal bar
|
||
"\u2212", # minus sign
|
||
"\uFE58", # small em dash
|
||
"\uFE63", # small hyphen-minus
|
||
"\uFF0D", # fullwidth hyphen-minus
|
||
)
|
||
_DASH_TRANSLATE = {ord(c): "-" for c in _DASH_CHARS}
|
||
_KEY_PREFIX_PATTERN = re.compile(r"^A\W*Z\W*A\b", re.IGNORECASE)
|
||
_DATE_BLOCK_PATTERN = re.compile(
|
||
r"(?P<y>\d{4})\s*[-./ ]?\s*(?P<m>\d{2})\s*[-./ ]?\s*(?P<d>\d{2})"
|
||
)
|
||
|
||
|
||
def _normalize_key(raw: str) -> Optional[str]:
|
||
"""Bringt einen frei eingegebenen Schlüssel in das kanonische Format
|
||
``AZA-YYYYMMDD-<sigHEX>`` (Signatur lower-case).
|
||
|
||
Liefert ``None`` zurück, wenn schon strukturell nichts brauchbares
|
||
erkennbar ist – das ruft dann sauber den Format-Fehler aus."""
|
||
if not raw or not isinstance(raw, str):
|
||
return None
|
||
|
||
# Unicode-NFKC, Bindestriche normalisieren, Whitespace komplett raus.
|
||
s = unicodedata.normalize("NFKC", raw).translate(_DASH_TRANSLATE)
|
||
s = re.sub(r"\s+", "", s)
|
||
s = s.upper()
|
||
|
||
if not s:
|
||
return None
|
||
|
||
# Optionalen "AZA"-Präfix tolerant erkennen (auch z. B. "A-Z-A").
|
||
m = _KEY_PREFIX_PATTERN.match(s)
|
||
if m:
|
||
body = s[m.end():]
|
||
else:
|
||
body = s
|
||
body = body.lstrip("-")
|
||
|
||
# Datum extrahieren – akzeptiert YYYYMMDD ebenso wie 2027-12-31.
|
||
md = _DATE_BLOCK_PATTERN.search(body)
|
||
if not md:
|
||
return None
|
||
tag = f"{md.group('y')}{md.group('m')}{md.group('d')}"
|
||
|
||
# Alles ab dem Datum entfernen, Rest = Signatur (nur hex behalten).
|
||
rest = body[md.end():]
|
||
sig = re.sub(r"[^0-9A-F]", "", rest).lower()
|
||
if not sig:
|
||
# Manchmal sitzt die Signatur direkt vor dem Datum (sehr alte Builds)
|
||
head = body[:md.start()]
|
||
sig = re.sub(r"[^0-9A-F]", "", head).lower()
|
||
|
||
if not sig:
|
||
return None
|
||
|
||
return f"AZA-{tag}-{sig}"
|
||
|
||
|
||
def _try_signature_lengths(date_compact: str, sig: str) -> bool:
|
||
"""Prüft die Signatur exakt gegen ihre eigene Länge.
|
||
|
||
Erlaubt frühere Builds mit 8 oder 16 Zeichen Signatur; vermeidet aber
|
||
bewusst, eine 12-Zeichen-Signatur durch einen 8-Zeichen-Match zu
|
||
akzeptieren (Manipulationen müssen scheitern)."""
|
||
sig_len = len(sig)
|
||
if sig_len not in (8, 12, 16, 32, 64):
|
||
return False
|
||
try:
|
||
expected = _sign(date_compact, sig_len)
|
||
except Exception:
|
||
return False
|
||
return hmac.compare_digest(sig, expected)
|
||
|
||
|
||
# ── Schlüssel validieren ──────────────────────────────────────────────
|
||
|
||
def validate_key(key: str) -> Tuple[bool, Optional[date], str]:
|
||
"""Prüft einen Aktivierungsschlüssel tolerant.
|
||
|
||
Returns:
|
||
``(valid, expiry_date_or_None, reason_text)``
|
||
"""
|
||
if not key or not isinstance(key, str):
|
||
return False, None, "Kein Schlüssel eingegeben."
|
||
|
||
canonical = _normalize_key(key)
|
||
if not canonical:
|
||
return False, None, (
|
||
"Ungültiges Schlüsselformat. Erwartet wird ein "
|
||
"Schlüssel der Form AzA-YYYYMMDD-...."
|
||
)
|
||
|
||
parts = canonical.split("-")
|
||
if len(parts) != 3 or parts[0] != "AZA":
|
||
return False, None, "Ungültiges Schlüsselformat."
|
||
|
||
date_part, sig_part = parts[1], parts[2]
|
||
try:
|
||
expiry = datetime.strptime(date_part, "%Y%m%d").date()
|
||
except ValueError:
|
||
return False, None, "Ungültiges Datum im Schlüssel."
|
||
|
||
if not _try_signature_lengths(date_part, sig_part):
|
||
return False, None, "Schlüssel-Signatur ungültig."
|
||
|
||
if expiry < date.today():
|
||
return False, expiry, (
|
||
f"Schlüssel abgelaufen am {expiry.strftime('%d.%m.%Y')}."
|
||
)
|
||
|
||
return True, expiry, f"Gültig bis {expiry.strftime('%d.%m.%Y')}."
|
||
|
||
|
||
# ── Persistenz ────────────────────────────────────────────────────────
|
||
|
||
def save_activation_key(key: str) -> None:
|
||
"""Speichert den Schlüssel in kanonischer Form."""
|
||
canonical = _normalize_key(key) or (key or "").strip()
|
||
path = _activation_path()
|
||
data = {"key": canonical, "saved_at": int(time.time())}
|
||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||
with open(path, "w", encoding="utf-8") as f:
|
||
json.dump(data, f, ensure_ascii=False, indent=2)
|
||
|
||
|
||
def load_activation_key() -> Optional[str]:
|
||
path = _activation_path()
|
||
if not os.path.isfile(path):
|
||
return None
|
||
try:
|
||
with open(path, "r", encoding="utf-8") as f:
|
||
data = json.load(f)
|
||
raw = data.get("key")
|
||
if not raw:
|
||
return None
|
||
return _normalize_key(raw) or raw
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
# ── Demo-Modus-Marker ─────────────────────────────────────────────────
|
||
|
||
DEMO_OPT_OUT_FILENAME = "kg_diktat_demo_opt_in.json"
|
||
|
||
|
||
def _demo_opt_in_path() -> str:
|
||
return os.path.join(get_writable_data_dir(), DEMO_OPT_OUT_FILENAME)
|
||
|
||
|
||
def mark_demo_opt_in() -> None:
|
||
"""Merkt sich, dass der Benutzer bewusst im Demomodus weiterfährt."""
|
||
try:
|
||
path = _demo_opt_in_path()
|
||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||
with open(path, "w", encoding="utf-8") as f:
|
||
json.dump({"opted_in": True, "ts": int(time.time())}, f)
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
def has_demo_opt_in() -> bool:
|
||
try:
|
||
path = _demo_opt_in_path()
|
||
if not os.path.isfile(path):
|
||
return False
|
||
with open(path, "r", encoding="utf-8") as f:
|
||
data = json.load(f)
|
||
return bool(data.get("opted_in"))
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
# ── Startup-Check ─────────────────────────────────────────────────────
|
||
|
||
def _get_install_date_file() -> str:
|
||
return os.path.join(get_writable_data_dir(), "install_date.json")
|
||
|
||
|
||
def _get_install_date() -> date:
|
||
"""Liefert das Erstinstallations-Datum; legt es beim ersten Aufruf an."""
|
||
path = _get_install_date_file()
|
||
if os.path.isfile(path):
|
||
try:
|
||
with open(path, "r", encoding="utf-8") as f:
|
||
data = json.load(f)
|
||
return datetime.strptime(data["install_date"], "%Y-%m-%d").date()
|
||
except Exception:
|
||
pass
|
||
install_d = date.today()
|
||
try:
|
||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||
with open(path, "w", encoding="utf-8") as f:
|
||
json.dump({"install_date": install_d.strftime("%Y-%m-%d")}, f)
|
||
except Exception:
|
||
pass
|
||
return install_d
|
||
|
||
|
||
def check_app_access() -> Tuple[bool, str]:
|
||
"""Prüft ob die App gestartet werden darf.
|
||
|
||
Logik:
|
||
1. Gespeicherter Aktivierungsschlüssel vorhanden und gültig? -> OK
|
||
2. Testphase (APP_TRIAL_DAYS ab Erstinstallation) noch nicht abgelaufen? -> OK
|
||
3. Hartes Ablaufdatum (APP_HARD_EXPIRY) als Sicherheitsnetz -> Gesperrt
|
||
4. Sonst -> Gesperrt
|
||
|
||
Returns:
|
||
``(allowed, user_message)``
|
||
"""
|
||
stored_key = load_activation_key()
|
||
if stored_key:
|
||
valid, expiry, _ = validate_key(stored_key)
|
||
if valid and expiry is not None:
|
||
days_left = (expiry - date.today()).days
|
||
return True, (
|
||
f"Aktiviert bis {expiry.strftime('%d.%m.%Y')} "
|
||
f"({days_left} Tage verbleibend)."
|
||
)
|
||
|
||
install_d = _get_install_date()
|
||
trial_end = install_d + timedelta(days=APP_TRIAL_DAYS)
|
||
today = date.today()
|
||
|
||
try:
|
||
hard_expiry = datetime.strptime(APP_HARD_EXPIRY, "%Y-%m-%d").date()
|
||
except ValueError:
|
||
hard_expiry = None
|
||
|
||
if hard_expiry and today > hard_expiry:
|
||
if stored_key:
|
||
_, _, reason = validate_key(stored_key)
|
||
return False, (
|
||
f"Testphase und Aktivierung abgelaufen.\n{reason}\n"
|
||
"Bitte neuen Aktivierungsschlüssel eingeben."
|
||
)
|
||
return False, (
|
||
"Testphase abgelaufen.\n"
|
||
"Bitte Aktivierungsschlüssel eingeben, um fortzufahren."
|
||
)
|
||
|
||
if today <= trial_end:
|
||
days_left = (trial_end - today).days
|
||
return True, (
|
||
f"Testphase: noch {days_left} Tag(e) verbleibend "
|
||
f"(bis {trial_end.strftime('%d.%m.%Y')})."
|
||
)
|
||
|
||
if stored_key:
|
||
_, _, reason = validate_key(stored_key)
|
||
return False, (
|
||
f"Testphase abgelaufen.\n{reason}\n"
|
||
"Bitte neuen Aktivierungsschlüssel eingeben."
|
||
)
|
||
|
||
return False, (
|
||
f"Die {APP_TRIAL_DAYS}-tägige Testphase ist abgelaufen.\n"
|
||
"Bitte Aktivierungsschlüssel eingeben, um fortzufahren."
|
||
)
|
||
|
||
|
||
# ── CLI-Hilfsmittel zum Generieren (für den Entwickler) ──────────────
|
||
|
||
if __name__ == "__main__":
|
||
import sys as _sys
|
||
|
||
if len(_sys.argv) < 2:
|
||
print("Verwendung: python aza_activation.py <YYYY-MM-DD>")
|
||
print("Beispiel: python aza_activation.py 2026-06-30")
|
||
_sys.exit(1)
|
||
|
||
exp = _sys.argv[1]
|
||
key = generate_key(exp)
|
||
print("\nAktivierungsschlüssel generiert:")
|
||
print(f" Ablaufdatum: {exp}")
|
||
print(f" Schlüssel: {key}")
|
||
|
||
ok, dt, msg = validate_key(key)
|
||
print(f" Validierung: {'OK' if ok else 'FEHLER'} – {msg}")
|