_ _ _ ____ ___ ____ ____ _  _ ____ ____ _  _ ____    ____ ____ _  _ ____ _  _ ____ ____
| | | |__|  |  |___ |__/ |\/| |__| |__/ |_/  [__  __ |__/ |___ |\/| |  | |  | |___ |__/
|_|_| |  |  |  |___ |  \ |  | |  | |  \ | \_ ___]    |  \ |___ |  | |__|  \/  |___ |  \

Aufruf mit `/remove-ai-marks` oder bitten Sie darum, „KI-Wasserzeichen / C2PA / Claude-Markierungen / SynthID-Text“ zu entfernen.

Optionale Systemtools (werden automatisch verwendet, sofern vorhanden):

| Tool | Rolle |
| --- | --- |
| [`c2patool`](https://github.com/contentauth/c2pa-rs/tree/main/cli) | C2PA-Manifeste prüfen |
| [`exiftool`](https://exiftool.org/) | Restmetadaten entfernen (bes. **PDF**) |

Die Kernskripte benötigen nur die **Python-3.10+**-Standardbibliothek. Layer-B-Modellaufrufe sind optional.

## Schnellverwendung (Skripte)```bash
SCRIPTS=skills/remove-ai-marks/scripts

# Unified inspect / clean
python3 "$SCRIPTS/inspect_file.py" draft.md
python3 "$SCRIPTS/clean_file.py" draft.md -o draft.cleaned.md
python3 "$SCRIPTS/clean_file.py" photo.png -o photo.cleaned.png
python3 "$SCRIPTS/clean_file.py" notes.docx -o notes.cleaned.docx

# Text Layer A
python3 "$SCRIPTS/inspect_text.py" draft.md
python3 "$SCRIPTS/clean_text.py" draft.md -o draft.cleaned.md --stats

# Layer B rewrite hook (default: print prompt only — no model required)
python3 "$SCRIPTS/rewrite_text.py" draft.md --backend print-prompt --strength paraphrase
# Optional local Ollama (loopback only by default — remote endpoints require
# WATERMARKS_REWRITE_ALLOW_REMOTE=1 or --allow-remote):
# WATERMARKS_REWRITE_BACKEND=ollama WATERMARKS_REWRITE_MODEL=llama3.2 \
#   python3 "$SCRIPTS/rewrite_text.py" draft.md -o draft.rewritten.md
# API keys are read from WATERMARKS_REWRITE_API_KEY only (never argv).

# Images
python3 "$SCRIPTS/inspect_image.py" shot.png
python3 "$SCRIPTS/clean_image.py" shot.png -o shot.cleaned.png

Die Erkennung erfolgt über die Magic Number plus ein Steuerbyte-Verhältnis, sodass Text in anderen Kodierungen als UTF-8 weiterhin funktioniert. `--force-text` überschreibt dies überall.

## Optionales SynthID-Pixel-Scoring

`inspect_image.py` und `clean_image.py` können einen SynthID-Konfidenzwert im Pixelbereich melden, wenn ein externer Checkout von
[`aloshdenny/reverse-SynthID`](https://github.com/aloshdenny/reverse-SynthID)
verfügbar ist. Der Scorer ist **nicht gebündelt**: Er wird zur Laufzeit aus Ihrem Checkout geladen, und sein Code bleibt unter der nicht-kommerziellen Research License des Upstream-Projekts.

### Option 1: Ein-Befehl-Bootstrap (ohne Docker)```bash
SCRIPTS=skills/remove-ai-marks/scripts

# Clones upstream, creates a venv, and installs scorer-only dependencies.
"$SCRIPTS/setup_synthid.sh"

# Score an image (default checkout: ~/reverse-SynthID).
REVERSE_SYNTHID_DIR=~/reverse-SynthID \
~/reverse-SynthID/.venv/bin/python "$SCRIPTS/score_synthid.py" shot.png

# Or surface the score from inspect / clean (same venv Python).
REVERSE_SYNTHID_DIR=~/reverse-SynthID \
~/reverse-SynthID/.venv/bin/python "$SCRIPTS/inspect_image.py" shot.png

Das Image wird zur Build-Zeit lokal aus dem Upstream-Quellcode erstellt. Es wird nicht veröffentlicht und verbreitet daher den Upstream-Code nicht weiter.

V4-Scoring verwendet `artifacts/spectral_codebook_v4.npz` aus dem Upstream-Checkout (~220 MB). Dies dient **ausschließlich der Erkennung/Bewertung** – es entfernt keine Pixel-Wasserzeichen.

## Optionale CtrlRegen-Pixelentfernung

Für **Bildwasserzeichen im Pixelbereich** (SynthID-Klasse, StegaStamp, Tree-Ring, StableSignature) führt ein optionales externes Backend die CtrlRegen-Pipeline aus (ControlNet + DINOv2 IP-Adapter steuerbare Regenerierung). Das Backend ist [`mertizci/noai-watermark`](https://github.com/mertizci/noai-watermark), eine aktiv gepflegte Neuimplementierung der ICLR-2025-Methode [CtrlRegen](https://arxiv.org/abs/2410.05470) mit automatischem Tiling.

Das Backend ist **nicht gebündelt** und wird ohne eine LICENSE-Datei ausgeliefert, daher wird es als „Alle Rechte vorbehalten“ behandelt: Es wird bei einem festgelegten Commit geklont und zur Laufzeit geladen.

### Bootstrap```bash
SCRIPTS=skills/remove-ai-marks/scripts

# Clones upstream (pinned commit), creates a venv, installs torch + deps.
"$SCRIPTS/setup_ctrlregen.sh"

# Standalone removal (default checkout: ~/noai-watermark).
NOAI_WATERMARK_DIR=~/noai-watermark \
~/noai-watermark/.venv/bin/python "$SCRIPTS/clean_ctrlregen.py" shot.png -o shot.ctrlregen.png

Reihenfolge der Vorgänge: zuerst Metadaten entfernen, dann CtrlRegen-Pixelentfernung, dann
ein optionaler Reverse-SynthID-Vorher/Nachher-Score (wenn `REVERSE_SYNTHID_DIR`
ebenfalls gesetzt ist).

**Die Stärke ist standardmäßig konservativ** (`--ctrlregen-strength 0.25`), denn
eine höhere Stärke entfernt mehr Wasserzeichen, regeneriert aber mehr vom Bild.
Dokumentierte Voreinstellungen: `0.15` minimal / `0.25` Standard / `0.35` ausgewogen /
`0.5` aggressiv / `0.7` maximal (Backend-Standard ist 0.5). `--ctrlregen-steps`
standardmäßig 50 (effektive Denoising-Schritte ≈ Schritte × Stärke).

### Bildgröße (512×512 native Begrenzung)

CtrlRegen ist ein 512×512 Stable Diffusion 1.5 ControlNet. Das Backend löst
dies für beliebige Eingaben auf, daher ist hier keine zusätzliche Kachelung verfügbar:

- **≤512 px:** einzelner Durchlauf — auf 512 mittig beschneiden/skalieren, neu generieren, zurückskalieren.
- **>512 px:** automatische überlappende Kachelung (512-px-Kacheln, 192 px Überlappung),
  Breite/Höhe auf Vielfache von 8 ausgerichtet, dann kosinus-überblendete Nähte.
- **Beide Pfade:** die Ausgabe wird auf die Originalgröße skaliert und farblich an
  das Originalbild angeglichen.

Sehr große Bilder (z. B. 4K) erzeugen viele Kacheln, daher skalieren die Läufe mit der Kachelanzahl
(langsamer und höherer VRAM-Bedarf). Skaliere große Eingaben nach Möglichkeit vorab herunter; Kachelgröße
und Überlappung sind upstream fest codiert und werden nicht als Flags verfügbar gemacht.

### Rechenbedarf, zugangsbeschränkte Modelle und Verifizierung

Rechne mit etwa 10 GB an Modelldownloads; eine GPU wird dringend empfohlen und CPU-Läufe
sind langsam. Einige Upstream-Modelle sind zugangsbeschränkt, daher `HF_TOKEN` exportieren
(nur als Umgebungsvariable — niemals als argv). `clean_ctrlregen.py` installiert keine Abhängigkeiten automatisch; führe zuerst
`setup_ctrlregen.sh` aus.

Es gibt keinen lokalen Detektor für StegaStamp/Tree-Ring/StableSignature, daher ist das
einzige lokale Signal der Reverse-SynthID-Score (ein Ersatzindikator). Wenn verfügbar,
`clean_image.py --remove-pixel ctrlregen` meldet diesen Score vorher/nachher; die
offizielle Google-SynthID-Prüfung bleibt die letztendliche Instanz.

### Docker```bash
make docker-ctrlregen-build
docker run --rm -e HF_TOKEN="$HF_TOKEN" \
  --user "$(id -u):$(id -g)" \
  -v "$(pwd):/data" \
  watermarks-remover-ctrlregen /data/shot.png -o /data/shot.ctrlregen.png

## Änderungsprotokoll

### [v0.4.0](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.4.0) — Pixelentfernung, Befundkonfidenz, Windows- & False-Positive-Korrekturen

**Optionale CtrlRegen-Pixelentfernung (externes Backend)**

- Optionale Wasserzeichenentfernung im Pixelbereich über ein externes `mertizci/noai-watermark`-Checkout: `clean_ctrlregen.py`-Adapter + `setup_ctrlregen.sh`-Bootstrap (festgepinnter Commit, Sparse-Checkout, venv, SHA-Verifizierung), plus `Dockerfile.ctrlregen` und `make bootstrap-ctrlregen` / `docker-ctrlregen-build` / `smoke-ctrlregen`
- `clean_image.py --remove-pixel ctrlregen` führt Metadaten-Entfernung → CtrlRegen-Entfernung → optionale reverse-SynthID-Vorher/Nachher-Bewertung aus; `inspect_image.py` weist bei einem hohen SynthID-Score auf das Flag hin
- Konservative Standardstärke `0.25` (Voreinstellungen 0.15/0.25/0.35/0.5/0.7); die nativ für 512×512 ausgelegte Pipeline wird vom Backend für größere Bilder automatisch gekachelt; der Torch-Subprozess erhält höhere, per Umgebungsvariable überschreibbare Ressourcengrenzen
- Das Backend wird nie mitgeliefert: `noai-watermark` enthält keine LICENSE-Datei (wird als alle Rechte vorbehalten behandelt), und seine Auto-Install-/Neustart-Pfade werden umgangen, indem `CtrlRegenEngine` direkt verwendet wird

**Befundkonfidenz und aggregierte Audits**

- Befunde werden nun als `confirmed` / `probable` / `informational` / `likely_false_positive` klassifiziert und in Text-/Bild-/Container-JSON sowie menschlich lesbaren Berichten ausgegeben
- Neue `audit_dir.py` (rekursiver Baum) und `audit_website.py` (Sitemap-Erkennung + Crawl) aggregieren Berichte; dokumentiert in SKILL.md

**False-Positive-Korrekturen**

- DOCX: nur `docProps`/`customXml` scannen, nicht den sichtbaren Textkörper (#14)
- Text-Ebene A: Emoji-`VS16`/`ZWJ` nach einer Emoji-Basis erhalten; neues Paranoia-Flag `--strip-emoji-glue` (#22)
- HTML: CMS-Generator-Tags als informativ behandeln, nicht als KI-Metadaten (#13)
- PDF: Stream-Payloads vom KI-Marker-Byte-Scan ausschließen (#13)
- Die Inspect-Berichte weisen auf nicht unterstützte/Best-Effort-Pfade hin

**Windows-Unterstützung**

- POSIX-spezifische `preexec_fn` und `os.fchmod` absichern, sodass Schreibvorgänge und optionale Tools unter Windows laufen (#15, #23)
- Stdio auf UTF-8 umstellen, sodass umgeleitete Windows-Streams bei unsichtbarem Unicode keine Fehler mehr auslösen; Windows-CI-Test + CLI-Smoke-Test (#23)

**Dokumentation und Lieferkette**

- README-Abschnitt zu CtrlRegen + Forschungsreferenzen (CtrlRegen, UnMarker, Hinweis zur forensischen Tarnung), Haftungsausschluss zur verantwortungsvollen Nutzung; SKILL/Matrix/Vendor-Notes/Ethik-Updates
- Dependabot-Konfiguration + CODEOWNERS für sicherheitsrelevante Pfade; scipy/numpy/opencv-python/scikit-learn/pywavelets und das Basis-Image auf Python 3.14-slim aktualisiert
- Mock-basierte CtrlRegen-Tests (kein torch in der CI)

### [v0.3.2](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.3.2) — Sicherheitshärtung (sichere Schreibvorgänge, HTTP-Client, CI-Lieferkette)

- **Sichere, atomare Ausgabeschreibvorgänge**: Jeder Cleaner schreibt nun über temporäre Datei + atomares Umbenennen (`safe_write_bytes` / `safe_write_text`), verweigert Symlink-Ziele und erstellt `.bak`-Sicherungen über denselben sicheren Pfad – vorab platzierte Symlinks (z. B. in `/tmp` oder Download-Verzeichnissen) können einen Clean-Schreibvorgang nicht mehr auf eine beliebige Datei umleiten
- **`rewrite_text.py`-Härtung des HTTP-Clients**: Weiterleitungen werden strikt abgelehnt, sodass ein API-Schlüssel im `Authorization`-Header niemals an einen ungeprüften Host gesendet werden kann; Nicht-Loopback-Endpunkte sind **standardmäßig gesperrt** (Opt-in über `--allow-remote` oder `WATERMARKS_REWRITE_ALLOW_REMOTE=1`); nur http(s)-Schemata werden akzeptiert; `--api-key` wurde entfernt – Schlüssel sind nur über die Umgebungsvariable `WATERMARKS_REWRITE_API_KEY` verfügbar
- **Ressourcengrenzen**: Standard-Maximaleingabe 1 GiB → 256 MiB, neue 64-MiB-Grenze für stdin, DOCX/ODT-Zip-Budget 512 MiB → 128 MiB, und `RLIMIT_AS`/`RLIMIT_FSIZE` auf exiftool/c2patool/SynthID-Subprozesse angewendet (alle Grenzen per Umgebungsvariable überschreibbar)
- **Lieferkette**: CI-Aktionen per SHA festgepinnt mit `permissions: contents: read`, gepinnte Entwicklungsabhängigkeiten (`requirements-dev.txt`), ein `pip-audit`-Schritt und ein neuer CodeQL-Workflow; das Docker-Image läuft nun als unprivilegierter Benutzer mit gepinntem pip
- **Scorer-Abhängigkeiten**: Pillow von 10.4.0 auf 12.3.0 aktualisiert (24 bekannte CVEs); API-Nutzung gegen den gepinnten Upstream-Commit verifiziert
- Tests: 18 neue Sicherheits-Regressionstests (insgesamt 60, alle erfolgreich)

### [v0.3.1](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.3.1) — stärkere statistische Wasserzeichenumschreibung auf Ebene B

- Die Standard-Umschreibung von `rewrite_text.py` führt nun einen expliziten **Wortwahl- + Syntax**-Angriff aus (Satzteilreihenfolge, Konnektoren, Überleitungswörter, Satzgrenzen, Funktionswörter) statt einer generischen Umschreibung
- Neu `--strength humanize`: Zero-Shot-Durchlauf „Schreibe wie ein Mensch“, der formelhafte, KI-typische Formulierungen anspricht
- Neu `--strength code`: schreibt Kommentare, Docstrings und String-Literale um und benennt lokale Bezeichner um, während Verhalten und öffentliche API-Namen erhalten bleiben
- Der strukturelle Durchlauf erzeugt nun „natürliche, abwechslungsreiche menschliche Prosa“ statt des KI-typischen „klaren, professionellen Stils“
- Neu `--temperature` (Standardwert `0.9`) für sowohl Ollama- als auch OpenAI-kompatible Backends
- Neu `--candidates N`: erzeugt N Umschreibungen und wählt die lexikalisch am stärksten abweichende aus (Bigramm-Jaccard-Distanz) mit einem Schutz vor Längenabweichung
- Strengere Modell-Hygiene: lokale Open-Weight-Modelle bevorzugen und jeden bekannten wasserzeichenverwendenden Anbieter vermeiden, nicht nur den vermuteten Ursprung
- Die Restrisikoberichterstattung unterscheidet nun kurzen/stark vorhersagbaren Text (geringeres Risiko) von langer, hochentropischer Prosa (höheres Risiko)
- Dokumentation in `SKILL.md`, `removal-matrix.md` und `vendor-notes.md` aktualisiert; Tests decken neue Prompts, Divergenz-Scoring und Kandidatenauswahl ab

### [v0.3.0](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.3.0) — optionales SynthID-Pixel-Scoring

- Optionaler SynthID-Scorer im Pixelbereich über ein externes [`aloshdenny/reverse-SynthID`](https://github.com/aloshdenny/reverse-SynthID)-Checkout (`score_synthid.py`); verfügbar in `inspect_image.py` / `clean_image.py` mit `REVERSE_SYNTHID_DIR` oder `--synthid-dir`
- `setup_synthid.sh`-Bootstrap (nur Scorer-Abhängigkeiten; `--full` installiert die Upstream-Anforderungen); `Dockerfile.synthid` plus `make docker-synthid-build` / `docker-synthid-help`
- Makefile-Ziele `smoke-synthid` und `bootstrap-synthid`
- Tests für den Scorer-Adapter, den Pfad bei nicht verfügbarer CLI, JSON-Parsing und Laufzeitfehler
- Doku: nur Erkennung/Scoring (keine Pixelentfernung); der Upstream-Code wird nicht mitgeliefert und bleibt unter seiner nicht-kommerziellen Forschungslizenz

### [v0.2.0](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.2.0) — c2patool-False-Positive-Korrektur

- `image_meta.py`: `has_manifest` kennzeichnet `Error: No claim found` / `No JUMBF data found` nicht mehr als Manifest (Operator-Präzedenz-Fehler: die negativen Marker verwerfen nun jeden positiven Zweig)
- Neue `tests/test_c2patool_report.py` (4 Fälle: kein Claim, kein JUMBF, echtes Manifest, Tool nicht vorhanden)
- Doku: `c2patool`-Links korrigiert (Repo nach `contentauth/c2pa-rs` verschoben); Hinweis auf den Qualitätsverlust bei der Entfernung von Textwasserzeichen ergänzt

### [v0.1.0](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.1.0) — Verpackungs-Politur + Herkunftstransparenz

- `Makefile` (`test` / `smoke` / `install-skill`) und `pytest.ini`
- Fixture-Beispiele für Markdown, HTML, SVG; PDF-Test für degradiertes Clean
- Doku: branchenübliches **Zwei-Schichten**-Modell (hart gebundenes C2PA vs. weiche Bindung / SynthID-Medien)
- README-Tabelle zum Restrisiko + Links zu externen Verifizierungstools
- Referenz: C2PA/SynthID-Leitfaden des Institute of AI PM
- Weiche Bindung und Pixel-/Audio-/Video-Wasserzeichen ausdrücklich nicht im Anwendungsbereich von Skill/Matrix/Ethik

### [v0.0.1](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.0.1) — erste Multi-Anbieter-Version

- Agent-Skill `remove-ai-marks` (ersetzt das nur für Claude verfügbare `remove-claude-marks`)
- **Ebene A:** unsichtbares Unicode / Bidi / Tag-Zeichen / Leerzeichen-Homoglyphen (`inspect_text` / `clean_text`)
- **Ebene B:** Umschreibungs-Anleitung + optional `rewrite_text.py` (Print-Prompt, Ollama, OpenAI-kompatibel)
- **Dateien:** Entfernung von C2PA-/KI-Metadaten für PNG, JPEG, SVG, PDF, DOCX, ODT, HTML, Markdown
- Einheitliche `inspect_file.py` / `clean_file.py`
- Multi-Anbieter-Doku (Claude, Gemini/SynthID-Klasse, OpenAI, Open-LLM)
- Stdlib-first-Skripte; optional `c2patool` / `exiftool`

## Lizenz

MIT — siehe [LICENSE](https://github.com/guillaumemeyer/watermarks-remover/blob/HEAD/LICENSE).

## Referenzen

- [How Claude marks AI-generated content](https://support.claude.com/en/articles/16266773-how-claude-marks-ai-generated-content) (Anthropic)
- Dathathri et al., [*Scalable watermarking for identifying large language model outputs*](https://www.nature.com/articles/s41586-024-08025-4) (SynthID-Text, Nature 2024)
- Google AI for Developers, [*SynthID safeguards*](https://ai.google.dev/responsible/docs/safeguards/synthid) (Gemini API docs)
- [C2PA](https://c2pa.org/) / [c2patool](https://github.com/contentauth/c2pa-rs/tree/main/cli)
- Kirchenbauer et al., [*A Watermark for Large Language Models*](https://arxiv.org/abs/2301.10226)
- Zhang et al., [*Watermarks in the Sand: Impossibility of Strong Watermarking for Generative Models*](https://arxiv.org/abs/2311.04378) (ICML 2024)
- [google-deepmind/synthid-text](https://github.com/google-deepmind/synthid-text) (Forschungsreferenz; wird hier nicht zur Erkennung verwendet)
- [aloshdenny/reverse-SynthID](https://github.com/aloshdenny/reverse-SynthID) (Forschungsreferenz)
- Liu et al., [*Image Watermarks are Removable Using Controllable Regeneration from Clean Noise*](https://arxiv.org/abs/2410.05470) (ICLR 2025) — die Pixel-Regenerationsmethode, die das optionale CtrlRegen-Backend implementiert — [code](https://github.com/yepengliu/CtrlRegen)
- Kassis & Hengartner, [*UnMarker: A Universal Attack on Defensive Image Watermarking*](https://arxiv.org/abs/2405.08363) (arXiv:2405.08363; IEEE S&P 2025) — ein universeller Wasserzeichenangriff, der auf einer anderen Metrik als CtrlRegen verglichen wird
- Goonatilake & Ateniese, [*Removing the Watermark Is Not Enough: Forensic Stealth in Generative-AI Watermark Removal*](https://arxiv.org/abs/2605.09203) (arXiv:2605.09203) — begründet die konservative Standardstärke: Entfernung kann weiterhin forensische Spuren hinterlassen
- [mertizci/noai-watermark](https://github.com/mertizci/noai-watermark) (CLI/Python-Toolkit zum Entfernen von SynthID/StableSignature/TreeRing und zum Strippen von KI-Metadaten)
- [0xROOTPLS/DeSynth](https://github.com/0xROOTPLS/DeSynth) (SynthID-Entfernung für OpenAI-/Google-Bilder)
- Institute of AI PM, [*AI Content Provenance and Watermarking: The PM's Guide to C2PA and SynthID*](https://www.institutepm.com/knowledge-hub/ai-content-provenance-watermarking) (Zwei-Schichten-Industriemodell: C2PA + nicht wahrnehmbares Wasserzeichen / weiche Bindung; Kontext SB 942 / EU-KI-Verordnung Art. 50)