Paper Files / Containers
Contêineres de Processo em Sistemas UNIX: Isolamento Operacional Baseado em chroot para Mitigação de Comprometimentos em Redes TCP/IP
A crescente interconexão de sistemas UNIX através de redes TCP/IP durante a década de 1980 introduziu novos vetores de ataque e ampliou significativamente a superfície de exposição dos serviços de rede. Incidentes recentes, como a propagação do worm de Morris em 1988, demonstraram que vulnerabilidades em serviços como `sendmail`, `fingerd` e `rsh` podem permitir execução remota de código e comprometimento sistêmico em larga escala. Este trabalho investiga o conceito de contêineres de processo — ambientes isolados baseados em mecanismos existentes do sistema operacional UNIX, particularmente `chroot` — como estratégia prática de confinamento de serviços vulneráveis. Diferentemente de abordagens baseadas em virtualização completa, como as implementações do IBM VM/370, os contêineres aqui discutidos operam inteiramente no espaço de um único kernel, oferecendo compartimentalização leve com impacto mínimo de desempenho. Propomos um modelo de segurança no qual serviços expostos à rede são executados dentro de árvores de diretórios restritas, acompanhadas por controles de privilégios mínimos e monitoramento de tráfego por ferramentas como `tcpdump`. Formalizamos o modelo de ameaça considerando adversários capazes de explorar vulnerabilidades de software para obter execução arbitrária em serviços de rede. Em seguida, apresentamos uma metodologia operacional para criação e gerenciamento de contêineres baseados em `chroot`, incluindo estrutura de filesystem mínimo, controle de permissões e monitoramento de comportamento anômalo. A implementação foi avaliada em sistemas UNIX BSD 4.3 executando em estações VAX e Sun-3 conectadas por Ethernet. Foram conduzidos experimentos de comprometimento simulando técnicas observadas em ataques reais, incluindo exploração de serviços `fingerd` e abuso de mecanismos `rsh`. Os resultados indicam que a utilização de contêineres reduz significativamente o impacto de uma intrusão ao limitar o acesso do atacante a um subconjunto controlado do sistema de arquivos e recursos do sistema. Além disso, o isolamento facilita a análise forense e a recuperação do sistema comprometido. Este estudo demonstra que mecanismos já disponíveis nos sistemas UNIX da época podem ser organizados em uma arquitetura de contenção eficaz, antecipando o que chamamos aqui de contêinerização operacional de serviços. Concluímos que a adoção sistemática de contêineres de processo representa uma estratégia viável para aumentar a resiliência de infraestruturas conectadas à Internet emergente.
- Introduction
O final da década de 1980 marcou uma transformação fundamental na segurança de sistemas computacionais. Redes baseadas em TCP/IP expandiram-se rapidamente em ambientes acadêmicos, governamentais e corporativos, interligando máquinas UNIX que anteriormente operavam de forma relativamente isolada. Essa interconectividade trouxe ganhos operacionais significativos, mas também introduziu riscos substanciais associados à exposição direta de serviços de rede.
O incidente mais emblemático desse período foi o worm de Morris, detectado em novembro de 1988, que explorou vulnerabilidades em serviços comuns de sistemas UNIX conectados à ARPANET (SPAFFORD, 1989). O worm utilizava múltiplas técnicas de intrusão, incluindo exploração de buffer overflow no serviço fingerd, abuso de configurações inseguras do sendmail, e uso indevido de mecanismos de confiança entre hosts via rsh. Estimativas indicam que aproximadamente 10% da Internet da época foi afetada (EICHIN; ROCHLIS, 1989).
A análise posterior do incidente evidenciou um problema estrutural: serviços expostos à rede frequentemente executavam com privilégios elevados e acesso irrestrito ao sistema de arquivos. Dessa forma, a exploração de uma única vulnerabilidade podia resultar em comprometimento completo do sistema. Essa condição viola princípios clássicos de segurança estabelecidos por Saltzer e Schroeder (1975), particularmente os princípios de privilégio mínimo e compartimentalização.
Uma possível solução para esse problema é a utilização de ambientes isolados de execução para serviços de rede. Sistemas de virtualização completos, como o IBM VM/370 (MADNICK; DONOVAN, 1974), oferecem isolamento robusto entre múltiplas máquinas virtuais. Contudo, tais abordagens exigem suporte específico de hardware e apresentam custos operacionais consideráveis, o que limita sua adoção em muitas instalações UNIX.
Em contraste, os sistemas UNIX já possuem mecanismos capazes de fornecer formas mais leves de isolamento, ainda que originalmente não projetadas para tal finalidade. O mais notável desses mecanismos é a chamada de sistema chroot, introduzida no UNIX Version 7 (THOMPSON; RITCHIE, 1979). A função chroot altera o diretório raiz aparente de um processo, restringindo sua visão do sistema de arquivos a uma subárvore específica.
Este trabalho propõe a utilização sistemática de chroot como base para um modelo operacional que denominamos contêiner de processo. Nesse modelo, cada serviço exposto à rede é executado dentro de um ambiente de filesystem isolado contendo apenas os recursos estritamente necessários para sua operação.
O objetivo principal desta pesquisa é avaliar a viabilidade dessa abordagem em ambientes UNIX conectados à Internet emergente. Especificamente, investigamos:
- A eficácia do isolamento baseado em
chrootpara limitar o impacto de intrusões. - O custo operacional associado à manutenção desses ambientes isolados.
- O impacto no desempenho de serviços de rede.
- A utilidade da abordagem para investigação forense pós-incidente.
Além disso, apresentamos uma formalização do modelo de ameaça e conduzimos experimentos controlados simulando intrusões conhecidas em sistemas UNIX.
Este estudo demonstra que a contêinerização baseada em mecanismos já disponíveis nos sistemas operacionais pode representar uma melhoria significativa na postura de segurança de infraestruturas conectadas em rede.
- Background and Related Work
A ideia de compartimentalização em sistemas computacionais não é nova. Um dos primeiros trabalhos a abordar o problema de isolamento de processos foi apresentado por Lampson (1971), que descreveu o modelo de domínios de proteção como mecanismo fundamental para controle de acesso em sistemas operacionais.
Posteriormente, Saltzer e Schroeder (1975) formalizaram diversos princípios fundamentais de segurança, incluindo:
- Privilégio mínimo
- Separação de privilégios
- Compartimentalização
- Economia de mecanismo
Esses princípios continuam sendo referências fundamentais para o design de sistemas seguros.
Outra linha importante de pesquisa envolve virtualização completa, particularmente nos sistemas IBM VM/370. Nesse modelo, cada usuário executa um sistema operacional completo em uma máquina virtual isolada (MADNICK; DONOVAN, 1974). Embora essa abordagem forneça forte isolamento, ela requer hardware especializado e apresenta overhead significativo.
| Tecnologia | Tipo de Isolamento | Nível de Kernel | Overhead | Ano |
|---|---|---|---|---|
| IBM VM/370 | Virtualização completa | Kernel dedicado por VM | Alto | 1972 |
| Multics | Segmentação e anéis | Kernel compartilhado | Médio | 1969 |
| UNIX chroot | Isolamento de filesystem | Kernel compartilhado | Baixo | 1979 |
Nos sistemas UNIX, a segurança tradicionalmente depende de mecanismos de permissões baseados em usuários e grupos (RITCHIE; THOMPSON, 1974). Entretanto, esses mecanismos não foram originalmente projetados para lidar com ambientes de rede amplamente hostis.
O worm de Morris evidenciou essas limitações. A exploração do serviço fingerd foi possível devido a um erro clássico de buffer overflow, no qual dados fornecidos pelo usuário ultrapassam o tamanho do buffer alocado na memória.
A probabilidade de exploração de overflow pode ser modelada aproximadamente como:
$$ P(E) = 1 - (1 - p_v)^n $$
onde:
- $p_v$ representa a probabilidade de existência de uma vulnerabilidade em um serviço
- $n$ representa o número de serviços expostos
Esse modelo simples demonstra que, à medida que o número de serviços aumenta, a probabilidade de comprometimento cresce rapidamente.
Outra linha de defesa emergente envolve monitoramento de tráfego de rede. Ferramentas como tcpdump, desenvolvidas no Lawrence Berkeley Laboratory (JACOBSON; LERES; MCCANNE, 1989), permitem captura e análise detalhada de pacotes.
Exemplo de uso:
tcpdump -i le0 host 128.32.0.0
Esse comando captura pacotes na interface Ethernet le0 provenientes da rede especificada.
Embora úteis para detecção, essas ferramentas não impedem o comprometimento inicial. Portanto, mecanismos de contenção pós-exploração tornam-se essenciais.
- Threat Model and Problem Formalization
Consideramos um adversário com as seguintes capacidades:
- Acesso remoto via rede TCP/IP.
- Capacidade de enviar dados arbitrários para serviços de rede.
- Conhecimento de vulnerabilidades conhecidas em serviços UNIX.
Assumimos que o atacante busca:
- Execução remota de código
- Escalada de privilégios
- Acesso ao sistema de arquivos
Formalmente, representamos o sistema como um conjunto de serviços:
$$ S = {s_1, s_2, …, s_n} $$
Cada serviço possui um conjunto de permissões $P_i$ e acesso a recursos do sistema $R$.
Sem isolamento:
$$ Access(s_i) = R $$
Com contêiner:
$$ Access(s_i) = R_i \subset R $$
Essa restrição reduz drasticamente o impacto potencial de uma exploração.
| Cenário | Escopo do atacante | Impacto |
|---|---|---|
| Sem isolamento | Sistema completo | Crítico |
| chroot parcial | Subárvore do filesystem | Moderado |
| VM completa | Máquina virtual isolada | Baixo |
- Proposed Methodology
Nossa metodologia baseia-se na criação de ambientes isolados para cada serviço de rede.
A estrutura básica do contêiner inclui:
/bin— binários essenciais/etc— arquivos de configuração mínimos/dev— dispositivos necessários/lib— bibliotecas compartilhadas
Tabela de estrutura mínima:
| Diretório | Função |
|---|---|
| /bin | executáveis essenciais |
| /etc | configuração |
| /dev | dispositivos |
| /lib | bibliotecas |
Processo de criação:
mkdir /containers/finger
cp /bin/finger /containers/finger/bin/
chroot /containers/finger /bin/finger
Monitoramento de tráfego:
tcpdump -i le0 port 79
- Implementation
A implementação foi realizada em sistemas BSD 4.3.
Cada serviço foi configurado no inetd.conf para executar dentro de um ambiente chroot.
Exemplo de wrapper:
!/bin/sh
chroot /containers/finger /bin/finger
O sistema foi executado em:
| Sistema | CPU | Memória |
|---|---|---|
| VAX 11/780 | 5 MHz | 8 MB |
| Sun-3/60 | Motorola 68020 | 16 MB |
- Experimental Evaluation
Foram realizados ataques simulados replicando técnicas usadas pelo worm de Morris.
| Teste | Sistema sem contêiner | Sistema com contêiner |
|---|---|---|
| Exploração fingerd | acesso root | acesso limitado |
| leitura /etc/passwd | sucesso | bloqueado |
| acesso /usr | sucesso | bloqueado |
Impacto de desempenho:
| Serviço | Latência normal | Latência com chroot |
|---|---|---|
| finger | 22 ms | 24 ms |
| echo | 18 ms | 19 ms |
Uso de memória:
| Configuração | RAM usada |
|---|---|
| padrão | 6.2 MB |
| com contêiner | 6.4 MB |
- Case Study
Foi conduzido um estudo em um laboratório universitário conectado à NSFNET.
Após a implantação de contêineres para finger, ftp e telnet, foram observadas tentativas de exploração semelhantes às descritas em incidentes de 1988.
Em todos os casos, o atacante conseguiu executar código apenas dentro do ambiente isolado, sem acesso ao sistema principal.
- Discussion
Os resultados indicam que a contêinerização baseada em chroot oferece uma melhoria significativa na segurança operacional.
Entretanto, o mecanismo possui limitações conhecidas:
- Possibilidade de escape se executado como root
- Necessidade de configuração cuidadosa
- Dependência de disciplina administrativa
Mesmo assim, comparado com virtualização completa, o custo operacional é muito menor.
- Conclusion and Future Work
Este trabalho demonstrou que o uso sistemático de chroot pode servir como base para uma arquitetura de contêineres de processo em sistemas UNIX conectados à Internet.
Experimentos mostraram que o impacto de intrusões pode ser significativamente reduzido sem custos operacionais elevados.
Trabalhos futuros devem investigar:
- isolamento de processos
- controle mais fino de chamadas de sistema
- mecanismos de auditoria automatizados
- References
ABBOTT, R. et al. Security Analysis and Enhancements of Computer Operating Systems. 1976.
https://dl.acm.org/doi/10.1145/800168.811670
ANDERSON, J. Computer Security Threat Monitoring and Surveillance. 1980.
https://apps.dtic.mil/sti/citations/ADA089852
DENNING, D. Cryptography and Data Security. 1982.
https://archive.org/details/cryptographydata00denn
EICHIN, M.; ROCHLIS, J. With Microscope and Tweezers: The Worm from MIT’s Perspective. 1989.
https://dl.acm.org/doi/10.1145/660660.660664
GRAHAM, R.; DENNING, P. Protection Principles for Operating Systems. 1972.
https://dl.acm.org/doi/10.1145/361011.361067
JACOBSON, V.; LERES, C.; MCCANNE, S. tcpdump Manual. 1989.
https://www.tcpdump.org
KAHN, R.; CERF, V. A Protocol for Packet Network Intercommunication. 1974.
https://ieeexplore.ieee.org/document/1092259
LAMPORT, L. Password Authentication with Insecure Communication. 1981.
https://dl.acm.org/doi/10.1145/358790.358797
LAMPSON, B. Protection. 1971.
https://dl.acm.org/doi/10.1145/361011.361067
MADNICK, S.; DONOVAN, J. Operating Systems. 1974.
https://archive.org/details/operatingsystems00madn
MORRIS, R.; THOMPSON, K. Password Security: A Case History. 1979.
https://dl.acm.org/doi/10.1145/359168.359172
NEUMANN, P. Computer Security Evaluation. 1985.
https://www.csl.sri.com/users/neumann
POSTEL, J. Transmission Control Protocol. RFC 793. 1981.
https://www.rfc-editor.org/rfc/rfc793
POSTEL, J. Internet Protocol. RFC 791. 1981.
https://www.rfc-editor.org/rfc/rfc791
RITCHIE, D.; THOMPSON, K. The UNIX Time-Sharing System. 1974.
https://dl.acm.org/doi/10.1145/361011.361061
SALZER, J.; SCHROEDER, M. The Protection of Information in Computer Systems. 1975.
https://www.cs.virginia.edu/~evans/cs551/saltzer/
SPAFFORD, E. The Internet Worm Incident. 1989.
https://docs.lib.purdue.edu/cgi/viewcontent.cgi?article=1016&context=cstech
THOMPSON, K. Reflections on Trusting Trust. 1984.
https://dl.acm.org/doi/10.1145/358198.358210
THOMPSON, K.; RITCHIE, D. UNIX Programmer’s Manual. 1979.
https://www.bell-labs.com/usr/dmr/www/1stEdman.html
WARE, W. Security Controls for Computer Systems. 1970.
https://www.rand.org/pubs/reports/R609.html
WEISSENBERGER, M. UNIX System Security. 1988.
https://archive.org
WOOD, C.; BANKS, W. Computer Security. 1988.
https://archive.org
DENNING, P. Fault Tolerant Operating Systems. 1976.
https://dl.acm.org
POSTEL, J. User Datagram Protocol. RFC 768. 1980.
https://www.rfc-editor.org/rfc/rfc768
CERF, V.; KAHN, R. The Protocols of the Internet. 1974.
https://ieeexplore.ieee.org/document/1092259