流程

1. 在您选择的文本编辑器中打开 /etc/selinux/config 文件，例如：

   # vi /etc/selinux/config

2. 配置 SELINUX=permissive 选项：

   # 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 two values:
   #       targeted - Targeted processes are protected,
   #       mls - Multi Level Security protection.
   SELINUXTYPE=targeted

3. 重启系统：

   # reboot

验证

1. 系统重启后，确认 getenforce 命令返回 许可 ：

   $ getenforce
   Permissive

流程

1. 在您选择的文本编辑器中打开 /etc/selinux/config 文件，例如：

   # vi /etc/selinux/config

2. 配置 SELINUX=enforcing 选项：

   # 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 two values:
   #       targeted - Targeted processes are protected,
   #       mls - Multi Level Security protection.
   SELINUXTYPE=targeted

3. 保存更改，重启系统：

   # reboot

   在下一次引导中，SELinux 会重新标记系统中的所有文件和目录，并为禁用 SELinux 时创建的文件和目录添加 SELinux 上下文。

验证

1. 系统重启后，确认 getenforce 命令返回 Enforcing:

   $ getenforce
   Enforcing

流程

1. 以 permissive 模式启用 SELinux。如需更多信息，请参阅切换到 permissive 模式。

2. 重启您的系统：

   # reboot

3. 检查 SELinux 拒绝信息。如需更多信息，请参阅 识别 SELinux 拒绝操作信息。

4. 确保在下次重启时重新标记文件：

   # fixfiles -F onboot

   这会创建包含 -F 选项的 /.autorelabel 文件。

   警告

   进入 fixfiles -F onboot 命令前，始终切换到 permissive 模式。这可防止系统在系统包含未标记的文件时无法引导。如需更多信息，请参阅 RHBZ#2021835。

5. 如果没有拒绝的操作，切换到 enforcing 模式。如需更多信息，请参阅在引导时进入 SELinux 模式。

验证

1. 系统重启后，确认 getenforce 命令返回 Enforcing:

   $ getenforce
   Enforcing

流程

1. 在您选择的文本编辑器中打开 /etc/selinux/config 文件，例如：

   # vi /etc/selinux/config

2. 配置 SELINUX=disabled 选项：

   # 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=disabled
   # SELINUXTYPE= can take one of these two values:
   #       targeted - Targeted processes are protected,
   #       mls - Multi Level Security protection.
   SELINUXTYPE=targeted

3. 保存更改并重启您的系统：

   # reboot

验证

1. 重启后，确认 getenforce 命令返回 Disabled:

   $ getenforce
   Disabled

流程

1. 输入以下命令创建一个名为 example.user 的新的 Linux 用户：

   # useradd example.user

2. 要为 Linux example.user 用户分配密码：

   # passwd example.user
   Changing password for user example.user.
   New password:
   Retype new password:
   passwd: all authentication tokens updated successfully.

3. 退出当前会话。
4. 以 Linux example.user 用户身份登录。登录时，pam_selinux PAM 模块会自动将 Linux 用户映射到 SELinux 用户（本例中为 unconfined_u），并设置生成的 SELinux 上下文。然后会使用这个上下文启动 Linux 用户的 shell。

验证

1. 当以 example.user 用户身份登录时，检查 Linux 用户的上下文：

   $ id -Z
   unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023

流程

1. 输入以下命令创建一个名为 example.user 的新 Linux 用户，并将其映射到 SELinux staff_u 用户：

   # useradd -Z staff_u example.user

2. 要为 Linux example.user 用户分配密码：

   # passwd example.user
   Changing password for user example.user.
   New password:
   Retype new password:
   passwd: all authentication tokens updated successfully.

3. 退出当前会话。
4. 以 Linux example.user 用户身份登录。用户的 shell 使用 staff_u 上下文启动。

验证

1. 当以 example.user 用户身份登录时，检查 Linux 用户的上下文：

   $ id -Z
   uid=1000(example.user) gid=1000(example.user) groups=1000(example.user) context=staff_u:staff_r:staff_t:s0-s0:c0.c1023

流程

1. 显示 SELinux 登录记录列表。这个列表显示了 Linux 用户与 SELinux 用户的映射：

   # semanage login -l
   
   Login Name    SELinux User  MLS/MCS Range   Service
   
   __default__   unconfined_u  s0-s0:c0.c1023       *
   root          unconfined_u  s0-s0:c0.c1023       *

2. 将 __default__ 用户（代表所有没有显式映射的用户）映射到 user_u SELinux 用户：

   # semanage login -m -s user_u -r s0 __default__

验证

1. 检查 __default__ 用户是否已映射到 user_u SELinux 用户：

   # semanage login -l
   
   Login Name    SELinux User   MLS/MCS Range    Service
   
   __default__   user_u         s0               *
   root          unconfined_u   s0-s0:c0.c1023   *

2. 验证新用户的进程是否在 user_u:user_r:user_t:s0 SELinux 上下文中运行。

   1. 创建一个新用户：

      # adduser example.user

   2. 定义 example.user 的密码：

      # passwd example.user

   3. 以 root 身份注销，然后以新用户身份登录。

   4. 显示用户 ID 的安全上下文：

      [example.user@localhost ~]$ id -Z
      user_u:user_r:user_t:s0

   5. 显示用户当前进程的安全上下文：

      [example.user@localhost ~]$ ps axZ
      LABEL                           PID TTY      STAT   TIME COMMAND
      -                                 1 ?        Ss     0:05 /usr/lib/systemd/systemd --switched-root --system --deserialize 18
      -                              3729 ?        S      0:00 (sd-pam)
      user_u:user_r:user_t:s0        3907 ?        Ss     0:00 /usr/lib/systemd/systemd --user
      -                              3911 ?        S      0:00 (sd-pam)
      user_u:user_r:user_t:s0        3918 ?        S      0:00 sshd: example.user@pts/0
      user_u:user_r:user_t:s0        3922 pts/0    Ss     0:00 -bash
      user_u:user_r:user_dbusd_t:s0  3969 ?        Ssl    0:00 /usr/bin/dbus-daemon --session --address=systemd: --nofork --nopidfile --systemd-activation --syslog-only
      user_u:user_r:user_t:s0        3971 pts/0    R+     0:00 ps axZ

流程

1. 可选：允许 sysadm_u 用户使用 SSH 连接到系统：

   # setsebool -P ssh_sysadm_login on

2. 创建新用户，将用户添加到 wheel 用户组中，并将该用户 映射到 sysadm_u SELinux 用户：

   # adduser -G wheel -Z sysadm_u example.user

3. 可选：将现有用户 映射到 sysadm_u SELinux 用户，并将该用户添加到 wheel 用户组中：

   # usermod -G wheel -Z sysadm_u example.user

验证

1. 检查 example.user 是否已映射到 sysadm_u SELinux 用户：

   # semanage login -l | grep example.user
   example.user     sysadm_u    s0-s0:c0.c1023   *

2. 以 example.user 身份登录，例如使用 SSH，并显示用户的安全上下文：

   [example.user@localhost ~]$ id -Z
   sysadm_u:sysadm_r:sysadm_t:s0-s0:c0.c1023

3. 切换到 root 用户：

   $ sudo -i
   [sudo] password for example.user:

4. 验证安全性上下文是否保持不变：

   # id -Z
   sysadm_u:sysadm_r:sysadm_t:s0-s0:c0.c1023

5. 尝试管理任务，例如重启 sshd 服务：

   # systemctl restart sshd

   如果没有输出结果，则代表命令可以成功完成。

   如果该命令没有成功完成，它会输出以下信息：

   Failed to restart sshd.service: Access denied
   See system logs and 'systemctl status sshd.service' for details.

流程

1. 创建新用户，将用户添加到 wheel 用户组中，并将该用户映射到 staff_u SELinux 用户：

   # adduser -G wheel -Z staff_u example.user

2. 可选：将现有用户映射到 staff_u SELinux 用户，并将该用户添加到 wheel 用户组中：

   # usermod -G wheel -Z staff_u example.user

3. 要允许 example.user 获取 SELinux 管理员角色，请在 /etc/sudoers.d/ 目录中创建一个新文件，例如：

   # visudo -f /etc/sudoers.d/example.user

4. 在新文件中添加以下行：

   example.user ALL=(ALL) TYPE=sysadm_t ROLE=sysadm_r ALL

验证

1. 检查 example.user 是否已映射到 staff_u SELinux 用户：

   # semanage login -l | grep example.user
   example.user     staff_u    s0-s0:c0.c1023   *

2. 以 example.user 身份登录，例如使用 SSH，并切换到 root 用户：

   [example.user@localhost ~]$ sudo -i
   [sudo] password for example.user:

3. 显示 根 安全上下文：

   # id -Z
   staff_u:sysadm_r:sysadm_t:s0-s0:c0.c1023

4. 尝试管理任务，例如重启 sshd 服务：

   # systemctl restart sshd

   如果没有输出结果，则代表命令可以成功完成。

   如果该命令没有成功完成，它会输出以下信息：

   Failed to restart sshd.service: Access denied
   See system logs and 'systemctl status sshd.service' for details.

流程

1. 启动 httpd 服务并检查状态：

   # systemctl start httpd
   # systemctl status httpd
   ...
   httpd[14523]: (13)Permission denied: AH00072: make_sock: could not bind to address [::]:3131
   ...
   systemd[1]: Failed to start The Apache HTTP Server.
   ...

2. SELinux 策略假设 httpd 在端口 80 上运行：

   # semanage port -l | grep http
   http_cache_port_t              tcp      8080, 8118, 8123, 10001-10010
   http_cache_port_t              udp      3130
   http_port_t                    tcp      80, 81, 443, 488, 8008, 8009, 8443, 9000
   pegasus_http_port_t            tcp      5988
   pegasus_https_port_t           tcp      5989

3. 更改 SELinux 类型端口 3131 使其与端口 80 匹配：

   # semanage port -a -t http_port_t -p tcp 3131

4. 再次启动 httpd:

   # systemctl start httpd

5. 但是，内容仍无法访问：

   # wget localhost:3131/index.html
   ...
   HTTP request sent, awaiting response... 403 Forbidden
   ...

   使用 sealert 工具查找原因：

   # sealert -l "*"
   ...
   SELinux is preventing httpd from getattr access on the file /var/test_www/html/index.html.
   ...

6. 使用 matchpathcon 工具比较标准 SELinux 类型和新路径：

   # matchpathcon /var/www/html /var/test_www/html
   /var/www/html       system_u:object_r:httpd_sys_content_t:s0
   /var/test_www/html  system_u:object_r:var_t:s0

7. 将新 /var/test_www/html/ 内容目录的 SELinux 类型改为默认 /var/www/html 目录的类型：

   # semanage fcontext -a -e /var/www /var/test_www

8. 递归重新标记 /var 目录：

   # restorecon -Rv /var/
   ...
   Relabeled /var/test_www/html from unconfined_u:object_r:var_t:s0 to unconfined_u:object_r:httpd_sys_content_t:s0
   Relabeled /var/test_www/html/index.html from unconfined_u:object_r:var_t:s0 to unconfined_u:object_r:httpd_sys_content_t:s0

验证

1. 检查 httpd 服务是否正在运行：

   # systemctl status httpd
   ...
   Active: active (running)
   ...
   systemd[1]: Started The Apache HTTP Server.
   httpd[14888]: Server configured, listening on: port 3131
   ...

2. 验证 Apache HTTP 服务器提供的内容是否可以访问：

   # wget localhost:3131/index.html
   ...
   HTTP request sent, awaiting response... 200 OK
   Length: 0 [text/html]
   Saving to: ‘index.html’
   ...

流程

1. 识别与 NFS、CIFS 和 Apache 相关的 SELinux 布尔值：

   # semanage boolean -l | grep 'nfs\|cifs' | grep httpd
   httpd_use_cifs                 (off  ,  off)  Allow httpd to access cifs file systems
   httpd_use_nfs                  (off  ,  off)  Allow httpd to access nfs file systems

2. 列出布尔值的当前状态：

   $ getsebool -a | grep 'nfs\|cifs' | grep httpd
   httpd_use_cifs --> off
   httpd_use_nfs --> off

3. 启用指定的布尔值：

   # setsebool httpd_use_nfs on
   # setsebool httpd_use_cifs on

   注意

   将 setsebool 与 -P 选项配合使用，以在重启后保留更改。setsebool -P 命令需要重新构建整个策略，并且可能需要一些时间，具体取决于您的配置。

验证

1. 检查布尔值 是否位于 ：

   $ getsebool -a | grep 'nfs\|cifs' | grep httpd
   httpd_use_cifs --> on
   httpd_use_nfs --> on

流程

1. 当您的场景被 SELinux 阻止时，/var/log/audit/audit.log 文件是第一个检查拒绝的更多信息。要查询 Audit 日志，请使用 ausearch 工具。因为 SELinux 决策（如允许或禁止访问）已被缓存，且此缓存被称为 Access Vector Cache(AVC)，所以在消息类型参数中使用 AVC 和 USER_AVC 值，例如：

   # ausearch -m AVC,USER_AVC,SELINUX_ERR,USER_SELINUX_ERR -ts recent

   如果没有匹配项，请检查 audit 守护进程是否正在运行。如果没有，在您启动 auditd 后重复拒绝的场景，然后再次检查审计日志。

2. 如果 auditd 正在运行，但 ausearch 输出中没有匹配项，请检查 systemd Journal 提供的信息：

   # journalctl -t setroubleshoot

3. 如果 SELinux 活跃且 Audit 守护进程没有在您的系统中运行，则在 dmesg 命令输出中搜索某些 SELinux 信息：

   # dmesg | grep -i -e type=1300 -e type=1400

4. 即使进行了前面的三个检查后，您仍可能找不到任何结果。在这种情况下，因为 dontaudit 规则，AVC 拒绝可以被静默。

   临时禁用 dontaudit 规则，允许记录所有拒绝信息：

   # semodule -DB

   在重新运行拒绝的场景并使用前面的步骤查找拒绝信息后，以下命令会在策略中再次启用 dontaudit 规则 ：

   # semodule -B

5. 如果您应用了前面所有四个步骤，这个问题仍然无法识别，请考虑 SELinux 是否真正阻止了您的场景：

   • 切换到 permissive 模式：

     # setenforce 0
     $ getenforce
     Permissive

   • 重复您的场景。

   如果问题仍然存在，则代表 SELinux 以外的系统阻断了您的场景。

流程

1. 使用 sealert 命令列出有关日志拒绝的详情，例如：

   $ sealert -l "*"
   SELinux is preventing /usr/bin/passwd from write access on the file
   /root/test.
   
   *****  Plugin leaks (86.2 confidence) suggests *****************************
   
   If you want to ignore passwd trying to write access the test file,
   because you believe it should not need this access.
   Then you should report this as a bug.
   You can generate a local policy module to dontaudit this access.
   Do
   # ausearch -x /usr/bin/passwd --raw | audit2allow -D -M my-passwd
   # semodule -X 300 -i my-passwd.pp
   
   *****  Plugin catchall (14.7 confidence) suggests **************************
   
   ...
   
   Raw Audit Messages
   type=AVC msg=audit(1553609555.619:127): avc:  denied  { write } for
   pid=4097 comm="passwd" path="/root/test" dev="dm-0" ino=17142697
   scontext=unconfined_u:unconfined_r:passwd_t:s0-s0:c0.c1023
   tcontext=unconfined_u:object_r:admin_home_t:s0 tclass=file permissive=0
   
   ...
   
   Hash: passwd,passwd_t,admin_home_t,file,write

2. 如果上一步中的输出没有包含清晰的建议：

   • 启用全路径审核查看访问对象的完整路径，并让其他 Linux Audit 事件字段可见：

     # auditctl -w /etc/shadow -p w -k shadow-write

   • 清除 setroubleshoot 缓存：

     # rm -f /var/lib/setroubleshoot/setroubleshoot.xml

   • 重现问题。

   • 重复步骤 1。

     完成这个过程后，禁用全路径审核：

     # auditctl -W /etc/shadow -p w -k shadow-write

3. 如果 sealert 仅返回 概括 性建议或建议使用 audit2allow 工具添加新规则，请将您的问题与 审计日志中 SELinux 拒绝中列出的 示例匹配。

流程

1. 安装 selinux-policy-mls 软件包：

   # yum install selinux-policy-mls

2. 在您选择的文本编辑器中打开 /etc/selinux/config 文件，例如：

   # vi /etc/selinux/config

3. 将 SELinux 模式从 enforcing 改为 permissive，并从 targeted 策略切换到 MLS：

   SELINUX=permissive
   SELINUXTYPE=mls

   保存更改，退出编辑器。

4. 在启用 MLS 策略前，您必须使用 MLS 标签重新标记文件系统中的每个文件：

   # fixfiles -F onboot
   System will relabel on next boot

5. 重启系统：

   # reboot

6. 检查 SELinux 拒绝信息：

   # ausearch -m AVC,USER_AVC,SELINUX_ERR,USER_SELINUX_ERR -ts recent -i

   因为前面的命令没有涵盖所有情况，请参阅 SELinux 故障排除中有关识别、分析以及修复 SELinux 拒绝的指导。

7. 确保系统中没有与 SELinux 相关的问题后，通过更改 /etc/selinux/config 中的对应选项将 SELinux 切回到 enforcing 模式：

   SELINUX=enforcing

8. 重启系统：

   # reboot

验证

1. 验证 SELinux 是否在 enforcing 模式下运行：

   # getenforce
   Enforcing

2. 检查 SELinux 的状态是否返回 mls 值：

   # sestatus | grep mls
   Loaded policy name:             mls

流程

1. 可选：要防止在 SELinux 策略中添加错误，切换到 permissive SELinux 模式，这有助于进行故障排除：

   # setenforce 0

   重要

   在 permissive 模式中，SELinux 不会强制执行活跃策略，而仅记录 Access Vector Cache(AVC)消息，这些信息随后可用于故障排除和调试。

2. 为 staff_u SELinux 用户定义一个许可范围。例如，这个命令设置从 s1 到 s 15 范围，并将 s1 设置为默认许可级别：

   # semanage user -m -L s1 -r s1-s15 _staff_u

3. 为用户主目录生成 SELinux 文件上下文配置条目：

   # genhomedircon

4. 默认恢复文件安全上下文：

   # restorecon -R -F -v /home/
   Relabeled /home/staff from staff_u:object_r:user_home_dir_t:s0 to staff_u:object_r:user_home_dir_t:s1
   Relabeled /home/staff/.bash_logout from staff_u:object_r:user_home_t:s0 to staff_u:object_r:user_home_t:s1
   Relabeled /home/staff/.bash_profile from staff_u:object_r:user_home_t:s0 to staff_u:object_r:user_home_t:s1
   Relabeled /home/staff/.bashrc from staff_u:object_r:user_home_t:s0 to staff_u:object_r:user_home_t:s1

5. 为用户分配授权级别：

   # semanage login -m -r s1 example_user

   其中 s1 是分配给用户的许可级别。

6. 将用户的主目录重新标记到用户的授权级别：

   # chcon -R -l s1 /home/example_user

7. 可选：如果您之前切换到 permissive SELinux 模式，在验证一切正常后，请切换回 enforcing SELinux 模式：

   # setenforce 1

验证步骤

1. 验证用户是否已映射到正确的 SELinux 用户，并分配了正确的授权级别：

   # semanage login -l
   Login Name      SELinux User         MLS/MCS Range        Service
   __default__     user_u               s0-s0                *
   example_user    user_u               s1                   *
   ...

2. 在 MLS 中以 用户身份登录。

3. 验证用户的安全级别是否正常工作：

   重要

   您用于验证的文件不应包含任何敏感信息，如果配置不正确，用户实际上无需授权即可访问这些文件。

   1. 验证用户无法读取具有更高级别敏感度的文件。
   2. 验证用户可以写入具有相同敏感性的文件。
   3. 验证用户是否可以读取具有较低级别敏感度的文件。

流程

1. 以 用户身份登录安全终端。

   注意

   安全终端在 /etc/selinux/mls/contexts/securetty_types 文件中定义。默认情况下，控制台是一个安全终端，但 SSH 不是。

2. 检查当前用户的安全上下文：

   $ id -Z
   user_u:user_r:user_t:s0-s2

   在本例中，该用户被分配给 user_u SELinux 用户、user_r 角色、user_t 类型，以及 MLS 安全范围 s0-s2。

3. 检查当前用户的安全上下文：

   $ id -Z
   user_u:user_r:user_t:s1-s2

4. 切换到用户清晰范围内的不同安全清晰范围：

   $ newrole -l s1

   您可以切换到其最大值较低或等于您的分配范围的任何范围。输入单个级别范围会更改所分配范围的较低限制。例如，输入 newrole -l s1 作为具有 s0-s2 范围的用户，相当于输入 newrole -l s1-s2。

验证

1. 显示当前用户的安全上下文：

   $ id -Z
   user_u:user_r:user_t:s1-s2

2. 通过终止当前 shell，返回到之前带有原始范围的 shell：

   $ exit

流程

1. 可选：显示当前用户的安全上下文：

   $ id -Z
   user_u:user_r:user_t:s0-s2

2. 将用户的 MLS clearance 范围的较低级别改为您要分配给该文件的级别：

   $ newrole -l s1-s2

3. 可选：显示当前用户的安全上下文：

   $ id -Z
   user_u:user_r:user_t:s1-s2

4. 可选：显示文件的安全上下文：

   $ ls -Z /path/to/file
   user_u:object_r:user_home_t:s0 /path/to/file

5. 通过修改该文件，将文件的敏感度级别改为用户清晰的较低级别：

   $ touch /path/to/file

   重要

   如果系统上使用了 restorecon 命令，则分类级别恢复为默认值。

6. 可选：退出 shell 以返回到用户的前一个安全范围：

   $ exit

流程

1. 检查文件的分类级别：

   # ls -lZ /path/to/file
   -rw-r-----. 1 User1 User1 user_u:object_r:user_home_t:s1 0 12. Feb 10:43 /path/to/file

2. 更改文件的默认分类级别：

   # semanage fcontext -a -r s2 /path/to/file

3. 强制重新标记文件的 SELinux 上下文：

   # restorecon -F -v /path/to/file
   Relabeled /path/to/file from user_u:object_r:user_home_t:s1 to user_u:object_r:user_home_t:s2

验证

1. 检查文件的分类级别：

   # ls -lZ /path/to/file
   -rw-r-----. 1 User1 User1 user_u:object_r:user_home_t:s2 0 12. Feb 10:53 /path/to/file

2. 可选：验证 lower-clearance 用户无法读取该文件：

   $ cat /path/to/file
   cat: file: Permission denied

流程

1. 在 /etc/ sudoers.d 目录中为用户创建新的 sudoers 文件：

   # visudo -f /etc/sudoers.d/<sec_adm_user>

   为保持 sudoers 文件组织，请将 & lt;sec_adm_user > 替换为将分配给 secadm 角色的 Linux 用户。

2. 在 /etc/sudoers.d/ <sec_adm_user> 文件中添加以下内容：

   <sec_adm_user> ALL=(ALL) TYPE=secadm_t ROLE=secadm_r ALL

   此行授权所有主机上执行 所有命令的 <secadmuser >，并将用户默认映射到 secadm SELinux 类型和角色。

3. 以 < sec_adm_user> 用户身份登录：

   注意

   为确保 SELinux 上下文（由 SELinux 用户、角色和类型组成），使用 ssh 登录、控制台或 xdm。su 和 sudo 等其他方法无法更改整个 SELinux 上下文。

4. 验证用户的安全上下文：

   $ id
   uid=1000(<sec_adm_user>) gid=1000(<sec_adm_user>) groups=1000(<sec_adm_user>) context=staff_u:staff_r:staff_t:s0-s15:c0.c1023

5. 为 root 用户运行交互式 shell：

   $ sudo -i
   [sudo] password for <sec_adm_user>:

6. 验证当前用户的安全上下文：

   # id
   uid=0(root) gid=0(root) groups=0(root) context=staff_u:secadm_r:secadm_t:s0-s15:c0.c1023

7. 从策略中禁用 sysadm_secadm 模块：

   # semodule -d sysadm_secadm

   重要

   使用 semodule -d 命令而不是删除系统策略模块，而不是使用 semodule -r 命令。semodule -r 命令从您的系统存储中删除模块，这意味着无法重新安装 selinux-policy-mls 软件包。

验证

1. 作为分配给 secadm 角色的用户，并在 root 用户的交互式 shell 中验证您可以访问安全策略数据：

   # seinfo -xt secadm_t
   
   Types: 1
      type secadm_t, can_relabelto_shadow_passwords, (...) userdomain;

2. 从 root shell 注销：

   # logout

3. 从 < sec_adm_user> 用户注销：

   $ logout
   Connection to localhost closed.

4. 显示当前安全上下文：

   # id
   uid=0(root) gid=0(root) groups=0(root) context=root:sysadm_r:sysadm_t:s0-s15:c0.c1023

5. 尝试启用 sysadm_secadm 模块。该命令应该失败：

   # semodule -e sysadm_secadm
   SELinux:  Could not load policy file /etc/selinux/mls/policy/policy.31:  Permission denied
   /sbin/load_policy:  Can't load policy:  Permission denied
   libsemanage.semanage_reload_policy: load_policy returned error code 2. (No such file or directory).
   SELinux:  Could not load policy file /etc/selinux/mls/policy/policy.31:  Permission denied
   /sbin/load_policy:  Can't load policy:  Permission denied
   libsemanage.semanage_reload_policy: load_policy returned error code 2. (No such file or directory).
   semodule:  Failed!

6. 尝试显示有关 sysadm_t SELinux 类型的详情。该命令应该失败：

   # seinfo -xt sysadm_t
   [Errno 13] Permission denied: '/sys/fs/selinux/policy'

流程

1. 确定当前的终端类型：

   # ls -Z `tty`
   root:object_r:user_devpts_t:s0 /dev/pts/0

   在本例中，user_devpts_t 是当前的终端类型。

2. 在 /etc/selinux/mls/contexts/securetty_types 文件中的新行中添加相关的 SELinux 类型。

3. 可选：将 SELinux 切换到 enforcing 模式：

   # setenforce 1

流程

1. 可选：切换到 permissive 模式以方便故障排除。

   # setenforce 0

2. 使用文本编辑器打开新的 .cil 文件，如 ~/local_mlsfilewrite.cil，并插入以下自定义规则：

   (typeattributeset mlsfilewrite (_staff_t_))

   您可以将 staff_t 替换为不同的 SELinux 类型。通过在此处指定 SELinux 类型，您可以控制哪些 SELinux 角色可以编辑低级别文件。

   要让您的本地模块更好地组织，请在本地 SELinux 策略模块的名称中使用 local_ 前缀。

3. 安装策略模块：

   # semodule -i ~/local_mlsfilewrite.cil

   注意

   要删除本地策略模块，请使用 semodule -r ~/local_mlsfilewrite。请注意，您必须引用不带 .cil 后缀的模块名称。

4. 可选：如果您之前切换到 permissive 模式，返回 enforcing 模式：

   # setenforce 1

验证

1. 在安装的 SELinux 模块列表中找到本地模块：

   # semodule -lfull | grep "local_mls"
   400 local_mlsfilewrite  cil

   由于本地模块具有优先级 400，所以您也可以使用 semodule -lfull | grep -v ^100 命令列出它们。

2. 以分配给自定义规则中定义的类型的用户身份登录，例如 staff_t。

3. 尝试写入到具有较低敏感度级别的文件。这会增加文件的分类级别到用户的清晰度级别。

   重要

   您用于验证的文件不应包含任何敏感信息，如果配置不正确，用户实际上无需授权即可访问这些文件。

流程

1. 创建一个名为 的新文件，如 local_mcs_user.cil ：

   # vim local_mcs_user.cil

2. 插入以下规则：

   (typeattributeset mcs_constrained_type (user_t))

3. 安装策略模块：

   # semodule -i local_mcs_user.cil

流程

1. 通过在文本编辑器中编辑 /etc/selinux/<selinuxpolicy>/setrans.conf 文件修改现有类别或创建新类别。根据您使用的 SELinux 策略，将 <selinuxpolicy> 替换为 targeted 或 mls。例如：

   # vi /etc/selinux/targeted/setrans.conf

2. 在策略的 setrans.conf 文件中，使用语法 s _<security level>_:c_<category number>_= <category number>_=<category.name> 定义您的场景所需的类别组合，例如：

   s0:c0=Marketing
   s0:c1=Finance
   s0:c2=Payroll
   s0:c3=Personnel

   • 您可以使用 c0 到 c1023 的类别编号。
   • 在 目标策略 中，使用 s0 安全性级别。
   • 在 mls 策略中，您可以标记每个 sensitivity 级别和类别的组合。
3. 可选：在 setrans.conf 文件中，您还可以标记 MLS sensitivity 级别。
4. 保存并退出文件。

5. 要使更改有效，请重启 MCS 转换服务：

   # systemctl restart mcstrans

流程

1. 定义 SELinux 用户的安全范围。

   # semanage user -m -rs0:c0,c1-s0:c0.c9 <user_u>

   使用类别编号 c0 到 setrans.conf 文件中定义的 c1023 或 category 标签。如需更多信息，请参阅 MCS 中的定义类别标签。

2. 为 Linux 用户分配 MCS 类别。您只能在为相关 SELinux 用户定义的范围内指定范围：

   # semanage login -m -rs0:c1 <Linux.user1>

   注意

   您可以使用 chcat 命令从 Linux 用户添加或删除类别。以下示例添加了 <category1>，并从 <Linux.user1> 和 <Linux.user2> 中删除 <category2> ：

   # chcat -l -- +<category1>,-<category2> <Linux.user1>,<Linux.user2>

   请注意，您必须在命令行中指定 --，然后使用 -<category> 语法。否则，chcat 命令会错误地将类别删除视为命令选项。

验证

1. 显示文件的安全上下文以验证它具有正确的类别：

   $ ls -lZ <path/to/file>
   -rw-r--r--  <LinuxUser1> <Group1> root:object_r:user_home_t:_<sensitivity>_:_<category>_ <path/to/file>

   文件的特定安全上下文可能有所不同。

2. 可选：当以未分配给文件相同的类别的 Linux 用户的身份登录时，尝试访问该文件：

   $ cat <path/to/file>
   cat: <path/to/file>: Permission Denied

流程

1. 在本例中，准备一个简单的守护进程，它会打开 /var/log/messages 文件进行写入：

   1. 创建一个新文件，然后在您选择的文本编辑器中打开：

      $ vi mydaemon.c

   2. 插入以下代码：

      #include <unistd.h>
      #include <stdio.h>
      
      FILE *f;
      
      int main(void)
      {
      while(1) {
      f = fopen("/var/log/messages","w");
              sleep(5);
              fclose(f);
          }
      }

   3. 编译文件：

      $ gcc -o mydaemon mydaemon.c

   4. 为您的守护进程创建一个 systemd 单元文件：

      $ vi mydaemon.service
      [Unit]
      Description=Simple testing daemon
      
      [Service]
      Type=simple
      ExecStart=/usr/local/bin/mydaemon
      
      [Install]
      WantedBy=multi-user.target

   5. 安装并启动守护进程：

      # cp mydaemon /usr/local/bin/
      # cp mydaemon.service /usr/lib/systemd/system
      # systemctl start mydaemon
      # systemctl status mydaemon
      ● mydaemon.service - Simple testing daemon
         Loaded: loaded (/usr/lib/systemd/system/mydaemon.service; disabled; vendor preset: disabled)
         Active: active (running) since Sat 2020-05-23 16:56:01 CEST; 19s ago
       Main PID: 4117 (mydaemon)
          Tasks: 1
         Memory: 148.0K
         CGroup: /system.slice/mydaemon.service
                 └─4117 /usr/local/bin/mydaemon
      
      May 23 16:56:01 localhost.localdomain systemd[1]: Started Simple testing daemon.

   6. 检查新守护进程是否没有被 SELinux 限制：

      $ ps -efZ | grep mydaemon
      system_u:system_r:unconfined_service_t:s0 root 4117    1  0 16:56 ?        00:00:00 /usr/local/bin/mydaemon

2. 为守护进程生成自定义策略：

   $ sepolicy generate --init /usr/local/bin/mydaemon
   Created the following files:
   /home/example.user/mysepol/mydaemon.te # Type Enforcement file
   /home/example.user/mysepol/mydaemon.if # Interface file
   /home/example.user/mysepol/mydaemon.fc # File Contexts file
   /home/example.user/mysepol/mydaemon_selinux.spec # Spec file
   /home/example.user/mysepol/mydaemon.sh # Setup Script

3. 使用上一命令创建的设置脚本使用新策略模块重建系统策略：

   # ./mydaemon.sh
   Building and Loading Policy
   + make -f /usr/share/selinux/devel/Makefile mydaemon.pp
   Compiling targeted mydaemon module
   Creating targeted mydaemon.pp policy package
   rm tmp/mydaemon.mod.fc tmp/mydaemon.mod
   + /usr/sbin/semodule -i mydaemon.pp
   ...

   请注意，设置脚本使用 restorecon 命令重新标记文件系统的对应部分：

   restorecon -v /usr/local/bin/mydaemon /usr/lib/systemd/system

4. 重启守护进程，检查它现在被 SELinux 限制：

   # systemctl restart mydaemon
   $ ps -efZ | grep mydaemon
   system_u:system_r:mydaemon_t:s0 root        8150       1  0 17:18 ?        00:00:00 /usr/local/bin/mydaemon

5. 由于守护进程现在被 SELinux 限制，SELinux 也会阻止它访问 /var/log/messages。显示对应的拒绝信息：

   # ausearch -m AVC -ts recent
   ...
   type=AVC msg=audit(1590247112.719:5935): avc:  denied  { open } for  pid=8150 comm="mydaemon" path="/var/log/messages" dev="dm-0" ino=2430831 scontext=system_u:system_r:mydaemon_t:s0 tcontext=unconfined_u:object_r:var_log_t:s0 tclass=file permissive=1
   ...

6. 您还可以使用 sealert 工具获取更多信息：

   $ sealert -l "*"
   SELinux is preventing mydaemon from open access on the file /var/log/messages.
   
    Plugin catchall (100. confidence) suggests *
   
   If you believe that mydaemon should be allowed open access on the messages file by default.
   Then you should report this as a bug.
   You can generate a local policy module to allow this access.
   Do
   allow this access for now by executing:
   # ausearch -c 'mydaemon' --raw | audit2allow -M my-mydaemon
   # semodule -X 300 -i my-mydaemon.pp
   
   Additional Information:
   Source Context                system_u:system_r:mydaemon_t:s0
   Target Context                unconfined_u:object_r:var_log_t:s0
   Target Objects                /var/log/messages [ file ]
   Source                        mydaemon
   
   ...

7. 使用 audit2allow 工具推荐更改：

   $ ausearch -m AVC -ts recent | audit2allow -R
   
   require {
   	type mydaemon_t;
   }
   
   #============= mydaemon_t ==============
   logging_write_generic_logs(mydaemon_t)

8. 因为 audit2allow 推荐的规则在某些情况下可能不正确，所以只使用其输出的一部分来查找对应的策略接口：

   $ grep -r "logging_write_generic_logs" /usr/share/selinux/devel/include/ | grep .if
   /usr/share/selinux/devel/include/system/logging.if:interface(`logging_write_generic_logs',`

9. 检查接口的定义：

   $ cat /usr/share/selinux/devel/include/system/logging.if
   ...
   interface(`logging_write_generic_logs',`
           gen_require(`
                   type var_log_t;
           ')
   
           files_search_var($1)
           allow $1 var_log_t:dir list_dir_perms;
           write_files_pattern($1, var_log_t, var_log_t)
   ')
   ...

10. 在这个示例中，您可以使用推荐的接口。在您的类型强制文件中添加对应的规则：

    $ echo "logging_write_generic_logs(mydaemon_t)" >> mydaemon.te

    另外，您可以添加这个规则而不是使用接口：

    $ echo "allow mydaemon_t var_log_t:file { open write getattr };" >> mydaemon.te

11. 重新安装策略：

    # ./mydaemon.sh
    Building and Loading Policy
    + make -f /usr/share/selinux/devel/Makefile mydaemon.pp
    Compiling targeted mydaemon module
    Creating targeted mydaemon.pp policy package
    rm tmp/mydaemon.mod.fc tmp/mydaemon.mod
    + /usr/sbin/semodule -i mydaemon.pp
    ...

验证

1. 检查您的应用程序是否受 SELinux 限制，例如：

   $ ps -efZ | grep mydaemon
   system_u:system_r:mydaemon_t:s0 root        8150       1  0 17:18 ?        00:00:00 /usr/local/bin/mydaemon

2. 验证您的自定义应用程序不会导致任何 SELinux 拒绝：

   # ausearch -m AVC -ts recent
   <no matches>

流程

1. 使用文本编辑器打开 new .cil 文件，例如：

   # vim <local_module>.cil

   要让您的本地模块更好地组织，请在本地 SELinux 策略模块的名称中使用 local_ 前缀。

2. 插入来自已知问题或红帽解决方案的自定义规则。

   重要

   请勿自行编写规则。仅使用特定已知问题或红帽解决方案中提供的规则。

   例如，要在 RHEL 解决方案中实施 SELinux 拒绝 cups-lpd 对 cups.sock 的读取访问权限，请插入以下规则：

   注意

   在 RHBA-2021:4420 中为 RHEL 永久修复了示例解决方案。因此，特定于本解决方案的部分对更新的 RHEL 8 和 9 个系统没有影响，且只作为语法示例包括。

   (allow cupsd_lpd_t cupsd_var_run_t (sock_file (read)))

   请注意，您可以使用两种 SELinux 规则语法之一：通用中间语言(CIL)和 m4。例如，在 CIL 中 （允许 cupsd_lpd_t cupsd_var_run_t（sock_file（读取）） 等同于 m4 中的以下内容：

   module local_cupslpd-read-cupssock 1.0;
   
   require {
       type cupsd_var_run_t;
       type cupsd_lpd_t;
       class sock_file read;
   }
   
   #============= cupsd_lpd_t ==============
   allow cupsd_lpd_t cupsd_var_run_t:sock_file read;

3. 保存并关闭该文件。

4. 安装策略模块：

   # semodule -i <local_module>.cil

   注意

   要删除使用 semodule -i 创建的本地策略模块时，请参考没有 .cil 后缀的模块名称。要删除本地策略模块，请使用 semodule -r < local_module>。

5. 重启与规则相关的任何服务：

   # systemctl restart <service-name>

验证

1. 列出 SELinux 策略中安装的本地模块：

   # semodule -lfull | grep "local_"
   400 local_module  cil

   注意

   由于本地模块具有优先级 400，所以您也可以通过使用该值来从列表中过滤它们，例如使用 semodule -lfull | grep -v ^100 命令。

2. 在 SELinux 策略中搜索相关的 allow 规则：

   # sesearch -A --source=<SOURCENAME> --target=<TARGETNAME> --class=<CLASSNAME> --perm=<P1>,<P2>

   其中 <SOURCENAME> 是源 SELinux 类型，<TARGETNAME> 是目标 SELinux 类型，<CLASSNAME> 是安全类或对象类名称，<P1> 和 <P2> 是 规则的特定权限。

   例如，对于 SELinux 拒绝 cups-lpd 对 RHEL 解决方案中的 cups.sock 的读取访问权限 ：

   # sesearch -A --source=cupsd_lpd_t --target=cupsd_var_run_t --class=sock_file --perm=read
   allow cupsd_lpd_t cupsd_var_run_t:sock_file { append getattr open read write };

   最后一行现在应包含 读取操作。

3. 验证相关服务是否受到 SELinux 的限制：

   1. 识别与相关服务相关的进程：

      $ systemctl status <service-name>

   2. 检查上一命令输出中所列进程的 SELinux 上下文：

      $ ps -efZ | grep <process-name>

4. 验证该服务是否没有导致任何 SELinux 拒绝：

   # ausearch -m AVC -ts recent
   <no matches>

1. 以 JSON 格式解析容器规格文件
2. 根据第一部分的结果查找合适的允许规则
3. 生成最终 SELinux 策略

流程

1. 安装 udica 软件包：

   # yum install -y udica

   或者，安装 container-tools 模块，它提供一组容器软件包，包括 udica:

   # yum module install -y container-tools

2. 启动 ubi8 容器，该容器使用只读权限挂载 /home 目录，并使用读写权限挂载 /var/spool 目录。容器会公开端口 21。

   # podman run --env container=podman -v /home:/home:ro -v /var/spool:/var/spool:rw -p 21:21 -it ubi8 bash

   请注意，现在容器使用 container_t SELinux 类型运行。这个类型是 SELinux 策略中所有容器的通用域。针对于您的具体情况，这可能太严格或太宽松。

3. 打开一个新终端，输入 podman ps 命令以获取容器的 ID：

   # podman ps
   CONTAINER ID   IMAGE                                   COMMAND   CREATED          STATUS              PORTS   NAMES
   37a3635afb8f   registry.access.redhat.com/ubi8:latest  bash      15 minutes ago   Up 15 minutes ago           heuristic_lewin

4. 创建容器 JSON 文件，并使用 udica 根据 JSON 文件中的信息创建策略模块：

   # podman inspect 37a3635afb8f > container.json
   # udica -j container.json my_container
   Policy my_container with container id 37a3635afb8f created!
   [...]

   或者：

   # podman inspect 37a3635afb8f | udica my_container
   Policy my_container with container id 37a3635afb8f created!
   
   Please load these modules using:
   # semodule -i my_container.cil /usr/share/udica/templates/{base_container.cil,net_container.cil,home_container.cil}
   
   Restart the container with: "--security-opt label=type:my_container.process" parameter

5. 如上一步中 udica 的输出所建议，载入策略模块：

   # semodule -i my_container.cil /usr/share/udica/templates/{base_container.cil,net_container.cil,home_container.cil}

6. 停止容器并使用 --security-opt label=type:my_container.process 选项再次启动它：

   # podman stop 37a3635afb8f
   # podman run --security-opt label=type:my_container.process -v /home:/home:ro -v /var/spool:/var/spool:rw -p 21:21 -it ubi8 bash

验证

1. 检查容器是否使用 my_container.process 类型运行：

   # ps -efZ | grep my_container.process
   unconfined_u:system_r:container_runtime_t:s0-s0:c0.c1023 root 2275 434  1 13:49 pts/1 00:00:00 podman run --security-opt label=type:my_container.process -v /home:/home:ro -v /var/spool:/var/spool:rw -p 21:21 -it ubi8 bash
   system_u:system_r:my_container.process:s0:c270,c963 root 2317 2305  0 13:49 pts/0 00:00:00 bash

2. 验证 SELinux 现在允许访问 /home 和 /var/spool 挂载点：

   [root@37a3635afb8f /]# cd /home
   [root@37a3635afb8f home]# ls
   username
   [root@37a3635afb8f ~]# cd /var/spool/
   [root@37a3635afb8f spool]# touch test
   [root@37a3635afb8f spool]#

3. 检查 SELinux 是否只允许绑定到端口 21：

   [root@37a3635afb8f /]# yum install nmap-ncat
   [root@37a3635afb8f /]# nc -lvp 21
   ...
   Ncat: Listening on :::21
   Ncat: Listening on 0.0.0.0:21
   ^C
   [root@37a3635afb8f /]# nc -lvp 80
   ...
   Ncat: bind to :::80: Permission denied. QUITTING.

流程

1. 准备您的 playbook。您可以从头开始，或修改作为 rhel-system-roles 软件包一部分安装的示例 playbook：

   # cp /usr/share/doc/rhel-system-roles/selinux/example-selinux-playbook.yml my-selinux-playbook.yml
   # vi my-selinux-playbook.yml

2. 更改 playbook 的内容，使其适合您的场景。例如，以下部分可确保系统安装并启用 selinux-local-1.pp SELinux 模块：

   selinux_modules:
   - { path: "selinux-local-1.pp", priority: "400" }

3. 保存更改，再退出文本编辑器。

4. 在 host1、host2 和 host 3 系统中运行您的 playbook：

   # ansible-playbook -i host1,host2,host3 my-selinux-playbook.yml

流程

1. 导出验证的 SELinux 设置：

   # semanage export -f ./my-selinux-settings.mod

2. 使用设置将该文件复制到新系统：

   # scp ./my-selinux-settings.mod new-system-hostname:

3. 登录新系统：

   $ ssh root@new-system-hostname

4. 在新系统中导入设置：

   new-system-hostname# semanage import -f ./my-selinux-settings.mod