Dokuwiki

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Selinux ======
===== Sources =====
  * http://doc.fedora-fr.org/wiki/SELinux
  * http://selinuxproject.org

===== Description =====
Security-Enhanced Linux, abrégé SELinux, est un LSM (Linux security module), qui permet de définir une politique d'accès MAC (mandatory access control) aux éléments d'un système basé sur Linux.
====== Les Modes ======
  * **Enforcing** : il s'agit du mode proposé par défaut à l'installation de Fedora. Dans ce mode, les accès sont restreints en fonction des règles SELinux en vigueur sur la machine.
  * **Permissive** : ce mode est généralement à considérer comme un mode de déboguage. En mode permissif, les règles SELinux seront interrogées, les erreurs d'accès logguées, mais l'accès ne sera pas bloqué. Ce mode peut être utile pour constater l'ensemble des erreurs SELinux posées par un processus particulier, par exemple.
  * **Disabled** : SELinux est désactivé. Rien ne sera restreint, rien ne sera loggué

====== Contexte SELinux ======
Chaque processus est confiné à un (voire plusieurs) domaine, et les fichiers sont étiquetés en conséquence. Pour simplifier, un processus ne peut accéder qu'aux fichiers étiquetés pour le domaine auquel il est confiné.

Un contexte SELinux est présenté de la manière suivante :
<xtermrtf>
utilisateur:rôle:type:niveau
</xtermrtf>

Pour le contexte du dossier ''/var/www/html'' :
<xtermrtf>
system_u:object_r:httpd_sys_content_t:s0 html
</xtermrtf>

Nous avons donc :
  * l'utilisateur //system_u//
  * le rôle //object_r//
  * le type //httpd_sys_content_t//
  * et le niveau //s0//

===== Utilisateurs =====
Tout utilisateur Linux est mappé à un utilisateur SELinux par la politique actuelle. Ce mappage permet l'héritage des droits et restrictions de l'utilisateur SELinux correspondant.

La liste des utilisateurs SELinux peut être obtenue avec la commande **//semanage login -l//** :
<xtermrtf>
$ semanage login -l

Nom pour l'ouverture de session Identité SELinux     Intervalle MLS/MCS   Service

__default__          unconfined_u         s0-s0:c0.c1023       *
root                 unconfined_u         s0-s0:c0.c1023       *
system_u             system_u             s0-s0:c0.c1023       *
</xtermrtf>

===== Rôles =====
Les rôles sont l'intermédiaire entre les utilisateurs et les domaines SELinux. Les domaines sont accessibles par des rôles définis, et les rôles sont eux-mêmes accessibles par des utilisateurs définis.

===== Types =====
Un type SELinux est en quelque sorte un regroupement d'objets sur leur similarité d'un point de vue sécurité ; qui ne sont donc pas liés à un contexte ou à un fichier particulier. Par exemple, les dossiers personnels des utilisateurs peuvent contenir des contenus très différents, donc la particularité commune est d'appartenir à un utilisateur ; on trouvera dans ce cas précis le type home_user_t.

===== Niveau =====
  * [[http://selinuxproject.org/page/NB_MLS|MCS/MLS]]
  * Voir aussi http://selinuxproject.org/page/MultiCategorySecurity

====== Interface graphique ======
Une interface graphique est disponible pour la gestion des différents paramètres de SELinux. Normalement, l'interface est installée par défaut, si tel n'était pas le cas, faites simplement :
<xtermrtf>
$ yum -y install policycoreutils-gui
</xtermrtf>

====== Relabeliser l'OS ======
<xtermrtf>
$ touch /.autorelabel
</xtermrtf>


====== Compiler une règle te en pp ======
Compiler une rule **te** :
<xtermrtf>
$ checkmodule -M -m -o gigix-tlp.mod gigix-tlp.te
checkmodule:  loading policy configuration from gigix-tlp.te
checkmodule:  policy configuration loaded
checkmodule:  writing binary representation (version 17) to gigix-tlp.mod
</xtermrtf>

<xtermrtf>
$ semodule_package -m gigix-tlp.mod -o gigix-tlp.pp
</xtermrtf>

On installe le module :
<xtermrtf>
$ semodule -i gigix-tlp.pp
</xtermrtf>

====== audit2allow ======
===== Ajouter des régles =====
Voir : http://selinuxproject.org/page/Audit2allowRecipe

  * Créer un fichier pour un module test :
<xtermrtf>
$ grep smtpd_t /var/log/audit/audit.log | audit2allow -m test > test.te
$ cat test.te
module test 1.0;
require {
        type postfix_smtpd_t;
        type postfix_spool_t;
        type initrc_t;
        class sock_file write;
        class unix_stream_socket connectto;
}
#============= postfix_smtpd_t ==============
allow postfix_smtpd_t initrc_t:unix_stream_socket connectto;
allow postfix_smtpd_t postfix_spool_t:sock_file write; 
</xtermrtf>

  * Ajouter la règle directement :
<xtermrtf>
$ grep smtpd_t /var/log/audit/audit.log | audit2allow -M test
</xtermrtf>

  * On active le module :
<xtermrtf>
$ semodule -i test.pp
</xtermrtf>

===== Analyser les bloquages =====
<xtermrtf>
$ audit2allow -a -w
</xtermrtf>

<xtermrtf>
$ audit2allow -la


#============= ifconfig_t ==============

#!!!! WARNING 'ifconfig_t' is not allowed to write or create to var_run_t.  Change the label to ifconfig_var_run_t.
#!!!! $ semanage fcontext -a -t ifconfig_var_run_t /run/tlp/lock_tlp   
#!!!! $ restorecon -R -v /run/tlp/lock_tlp
#!!!! The file '/run/tlp/lock_tlp' is mislabeled on your system.  
#!!!! Fix with $ restorecon -R -v /run/tlp/lock_tlp
allow ifconfig_t var_run_t:file write;

#============= tlp_t ==============

#!!!! WARNING 'tlp_t' is not allowed to write or create to var_run_t.  Change the label to tlp_var_run_t.
allow tlp_t var_run_t:file { getattr lock open read write };
</xtermrtf>

Il y a aussi la log ''/var/log/audit/audit.log'' qui renseigne les blocages.

  * Voir les blocage httpd :
<xtermrtf>
$ ausearch -m avc -c httpd
</xtermrtf>

  * Voir les blocages de la journée :
<xtermrtf>
$ ausearch -m avc -ts today
</xtermrtf>

  * Voir les blocages des 10 dernière minutes :
<xtermrtf>
$ ausearch -m avc -ts recent
</xtermrtf>

  * Voir tous les problèmes :
<xtermrtf>
$ aureport -a
</xtermrtf>

  * Transformer une date auditd :
<note tip>
<xtermrtf>
$ date -d @1363292159.532
jeu. mars 14 21:15:59 CET 2013
</xtermrtf>
</note>
===== man =====
Générer les man à l'aide de **//sepolicy//** :
<xtermrtf>
$ sepolicy manpage -a -p /usr/share/man/man8
$ mandb
$ man -k _selinux
$ man httpd_selinux
</xtermrtf>

====== audit2why ======
Comprendre pourquoi il y a eu un blocage :
<xtermrtf>
$ /usr/sbin/audit2why < /var/log/audit/audit.log
type=KERNEL msg=audit(1115316408.926:336418): avc:  denied  { getattr }
for  path=/home/sds dev=hda5 ino=1175041 scontext=root:secadm_r:secadm_t:s0-s9:c0.c127
tcontext=user_u:object_r:user_home_dir_t:s0 tclass=dir
        Was caused by:
                Missing or disabled TE allow rule.
                Allow rules may exist but be disabled by boolean settings;
check boolean settings.
                You can see the necessary allow rules by running audit2allow
with this audit message as input.
type=KERNEL msg=audit(1115320071.648:606858): avc:  denied  { append } for
 name=.bash_history dev=hda5 ino=1175047 scontext=user_u:user_r:user_t:s1-s9:c0.c127
tcontext=user_u:object_r:user_home_t:s0 tclass=file
        Was caused by:
                Constraint violation.
                Check policy/constraints.
                Typically, you just need to add a type attribute to the
domain to satisfy the constraint.
</xtermrtf>

====== sealert ======
Afficher les solutions pour une alerte :
<xtermrtf>
$ journalctl --no-pager -t setroubleshoot
</xtermrtf>

<xtermrtf>
$ sealert -l 8f01dd48-8337-4ee9-b5d6-952da4422b14

SELinux is preventing iw from write access on the file /run/tlp/lock_tlp.

*****  Plugin restorecon (99.5 confidence) suggests   ************************

If vous souhaitez corriger l'étiquette. 
L'étiquette par défaut de /run/tlp/lock_tlp devrait être tlp_var_run_t.
Then vous pouvez exécuter restorecon.
Do
# /sbin/restorecon -v /run/tlp/lock_tlp

*****  Plugin catchall (1.49 confidence) suggests   **************************

If vous pensez que iw devrait être autorisé à accéder write sur lock_tlp file par défaut.
Then vous devriez rapporter ceci en tant qu'anomalie.
Vous pouvez générer un module de stratégie local pour autoriser cet accès.
Do
allow this access for now by executing:
# ausearch -c 'iw' --raw | audit2allow -M my-iw
# semodule -X 300 -i my-iw.pp


Additional Information:
Source Context                system_u:system_r:ifconfig_t:s0-s0:c0.c1023
Target Context                system_u:object_r:var_run_t:s0
Target Objects                /run/tlp/lock_tlp [ file ]
Source                        iw
Source Path                   iw
Port                          <Unknown>
Host                          portable.localdomain
Source RPM Packages           
Target RPM Packages           
Policy RPM                    selinux-policy-3.13.1-225.13.fc25.noarch
Selinux Enabled               True
Policy Type                   targeted
Enforcing Mode                Enforcing
Host Name                     portable.localdomain
Platform                      Linux portable.localdomain 4.10.11-200.fc25.x86_64
                              #1 SMP Tue Apr 18 17:25:01 UTC 2017 x86_64 x86_64
Alert Count                   14
First Seen                    2017-03-20 11:18:00 CET
Last Seen                     2017-04-27 20:40:40 CEST
Local ID                      8f01dd48-8337-4ee9-b5d6-952da4422b14

Raw Audit Messages
type=AVC msg=audit(1493318440.152:161): avc:  denied  { write } for  pid=1297 comm="iw" path="/run/tlp/lock_tlp" dev="tmpfs" ino=29849 scontext=system_u:system_r:ifconfig_t:s0-s0:c0.c1023 tcontext=system_u:object_r:var_run_t:s0 tclass=file permissive=0
</xtermrtf>

====== Modules ======
Voir : http://selinuxproject.org/page/ReferencePolicy

====== Description des permissions ======
Voir : http://selinuxproject.org/page/ObjectClassesPerms

====== Fichier de configuration ======
  * http://selinuxproject.org/page/GlobalConfigurationFiles
  * http://selinuxproject.org/page/PolicyStoreConfigurationFiles
  * http://selinuxproject.org/page/PolicyConfigurationFiles
====== Commandes OS ======
  * Voir les permissions des processus :
<xtermrtf>
$ ps fauxZwww
</xtermrtf>

  * Voir les permissions des fichiers :
<xtermrtf>
$  ls -lZ
</xtermrtf>

  * Voir les permission pour sa session courante :
<xtermrtf>
  $ id -Z
</xtermrtf>
====== Commandes selinux ======
===== getenforce =====
La commande getenforce vous informera sur le mode actuellement actif sur votre machine :
<xtermrtf>
$ getenforce 
Permissive
</xtermrtf>

===== sestatus =====
Pour connaître l'état général (activé ou désactivé, mode courant, politique chargée, etc...), utilisez la commande **//sestatus//** :
<xtermrtf>
$ sestatus
SELinux status:                 enabled
SELinuxfs mount:                /sys/fs/selinux
SELinux root directory:         /etc/selinux
Loaded policy name:             targeted
Current mode:                   permissive
Mode from config file:          enforcing
Policy MLS status:              enabled
Policy deny_unknown status:     allowed
Max kernel policy version:      29

Process contexts:
Current context:                unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
Init context:                   system_u:system_r:init_t:s0

File contexts:
Controlling terminal:           unconfined_u:object_r:user_devpts_t:s0
/etc/passwd                     system_u:object_r:passwd_file_t:s0
/etc/shadow                     system_u:object_r:shadow_t:s0
/bin/bash                       system_u:object_r:shell_exec_t:s0
/bin/login                      system_u:object_r:login_exec_t:s0
/bin/sh                         system_u:object_r:bin_t:s0 -> system_u:object_r:shell_exec_t:s0
/sbin/agetty                    system_u:object_r:getty_exec_t:s0
/sbin/init                      system_u:object_r:bin_t:s0 -> system_u:object_r:init_exec_t:s0
/usr/sbin/sshd                  system_u:object_r:sshd_exec_t:s0
</xtermrtf>

===== setenforce =====
La commande **//setenforce//** permet de basculer de façon temporaire (la modification ne sera pas prise ne compte au prochain redémarrage de votre machine) entre les modes Appliqué et Permissif. Si vous souhaitez rendre la modification permanente, utilisez **//setenforce 1//** pour activer le mode Appliqué ou **//setenforce 0//** pour activer le mode Permissif.

Editer le fichier ''/etc/selinux/config'' pour une modification définitive.

<note warning>
Lorsque SELinux est exécuté en mode permissif ou s'il est désactivé, les nouveaux fichiers crées ne porteront aucune étiquette. Lorsque SELinux sera réactivé, cela pourra poser des problèmes, et il vous faudra donc re-étiqueter l'intégralité de votre système. Pour ce faire, entrez la commande suivante :
<xtermrtf>
$ touch /.autorelabel'
</xtermrtf>
puis redémarrez votre système. Au démarrage, l'intégralité de vos fichiers sera ré-étiquettée, cela peut prendre un certain temps ; à plus forte raison si vous avez beaucoup de fichiers. 
</note>

===== sesearch =====
Il est possible de connaître la liste des contextes auxquels peut accéder un processus à l'aide de la commande **//sesearch//**.
<xtermrtf>
$ sesearch --allow -s httpd_t -c file -p write 
WARNING: This policy contained disabled aliases; they have been removed.
Found 29 semantic av rules:                                             
   allow httpd_t httpd_t : file { ioctl read write getattr lock append } ; 
   allow httpd_t httpd_var_lib_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ; 
   allow httpd_t httpd_var_run_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ; 
   allow httpd_t httpd_lock_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;    
   allow @ttr2119 xdm_home_t : file { ioctl read write getattr lock append } ;                                            
   allow httpd_t @ttr2306 : file { ioctl read write create getattr setattr lock append unlink link rename open } ;        
   allow httpd_t squirrelmail_spool_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ; 
   allow httpd_t httpd_cache_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;        
   allow httpd_t httpd_tmpfs_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;        
   allow httpd_t httpd_tmp_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;          
   allow httpd_t httpd_squirrelmail_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ; 
   allow @ttr2119 user_tmp_t : file { ioctl write getattr lock append } ;                                                      
   allow httpd_t httpd_squid_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ; 
   allow httpd_t httpd_awstats_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ; 
   allow httpd_t httpd_apcupsd_cgi_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ; 
   allow httpd_t public_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;            
   allow httpd_t httpd_prewikka_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;    
   allow @ttr2119 root_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;                        
   allow httpd_t httpd_w3c_validator_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ; 
   allow httpd_t cifs_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;                           
   allow httpd_t nfs_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;                            
   allow httpd_t httpd_user_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;          
   allow httpd_t @ttr0804 : file { ioctl read write create getattr setattr lock append unlink link rename open } ;                         
   allow httpd_t httpd_munin_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;         
   allow httpd_t httpd_bugzilla_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;      
   allow httpd_t httpd_nagios_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;        
   allow httpd_t httpd_sys_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;           
   allow httpd_t httpd_sys_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;           
   allow httpd_t httpd_cvs_content_rw_t : file { ioctl read write create getattr setattr lock append unlink link rename open } ;
</xtermrtf>

Tout fichier qui ne serait pas étiqueté avec l'un des contextes listés ne serait pas accessible par le processus **httpd** ; donc votre serveur apache n'aurait pas le droit de lire le fichier, et ce même si les droits unix le lui permettent.

  * Voir ce que **//httpd_t//** peut faire vers le contexte **//user_home_t//** (les champs entre crochets sont des booléens) :
<xtermrtf>
$ sesearch -s httpd_t -t user_home_t -AC
Found 7 semantic av rules:
   allow daemon user_home_t : file { getattr append } ; 
   allow httpd_t file_type : filesystem getattr ; 
   allow httpd_t file_type : dir { getattr search open } ; 
DT allow httpd_t user_home_type : file { ioctl read getattr lock open } ; [ httpd_read_user_content ]
DT allow httpd_t user_home_type : dir { getattr search open } ; [ httpd_enable_homedirs ]
DT allow httpd_t user_home_type : dir { ioctl read getattr lock search open } ; [ httpd_read_user_content ]
DT allow httpd_t user_home_type : lnk_file { read getattr } ; [ httpd_enable_homedirs ]
</xtermrtf>

  * Voir ce que fait le booléen **//httpd_can_sendmail//** :
<xtermrtf>
$ sesearch -b httpd_enable_homedirs -AC
</xtermrtf>

<xtermrtf>
$ sesearch --auditallow
</xtermrtf>

<xtermrtf>
$ sesearch -T -s unconfined_t -t initrc_exec_t
Found 1 semantic te rules:
   type_transition unconfined_t initrc_exec_t : process initrc_t;
</xtermrtf>

<xtermrtf>
$ sesearch -T -s unconfined_t -c process -C
</xtermrtf>

===== matchpathcon =====
La commande **//matchpathcon//** vous indique quel contexte devrait posséder votre fichier :
<xtermrtf>
$ matchpathcon /var/www/html/gigix.html
/var/www/html/gigix.html	system_u:object_r:httpd_sys_content_t:s0
$ ll -Z /var/www/html/gigix.html
-rw-r--r--. 1 root root unconfined_u:object_r:user_tmp_t:s0 0  8 août  15:00 /var/www/html/gigix.html
</xtermrtf>

Dans notre cas, le contexte qui aurait du être appliqué est **//httpd_sys_content_t//**.
On peut utiliser la commande [[#restorecon]] pour restaurer le contexte.

===== restorecon =====
**//restorecon//** permet de restaurer le(s) contexte(s) original(aux) du ou des chemins spécifiés.
<xtermrtf>
$ restorecon -v /var/www/html/gigix.html
restorecon reset /var/www/html/gigix.html context unconfined_u:object_r:user_tmp_t:s0->unconfined_u:object_r:httpd_sys_content_t:s0
</xtermrtf>

On voit ici que le contexte de notre fichier erroné est passé de **//user_tmp_t//** à **//httpd_sys_content_t//**. 

===== chcon =====
//**chcon**// permet de changer le contexte SELinux d'un fichier ou dossier donné, mais pas de façon permanente. Au prochain ré-étiquetage du disque ou à la prochaine utilisation de **//restorecon//** sur le fichier ou sur ses parents, le fichier sera ré-étiqueté avec le contexte de son plus proche parent pour lequel un contexte spécifique est défini.
<xtermrtf>
$ chcon -t httpd_sys_content_t /var/www/html/gigix.html
</xtermrtf>

Pour modifier de façon définitive, il faut utiliser [[#semanage]].

===== semanage =====
==== Mapping entre utilisateurs Linux et utilisateurs SELinux ====
<xtermrtf>
$ semanage login -l
</xtermrtf>

==== Ajoute l'utilisateur ====
<xtermrtf>
$ useradd myuser
$ semanage login -a -s user_u myuser
</xtermrtf>

Ou 
<xtermrtf>
$ useradd -Z user_u test
</xtermrtf>

==== Mapping des utilsateurs par défaut  ====

<xtermrtf>
$ semanage login -m -S targeted -s "user_u" -r s0 __default__
</xtermrtf>

Pour revenir au mapping original:
<xtermrtf>
$ semanage login -m -S targeted -s "unconfined_u" -r s0-s0:c0.c1023
</xtermrtf>


Créez un nouvel utilisateur SELinux et spécifiez le rôle SELinux par défaut et un rôle d'administrateur confiné supplémentaire
<xtermrtf>
$ semanage user -a -r s0-s0:c0.c1023 -R "default_role_r administrator_r" gigix_user_u
</xtermrtf>

==== Mapping entre utilisateurs SELinux et les rôles SELinux ====
<xtermrtf>
$ semanage user -l
</xtermrtf>

[[https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/6/html/Security-Enhanced_Linux/sect-Security-Enhanced_Linux-Targeted_Policy-Confined_and_Unconfined_Users.html#tabl-Security-Enhanced_Linux-Confined_and_Unconfined_Users-SELinux_User_Capabilities|Explication des rôles / utilisateurs selinux]]

Voir : http://selinuxproject.org/page/RefpolicyBasicRoleCreation
==== Réseau ====
Voir : http://selinuxproject.org/page/NetworkStatements

**//semanage port//** controls the port number to port type defitions.
Lister les ports :
<xtermrtf>
$ semanage port -l
</xtermrtf>

Si vous souhaitez par exemple faire tourner apache sur le port 81, il va falloir le rajouter dans la liste des contextes :
<xtermrtf>
$ semanage port -a -t http_port_t -p tcp 81
</xtermrtf>

**//semanage interface//** controls the labels assigned to network interfaces.
Lister les interfaces :
<xtermrtf>
$ semanage interface -l
</xtermrtf>

**//semanage node//** controls the ipaddress to node type definitions.
Lister les nodes :
<xtermrtf>
$ semanage node -l
</xtermrtf>

==== Policy modules ====
Permet de gérer les Policy Modules. Voir aussi [[#semodule]]
  * Lister les policy modules chargés :
<xtermrtf>
$ semanage module -l
</xtermrtf>

  * Lister les modules modifiés :
<xtermrtf>
$ semanage module -lC
</xtermrtf>

==== Permissive mode ====
  * Vous avez également le choix de ne désactiver qu'un domaine si vous le souhaitez. Nous allons prendre par exemple Apache :
<xtermrtf>
$ semanage permissive -a httpd_t
</xtermrtf>

  * Pour le supprimer :
<xtermrtf>
$ semanage permissive -d httpd_t
</xtermrtf>


  * Pour lister les domaine désactivé :
<xtermrtf>
$ semanage permissive -l
</xtermrtf>

<xtermrtf>
seinfo --permissive -x
</xtermrtf>

<xtermrtf>
$ semodule -l | grep permissive
permissive_httpd_t	1.0	
permissivedomains	21	
</xtermrtf>

==== log ====
Si vous ne voyez rien dans les logs et que **//audit2allow//** ne vous aide pas non plus, vous pouvez demander à SELinux de tout logger :
<xtermrtf>
$ semanage dontaudit off
</xtermrtf>

On peut aussi le faire de cette manière :
<xtermrtf>
$ semodule -DB
$ semodule -B
</xtermrtf>

Il ne vous reste plus qu'à regarder dans les logs : ''/var/log/audit/audit.log'' et ''/var/log/messages'' :
<xtermrtf>
$ grep "SELinux is preventing" /var/log/messages
</xtermrtf>

<xtermrtf>
$ grep "denied" /var/log/audit/audit.log
</xtermrtf>

Voir ce qui ne log pas pour apache :
<xtermrtf>
$ sesearch --dontaudit -s httpd_t
</xtermrtf>
==== Context ====
//**semanage**// ne vous permet pas de modifier directement le contexte d'un fichier ou d'un dossier comme le fait [[#chcon]], mais de définir un contexte par défaut qui sera appliqué par [[#restorecon]] ou lors d'un ré-étiquetage du système de fichiers. Cette solution est donc à privilégier lorsque l'on souhaite placer un contexte qui restera (si vous vous bornez à utiliser chcon pour corriger un problème, il y a des chances que dans quelque temps le contexte soit réinitialisé et que vous vous demandiez pourquoi).

<note tip>
Les chemins déclarés via //**semanage**// sont stockés dans le fichier : ''/etc/selinux/targeted/contexts/files/file_contexts.local''.
</note>

  * Exemple :  si je décide de  déplacer mon fichier le fichier ''gigix.html'' dans ''/srv/gigix'' et qu'on applique //**restorecon**// il change de contexte :
<xtermrtf>
$ mkdir /srv/gigix
$ mv gigix.html /srv/gigix/
$ restorecon -R -v /srv/gigix/
restorecon reset /srv/gigix/gigix.html context unconfined_u:object_r:httpd_sys_content_t:s0->unconfined_u:object_r:var_t:s0
</xtermrtf>

  * Pour qu'il garde le contexte voulu :
<xtermrtf>
$ semanage fcontext -a -t httpd_sys_content_t '/srv/gigix(/.*)?'
$ restorecon -R -v /srv/gigix/
restorecon reset /srv/gigix context unconfined_u:object_r:var_t:s0->unconfined_u:object_r:httpd_sys_content_t:s0
restorecon reset /srv/gigix/gigix.html context unconfined_u:object_r:var_t:s0->unconfined_u:object_r:httpd_sys_content_t:s0
</xtermrtf>

<xtermrtf>
$ cat /etc/selinux/targeted/contexts/files/file_contexts.local
# This file is auto-generated by libsemanage
# Do not edit directly.

/srv/gigix(/.*)?    system_u:object_r:httpd_sys_content_t:s0
</xtermrtf>

  * Pour le retirer :
<xtermrtf>
$ semanage fcontext -d -t httpd_sys_content_t '/srv/gigix(/.*)?'
$ restorecon -R -v /srv/gigix/
restorecon reset /srv/gigix context unconfined_u:object_r:httpd_sys_content_t:s0->unconfined_u:object_r:var_t:s0
restorecon reset /srv/gigix/gigix.html context unconfined_u:object_r:httpd_sys_content_t:s0->unconfined_u:object_r:var_t:s0
</xtermrtf>

  * On aurait également pu copier le contexte de cette façon :
<xtermrtf>
$ semanage fcontext -a -e /var/www /srv/www
$ semanage fcontext -m -e /var/www/html /srv/gigix
</xtermrtf>

  * Pour voir l'ensemble des règles :
<xtermrtf>
$ semanage fcontext -l
</xtermrtf>

  * Pour vérifier le contexte:
<xtermrtf>
$ matchpathcon -V /var/www/html/*
/var/www/html/file1 has context unconfined_u:object_r:samba_share_t:s0, should be system_u:object_r:httpd_sys_content_t:s0
/var/www/html/file2 verified.
/var/www/html/file3 verified.
</xtermrtf>

==== Booléen ====
Les booléens permettent de modifier une politique SELinux, sans avoir la moindre connaissance ou compétence sur le sujet de la rédaction de politiques. L'activation ou la désactivation d'un booléen ne requiert pas la compilation ou le rechargement d'un module.

Pour les lister, et obtenir quelques informations sur l'utilité de chacun, utilisez :
<xtermrtf>
$ semanage boolean -l
</xtermrtf>

Pour simplement lister les booléens, sans aucune information complémentaire : [[#getsebool]]

<note tip>
La commande //**semanage**// est bien plus générique que //**getsebool**// et //**setsebool**// ; puisqu'elle permet d'intervenir sur beaucoup d'autres aspects que les booléens, alors que les secondes sont très spécifiques.
De plus, //**semanage boolean**// ne peut-être lancé qu'en tant que root, **//getsebool//** et **//setsebool//** peuvent être lancées en tant qu'utilisateur simple.
</note>

Pour activer un booléen :
<xtermrtf>
$ semanage boolean -m --on httpd_can_sendmail
</xtermrtf>

Voir les booléens modifiés :
<xtermrtf>
$ semanage boolean -l -C
</xtermrtf>

===== getsebool =====
Pour simplement lister les booléens, sans aucune information complémentaire :
<xtermrtf>
$ getsebool -a
</xtermrtf>

Pour plus d'informations :
<xtermrtf>
$ semanage boolean -l
</xtermrtf>

===== setsebool =====
Permet d'activer un booléen :
<xtermrtf>
$ setsebool -P httpd_can_sendmail on
</xtermrtf>

L'option **-P** permet de rendre la directive permanente, et donc de la conserver en cas de ré-amorçage du système.

===== semodule =====
Permet de gérer les module SELinux.

Lister les modules :
<xtermrtf>
$ semodule -l
</xtermrtf>

===== seinfo =====
Permet de voir un certain nombre de choses sur SELinux.
<xtermrtf>
$ seinfo 

Statistics for policy file: /sys/fs/selinux/policy
Policy Version & Type: v.29 (binary, mls)

   Classes:            83    Permissions:       254
   Sensitivities:       1    Categories:       1024
   Types:            4617    Attributes:        356
   Users:               8    Roles:              14
   Booleans:          302    Cond. Expr.:       353
   Allow:           95893    Neverallow:          0
   Auditallow:        154    Dontaudit:        8395
   Type_trans:      17478    Type_change:        74
   Type_member:        35    Role allow:         30
   Role_trans:        414    Range_trans:      5667
   Constraints:       103    Validatetrans:       0
   Initial SIDs:       27    Fs_use:             28
   Genfscon:          101    Portcon:           579
   Netifcon:            0    Nodecon:             0
   Permissives:        14    Polcap:              2
</xtermrtf>

  * Lister tous les utilisateurs et leurs rôles:
<xtermrtf>
$ seinfo -u -x

Users: 8
   user guest_u roles guest_r level s0 range s0;
   user root roles { staff_r system_r sysadm_r unconfined_r } level s0 range s0 - s0:c0.c1023;
   user staff_u roles { staff_r system_r sysadm_r unconfined_r } level s0 range s0 - s0:c0.c1023;
   user sysadm_u roles sysadm_r level s0 range s0 - s0:c0.c1023;
   user system_u roles { system_r unconfined_r } level s0 range s0 - s0:c0.c1023;
   user unconfined_u roles { system_r unconfined_r } level s0 range s0 - s0:c0.c1023;
   user user_u roles user_r level s0 range s0;
   user xguest_u roles xguest_r level s0 range s0;
</xtermrtf>

  * Lister tous les types des rômes:
<xtermrtf>
$ seinfo -r -x
</xtermrtf>

  * Lister tous les types d'un attribut :
<xtermrtf>
$ seinfo -auserdomain -x
   userdomain
      logadm_t
      secadm_t
      sysadm_t
      webadm_t
      dbadm_t
      user_wine_t
      auditadm_t
      staff_wine_t
      xguest_t
      guest_t
      staff_t
      user_t
      unconfined_t
</xtermrtf>

  * Lister les rôles d'un utilisateur précis :
<xtermrtf>
$ seinfo -usystem_u -x
   system_u
      default level: s0
      range: s0 - s0:c0.c1023
      roles:
         object_r
         system_r
         unconfined_r
</xtermrtf>

  * Lister quel sont les domaines d'un rôle :
<xtermrtf>
$ seinfo -ruser_r -x
</xtermrtf>

  * Afficher les types d'un attribut :
<xtermrtf>
$ seinfo -avirt_domain -x

Type Attributes: 1
   attribute virt_domain;
	svirt_t
	svirt_tcg_t

</xtermrtf>

  * Afficher les info sur le type **//httpd_sys_content_t//** :
<xtermrtf>
$ seinfo -thttpd_sys_content_t -x
   httpd_sys_content_t
      file_type
      exec_type
      entry_type
      httpdcontent
      non_security_file_type
      httpd_content_type
      non_auth_file_type
   Aliases
      httpd_fastcgi_content_t
      httpd_httpd_sys_script_ro_t
      httpd_fastcgi_script_ro_t
</xtermrtf>

  * Tout afficher :      
<xtermrtf>
$ seinfo --all -x | less
</xtermrtf>
===== runcon =====
Lancer un programme dans un contexte donnée :
<xtermrtf>
$ runcon system_u:system_r:crond_t:s0:c0.c255 /bin/bash
</xtermrtf>

===== sepolicy =====
==== sepolicy generate ====
Générer une policy pour un service:
<xtermrtf>
$ sepolicy generate --init -n myprogram /usr/bin/myprogram
</xtermrtf>

Voir https://www.youtube.com/watch?v=2i1jFRHE7Wg&t=5660

==== sepolicy transition ====
Interroger la stratégie SELinux pour voir si un domaine de traitement source peut transitionner vers un domaine de traitement cible:
<xtermrtf>
$ sepolicy transition -s httpd_t
</xtermrtf>

==== sepolicy network ====
Interroger les stratégies SELinux relatives aux information réseau:
<xtermrtf>
$ sepolicy network -p 22
22: tcp ssh_port_t 22
22: udp reserved_port_t 1-511
22: tcp reserved_port_t 1-511
22: sctp reserved_port_t 1-511
</xtermrtf>

==== sepolicy booleans ====
Interroger la stratégie SELinux pour voir les descriptions des booléens:
<xtermrtf>
$ sepolicy booleans -a
$ sepolicy booleans -b user_ping
</xtermrtf>

==== sepolicy communicate ====
Interroger la stratégie SELinux pour voir si les domaines peuvent communiquer ensemble:
<xtermrtf>
$ sepolicy communicate -s syslogd_t -t httpd_t -c file
</xtermrtf>

====== auditd ======
===== status =====
Voir le status d'auditd :
<xtermrtf>
$ auditctl -s
</xtermrtf>

===== Lister les régles =====
<xtermrtf>
$ auditctl -l
</xtermrtf>


====== Scripts ======
Download and extract and set the variable **POLICY_LOCATION**.

Add to your ''~/.bashrc'':
<code bash>
POLICY_LOCATION="~/refpolicy/";

# sefindif - Find interface definitions that have a string that matches the
# given regular expression
sefindif() {
  REGEXP="$1";
  pushd ${POLICY_LOCATION}/policy/modules > /dev/null 2>&1;
  for FILE in */*.if;
  do
    awk "/(interface\(|template\()/ { NAME=\$NF; P=0 }; /${REGEXP}/ { if (P==0) {P=1; print NAME}; print };" ${FILE} | sed -e "s:^:${FILE}\: :g";
  done
  popd > /dev/null 2>&1;
}

# seshowif - Show the interface definition
seshowif() {
  INTERFACE="$1";
  pushd ${POLICY_LOCATION}/policy/modules > /dev/null 2>&1;
  for FILE in */*.if;
  do
    grep -A 9999 "\(interface(\`${INTERFACE}'\|template(\`${INTERFACE}'\)" ${FILE} | grep -B 9999 -m 1 "^')";
  done
  popd > /dev/null 2>&1;
}

# sefinddef - Find macro definitions that have a string that matches the given
# regular expression
sefinddef() {
  REGEXP="$1";
  grep -H "define(\`.*${REGEXP}.*" ${POLICY_LOCATION}/policy/support/* | sed -e 's:.*\/\([^(]*\):\1:g'
}

# seshowdef - Show the macro definition
seshowdef() {
  MACRONAME="$1";
  pushd ${POLICY_LOCATION}/policy/support > /dev/null 2>&1;
  for FILE in *.spt;
  do
    grep -A 9999 "define(\`${MACRONAME}'" ${FILE} | grep -B 999 -m 1 "')";
  done
  popd > /dev/null 2>&1;
}

# sefindcon - Find macro definitions for constrains
sefindcon() {
  awk "/(interface\(|template\()/ { NAME=\$NF; P=0 }; /${REGEXP}/ { if (P==0) {P=1; print NAME}; print };" ${POLICY_LOCATION}/policy/constraints | sed -e "s:^:${FILE}\: :g";
}

# selist - List all templates/interfaces in the order allowed by refpolicy
selist() {
  pushd ${POLICY_LOCATION}/policy/modules > /dev/null 2>&1;
  (
  egrep '^(interface|template)' kernel/kernel.if | awk -F'`' '{print $2}' | sed -e "s:',::g" | sed -e "s:$: (kernel, kernel):g" | sort;
  egrep '^(interface|template)' kernel/*.if | grep -v 'kernel/kernel.if' | awk -F'`' '{print $2}' | sed -e "s:',::g" | sed -e "s:$: (kernel, other):g" | sort;
  egrep '^(interface|template)' system/*.if | awk -F'`' '{print $2}' | sed -e "s:',::g" | sed -e "s:$: (system):g" | sort;
  egrep '^(interface|template)' admin/*.if apps/*.if roles/*.if services/*.if contrib/*.if | awk -F'`' '{print $2}' | sed -e "s:',::g" | sort;
  ) | nl | sed -e "s:$: :g";
  popd > /dev/null 2>&1;
}
</code>

<xtermrtf>
$ sefindif 'filetrans.*postfix_etc'
services/postfix.if: interface(`postfix_config_filetrans',`
services/postfix.if: 	filetrans_pattern($1, postfix_etc_t, $2, $3, $4)
</xtermrtf>

<xtermrtf>
$ seshowif systemd_tmpfilesd_managed   
interface(`systemd_tmpfilesd_managed',`
	gen_require(`
		type systemd_tmpfiles_t;
	')

	allow systemd_tmpfiles_t $1:$2 { setattr relabelfrom relabelto create };
')
</xtermrtf>

<xtermrtf>
$ sefinddef 'socket.*create'
obj_perm_sets.spt:define(`create_socket_perms', `{ create rw_socket_perms }')
obj_perm_sets.spt:define(`create_stream_socket_perms', `{ create_socket_perms listen accept }')
obj_perm_sets.spt:define(`connected_socket_perms', `{ create ioctl read getattr write setattr append bind getopt setopt shutdown }')
obj_perm_sets.spt:define(`create_netlink_socket_perms', `{ create_socket_perms nlmsg_read nlmsg_write }')
obj_perm_sets.spt:define(`rw_netlink_socket_perms', `{ create_socket_perms nlmsg_read nlmsg_write }')
obj_perm_sets.spt:define(`r_netlink_socket_perms', `{ create_socket_perms nlmsg_read }')
obj_perm_sets.spt:define(`client_stream_socket_perms', `{ create ioctl read getattr write setattr append bind getopt setopt shutdown }')
</xtermrtf>

<xtermrtf>
$ seshowdef manage_files_pattern
define(`manage_files_pattern',`
        allow $1 $2:dir rw_dir_perms;
        allow $1 $3:file manage_file_perms;
')
</xtermrtf>