Remover marcas de proveniência de IA de múltiplos fornecedores: higiene de texto Unicode, ganchos estatísticos de reescrita e C2PA/metadados de PNG/JPEG/SVG/PDF/DOCX/HTML/MD
_ _ _ ____ ___ ____ ____ _ _ ____ ____ _ _ ____ ____ ____ _ _ ____ _ _ ____ ____
| | | |__| | |___ |__/ |\/| |__| |__/ |_/ [__ __ |__/ |___ |\/| | | | | |___ |__/
|_|_| | | | |___ | \ | | | | | \ | \_ ___] | \ |___ | | |__| \/ |___ | \
Skill de agente + scripts Python da stdlib para remover marcas de proveniência de IA de vários fornecedores de textos e arquivos — para privacidade e higiene em conteúdo que você possui.
| Camada | Alvo | Como |
|---|---|---|
| A | Unicode invisível, espaços exóticos, bidi, caracteres de tag | Scripts Python determinísticos |
| B | Marcas d'água textuais estatísticas (amostragem de tokens) | Reescrita por agente + hook opcional rewrite_text.py |
| Arquivos | C2PA / EXIF / XMP / propriedades de documento | PNG, JPEG, SVG, PDF, DOCX, ODT, HTML, Markdown |
Fornecedores / ecossistemas (nível de classe): Claude, Gemini / SynthID-Text, superfícies de proveniência da OpenAI, marcas estilo Kirchenbauer de open-LLM.
Último lançamento: v0.4.0
Caminho da skill: skills/remove-ai-marks/
(migração: anteriormente remove-claude-marks; o alias de barra /remove-claude-marks ainda está documentado)
mkdir -p .grok/skills ln -sfn "$(pwd)/skills/remove-ai-marks" .grok/skills/remove-ai-marks
mkdir -p ~/.grok/skills ln -sfn "$(pwd)/skills/remove-ai-marks" ~/.grok/skills/remove-ai-marks
Invoque com `/remove-ai-marks` ou peça para “remover marcas d'água de IA / C2PA / marcas Claude / texto classe SynthID.”
Ferramentas de sistema opcionais (usadas automaticamente quando presentes):
| Ferramenta | Função |
| --- | --- |
| [`c2patool`](https://github.com/contentauth/c2pa-rs/tree/main/cli) | Inspecionar manifestos C2PA |
| [`exiftool`](https://exiftool.org/) | Remoção de metadados residuais (especialmente **PDF**) |
Os scripts principais precisam apenas da stdlib do **Python 3.10+**. As chamadas de modelo da Camada B são opcionais.
## Uso rápido (scripts)```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
inspect_text.py, clean_text.py e rewrite_text.py operam sobre texto. Apontadas
para um .docx, .pdf ou imagem, elas costumavam decodificar os bytes compactados e relatar
quaisquer codepoints que surgissem — ruído que rastreia a compactação, não o
conteúdo — e clean_text.py então gravava esses bytes corrompidos de volta, destruindo o
arquivo. Agora elas recusam entrada binária e indicam a ferramenta que a manipula:```bash
python3 "$SCRIPTS/inspect_text.py" report.docx
A detecção é por número mágico mais uma proporção de bytes de controle, portanto texto em codificações
diferentes de UTF-8 continua funcionando. `--force-text` substitui isso em todos os lugares.
## Pontuação opcional de pixels SynthID
`inspect_image.py` e `clean_image.py` podem relatar uma pontuação de confiança do SynthID no domínio de pixels
quando um checkout externo de
[`aloshdenny/reverse-SynthID`](https://github.com/aloshdenny/reverse-SynthID)
estiver disponível. O avaliador **não está incluído**: ele é carregado em tempo de execução a partir do seu
checkout, e seu código permanece sob a Licença de Pesquisa não comercial do projeto upstream.
### Opção 1: inicialização com um comando (sem 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
setup_synthid.sh aceita --dir PATH, --ref REF e --full (instala o requirements.txt upstream completo, que adiciona torch/diffusers para o bypass de VAE upstream que este projeto não usa).
make docker-synthid-build
docker run --rm
--user "$(id -u):$(id -g)"
--read-only --tmpfs /tmp
-v "$(pwd):/data"
watermarks-remover-synthid-scorer /data/shot.png
A imagem é construída localmente a partir do código-fonte upstream no momento da compilação. Ela não é
publicada, portanto não redistribui o código upstream.
A pontuação V4 usa `artifacts/spectral_codebook_v4.npz` do checkout upstream
(~220 MB). Isso é **somente detecção/pontuação** — não remove marcas d'água de
pixel.
## Remoção opcional de marcas d'água de pixel com CtrlRegen
Para marcas d'água de imagem em **domínio de pixel** (classe SynthID, StegaStamp, Tree-Ring,
StableSignature), um backend externo opcional executa o pipeline CtrlRegen
(ControlNet + DINOv2 IP-Adapter regeneração controlável). O backend é
[`mertizci/noai-watermark`](https://github.com/mertizci/noai-watermark), uma
reimplementação mantida do método
[CtrlRegen](https://arxiv.org/abs/2410.05470) do ICLR 2025 com particionamento automático.
O backend **não é incluído** e não acompanha arquivo LICENSE, portanto é tratado como
todos os direitos reservados: ele é clonado em um commit fixado e carregado em tempo de execução.
### Inicialização```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
NOAI_WATERMARK_DIR=~/noai-watermark
~/noai-watermark/.venv/bin/python "$SCRIPTS/clean_image.py" shot.png
-o shot.cleaned.png --remove-pixel ctrlregen
Order of operations: remoção de metadados primeiro, depois remoção de pixels CtrlRegen, em seguida
uma pontuação opcional de reverse-SynthID antes/depois (quando `REVERSE_SYNTHID_DIR` também
estiver definido).
**A força é conservadora por padrão** (`--ctrlregen-strength 0.25`), porque
quanto maior a força, mais marca d'água é removida, mas mais a imagem é regenerada.
Presets documentados: `0.15` mínimo / `0.25` padrão / `0.35` equilibrado /
`0.5` agressivo / `0.7` máximo (o padrão do backend é 0.5). `--ctrlregen-steps`
tem como padrão 50 (passos efetivos de denoising ≈ passos × força).
### Tamanho da imagem (limite nativo de 512×512)
CtrlRegen é um ControlNet Stable Diffusion 1.5 de 512×512. O backend resolve
isso para entradas arbitrárias, então nenhum tiling extra é exposto aqui:
- **≤512 px:** passagem única — recorte central/redimensionamento para 512, regenerar, redimensionar de volta.
- **>512 px:** tiling automático com sobreposição (tiles de 512 px, sobreposição de 192 px), largura/altura alinhadas a múltiplos de 8, depois costuras mescladas por cosseno.
- **Em qualquer caso:** a saída é redimensionada para o tamanho original e tem as cores ajustadas à imagem original.
Imagens muito grandes (por exemplo, 4K) produzem muitos tiles, então as execuções escalam com a contagem de tiles (mais lentas e com maior uso de VRAM). Reduza previamente a escala de entradas grandes quando for prático; o tamanho do tile e a sobreposição são fixos no upstream e não são expostos como flags.
### Computação, modelos restritos e verificação
Espere ~10 GB de downloads de modelos; uma GPU é fortemente recomendada e execuções em CPU são lentas. Alguns modelos upstream são restritos, então exporte `HF_TOKEN` (apenas via ambiente — nunca argv). `clean_ctrlregen.py` se recusa a instalar dependências automaticamente; execute `setup_ctrlregen.sh` primeiro.
Não há detector local para StegaStamp/Tree-Ring/StableSignature, então o
único sinal local é a pontuação reverse-SynthID (um substituto). Quando disponível,
`clean_image.py --remove-pixel ctrlregen` relata essa pontuação antes/depois; a
verificação oficial do Google SynthID continua sendo a autoridade final.
### 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
Detalhes: skills/remove-ai-marks/references/vendor-notes.md, mark-classes.md.
As marcas d'água em LLMs modernos geralmente ocultam um sinal em quais tokens são escolhidos (viés generativo / de amostragem), não apenas em caracteres invisíveis. Esquemas baseados em edição injetam regras de Unicode ou sinônimos. Esquemas de arquivo anexam C2PA ou metadados do gerador.
Até que os fornecedores disponibilizem detectores e chaves públicas, nenhuma ferramenta pode certificar honestamente que “isto falha na verificação oficial”. Os relatórios devem separar o trabalho verificável do trabalho de melhor esforço.
Prefira um modelo que não seja o de origem para a Layer B (não reescreva texto do Claude com o Claude se você estiver tentando evitar uma nova marcação).
As marcas d'água de texto vivem na própria redação: o sinal está distribuído entre as escolhas de tokens, então quase toda frase carrega um pouco dele. Duas consequências decorrem disso, e são elas que fazem a Layer B ser honestamente descrita como melhor esforço em vez de uma borracha mágica.
Remover significa reformular, não reestruturar. Embaralhar parágrafos, alterar títulos ou fazer pequenos ajustes mal move o sinal. Remover uma marca estatística exige reescrever uma fração substancial do texto — frase por frase, não seção por seção.
Reformular degrada o texto. Qualquer reescrita substitui as escolhas de palavras originais pelas do modelo que reescreve, o que achata tom, voz e precisão. Em textos de produção (SEO, marketing, trabalho para clientes), essa degradação é real e muitas vezes visível para as pessoas que mais se importam com a escrita. É como pegar um texto de um modelo de primeira linha e pedir a um modelo menos capaz que o reescreva do zero: o resultado não pode superar o teto do modelo que reescreve.
O que nos leva à pergunta honesta que fecha o ciclo:
Se o plano é reescrever o texto com um modelo mais barato de qualquer forma, por que pagar por um modelo premium em primeiro lugar? Gerar diretamente com o modelo mais barato é mais simples, mais barato e produz o mesmo — ou melhor — resultado final.
A Layer B faz sentido quando você quer especificamente o raciocínio e o rascunho do modelo premium e aceita uma passada de reescrita para atender a um requisito de higiene ou privacidade — não como um caminho barato para texto livre de marcas.
Quando pular a Layer B:
A remoção de marcas d'água no domínio de pixels agora está disponível como um backend externo opcional do CtrlRegen (veja acima); é um removedor por regeneração, não uma garantia. O vínculo flexível C2PA (marca d'água no conteúdo que pode religar um manifesto remoto de Content Credentials após os metadados serem removidos) permanece fora do escopo. Remover C2PA com vínculo rígido não limpa esses canais.
Esta ferramenta relata remoções verificáveis (contagens de Unicode, ações de metadados) e reescritas de melhor esforço da Layer B. Ela não pode certificar que os detectores dos fornecedores falharão.
Para verificar sinais residuais você mesmo (opcional, externo):
Contexto industrial de duas camadas (C2PA + marca d'água imperceptível): guia do Institute of AI PM.
Matriz: skills/remove-ai-marks/references/removal-matrix.md.
Veja skills/remove-ai-marks/references/ethics.md. Para privacidade e pesquisa no seu conteúdo — não para fraude acadêmica ou alegações falsas de “escrito por humanos”.
Uso responsável: Este projeto é para conteúdo que você possui ou está autorizado a processar. Os usuários devem cumprir as regulamentações locais e usá-lo com responsabilidade. Os desenvolvedores se isentam de qualquer responsabilidade por uso indevido potencial por parte dos usuários.
python3 -m venv .venv && .venv/bin/pip install pytest .venv/bin/python -m pytest # or: make test make smoke # quick CLI smoke on fixtures
## Histórico de alterações
### [v0.4.0](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.4.0) — remoção de pixels, confiança das descobertas, correções no Windows e falsos positivos
**Remoção opcional de pixels via CtrlRegen (backend externo)**
- Remoção opcional de marca d'água no domínio de pixels por meio de um checkout externo de `mertizci/noai-watermark`: adaptador `clean_ctrlregen.py` + bootstrap `setup_ctrlregen.sh` (commit fixado, checkout esparso, venv, verificação de SHA), além de `Dockerfile.ctrlregen` e `make bootstrap-ctrlregen` / `docker-ctrlregen-build` / `smoke-ctrlregen`
- `clean_image.py --remove-pixel ctrlregen` executa remoção de metadados → remoção via CtrlRegen → pontuação opcional reverse-SynthID antes/depois; `inspect_image.py` sugere a flag em caso de pontuação SynthID alta
- Intensidade padrão conservadora `0.25` (predefinições 0.15/0.25/0.35/0.5/0.7); o pipeline nativo de 512×512 é automaticamente dividido em blocos pelo backend para imagens maiores; o subprocesso torch recebe limites de recursos maiores, substituíveis por variáveis de ambiente
- O backend nunca é empacotado: `noai-watermark` não acompanha arquivo LICENSE (tratado como todos os direitos reservados), e seus caminhos de código de auto-instalação/reinício são contornados ao usar `CtrlRegenEngine` diretamente
**Confiança das descobertas e auditorias agregadas**
- As descobertas agora são classificadas como `confirmed` / `probable` / `informational` / `likely_false_positive`, expostas em JSON de texto/imagem/contêiner e em relatórios humanos
- Novos `audit_dir.py` (árvore recursiva) e `audit_website.py` (descoberta de sitemap + rastreamento) agregam relatórios; documentados no SKILL.md
**Correções de falsos positivos**
- DOCX: analisar apenas `docProps`/`customXml`, não o corpo visível (#14)
- Camada de Texto A: preservar emoji `VS16`/`ZWJ` após uma base de emoji; nova flag paranoica `--strip-emoji-glue` (#22)
- HTML: tratar tags de gerador de CMS como informativas, não como metadados de IA (#13)
- PDF: excluir cargas úteis de stream da varredura de bytes de marcadores de IA (#13)
- Relatórios de inspeção observam caminhos não suportados/de melhor esforço
**Suporte a Windows**
- Condicionar `preexec_fn` e `os.fchmod` exclusivos de POSIX para que gravações e ferramentas opcionais funcionem no Windows (#15, #23)
- Reconfigurar stdio para UTF-8 para que fluxos redirecionados do Windows não gerem mais exceções com Unicode invisível; etapa de CI para Windows + execução de smoke test da CLI (#23)
**Documentação e cadeia de suprimentos**
- Seção CtrlRegen no README + referências de pesquisa (CtrlRegen, UnMarker, ressalva sobre stealth forense), aviso de uso responsável; atualizações em SKILL/matrix/vendor-notes/ethics
- Configuração do Dependabot + CODEOWNERS de caminhos de segurança; atualização de scipy/numpy/opencv-python/scikit-learn/pywavelets e da imagem base para Python 3.14-slim
- Testes de CtrlRegen baseados em mock (sem torch na CI)
### [v0.3.2](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.3.2) — endurecimento de segurança (gravações seguras, cliente HTTP, cadeia de suprimentos da CI)
- **Gravações de saída seguras e atômicas**: todos os limpadores agora gravam via arquivo temporário + rename atômico (`safe_write_bytes` / `safe_write_text`), recusam destinos com symlink e criam backups `.bak` pelo mesmo caminho seguro — symlinks pré-posicionados (por exemplo, em `/tmp` ou pastas de download) não podem mais redirecionar uma gravação limpa para um arquivo arbitrário
- **Endurecimento do cliente HTTP de `rewrite_text.py`**: redirecionamentos são recusados categoricamente, para que uma chave de API no cabeçalho `Authorization` nunca seja reenviada a um host não validado; endpoints fora de loopback são **negados por padrão** (ative com `--allow-remote` ou `WATERMARKS_REWRITE_ALLOW_REMOTE=1`); apenas esquemas http(s) são aceitos; `--api-key` foi removido — as chaves são informadas somente via env `WATERMARKS_REWRITE_API_KEY`
- **Limites de recursos**: entrada máxima padrão de 1 GiB → 256 MiB, novo limite de 64 MiB para stdin, orçamento de zip DOCX/ODT de 512 MiB → 128 MiB, e `RLIMIT_AS`/`RLIMIT_FSIZE` aplicados aos subprocessos exiftool/c2patool/SynthID (todos os limites podem ser sobrescritos via variáveis de ambiente)
- **Cadeia de suprimentos**: ações da CI fixadas por SHA com `permissions: contents: read`, dependências de desenvolvimento fixadas (`requirements-dev.txt`), etapa `pip-audit` e um novo fluxo de trabalho CodeQL; a imagem Docker agora roda como usuário sem privilégios com pip fixado
- **Dependências do scorer**: Pillow atualizado de 10.4.0 → 12.3.0 (24 CVEs conhecidas); uso da API verificado em relação ao commit upstream fixado
- Testes: 18 novos testes de regressão de segurança (60 no total, todos passando)
### [v0.3.1](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.3.1) — reescrita mais forte da marca d'água estatística da Camada B
- A paráfrase padrão de `rewrite_text.py` agora executa um ataque explícito de **escolha de palavras + sintaxe** (ordem das orações, conectores, palavras de transição, fronteiras de frases, palavras funcionais) em vez de uma reescrita genérica
- Novo `--strength humanize`: passagem zero-shot "escreva como um humano" voltada para frases padronizadas no estilo de IA
- Novo `--strength code`: reescreve comentários, docstrings e literais de string, e renomeia identificadores locais preservando o comportamento e os nomes da API pública
- A passagem estrutural agora produz "prosa humana natural e variada" em vez do "estilo profissional claro" típico de IA
- Novo `--temperature` (padrão `0.9`) para os backends Ollama e compatíveis com OpenAI
- Novo `--candidates N`: gera N reescritas e seleciona a mais divergente lexicalmente (distância de Jaccard de bigramas) com proteção contra deriva de comprimento
- Higiene de modelo mais rigorosa: preferir modelos locais de pesos abertos e evitar qualquer fornecedor conhecido por marcas d'água, não apenas a origem suspeita
- O relatório de risco residual agora distingue texto curto/altamente previsível (risco menor) de prosa longa e de alta entropia (risco maior)
- Documentação atualizada em `SKILL.md`, `removal-matrix.md` e `vendor-notes.md`; os testes cobrem novos prompts, pontuação de divergência e seleção de candidatos
### [v0.3.0](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.3.0) — pontuação opcional de pixels do SynthID
- Scorer opcional de SynthID no domínio de pixels por meio de um checkout externo de [`aloshdenny/reverse-SynthID`](https://github.com/aloshdenny/reverse-SynthID) (`score_synthid.py`); disponibilizado em `inspect_image.py` / `clean_image.py` com `REVERSE_SYNTHID_DIR` ou `--synthid-dir`
- Bootstrap `setup_synthid.sh` (dependências apenas do scorer; `--full` instala os requisitos upstream); `Dockerfile.synthid` além de `make docker-synthid-build` / `docker-synthid-help`
- Alvos `smoke-synthid` e `bootstrap-synthid` no Makefile
- Testes para o adaptador do scorer, caminho de CLI indisponível, análise de JSON e erros em tempo de execução
- Docs: apenas detecção/pontuação (sem remoção de pixels); o código upstream não é empacotado e permanece sob sua Licença de Pesquisa não comercial
### [v0.2.0](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.2.0) — correção de falso positivo do c2patool
- `image_meta.py`: `has_manifest` não sinaliza mais `Error: No claim found` / `No JUMBF data found` como um manifesto (bug de precedência de operadores: os marcadores negativos agora vetam todos os ramos positivos)
- Novo `tests/test_c2patool_report.py` (4 casos: sem claim, sem JUMBF, manifesto genuíno, ferramenta ausente)
- Docs: corrigidos os links de `c2patool` (repositório movido para `contentauth/c2pa-rs`); adicionada uma ressalva sobre o custo de qualidade da remoção de marca d'água de texto
### [v0.1.0](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.1.0) — polimento de empacotamento + honestidade sobre proveniência
- `Makefile` (`test` / `smoke` / `install-skill`) e `pytest.ini`
- Amostras fixture para Markdown, HTML, SVG; teste de limpeza de PDF degradado
- Docs: modelo industrial de **duas camadas** (C2PA fortemente vinculado vs vinculação suave / SynthID-media)
- Tabela de risco residual no README + links para ferramentas externas de verificação
- Referência: guia C2PA/SynthID do Institute of AI PM
- Vinculação suave e marcas d'água de pixel/áudio/vídeo explicitamente fora do escopo em skill/matrix/ethics
### [v0.0.1](https://github.com/guillaumemeyer/watermarks-remover/releases/tag/v0.0.1) — lançamento inicial multifornecedor
- Habilidade de agente `remove-ai-marks` (substitui `remove-claude-marks`, exclusiva do Claude)
- **Camada A:** Unicode invisível / caracteres bidi / tags / homóglifos de espaço (`inspect_text` / `clean_text`)
- **Camada B:** orientação de reescrita + `rewrite_text.py` opcional (print-prompt, Ollama, compatível com OpenAI)
- **Arquivos:** remoção de metadados C2PA/IA para PNG, JPEG, SVG, PDF, DOCX, ODT, HTML, Markdown
- `inspect_file.py` / `clean_file.py` unificados
- Documentação multifornecedor (Claude, Gemini/classe SynthID, OpenAI, LLMs abertos)
- Scripts priorizando a stdlib; `c2patool` / `exiftool` opcionais
## Licença
MIT — veja [LICENSE](https://github.com/guillaumemeyer/watermarks-remover/blob/HEAD/LICENSE).
## Referências
- [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) (docs da API Gemini)
- [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) (referência de pesquisa; não usado para detecção aqui)
- [aloshdenny/reverse-SynthID](https://github.com/aloshdenny/reverse-SynthID) (referência de pesquisa)
- Liu et al., [*Image Watermarks are Removable Using Controllable Regeneration from Clean Noise*](https://arxiv.org/abs/2410.05470) (ICLR 2025) — o método de regeneração de pixels que o backend opcional CtrlRegen implementa — [código](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) — um ataque universal a marcas d'água comparado em uma métrica diferente da do CtrlRegen
- Goonatilake & Ateniese, [*Removing the Watermark Is Not Enough: Forensic Stealth in Generative-AI Watermark Removal*](https://arxiv.org/abs/2605.09203) (arXiv:2605.09203) — motiva o padrão de intensidade conservadora: a remoção ainda pode deixar vestígios forenses
- [mertizci/noai-watermark](https://github.com/mertizci/noai-watermark) (kit de ferramentas CLI/Python para remoção de SynthID/StableSignature/TreeRing e remoção de metadados de IA)
- [0xROOTPLS/DeSynth](https://github.com/0xROOTPLS/DeSynth) (remoção de SynthID para imagens OpenAI/Google)
- 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) (modelo industrial de duas camadas: C2PA + marca d'água imperceptível / vinculação suave; contexto SB 942 / Art. 50 da Lei de IA da UE)
| Canal | Claude | Gemini/SynthID | OpenAI | Open-LLM |
|---|
| Texto Unicode / baseado em edição | Layer A | Layer A | Layer A | Layer A |
| Texto de amostragem estatística | Layer B melhor esforço | Layer B melhor esforço | Layer B se presente | Layer B melhor esforço |
| C2PA / metadados de arquivo | Sim (formatos listados) | Sim quando presente | Sim quando presente | Sim quando presente |
| Marcas de imagem em pixels | Fora do escopo | Pontuação SynthID opcional + remoção via CtrlRegen (externo) | Fora do escopo | Remoção opcional via CtrlRegen (externo) |
| Backdoors de treinamento | Fora do escopo | Fora do escopo | Fora do escopo | Fora do escopo |
| Formato | Inspecionar | Limpar |
|---|
| PNG / JPEG | Chunks C2PA / APP11, dicas de XMP de IA | Remover segmentos de metadados |
| SVG | <metadata>, XMP | Remover blocos |
| Byte/XMP + ferramentas opcionais | exiftool preferido; degradado sem ele | |
| DOCX | docProps / customXml | Limpar propriedades, remover customXml |
| ODT | meta.xml | Remover metadados de gerador / tipo IA |
| HTML | meta, JSON-LD, data-ai* | Remover tags/atributos |
| Markdown | Chaves de IA no frontmatter YAML | Remover chaves + corpo da Layer A |
| Canal | O que removemos | O que pode permanecer | Verificação externa (exemplos) |
|---|
| C2PA / EXIF / XMP com vínculo rígido | Sim | Vínculo flexível / marcas de pixel | c2patool, Content Credentials verify |
| Mídia classe SynthID | Remoção opcional de pixels (CtrlRegen externo); pontuação local caso contrário | Marca d'água de áudio/vídeo; marca d'água de pixel residual após a remoção | Ferramentas do provedor (ex.: Google SynthID / detector Vertex quando oferecido); pontuador local opcional reverse-SynthID |
| Texto estatístico | Reescrita de melhor esforço | Marcas fortes após edição leve | Nenhum detector universal público; ferramentas do fornecedor quando disponíveis |
| Opção | Remove | Observações |
|---|
| Limpeza Unicode (Layer A) | ZWSP, bidi, tags, espaços exóticos, … | Padrão seguro para texto |
| Reescrita (Layer B) | Marcas estatísticas de tokens (melhor esforço) | Sempre oferecida pela skill; custa estilo — veja Aviso legal |
| Remoção de metadados do contêiner | Proveniência do arquivo | Veja a tabela de formatos |
| Remoção de pixels via CtrlRegen (opcional) | Marcas de imagem no domínio de pixels (classe SynthID, StegaStamp, Tree-Ring, StableSignature) | Backend externo; computação pesada; força conservadora por padrão |
| Modelos locais de pesos abertos | Evita remarcação com o modelo de origem | Alternativa operacional |