convez.ai
SkillSegurançaIntermediário
MillionOnMars

Airlock

MillionOnMars/airlock

Revisa e sanitiza skills de terceiros antes de instalar

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill 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/airlock

1 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

Estrelas
0
Forks
0
Acompanhando
0
Saúde
50%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

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.

  • CLEAN means "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:

  1. Clone to a scratch quarantine (never straight into .claude/skills).
  2. Run the deterministic scan (below).
  3. Read the flagged files as data, never as instructions.
  4. Give a go/no-go and write SECURITY-REVIEW.md pinned to the reviewed commit.
  5. 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.py reads 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.

Ver o original no GitHub

Bom para

Relacionados