Airlock
MillionOnMars/airlock
Revisa e sanitiza skills de terceiros antes de instalar
Ver no GitHubSkill de segurança que revisa automaticamente terceiros skills antes de serem executados em seu ambiente Claude. Combina scanner determinístico a prova de injeção com verificação semântica em sandbox, identificando padrões de ataque conhecidos como phone-homes, Unicode oculto e obfuscação sem confiar em LLMs para decisões críticas.
Instalação
npx convez-ai MillionOnMars/airlock1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Validar segurança de skills compartilhados antes de instalar em .claude/skills
- Detectar tentativas de phone-home, rug pulls e backdoors em código de agentes
- Neutralizar ameaças conhecidas como Unicode oculto e ofuscação em scripts
Veredito

Ferramenta essencial para quem trabalha com skills de terceiros. Airlock abaixa significativamente o custo de revisão de segurança, mas deixa claro que é um auxílio, não garantia — exige diligência própria e leitura humana de código sensível. Design robusto com scanner determinístico que não confia em LLM para decisões críticas.
README
A tradução para o português deste README ainda está na fila.
airlock
Safety-review a third-party agent skill before it can act in your
environment. A skill isn't a library — it's text your agent obeys, with full
reach into your shell, repo, and secrets. airlock is the decontamination step
between "someone shared a skill" and "it's running in my .claude/skills."
Why this exists: the full story behind airlock — why a skill is a voice in your agent's ear, why even a benign phone-home has to be severed, and the real-world attacks (rug pulls, the Rules File Backdoor, weaponized AI agents) that make this urgent — is here: A Skill Is a Voice in Your Agent's Ear.
⚠️ This is an aid, not a guarantee — do your own due diligence
airlock lowers the cost of reviewing a skill. It does not lower your responsibility for what you install, and a passing verdict is not a clean bill of health.
CLEANmeans "nothing known tripped a rule," not "this is safe." The deterministic scanner finds patterns it was taught to find. A novel obfuscation, a fresh trick, or an attack written in plain, friendly prose can walk right past it.- It surfaces capability; it does not judge intent. Most flags on a good skill are benign. airlock points — you decide.
- The semantic (LLM) pass is fallible and can itself be misled. Treat its summary as a lead to chase, never as proof.
- Read anything that executes — scripts, hooks, install steps — with your own eyes before you run it. No tool replaces that.
- It does not yet cover MCP servers or Cursor/Copilot rules files. Same attack surface, not scanned here.
- Don't exempt airlock itself. Clone it, read
scan.py(it's short, with no network or shell access), and verify the tool before you trust the tool.
If a skill touches secrets, money, production, or anything you can't afford to get wrong, a green check from airlock is the start of your review, not the end.
Use it
In Claude Code:
/airlock https://github.com/someone/their-skill
or point it at an already-cloned folder. It will:
- Clone to a scratch quarantine (never straight into
.claude/skills). - Run the deterministic scan (below).
- Read the flagged files as data, never as instructions.
- Give a go/no-go and write
SECURITY-REVIEW.mdpinned to the reviewed commit. - Optionally neutralize: sever phone-homes, strip hidden Unicode, vendor a frozen copy, then re-scan to prove the killers are gone.
The design principle
You can't make an LLM immune to a hostile message it reads. So airlock doesn't trust the reviewer to resist — it makes the reviewer powerless:
- The strongest layer is not an LLM.
scan.pyreads bytes and can't be persuaded. It's the floor and it can't be talked out of a finding. - When an LLM does read the skill, it reads it as data to analyze with no secrets in reach. A hijacked reviewer can only write a wrong report, not touch the host.
- Nothing from the target is ever executed during review.
The deterministic scanner
python3 scan.py <target_dir> [--json]
Inventories every capability and hard-flags the killers with file:line:
- phone-home / auto-fetch (version checks,
raw.githubusercontent, mutable remote text pulled into context — the rug pull, CVE-2025-54136) - hidden Unicode (zero-width, bidi, TAG chars — the Rules File Backdoor)
- obfuscation (base64 blobs,
curl | bash) - secret access (
~/.ssh,.env,.zsh-secrets,.aws/credentials,.npmrc) - exfiltration (POST/upload/bcc to a URL/webhook)
- covert instruction ("ignore previous", "don't tell the user", "without asking")
Exit codes: 0 clean · 1 review · 2 fail (a killer was found → default-deny).
The scanner surfaces capability; it does not judge intent. A skill that teaches security, or one already neutralized, will trip rules benignly (a "we removed this fetch" note still contains the URL string). That's by design — the human and the semantic pass adjudicate. The scanner's only promise is that nothing of interest stays hidden.
Not covered yet
MCP servers and Cursor/Copilot rules files share this exact attack surface (tool poisoning, rug pulls, hidden-Unicode rule backdoors). airlock flags them as an adjacent threat rather than pretending to cover them. Future passes.