使用 SELinux

步骤

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 命令返回 Permissive：

   $ 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 模式。

   默认情况下，autorelabel 使用并行多个线程，因为系统有可用的 CPU 内核。要在自动重新标记过程中只使用单个线程，请使用 fixfiles -T 1 onboot 命令。

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

验证

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

   $ getenforce
   Enforcing

流程

1. 将您的引导装载程序配置为在内核命令行中添加 selinux=0 ：

   $ sudo grubby --update-kernel ALL --args selinux=0

2. 重启您的系统：

   $ reboot

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. 输入以下命令创建一个名为 <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. 将新用户映射到 sysadm_u SELinux 用户：

   • 要映射新用户，请在 wheel 用户组中添加一个新用户，并将用户映射到 sysadm_u SELinux 用户：

     # adduser -G wheel -Z sysadm_u <example_user>

   • 要映射现有用户，将用户添加到 wheel 用户组，并将用户映射到 sysadm_u SELinux 用户：

     # usermod -G wheel -Z sysadm_u <example_user>

3. 恢复用户主目录的上下文：

   # restorecon -R -F -v /home/<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. 将新用户或现有用户映射到 staff_u SELinux 用户：

   1. 要映射新用户，请将新用户添加到 wheel 用户组，并将用户映射到 staff_u SELinux 用户：

      # adduser -G wheel -Z staff_u <example_user>

   2. 要映射现有用户，请将用户添加到 wheel 用户组，并将用户映射到 staff_u SELinux 用户：

      # usermod -G wheel -Z staff_u <example_user>

2. 恢复用户主目录的上下文：

   # restorecon -R -F -v /home/<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. 显示 root 安全上下文：

   # 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. 检查布尔值为 on：

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

步骤

1. 列出所有与 SELinux 相关的主题，并将结果限制为您要配置的组件。例如：

   # man -k selinux | grep samba
   samba_net_selinux (8) - Security Enhanced Linux Policy for the samba_net processes
   samba_selinux (8)    - Security Enhanced Linux Policy for the smbd processes
   …

   在与您的场景对应的 man page 中，找到相关的 SELinux 布尔值、端口类型和文件类型。

   请注意，只有安装 selinux-policy-doc 软件包后，man -k selinux 或 apropos selinux 命令才可用。

2. 可选：您可以使用 semanage fcontext -l 命令显示默认位置上进程的默认映射，例如：

   # semanage fcontext -l | grep samba
   …
   /var/cache/samba(/.*)?                             all files          system_u:object_r:samba_var_t:s0
   …
   /var/spool/samba(/.*)?                             all files          system_u:object_r:samba_spool_t:s0
   …

3. 使用 sesearch 命令显示默认 SELinux 策略中的规则。您可以通过列出对应的规则来查找要使用的类型和布尔值，例如：

   $ sesearch -A | grep samba | grep httpd
   …
   allow httpd_t cifs_t:dir { getattr open search }; [ use_samba_home_dirs && httpd_enable_homedirs ]:True
   …

4. SELinux 布尔值可能是您的配置问题最直接的解决方案。您可以使用 getsebool -a 命令显示所有可用的布尔值及其值，例如：

   $ getsebool -a | grep homedirs
   git_cgi_enable_homedirs --> off
   git_system_enable_homedirs --> off
   httpd_enable_homedirs --> off
   mock_enable_homedirs --> off
   mpd_enable_homedirs --> off
   openvpn_enable_homedirs --> on
   ssh_chroot_rw_homedirs --> off

5. 您可以使用 sesearch 命令验证所选布尔值是否准确执行所需的内容，例如：

   $ sesearch -A | grep httpd_enable_homedirs
   …
   allow httpd_suexec_t autofs_t:dir { getattr open search }; [ use_nfs_home_dirs && httpd_enable_homedirs ]:True
   allow httpd_suexec_t autofs_t:dir { getattr open search }; [ use_samba_home_dirs && httpd_enable_homedirs ]:True
   …

6. 如果没有与您的场景匹配，则找到适合您问题单的 SELinux 类型。您可以使用 sesearch 从默认策略查询对应的规则来查找您的文件类型，例如：

   $ sesearch -A -s httpd_t -c file -p read
   …
   allow httpd_t httpd_t:file { append getattr ioctl lock open read write };
   allow httpd_t httpd_tmp_t:file { append create getattr ioctl link lock map open read rename setattr unlink write };
   …

7. 如果前面的解决方案没有满足您的场景，您可以在 SELinux 策略中添加自定义规则。如需更多信息 ，请参阅创建本地 SELinux 策略模块 部分。

步骤

1. 在终端中打开 user_selinux (8) 手册页：

   $ man user_selinux

   在 MANAGED FILES 部分中，找到与您的场景对应的属性或类型。例如，user_home_type 属性。

2. 可选：要列出分配给属性的所有类型，请使用 seinfo 命令和 -x 和 -a 选项，例如：

   $ seinfo -x -a user_home_type
   
   Type Attributes: 1
      attribute user_home_type;
   …
   	chrome_sandbox_home_t
   	config_home_t
   	cvs_home_t
   	data_home_t
   	dbus_home_t
   	fetchmail_home_t
   	gconf_home_t
   	git_user_content_t
   …

3. 在找到相应类型的候选后，本例中的 data_home_t 类型会检查其 SELinux 映射：

   $ semanage fcontext -l | grep data_home_t
   …
   /root/\.local/share(/.*)?                          all files          system_u:object_r:data_home_t:s0
   …

4. 将对应的类型映射到您要供 user_u 访问的目录，例如 /shared-data ：

   $ semanage fcontext -a -t data_home_t '/shared-data(/.*)?'

验证

1. 检查您配置的目录的映射：

   # semanage fcontext -l | grep "shared-data"
   /shared-data(/.*)?                             	all files      	system_u:object_r:data_home_t:s0

2. 以映射到 user_u SELinux 用户的 Linux 用户身份登录，并验证您可以访问该目录。

步骤

1. 当您的情况被 SELinux 阻止时，/var/log/audit/audit.log 文件是第一个检查有关拒绝的更多信息。要查询审计日志，请使用 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 只返回 catchall 建议，或者建议使用 audit2allow 工具添加新规则，请将您的问题与 审计日志中 SELinux 拒绝中列出的 示例匹配。

步骤

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

   # vim <local_module>.cil

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

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

   重要

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

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

     (allow cupsd_lpd_t cupsd_var_run_t (sock_file (read)))

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

     您可以使用两个 SELinux 规则语法之一： Common Intermediate Language (CIL)和 m4。例如，CIL 中的 (allow cupsd_lpd_t cupsd_var_run_t (sock_file (read))) 等同于 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 策略中搜索相关的允许规则：

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

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

   例如，SELinux denies cups-lpd read access to cups.sock in RHEL 解决方案：

   # 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 };

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

3. 验证相关服务受 SELinux 限制：

   1. 确定与相关服务相关的进程：

      $ systemctl status <service-name>

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

      $ ps -efZ | grep <process-name>

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

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

   i 选项将数字值解译为人类可读的文本。

步骤

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 到 s15，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 安全许可范围的较低级别改为您要分配给该文件的级别：

   $ 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. 可选：验证具有较低级别权限的用户是否无法读取该文件：

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

步骤

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

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

   为保持 sudoers 文件的组织，请 <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.name> 来定义您的场景所需的类别组合，例如：

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

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

5. 要使更改有效，重启 MCS 翻译服务：

   # systemctl restart mcstrans

步骤

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

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

   使用 setrans.conf 文件中的类别号 c0 到 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 建议的规则在某些情况下可能不正确，所以只使用其输出的一部分来找到对应的策略接口。使用 扩展 工具检查 logging_write_generic_logs (mydaemon_t) 宏，以查看宏提供的所有允许的规则：

   $ macro-expander "logging_write_generic_logs(mydaemon_t)"
   allow mydaemon_t var_t:dir { getattr search open };
   allow mydaemon_t var_log_t:dir { getattr search open read lock ioctl };
   allow mydaemon_t var_log_t:dir { getattr search open };
   allow mydaemon_t var_log_t:file { open { getattr write append lock ioctl } };
   allow mydaemon_t var_log_t:dir { getattr search open };
   allow mydaemon_t var_log_t:lnk_file { getattr read };

9. 在这种情况下，您可以使用推荐的接口，因为它只提供对日志文件及其父目录的读写访问。在您的类型强制文件中添加对应的规则：

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

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

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

10. 重新安装策略：

    # ./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. 以 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. 验证 playbook 语法：

   $ ansible-playbook <my-selinux-playbook.yml> --syntax-check

   请注意，这个命令只验证语法，不会防止错误但有效的配置。

5. 运行您的 playbook:

   $ ansible-playbook <my-selinux-playbook.yml>

步骤

1. 登录到 RHEL 8 web 控制台。

   详情请参阅 登录到 web 控制台。

2. 点 SELinux。

3. 点 View the automation script。

   此时会打开一个带有生成的脚本的窗口。您可以在 shell 脚本页和 Ansible playbook 生成选项页之间转换。

   

4. 点 Copy to clipboard 按钮选择脚本或 playbook 并应用它。

步骤

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