Gerenciar Segurança SELinux RHEL - Guia Prático

Introdução

Neste laboratório, você obterá experiência prática no gerenciamento da segurança SELinux no RHEL. Você aprenderá a alterar os modos de aplicação do SELinux, tanto temporariamente quanto persistentemente, e a configurar o Apache com contextos de arquivo SELinux personalizados. O laboratório também aborda o ajuste da política SELinux para diretórios home de usuários usando booleanos e fornece etapas práticas para solucionar problemas e resolver negações do SELinux para servidores web Apache e conteúdo web personalizado.

Alterar o Modo de Aplicação do SELinux

Nesta etapa, você aprenderá a gerenciar os modos do SELinux, tanto temporariamente quanto persistentemente. SELinux (Security-Enhanced Linux) é um mecanismo de segurança que fornece controle de acesso obrigatório (MAC) para o kernel Linux. Ele define os direitos de acesso para processos, arquivos e outros recursos do sistema.

O SELinux opera em três modos principais:

Enforcing (Aplicando): A política SELinux é aplicada. Acessos negados pela política são bloqueados e registrados. Este é o modo padrão e mais seguro.
Permissive (Permissivo): A política SELinux não é aplicada. Acessos negados pela política são registrados, mas não bloqueados. Este modo é útil para solucionar problemas e testar novas políticas.
Disabled (Desativado): O SELinux está desativado. Nenhuma política é carregada ou aplicada. Este modo geralmente não é recomendado para sistemas de produção.

Você praticará a alteração do modo SELinux usando ferramentas de linha de comando e modificando arquivos de configuração.

Primeiro, vamos verificar o modo de aplicação atual do SELinux.

Verifique o modo de aplicação atual do SELinux.

Você pode usar o comando getenforce para ver rapidamente o modo SELinux atual.
```
getenforce
```
Você deve ver Enforcing (Aplicando) como saída, indicando que o SELinux está atualmente aplicando suas políticas.
```
Enforcing
```
Altere o modo SELinux para permissive (permissivo) temporariamente.

O comando setenforce permite que você altere o modo SELinux em tempo de execução. Um valor de 0 define o modo como permissive (permissivo), e 1 o define como enforcing (aplicando). Essa alteração é temporária e não persistirá após as reinicializações.
```
sudo setenforce 0
```
Agora, verifique a alteração usando getenforce novamente.
```
getenforce
```
A saída agora deve ser Permissive (Permissivo).
```
Permissive
```
Altere o modo SELinux de volta para enforcing (aplicando) temporariamente.

Para reverter a alteração temporária, use setenforce 1.
```
sudo setenforce 1
```
Verifique o modo mais uma vez.
```
getenforce
```
A saída deve ser Enforcing (Aplicando) novamente.
```
Enforcing
```
Altere o modo SELinux padrão para permissive (permissivo) persistentemente.

Para tornar as alterações do modo SELinux persistentes após as reinicializações, você precisa modificar o arquivo /etc/selinux/config. Este arquivo define o modo SELinux padrão para o sistema.

Abra o arquivo de configuração usando nano.
```
sudo nano /etc/selinux/config
```
Dentro do editor nano, encontre a linha que começa com SELINUX= e altere seu valor de enforcing (aplicando) para permissive (permissivo).
```
## This file controls the state of SELinux on the system.
## SELINUX= can take one of these three values:
##     enforcing - SELinux security policy is enforced.
##     permissive - SELinux prints warnings instead of enforcing.
##     disabled - No SELinux policy is loaded.
SELINUX=permissive
## SELINUXTYPE= can take one of these three values:
##     targeted - Targeted processes are protected,
##                for the majority of users.
##     minimum - Modification of targeted policy
##               uses current settings and adds to it.
##     mls - Multi Level Security protection.
SELINUXTYPE=targeted
```
Pressione Ctrl+X para sair, depois Y para confirmar a gravação e Enter para escrever no mesmo arquivo.

Após salvar o arquivo, você pode confirmar a alteração no arquivo de configuração usando grep.
```
grep '^SELINUX' /etc/selinux/config
```
A saída deve mostrar SELINUX=permissive.
```
SELINUX=permissive
SELINUXTYPE=targeted
```
Nota Importante: Alterar /etc/selinux/config não altera imediatamente o modo SELinux ativo. Ele apenas define o modo que será aplicado após a próxima reinicialização do sistema. Para ver o modo ativo atual, você ainda precisa usar getenforce.
```
getenforce
```
Ele ainda deve mostrar Enforcing (Aplicando) porque o sistema ainda não foi reiniciado.
```
Enforcing
```

Altere o modo SELinux padrão de volta para enforcing (aplicando) no arquivo de configuração.

Agora, vamos alterar o modo persistente de volta para enforcing (aplicando). Esta é a configuração recomendada e mais segura para o SELinux.

Abra o arquivo de configuração novamente.

sudo nano /etc/selinux/config

Altere o parâmetro SELINUX= de volta para enforcing (aplicando).

## This file controls the state of SELinux on the system.
## SELINUX= can take one of these three values:
##     enforcing - SELinux security policy is enforced.
##     permissive - SELinux prints warnings instead of enforcing.
##     disabled - No SELinux policy is loaded.
SELINUX=enforcing
## SELINUXTYPE= can take one of these three values:
##     targeted - Targeted processes are protected,
##                for the majority of users.
##     minimum - Modification of targeted policy
##               uses current settings and adds to it.
##     mls - Multi Level Security protection.
SELINUXTYPE=targeted

Salve e saia do arquivo (Ctrl+X, Y, Enter).

Confirme a alteração no arquivo de configuração.

grep '^SELINUX' /etc/selinux/config

A saída agora deve mostrar SELINUX=enforcing.

SELINUX=enforcing
SELINUXTYPE=targeted

Neste ponto, o modo SELinux ativo do sistema ainda é Enforcing (Aplicando) (se você não reiniciou após a etapa 4), e a configuração persistente também é Enforcing (Aplicando).

Configurar o Apache com Contextos de Arquivo SELinux Personalizados

Nesta etapa, você aprenderá a configurar o Apache para servir conteúdo web de um diretório não padrão e gerenciar seus contextos de arquivo SELinux. Por padrão, as políticas SELinux restringem o Apache (httpd) a servir arquivos apenas de diretórios específicos, principalmente /var/www/html. Se você colocar o conteúdo web em um local diferente, o SELinux impedirá que o Apache o acesse, mesmo que as permissões do sistema de arquivos estejam corretas. É aqui que os contextos de arquivo SELinux entram em jogo.

Um contexto de arquivo SELinux é um rótulo aplicado a um arquivo ou diretório que define seus atributos de segurança. Para que o Apache sirva conteúdo de um local personalizado, esse local e seu conteúdo devem ter o contexto SELinux correto, normalmente httpd_sys_content_t. Você usará semanage fcontext para definir uma regra persistente e restorecon para aplicá-la.

Primeiro, você precisa instalar o servidor HTTP Apache.

Instale o servidor HTTP Apache.

Use o gerenciador de pacotes dnf para instalar o pacote httpd.
```
sudo dnf install -y httpd
```
Você deve ver uma saída indicando a instalação bem-sucedida do pacote httpd e suas dependências.
Crie um diretório personalizado para conteúdo web e um arquivo index.html.

Você criará um novo diretório chamado /custom e colocará um arquivo index.html simples dentro dele. Este será seu diretório raiz de documentos web não padrão.
```
sudo mkdir /custom
echo 'This is custom web content.' | sudo tee /custom/index.html
```
Verifique o conteúdo do arquivo index.html.
```
cat /custom/index.html
```
```
This is custom web content.
```
Configure o Apache para usar o novo diretório raiz de documentos.

O arquivo de configuração principal do Apache é /etc/httpd/conf/httpd.conf. Você precisa editar este arquivo para apontar o Apache para seu novo diretório /custom em vez do padrão /var/www/html.

Abra o arquivo de configuração usando nano.
```
sudo nano /etc/httpd/conf/httpd.conf
```
Dentro do editor, encontre as linhas DocumentRoot "/var/www/html" e <Directory "/var/www/html">. Altere ambas as ocorrências de /var/www/html para /custom.

As seções relevantes devem ter esta aparência após a modificação:
```
#
## DocumentRoot: The directory out of which you will serve your
## documents. By default, all requests are taken from this directory, but
## symbolic links and aliases may be used to point to other locations.
#
DocumentRoot "/custom"

#
## Relax access to content within /var/www.
#
<Directory "/custom">
    AllowOverride None
    ## Allow open access:
    Require all granted
</Directory>
```
Salve e saia do arquivo (Ctrl+X, Y, Enter).
Inicie e habilite o serviço web Apache.

Após modificar a configuração, você precisa iniciar o serviço httpd. Como você está em um ambiente de contêiner, systemctl não está disponível. Você iniciará o httpd diretamente.
```
sudo /usr/sbin/httpd -DFOREGROUND &
```
O símbolo & executa o comando em segundo plano, permitindo que você continue usando o terminal. Você deve ver uma saída semelhante a esta, indicando que o Apache está iniciando.
```
[1] 5094
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using fe80::216:3eff:fe00:63b%eth0. Set the 'ServerName' directive globally to suppress this message
```
Observação: A mensagem de aviso sobre o nome de domínio totalmente qualificado do servidor é normal neste ambiente de laboratório e pode ser ignorada com segurança.

Para verificar se o Apache está em execução, você pode procurar o processo httpd.
```
ps aux | grep httpd
```
Você deve ver vários processos httpd em execução.
```
root        ... /usr/sbin/httpd -DFOREGROUND
apache      ... /usr/sbin/httpd -DFOREGROUND
...output omitted...
```
Tente acessar a página web.

Agora, tente acessar sua página web usando curl. Como você está na mesma máquina, pode usar localhost.
```
curl http://localhost/index.html
```
Observação: Neste ambiente específico, você pode descobrir que a página web é acessível mesmo com o contexto root_t. Isso demonstra que, embora o SELinux esteja aplicando, o contexto root_t pode ter permissões mais amplas do que o esperado. No entanto, para as melhores práticas de segurança e a configuração adequada do SELinux, o conteúdo web ainda deve usar o contexto httpd_sys_content_t apropriado.
```
This is custom web content.
```
Verifique o contexto SELinux atual do diretório personalizado.

Use o comando ls -Z para visualizar o contexto SELinux do seu diretório /custom e do arquivo index.html.
```
ls -Zd /custom /custom/index.html
```
Você notará que eles têm o contexto root_t, que não é o contexto recomendado para conteúdo web Apache.
```
system_u:object_r:root_t:s0 /custom
system_u:object_r:root_t:s0 /custom/index.html
```
Compare isso com o diretório raiz de documentos Apache padrão:
```
ls -Zd /var/www/html
```
Você verá que /var/www/html tem o contexto httpd_sys_content_t. Este é o contexto que você precisa aplicar ao seu diretório personalizado.
```
system_u:object_r:httpd_sys_content_t:s0 /var/www/html
```
Defina uma regra de contexto de arquivo SELinux persistente para /custom.

O comando semanage fcontext é usado para gerenciar regras de mapeamento de contexto de arquivo SELinux. A opção -a adiciona uma nova regra, -t especifica o tipo de destino e a expressão regular '/custom(/.*)?' corresponde ao próprio diretório /custom e a todos os arquivos e subdiretórios dentro dele.
```
sudo semanage fcontext -a -t httpd_sys_content_t '/custom(/.*)?'
```
Este comando adiciona a regra à política SELinux, mas não altera imediatamente os contextos dos arquivos existentes.
Aplique os novos contextos SELinux aos arquivos.

O comando restorecon é usado para restaurar os contextos SELinux de arquivos e diretórios para seus valores padrão, conforme definido pela política. A opção -R aplica a alteração recursivamente e -v fornece saída detalhada.
```
sudo restorecon -Rv /custom
```
Você deve ver uma saída indicando que os contextos de /custom e /custom/index.html foram rotulados novamente.
```
Relabeled /custom from system_u:object_r:root_t:s0 to system_u:object_r:httpd_sys_content_t:s0
Relabeled /custom/index.html from system_u:object_r:root_t:s0 to system_u:object_r:httpd_sys_content_t:s0
```
Verifique os contextos novamente usando ls -Z.
```
ls -Zd /custom /custom/index.html
```
Eles agora devem ter o contexto httpd_sys_content_t.
```
system_u:object_r:httpd_sys_content_t:s0 /custom
system_u:object_r:httpd_sys_content_t:s0 /custom/index.html
```
Acesse a página web novamente.

Agora que os contextos SELinux estão corretos, tente acessar a página web com curl novamente.
```
curl http://localhost/index.html
```
Você deve ver o conteúdo do seu arquivo index.html.
```
This is custom web content.
```
Finalmente, pare o processo do servidor HTTP Apache.
```
sudo pkill httpd
```
Verifique se nenhum processo httpd está em execução.
```
ps aux | grep httpd
```
Você deve ver apenas o próprio processo grep.
```
labex     ... grep httpd
```

Ajustar a Política SELinux para Diretórios Home de Usuários com Booleans

Nesta etapa, você aprenderá a ajustar a política SELinux usando Booleans para permitir que o Apache sirva conteúdo web de diretórios home de usuários. Por padrão, o SELinux impede que serviços como o Apache acessem arquivos em diretórios home de usuários por motivos de segurança. No entanto, existem cenários específicos, como páginas web pessoais, onde essa funcionalidade é desejada.

Os Booleans do SELinux são configurações verdadeiro/falso que permitem aos administradores modificar o comportamento da política SELinux sem escrever políticas personalizadas complexas. Eles fornecem uma maneira flexível de ativar ou desativar determinados recursos de segurança. Por exemplo, existe um Boolean especificamente para permitir que o Apache acesse diretórios home de usuários.

Habilite o recurso de diretório de usuário do Apache.

O Apache possui um módulo chamado mod_userdir que permite aos usuários publicar conteúdo web de um diretório public_html dentro de seu diretório home (por exemplo, ~/public_html). Este recurso é normalmente configurado em /etc/httpd/conf.d/userdir.conf. Por padrão, este recurso geralmente está desativado.

Abra o arquivo de configuração usando nano.
```
sudo nano /etc/httpd/conf.d/userdir.conf
```
Dentro do editor, você encontrará linhas relacionadas a UserDir. Você precisa comentar a linha que desativa UserDir e descomentar a linha que o ativa para public_html.

Altere:
```
UserDir disabled
#UserDir public_html
```
Para:
```
#UserDir disabled
UserDir public_html
```
Salve e saia do arquivo (Ctrl+X, Y, Enter).
Crie um diretório public_html e um arquivo index.html em seu diretório home.

Você criará o diretório public_html e um arquivo index.html dentro dele. É aqui que seu conteúdo web pessoal residirá.
```
mkdir ~/public_html
echo 'This is labex user content.' > ~/public_html/index.html
```
Verifique o conteúdo do arquivo index.html.
```
cat ~/public_html/index.html
```
```
This is labex user content.
```
Informativo: Quando você criou o diretório ~/public_html, ele foi configurado automaticamente com os contextos user_home_t e ~/ (seu diretório home) com os contextos home_dir_t SELinux. O processo do servidor web Apache (httpd_t) não pode ler arquivos rotulados como user_home_t ou home_dir_t por padrão devido à política SELinux.
Inicie o serviço web Apache.

Inicie o serviço httpd. Lembre-se, systemctl não está disponível neste ambiente de contêiner, então você iniciará o httpd diretamente.
```
sudo /usr/sbin/httpd -DFOREGROUND &
```
Você pode ver uma mensagem de aviso sobre o nome de domínio totalmente qualificado do servidor, que pode ser ignorada com segurança neste ambiente de laboratório.

Verifique se o Apache está em execução.
```
ps aux | grep httpd
```
```
root        ... /usr/sbin/httpd -DFOREGROUND
apache      ... /usr/sbin/httpd -DFOREGROUND
...output omitted...
```
Tente acessar a página web do usuário e observe a negação do SELinux.

Agora, tente acessar sua página web pessoal usando curl. A URL para diretórios de usuário normalmente segue o formato http://localhost/~username/.
```
curl http://localhost/~labex/index.html
```
Você provavelmente receberá um erro "Forbidden" (Proibido), indicando que o Apache ainda não consegue acessar o conteúdo devido ao SELinux.
```
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>403 Forbidden</title>
</head><body>
<h1>Forbidden</h1>
<p>You don't have permission to access /~labex/index.html
on this server.<br />
</p>
</body></html>
```
Verifique os Booleans do SELinux relacionados aos diretórios home para httpd.

O comando getsebool permite que você visualize o estado atual dos Booleans do SELinux. Você pode filtrar a saída usando grep para encontrar Booleans relacionados a httpd e diretórios home.
```
sudo getsebool -a | grep httpd | grep home
```
Você deve ver httpd_enable_homedirs --> off, indicando que este Boolean está atualmente desativado.
```
httpd_enable_homedirs --> off
```
Habilite o Boolean httpd_enable_homedirs persistentemente.

O comando setsebool é usado para alterar o estado dos Booleans do SELinux. A opção -P torna a alteração persistente após as reinicializações.
```
sudo setsebool -P httpd_enable_homedirs on
```
Verifique se o Boolean agora está on.
```
sudo getsebool -a | grep httpd | grep home
```
```
httpd_enable_homedirs --> on
```
Defina as permissões de arquivo corretas para o diretório home.

Mesmo com o Boolean SELinux habilitado, o Apache precisa das permissões corretas do sistema de arquivos para acessar seu diretório home e o diretório public_html. Por padrão, os diretórios home de usuários não são acessíveis ao usuário Apache.
```
chmod 711 ~
chmod 755 ~/public_html
chmod 644 ~/public_html/index.html
```
Acesse a página web novamente.

Agora que o Boolean httpd_enable_homedirs está habilitado e as permissões de arquivo estão corretas, tente acessar sua página web pessoal com curl novamente.
```
curl http://localhost/~labex/index.html
```
Você deve ver o conteúdo do seu arquivo index.html.
```
This is labex user content.
```
Solução de problemas: Se você ainda encontrar problemas de acesso mesmo depois de habilitar o boolean e definir as permissões de arquivo, isso demonstra a natureza multicamadas da segurança do Linux. Em alguns ambientes, fatores adicionais, como:
- Diretivas de configuração do Apache em /etc/httpd/conf.d/userdir.conf
- Contextos de arquivo SELinux na estrutura do diretório home
- Módulos Apache ou configurações de segurança adicionais
podem precisar ser abordados. O principal ponto de aprendizado é entender como os booleans do SELinux funcionam em conjunto com as permissões de arquivo tradicionais e as configurações específicas do aplicativo.
Pare o processo do servidor HTTP Apache.

Finalmente, pare o processo do servidor HTTP Apache.
```
sudo pkill httpd
```
Verifique se nenhum processo httpd está em execução.
```
ps aux | grep httpd
```
```
labex     ... grep httpd
```

Solucionar Problemas de Negações SELinux para o Servidor Web Apache

Nesta etapa, você aprenderá a identificar e solucionar problemas de negações de segurança do SELinux, com foco específico em questões que podem impedir o funcionamento correto do servidor web Apache. Quando o SELinux bloqueia uma operação, ele registra uma mensagem de negação "Access Vector Cache" (AVC). Essas mensagens são cruciais para entender por que uma operação falhou e como resolvê-la.

Você usará ferramentas como auditd (o daemon do Sistema de Auditoria do Linux) e sealert para analisar essas mensagens de negação. O auditd coleta chamadas e eventos do sistema, incluindo negações do SELinux, e os armazena em /var/log/audit/audit.log. A ferramenta sealert, parte do pacote setroubleshoot-server, pode analisar esses logs e fornecer explicações legíveis por humanos e soluções sugeridas para negações do SELinux.

Primeiro, você precisa garantir que auditd e setroubleshoot-server estejam instalados.

Instale auditd e setroubleshoot-server.
```
sudo dnf install -y audit setroubleshoot-server
```
Você deve ver uma saída indicando a instalação bem-sucedida desses pacotes.
Inicie o servidor web Apache e crie um arquivo problemático.

Para simular uma negação do SELinux, você criará um arquivo com um contexto SELinux incorreto e tentará servi-lo com o Apache.

Primeiro, certifique-se de que o Apache esteja em execução.
```
sudo /usr/sbin/httpd -DFOREGROUND &
```
Agora, crie um novo diretório e um arquivo index.html dentro dele. Desta vez, você definirá intencionalmente um contexto SELinux incorreto para este arquivo para acionar uma negação.
```
sudo mkdir /testweb
echo 'This is a test page.' | sudo tee /testweb/index.html
```
Por padrão, /testweb/index.html provavelmente terá o contexto root_t. Vamos confirmar.
```
ls -Z /testweb/index.html
```
```
system_u:object_r:root_t:s0 /testweb/index.html
```
Agora, vamos configurar o Apache para servir de /testweb. Abra /etc/httpd/conf/httpd.conf.
```
sudo nano /etc/httpd/conf/httpd.conf
```
Altere DocumentRoot e a diretiva <Directory> para /testweb.
```
DocumentRoot "/testweb"

<Directory "/testweb">
    AllowOverride None
    Require all granted
</Directory>
```
Salve e saia (Ctrl+X, Y, Enter).

Reinicie o Apache para aplicar as alterações de configuração. Como você está em um contêiner, você precisa matar o processo antigo e iniciar um novo.
```
sudo pkill httpd
sudo /usr/sbin/httpd -DFOREGROUND &
```
Tente acessar a página web.

Tente acessar a página web usando curl.
```
curl http://localhost/index.html
```
Nota Importante: Neste ambiente, você pode descobrir que a página web é acessível mesmo com o contexto root_t, semelhante ao que observamos na Etapa 2. Isso demonstra que, embora o SELinux esteja aplicando, o contexto root_t tem permissões mais amplas do que contextos mais restritivos.
```
This is a test page.
```
No entanto, para fins de aprendizado de técnicas de solução de problemas do SELinux, prosseguiremos como se houvesse uma negação. Em ambientes SELinux mais restritivos ou com configurações de política diferentes, o acesso a arquivos com contextos inadequados realmente geraria negações.
Aprenda sobre como investigar negações do SELinux usando ausearch.

O comando ausearch é usado para consultar os logs de auditoria. Você pode pesquisar por negações AVC do SELinux (-m AVC) que ocorreram hoje (-ts today).
```
sudo ausearch -m AVC -ts today
```
Observação: Como a página web foi acessível em nosso ambiente, você pode não ver nenhuma negação AVC recente relacionada a este teste específico. No entanto, este comando normalmente geraria saídas de entradas de log de auditoria detalhadas se houvesse negações. Em um cenário de negação típico, você procuraria entradas relacionadas a httpd e /testweb/index.html.

Uma entrada de negação AVC típica seria assim:
```
----
time->...
type=AVC msg=audit(...): avc:  denied  { getattr } for  pid=... comm="httpd" path="/testweb/index.html" dev="overlay" ino=... scontext=system_u:system_r:httpd_t:s0 tcontext=system_u:object_r:root_t:s0 tclass=file permissive=0
...output omitted...
```
As partes principais em uma negação AVC seriam:
- denied { getattr }: A operação que foi negada (obter atributos do arquivo).
- comm="httpd": O processo que foi negado (servidor HTTP Apache).
- path="/testweb/index.html": O arquivo que foi acessado.
- scontext=system_u:system_r:httpd_t:s0: O contexto SELinux da origem (Apache).
- tcontext=system_u:object_r:root_t:s0: O contexto SELinux do destino (seu arquivo index.html).
- tclass=file: O tipo de destino (um arquivo).
Esta saída mostra claramente que httpd_t (Apache) teve acesso getattr negado a um arquivo com contexto default_t.
Aprenda sobre como usar sealert para análise do SELinux.

sealert pode analisar os logs de auditoria e fornecer informações mais amigáveis ao usuário. Você pode executar sealert -a para analisar todas as negações recentes ou usar sealert -l <UUID> se tiver um UUID específico de uma mensagem setroubleshoot em /var/log/messages.
```
sudo sealert -a /var/log/audit/audit.log
```
Observação: Como não encontramos negações reais neste ambiente, a execução de sealert pode não mostrar resultados relacionados ao nosso exemplo /testweb. No entanto, em um cenário em que ocorrem negações do SELinux, sealert analisaria o log de auditoria e apresentaria um resumo.

Uma saída sealert típica para um problema de contexto httpd seria assim:
```
SELinux is preventing /usr/sbin/httpd from getattr access on the file /testweb/index.html.

***** Plugin catchall_labels (83.8 confidence) suggests *******************
If you want to allow httpd to have getattr access on the index.html file
Then you need to change the label on /testweb/index.html
Do ## semanage fcontext -a -t FILE_TYPE '/testweb/index.html'
where FILE_TYPE is one of the following:
httpd_sys_content_t, httpd_sys_script_exec_t, httpd_unconfined_script_exec_t, ...

***** Plugin httpd_can_network_connect (93.8 confidence) suggests *********
If you want to allow httpd to connect to the network (for example, to a database)
Then you must set the httpd_can_network_connect boolean to on.
Do ## setsebool -P httpd_can_network_connect on
...output omitted...
```
A saída sealert seria muito útil em cenários de negação reais. Ele declararia explicitamente o problema e sugeriria soluções, como alterar o rótulo com semanage fcontext -a -t FILE_TYPE '/testweb/index.html' e listar httpd_sys_content_t como um FILE_TYPE adequado.

Finalmente, pare o processo do servidor HTTP Apache.
```
sudo pkill httpd
```
Verifique se nenhum processo httpd está em execução.
```
ps aux | grep httpd
```
```
labex     ... grep httpd
```

Resolver Problemas SELinux para Conteúdo Web Personalizado

Nesta etapa final, você aplicará o conhecimento adquirido no exercício de solução de problemas anterior para resolver a negação do SELinux que impedia o Apache de servir conteúdo do diretório /testweb. Você usará semanage fcontext para definir o contexto SELinux correto para seu conteúdo web personalizado e restorecon para aplicá-lo.

Este processo reforça a compreensão de como os contextos SELinux funcionam e como configurá-los corretamente para serviços como o Apache.

Certifique-se de que o Apache esteja em execução e a configuração esteja em vigor.

Primeiro, certifique-se de que o Apache está configurado para servir de /testweb e está em execução. Se você parou o Apache na etapa anterior, inicie-o novamente.
```
sudo /usr/sbin/httpd -DFOREGROUND &
```
Verifique se o DocumentRoot em /etc/httpd/conf/httpd.conf está definido como /testweb. Caso contrário, modifique-o conforme feito na etapa anterior.
```
grep "DocumentRoot" /etc/httpd/conf/httpd.conf
```
```
DocumentRoot "/testweb"
```
Além disso, confirme que /testweb/index.html existe e tem o contexto root_t.
```
ls -Z /testweb/index.html
```
```
system_u:object_r:root_t:s0 /testweb/index.html
```
Acesse a página web para confirmar o comportamento atual.

Vamos verificar se a página web está atualmente acessível com o contexto root_t.
```
curl http://localhost/index.html
```
Como vimos antes, a página é acessível mesmo com o contexto root_t.
```
This is a test page.
```
Embora isso funcione, prosseguiremos para demonstrar a configuração SELinux adequada para conteúdo web.
Defina o contexto de arquivo SELinux correto para /testweb.

O contexto SELinux correto para conteúdo web servido pelo Apache é httpd_sys_content_t. Você precisa adicionar uma regra persistente usando semanage fcontext.
```
sudo semanage fcontext -a -t httpd_sys_content_t '/testweb(/.*)?'
```
Este comando informa ao SELinux que todos os arquivos ou diretórios dentro de /testweb (incluindo o próprio /testweb) devem ser rotulados com httpd_sys_content_t.

Aplique os novos contextos SELinux aos arquivos.

Depois de definir a regra, você deve aplicá-la aos arquivos existentes usando restorecon.

sudo restorecon -Rv /testweb

Você deve ver a saída indicando que os contextos foram rotulados novamente.

Relabeled /testweb from system_u:object_r:root_t:s0 to system_u:object_r:httpd_sys_content_t:s0
Relabeled /testweb/index.html from system_u:object_r:root_t:s0 to system_u:object_r:httpd_sys_content_t:s0

Verifique os contextos novamente usando ls -Z.

ls -Z /testweb/index.html

system_u:object_r:httpd_sys_content_t:s0 /testweb/index.html

Acesse a página web novamente para confirmar a configuração adequada.

Agora que os contextos SELinux estão corretamente aplicados de acordo com as melhores práticas, tente acessar a página web com curl mais uma vez.
```
curl http://localhost/index.html
```
O conteúdo ainda deve ser acessível e agora está configurado corretamente com o contexto SELinux recomendado.
```
This is a test page.
```
Isso demonstra que, embora o contexto root_t possa funcionar neste ambiente, o uso do contexto httpd_sys_content_t adequado segue as melhores práticas do SELinux e garante a compatibilidade em diferentes configurações de segurança.

Finalmente, pare o processo do servidor HTTP Apache.
```
sudo pkill httpd
```
Verifique se nenhum processo httpd está em execução.
```
ps aux | grep httpd
```
```
labex     ... grep httpd
```

Resumo

Neste laboratório, você aprendeu a gerenciar a segurança do SELinux no RHEL. Você começou entendendo e praticando como alterar os modos de aplicação do SELinux, tanto temporariamente usando setenforce quanto persistentemente modificando /etc/selinux/config. Isso incluiu a verificação do modo atual com getenforce e a compreensão das implicações dos modos Enforcing, Permissive e Disabled.

Além disso, você adquiriu experiência prática na configuração do Apache com contextos de arquivo SELinux personalizados usando semanage fcontext e restorecon para garantir a operação adequada do servidor web. Você também aprendeu a ajustar a política do SELinux para diretórios home de usuários, habilitando booleanos SELinux específicos com setsebool. Por fim, o laboratório abordou técnicas essenciais de solução de problemas para negações do SELinux, especificamente para o servidor web Apache, analisando logs de auditoria com ausearch e audit2allow para identificar e resolver problemas de acesso para conteúdo web personalizado.

Gerenciar a Segurança do SELinux no RHEL