安全强化

流程

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

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

2. 在 Overview 选项卡中，找到 系统信息 字段并点查看硬件详细信息。

3. 在 CPU Security 行上，点 Mitigations。

   如果这个链接不存在，这意味着您的系统不支持 SMT，因此不会受到这个安全漏洞的影响。

4. 在 CPU Security Toggles 表中，打开 Disable simultaneous multithreading (nosmt) 选项。
5. 点保存并重启按钮。

流程

1. 在系统安装过程中，将 fips=1 选项添加到内核命令行。
2. 在软件选择阶段，请勿安装任何第三方软件。
3. 安装后，系统会自动以 FIPS 模式启动。

流程

1. 将系统切换到 FIPS 模式：

   # fips-mode-setup --enable
   Kernel initramdisks are being regenerated. This might take some time.
   Setting system policy to FIPS
   Note: System-wide crypto policies are applied on application start-up.
   It is recommended to restart the system for the change of policies
   to fully take place.
   FIPS mode will be enabled.
   Please reboot the system for the setting to take effect.

2. 重启您的系统以允许内核切换到 FIPS 模式：

   # reboot

流程

1. 可选：显示当前加密策略：

   $ update-crypto-policies --show
   DEFAULT

2. 设置新的加密策略：

   # update-crypto-policies --set <POLICY>
   <POLICY>

   将 <POLICY > 替换为您要设置的策略或子策略，如 FUTURE、LEGACY 或 FIPS:OSPP。

3. 重启系统：

   # reboot

流程

1. 要将系统范围的加密策略切换到 LEGACY 级别，请以 root 用户身份输入以下命令：

   # update-crypto-policies --set LEGACY
   Setting system policy to LEGACY

流程

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

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

2. 在 Overview 页面的 Configuration 卡中，点 Crypto 策略旁的当前策略值。

   

3. 在 Change crypto policy 对话框窗口中，点您要在系统上开始使用的策略。

   

4. 点应用并重新引导按钮。

流程

1. 签出到 /etc/crypto-policies/policies/modules/ 目录：

   # cd /etc/crypto-policies/policies/modules/

2. 为您的调整创建子策略，例如：

   # touch MYCRYPTO-1.pmod
   # touch SCOPES-AND-WILDCARDS.pmod

   重要

   在策略模块的文件名中使用大写字母。

3. 在您选择的文本编辑器中打开策略模块并插入修改系统范围加密策略的选项，例如：

   # vi MYCRYPTO-1.pmod

   min_rsa_size = 3072
   hash = SHA2-384 SHA2-512 SHA3-384 SHA3-512

   # vi SCOPES-AND-WILDCARDS.pmod

   # Disable the AES-128 cipher, all modes
   cipher = -AES-128-*
   
   # Disable CHACHA20-POLY1305 for the TLS protocol (OpenSSL, GnuTLS, NSS, and OpenJDK)
   cipher@TLS = -CHACHA20-POLY1305
   
   # Allow using the FFDHE-1024 group with the SSH protocol (libssh and OpenSSH)
   group@SSH = FFDHE-1024+
   
   # Disable all CBC mode ciphers for the SSH protocol (libssh and OpenSSH)
   cipher@SSH = -*-CBC
   
   # Allow the AES-256-CBC cipher in applications using libssh
   cipher@libssh = AES-256-CBC+

4. 将更改保存到模块文件中。

5. 将您的策略调整应用到 DEFAULT 系统范围加密策略级别：

   # update-crypto-policies --set DEFAULT:MYCRYPTO-1:SCOPES-AND-WILDCARDS

6. 要使您的加密设置对已经运行的服务和应用程序有效，请重启系统：

   # reboot

流程

1. 将您的策略调整应用到 DEFAULT 系统范围加密策略级别：

   # update-crypto-policies --set DEFAULT:NO-SHA1

2. 要使您的加密设置对已经运行的服务和应用程序有效，请重启系统：

   # reboot

流程

1. 为自定义创建一个策略文件：

   # cd /etc/crypto-policies/policies/
   # touch MYPOLICY.pol

   或者，从复制四个预定义策略级别中的一个开始：

   # cp /usr/share/crypto-policies/policies/DEFAULT.pol /etc/crypto-policies/policies/MYPOLICY.pol

2. 在您选择的文本编辑器中编辑带有自定义加密策略的文件以满足您的要求，例如：

   # vi /etc/crypto-policies/policies/MYPOLICY.pol

3. 将系统范围的加密策略切换到自定义级别：

   # update-crypto-policies --set MYPOLICY

4. 要使您的加密设置对已经运行的服务和应用程序有效，请重启系统：

   # reboot

流程

1. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Configure cryptographic policies
     hosts: managed-node-01.example.com
     tasks:
       - name: Configure the FUTURE cryptographic security policy on the managed node
         ansible.builtin.include_role:
           name: rhel-system-roles.crypto_policies
         vars:
           - crypto_policies_policy: FUTURE
           - crypto_policies_reboot_ok: true

   示例 playbook 中指定的设置包括以下内容：

   crypto_policies_policy: FUTURE

   在受管节点上配置所需的加密策略(FUTURE)。它可以是基本策略，也可以是带有一些子策略的基本策略。必须在受管节点上提供指定的基本策略和子策略。默认值为 null。这意味着配置没有被更改，crypto_policies RHEL 系统角色只会收集 Ansible 事实。

   crypto_policies_reboot_ok: true

   会导致系统在加密策略更改后重新启动，以确保所有服务和应用程序都将读取新的配置文件。默认值为 false。

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.crypto_policies/README.md 文件。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/playbook.yml

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

3. 运行 playbook：

   $ ansible-playbook ~/playbook.yml

验证

1. 在控制节点上，创建另一个 playbook，例如 verify_playbook.yml ：

   ---
   - name: Verification
     hosts: managed-node-01.example.com
     tasks:
       - name: Verify active cryptographic policy
         ansible.builtin.include_role:
           name: rhel-system-roles.crypto_policies
       - name: Display the currently active cryptographic policy
         ansible.builtin.debug:
           var: crypto_policies_active

   示例 playbook 中指定的设置包括以下内容：

   crypto_policies_active

   导出的 Ansible 事实，其中含有当前活动的策略名称，格式为 crypto_policies_policy 变量接受的格式。

2. 验证 playbook 语法：

   $ ansible-playbook --syntax-check ~/verify_playbook.yml

3. 运行 playbook：

   $ ansible-playbook ~/verify_playbook.yml
   TASK [debug] **************************
   ok: [host] => {
       "crypto_policies_active": "FUTURE"
   }

   crypto_policies_active 变量显示受管节点上的活动策略。

流程

1. 列出所有由 OpenSC PKCS #11 模块提供的密钥，包括其 PKCS #11 URIs，并将输出保存到 key.pub 文件：

   $ ssh-keygen -D pkcs11: > keys.pub

2. 将公钥传送到远程服务器。使用带有上一步中创建的 key .pub 文件的 ssh-copy-id 命令：

   $ ssh-copy-id -f -i keys.pub <username@ssh-server-example.com>

3. 使用 ECDSA 密钥连接到 < ssh-server-example.com >。您只能使用 URI 的子集，它唯一引用您的密钥，例如：

   $ ssh -i "pkcs11:id=%01?module-path=/usr/lib64/pkcs11/opensc-pkcs11.so" <ssh-server-example.com>
   Enter PIN for 'SSH key':
   [ssh-server-example.com] $

   因为 OpenSSH 使用 p11-kit-proxy 打包程序和 OpenSC PKCS modprobe 模块注册到 p11-kit 工具，所以您可以简化上一个命令：

   $ ssh -i "pkcs11:id=%01" <ssh-server-example.com>
   Enter PIN for 'SSH key':
   [ssh-server-example.com] $

   如果您跳过 PKCS #11 URI 的 id= 部分，则 OpenSSH 会加载代理模块中可用的所有密钥。这可减少输入所需的数量：

   $ ssh -i pkcs11: <ssh-server-example.com>
   Enter PIN for 'SSH key':
   [ssh-server-example.com] $

4. 可选：您可以使用 ~/.ssh/config 文件中的同一 URI 字符串使配置持久：

   $ cat ~/.ssh/config
   IdentityFile "pkcs11:id=%01?module-path=/usr/lib64/pkcs11/opensc-pkcs11.so"
   $ ssh <ssh-server-example.com>
   Enter PIN for 'SSH key':
   [ssh-server-example.com] $

   ssh 客户端工具现在自动使用来自智能卡中的这个 URI 和密钥。

流程

1. 在 /etc/polkit-1/rules.d/ 目录中创建一个新文件：

   # touch /etc/polkit-1/rules.d/00-test.rules

2. 在您选择的编辑器中编辑该文件，例如：

   # vi /etc/polkit-1/rules.d/00-test.rules

3. 插入以下行：

   polkit.addRule(function(action, subject) {
     if (action.id == "org.debian.pcsc-lite.access_pcsc" ||
     	action.id == "org.debian.pcsc-lite.access_card") {
   	polkit.log("action=" + action);
   	polkit.log("subject=" + subject);
     }
   });

   保存文件并退出编辑器。

4. 重启 pcscd 和 polkit 服务：

   # systemctl restart pcscd.service pcscd.socket polkit.service

验证

1. 为 pcscd 发出一个授权请求。例如，打开 Firefox Web 浏览器，或者使用 opensc 软件包提供的 pkcs11-tool -L 命令。

2. 显示扩展的日志条目，例如：

   # journalctl -u polkit --since "1 hour ago"
   polkitd[1224]: <no filename>:4: action=[Action id='org.debian.pcsc-lite.access_pcsc']
   polkitd[1224]: <no filename>:5: subject=[Subject pid=2020481 user=user' groups=user,wheel,mock,wireshark seat=null session=null local=true active=true]

流程

1. 使用带有- remediate 选项的 oscap 命令修复系统：

   # oscap xccdf eval --profile <profileID> --remediate /usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml

   将 <profileID > 替换为系统应该遵守的配置集 ID，例如 hipaa。

2. 重启您的系统。

验证

1. 使用配置集评估系统合规性，并将扫描结果保存到文件中：

   $ oscap xccdf eval --report <scan-report.html> --profile <profileID> /usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml

   替换：

   • <scan-report.html >，使用 oscap 保存扫描结果的文件名。
   • <profile Id> 带有系统应该遵守的配置集 ID，例如 hipaa。

流程

1. 使用 Ansible 修复您的系统，使其与 HIPAA 一致：

   # ansible-playbook -i localhost, -c local /usr/share/scap-security-guide/ansible/rhel8-playbook-hipaa.yml

2. 重新启动系统。

验证

1. 使用 HIPAA 配置文件评估系统的合规性，并将扫描结果保存到文件中：

   # oscap xccdf eval --profile hipaa --report <scan-report.html> /usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml

   将 <scan-report.html > 替换为 oscap 保存扫描结果的文件名。

流程

1. 扫描系统并保存结果：

   # oscap xccdf eval --profile hipaa --results <hipaa-results.xml> /usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml

2. 在带有结果的文件中找到结果 ID 的值：

   # oscap info <hipaa-results.xml>

3. 根据在第 1 步中生成的文件生成一个 Ansible playbook：

   # oscap xccdf generate fix --fix-type ansible --result-id <xccdf_org.open-scap_testresult_xccdf_org.ssgproject.content_profile_hipaa> --output <hipaa-remediations.yml> <hipaa-results.xml>

4. 查看生成的文件，其中包含在第 1 步中执行扫描过程中失败的规则的 Ansible 修复。查看生成的文件后，您可以使用 ansible-playbook <hipaa-remediations.yml> 命令应用该文件。

流程

1. 使用 oscap 命令扫描系统，并将结果保存到 XML 文件中。在以下示例中，oscap 会根据 hipaa 配置文件评估系统：

   # oscap xccdf eval --profile hipaa --results <hipaa-results.xml> /usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml

2. 在带有结果的文件中找到结果 ID 的值：

   # oscap info <hipaa-results.xml>

3. 根据在第 1 步中生成的结果文件生成一个 Bash 脚本：

   # oscap xccdf generate fix --fix-type bash --result-id <xccdf_org.open-scap_testresult_xccdf_org.ssgproject.content_profile_hipaa> --output <hipaa-remediations.sh> <hipaa-results.xml>

4. <hipaa-remediations.sh> 文件包含在第 1 步中执行扫描的过程中失败的规则的补救。查看生成的文件后，当您位于与此文件相同的目录中时，您可以使用 ./<hipaa-remediations.sh> 命令应用该文件。

流程

1. 下载系统的最新 RHSA OVAL 定义：

   # wget -O - https://www.redhat.com/security/data/oval/v2/RHEL8/rhel-8.oval.xml.bz2 | bzip2 --decompress > rhel-8.oval.xml

2. 获取容器或容器镜像的 ID，例如：

   # podman images
   REPOSITORY                            TAG      IMAGE ID       CREATED       SIZE
   registry.access.redhat.com/ubi8/ubi   latest   096cae65a207   7 weeks ago   239 MB

3. 扫描容器或容器镜像的漏洞，并将结果保存到 vulnerability.html 文件中：

   # oscap-podman 096cae65a207 oval eval --report vulnerability.html rhel-8.oval.xml

   请注意，oscap-podman 命令需要 root 特权，容器的 ID 是第一个参数。

流程

1. 查找容器或容器镜像的 ID：

   1. 要查找容器的 ID，请输入 podman ps -a 命令。
   2. 要查找容器镜像的 ID，请输入 podman images 命令。

2. 使用配置集评估容器或容器镜像的合规性，并将扫描结果保存到文件中：

   # oscap-podman <ID> xccdf eval --report <scan-report.html> --profile <profileID> /usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml

   替换：

   • &lt;ID> 带有容器或容器镜像的 ID
   • <scan-report.html >，带有 oscap 保存扫描结果的文件名
   • <profile Id> 带有系统应该遵循的配置集 ID，例如 hipaa、ospp、或 pci-dss

流程

1. 安装 aide 软件包：

   # yum install aide

2. 生成一个初始数据库：

   # aide --init
   Start timestamp: 2024-07-08 10:39:23 -0400 (AIDE 0.16)
   AIDE initialized database at /var/lib/aide/aide.db.new.gz
   
   Number of entries:	55856
   
   ---------------------------------------------------
   The attributes of the (uncompressed) database(s):
   ---------------------------------------------------
   
   /var/lib/aide/aide.db.new.gz
   …
     SHA512   : mZaWoGzL2m6ZcyyZ/AXTIowliEXWSZqx
                IFYImY4f7id4u+Bq8WeuSE2jasZur/A4
                FPBFaBkoCFHdoE/FW/V94Q==

3. 可选：在默认配置中，aide --init 命令只检查 /etc/aide.conf 文件中定义的一组目录和文件。要在 AIDE 数据库中包含其他目录或文件，并更改其监视的参数，请相应地编辑 /etc/aide.conf。

4. 要开始使用数据库，请从初始数据库文件名中删除 .new 子字符串：

   # mv /var/lib/aide/aide.db.new.gz /var/lib/aide/aide.db.gz

5. 可选：要更改 AIDE 数据库的位置，请编辑 /etc/aide.conf 文件并修改 DBDIR 值。要获得额外的安全性，请将数据库、配置和 /usr/sbin/aide 二进制文件存储在安全的位置，如只读介质。

流程

1. 启动手动检查：

   # aide --check
   Start timestamp: 2024-07-08 10:43:46 -0400 (AIDE 0.16)
   AIDE found differences between database and filesystem!!
   
   Summary:
     Total number of entries:	55856
     Added entries:		0
     Removed entries:		0
     Changed entries:		1
   
   ---------------------------------------------------
   Changed entries:
   ---------------------------------------------------
   
   f   ...      ..S : /root/.viminfo
   
   ---------------------------------------------------
   Detailed information about changes:
   ---------------------------------------------------
   
   File: /root/.viminfo
     SELinux  : system_u:object_r:admin_home_t:s | unconfined_u:object_r:admin_home
                0                                | _t:s0
   …

2. 至少，将系统配置为每周运行 AIDE。最好每天运行 AIDE。例如，要使用 cron 命令计划在每日 04:05 a.m. 执行 AIDE，请在 /etc/crontab 文件中添加以下行：

    05 4 * * * root /usr/sbin/aide --check

流程

1. 更新您的基准 AIDE 数据库：

   # aide --update

   aide --update 命令创建 /var/lib/aide/aide.db.new.gz 数据库文件。

2. 若要开始使用更新的数据库进行完整性检查，请从文件名中删除 .new 子字符串。

流程

1. 使用具有持久句柄的 SHA-256 主存储密钥创建一个 2048 位 RSA 密钥，例如 81000001，使用以下工具之一：

   1. 通过使用 tss2 软件包：

      # TPM_DEVICE=/dev/tpm0 tsscreateprimary -hi o -st
      Handle 80000000
      # TPM_DEVICE=/dev/tpm0 tssevictcontrol -hi o -ho 80000000 -hp 81000001

   2. 通过使用 tpm2-tools 软件包：

      # tpm2_createprimary --key-algorithm=rsa2048 --key-context=key.ctxt
      name-alg:
        value: sha256
        raw: 0xb
      …
      sym-keybits: 128
      rsa: xxxxxx…
      
      # tpm2_evictcontrol -c key.ctxt 0x81000001
      persistentHandle: 0x81000001
      action: persisted

2. 创建一个可信密钥：

   1. 按照 keyctl add trusted <NAME> "new <KEY_LENGTH> keyhandle=<PERSISTENT-HANDLE> [options]" <KEYRING> 语法使用 TPM 2.0。在本例中，持久性句柄为 81000001。

      # keyctl add trusted kmk "new 32 keyhandle=0x81000001" @u
      642500861

      命令创建一个名为 kmk 的可信密钥，长度为 32 字节（256 位），并将其放置在用户密钥环 (@u) 中。密钥长度为 32 到 128 字节（256 到 1024 位）。

   2. 按照 keyctl add trusted <NAME> "new <KEY_LENGTH>" <KEYRING> 语法使用 TPM 1.2 :

      # keyctl add trusted kmk "new 32" @u

3. 列出内核密钥环的当前结构：

   # keyctl show
   Session Keyring
          -3 --alswrv    500   500  keyring: ses 97833714 --alswrv 500 -1 \ keyring: uid.1000 642500861 --alswrv 500 500 \ trusted: kmk

4. 使用可信密钥的序列号将密钥导出到用户空间 blob:

   # keyctl pipe 642500861 > kmk.blob

   命令使用 pipe 子命令和 kmk 的序列号。

5. 从用户空间 blob 加载可信密钥：

   # keyctl add trusted kmk "load `cat kmk.blob`" @u
   268728824

6. 创建使用 TPM 密封的可信密钥的安全加密密钥(kmk)。按照此语法：keyctl add encrypted <NAME> "new [FORMAT] <KEY_TYPE>:<PRIMARY_KEY_NAME> <KEY_LENGTH>" <KEYRING>:

   # keyctl add encrypted encr-key "new trusted:kmk 32" @u
   159771175

流程

1. 使用随机数字序列生成用户密钥：

   # keyctl add user kmk-user "$(dd if=/dev/urandom bs=1 count=32 2>/dev/null)" @u
   427069434

   命令生成名为 kmk-user 的用户密钥，该密钥充当 主密钥，用于密封实际加密的密钥。

2. 使用上一步中的主密钥生成加密密钥：

   # keyctl add encrypted encr-key "new user:kmk-user 32" @u
   1012412758

验证

1. 列出指定用户密钥环中的所有密钥：

   # keyctl list @u
   2 keys in keyring:
   427069434: --alswrv  1000  1000 user: kmk-user
   1012412758: --alswrv  1000  1000 encrypted: encr-key

流程

1. 创建测试文件：

   # echo <Test_text> > test_file

   IMA 和 EVM 确保 test_file 示例文件已分配了哈希值，该值被存储为其扩展属性。

2. 检查文件的扩展属性：

   # getfattr -m . -d test_file
   # file: test_file
   security.evm=0sAnDIy4VPA0HArpPO/EqiutnNyBql
   security.ima=0sAQOEDeuUnWzwwKYk+n66h/vby3eD

   示例输出显示带有 IMA 和 EVM 哈希值和 SELinux 上下文的扩展属性。EVM 添加了一个与其他属性相关的 security.evm 扩展属性。此时，您可以在 security.evm 上使用 evmctl 工具来生成基于 RSA 的数字签名或基于哈希的消息身份验证代码(HMAC-SHA1)的数字签名。

流程

1. 卸载您要加密的设备上的所有文件系统，例如：

   # umount /dev/mapper/vg00-lv00

2. 为存储 LUKS 标头腾出空间。使用以下适合您场景的选项之一：

   • 如果是加密逻辑卷，您可以扩展逻辑卷而无需调整文件系统的大小。例如：

     # lvextend -L+32M /dev/mapper/vg00-lv00

   • 使用分区管理工具（如 parted ）扩展分区。
   • 缩小该设备的文件系统。您可以对 ext2、ext3 或 ext4 文件系统使用 resize2fs 工具。请注意，您无法缩小 XFS 文件系统。

3. 初始化加密：

   # cryptsetup reencrypt --encrypt --init-only --reduce-device-size 32M /dev/mapper/vg00-lv00 lv00_encrypted
   
   /dev/mapper/lv00_encrypted is now active and ready for online encryption.

4. 挂载该设备：

   # mount /dev/mapper/lv00_encrypted /mnt/lv00_encrypted

5. 向 /etc/crypttab 文件添加持久映射的一个条目：

   1. 查找 luksUUID ：

      # cryptsetup luksUUID /dev/mapper/vg00-lv00
      
      a52e2cc9-a5be-47b8-a95d-6bdf4f2d9325

   2. 在您选择的文本编辑器中打开 /etc/crypttab，并在此文件中添加设备：

      $ vi /etc/crypttab
      
      lv00_encrypted UUID=a52e2cc9-a5be-47b8-a95d-6bdf4f2d9325 none

      将 a52e2cc9-a5be-47b8-a95d-6bdf4f2d9325 替换为您设备的 luksUUID。

   3. 使用 dracut 刷新 initramfs：

      $ dracut -f --regenerate-all

6. 在 /etc/fstab 文件中为永久挂载添加一个条目：

   1. 查找活跃 LUKS 块设备的文件系统 UUID：

      $ blkid -p /dev/mapper/lv00_encrypted
      
      /dev/mapper/lv00-encrypted: UUID="37bc2492-d8fa-4969-9d9b-bb64d3685aa9" BLOCK_SIZE="4096" TYPE="xfs" USAGE="filesystem"

   2. 在您选择的文本编辑器中打开 /etc/fstab，并在此文件中添加设备，例如：

      $ vi /etc/fstab
      
      UUID=37bc2492-d8fa-4969-9d9b-bb64d3685aa9 /home auto rw,user,auto 0

      将 37bc2492-d8fa-4969-9d9b-bb64d3685aa9 替换为您文件系统的 UUID。

7. 恢复在线加密：

   # cryptsetup reencrypt --resume-only /dev/mapper/vg00-lv00
   
   Enter passphrase for /dev/mapper/vg00-lv00:
   Auto-detected active dm device 'lv00_encrypted' for data device /dev/mapper/vg00-lv00.
   Finished, time 00:31.130, 10272 MiB written, speed 330.0 MiB/s

验证

1. 验证现有数据是否已加密：

   # cryptsetup luksDump /dev/mapper/vg00-lv00
   
   LUKS header information
   Version: 2
   Epoch: 4
   Metadata area: 16384 [bytes]
   Keyslots area: 16744448 [bytes]
   UUID: a52e2cc9-a5be-47b8-a95d-6bdf4f2d9325
   Label: (no label)
   Subsystem: (no subsystem)
   Flags: (no flags)
   
   Data segments:
     0: crypt
   	offset: 33554432 [bytes]
   	length: (whole device)
   	cipher: aes-xts-plain64
   [...]

2. 查看加密的空白块设备的状态：

   # cryptsetup status lv00_encrypted
   
   /dev/mapper/lv00_encrypted is active and is in use.
     type:    LUKS2
     cipher:  aes-xts-plain64
     keysize: 512 bits
     key location: keyring
     device:  /dev/mapper/vg00-lv00

流程

1. 卸载设备上的所有文件系统，例如：

   # umount /dev/nvme0n1p1

2. 初始化加密：

   # cryptsetup reencrypt --encrypt --init-only --header /home/header /dev/nvme0n1p1 nvme_encrypted
   
   WARNING!
   ========
   Header file does not exist, do you want to create it?
   
   Are you sure? (Type 'yes' in capital letters): YES
   Enter passphrase for /home/header:
   Verify passphrase:
   /dev/mapper/nvme_encrypted is now active and ready for online encryption.

   将 /home/header 替换为带有分离的 LUKS 标头的文件的路径。分离的 LUKS 标头必须可以访问，以便稍后解锁加密设备。

3. 挂载该设备：

   # mount /dev/mapper/nvme_encrypted /mnt/nvme_encrypted

4. 恢复在线加密：

   # cryptsetup reencrypt --resume-only --header /home/header /dev/nvme0n1p1
   
   Enter passphrase for /dev/nvme0n1p1:
   Auto-detected active dm device 'nvme_encrypted' for data device /dev/nvme0n1p1.
   Finished, time 00m51s,   10 GiB written, speed 198.2 MiB/s

验证

1. 验证使用带有分离标头的 LUKS2 块设备上的现有数据是否已加密：

   # cryptsetup luksDump /home/header
   
   LUKS header information
   Version:       	2
   Epoch:         	88
   Metadata area: 	16384 [bytes]
   Keyslots area: 	16744448 [bytes]
   UUID:          	c4f5d274-f4c0-41e3-ac36-22a917ab0386
   Label:         	(no label)
   Subsystem:     	(no subsystem)
   Flags:       	(no flags)
   
   Data segments:
     0: crypt
   	offset: 0 [bytes]
   	length: (whole device)
   	cipher: aes-xts-plain64
   	sector: 512 [bytes]
   [...]

2. 查看加密的空白块设备的状态：

   # cryptsetup status nvme_encrypted
   
   /dev/mapper/nvme_encrypted is active and is in use.
     type:    LUKS2
     cipher:  aes-xts-plain64
     keysize: 512 bits
     key location: keyring
     device:  /dev/nvme0n1p1

流程

1. 将分区设置为加密的 LUKS 分区：

   # cryptsetup luksFormat /dev/nvme0n1p1
   
   WARNING!
   ========
   This will overwrite data on /dev/nvme0n1p1 irrevocably.
   Are you sure? (Type 'yes' in capital letters): YES
   Enter passphrase for /dev/nvme0n1p1:
   Verify passphrase:

2. 打开加密的 LUKS 分区：

   # cryptsetup open /dev/nvme0n1p1 nvme0n1p1_encrypted
   
   Enter passphrase for /dev/nvme0n1p1:

   这会解锁分区，并使用设备映射器将其映射到新设备。要不覆盖加密的数据，这个命令会警告内核，该设备是一个加密设备，并使用 /dev/mapper/device_mapped_name 路径通过 LUKS 解决了。

3. 创建一个文件系统来将加密的数据写入分区，该分区必须可通过设备映射名称访问：

   # mkfs -t ext4 /dev/mapper/nvme0n1p1_encrypted

4. 挂载该设备：

   # mount /dev/mapper/nvme0n1p1_encrypted mount-point

验证

1. 验证空白块设备是否已加密：

   # cryptsetup luksDump /dev/nvme0n1p1
   
   LUKS header information
   Version:       	2
   Epoch:         	3
   Metadata area: 	16384 [bytes]
   Keyslots area: 	16744448 [bytes]
   UUID:          	34ce4870-ffdf-467c-9a9e-345a53ed8a25
   Label:         	(no label)
   Subsystem:     	(no subsystem)
   Flags:       	(no flags)
   
   Data segments:
     0: crypt
   	offset: 16777216 [bytes]
   	length: (whole device)
   	cipher: aes-xts-plain64
   	sector: 512 [bytes]
   [...]

2. 查看加密的空白块设备的状态：

   # cryptsetup status nvme0n1p1_encrypted
   
   /dev/mapper/nvme0n1p1_encrypted is active and is in use.
     type:    LUKS2
     cipher:  aes-xts-plain64
     keysize: 512 bits
     key location: keyring
     device:  /dev/nvme0n1p1
     sector size:  512
     offset:  32768 sectors
     size:    20938752 sectors
     mode:    read/write

流程

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

   详情请参阅 Web 控制台的日志记录。

2. 点 Storage。
3. 在 Storage 表中，单击您要加密的存储设备旁边的菜单按钮 ⋮。
4. 从下拉菜单中选择 Format。
5. 在 Encryption field 中，选择加密规格 LUKS1 或 LUKS2。
6. 设置并确认您的新密码短语。
7. 可选：修改进一步加密选项。
8. 完成格式化设置。
9. 点 Format。

流程

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

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

2. 点 Storage
3. 在 Storage 表中，选择带有加密数据的磁盘。

4. 在磁盘页面中，滚动到 Keys 部分，然后点 edit 按钮。

   

5. 在更改密码短语对话框中：

   1. 输入您当前的密码短语。
   2. 输入您的新密码短语。

   3. 确认您的新密码短语。

      

6. 点 Save

流程

1. 将您的敏感变量存储在一个加密文件中：

   1. 创建 vault ：

      $ ansible-vault create vault.yml
      New Vault password: <vault_password>
      Confirm New Vault password: <vault_password>

   2. 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据：

      luks_password: <password>

   3. 保存更改，并关闭编辑器。Ansible 加密 vault 中的数据。

2. 创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ：

   ---
   - name: Manage local storage
     hosts: managed-node-01.example.com
     vars_files:
       - vault.yml
     tasks:
       - name: Create and configure a volume encrypted with LUKS
         ansible.builtin.include_role:
           name: rhel-system-roles.storage
         vars:
           storage_volumes:
             - name: barefs
               type: disk
               disks:
                 - sdb
               fs_type: xfs
               fs_label: <label>
               mount_point: /mnt/data
               encryption: true
               encryption_password: "{{ luks_password }}"

   有关 playbook 中使用的所有变量的详情，请查看控制节点上的 /usr/share/ansible/roles/rhel-system-roles.storage/README.md 文件。

3. 验证 playbook 语法：

   $ ansible-playbook --ask-vault-pass --syntax-check ~/playbook.yml

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

4. 运行 playbook：

   $ ansible-playbook --ask-vault-pass ~/playbook.yml

验证

1. 查找 LUKS 加密卷的 luksUUID 值：

   # ansible managed-node-01.example.com -m command -a 'cryptsetup luksUUID /dev/sdb'
   
   4e4e7970-1822-470e-b55a-e91efe5d0f5c

2. 查看卷的加密状态：

   # ansible managed-node-01.example.com -m command -a 'cryptsetup status luks-4e4e7970-1822-470e-b55a-e91efe5d0f5c'
   
   /dev/mapper/luks-4e4e7970-1822-470e-b55a-e91efe5d0f5c is active and is in use.
     type:    LUKS2
     cipher:  aes-xts-plain64
     keysize: 512 bits
     key location: keyring
     device:  /dev/sdb
   ...

3. 验证创建的 LUKS 加密的卷：

   # ansible managed-node-01.example.com -m command -a 'cryptsetup luksDump /dev/sdb'
   
   LUKS header information
   Version:        2
   Epoch:          3
   Metadata area:  16384 [bytes]
   Keyslots area:  16744448 [bytes]
   UUID:           4e4e7970-1822-470e-b55a-e91efe5d0f5c
   Label:          (no label)
   Subsystem:      (no subsystem)
   Flags:          (no flags)
   
   Data segments:
     0: crypt
           offset: 16777216 [bytes]
           length: (whole device)
           cipher: aes-xts-plain64
           sector: 512 [bytes]
   ...

流程

1. 要安装 tang 软件包及其依赖项，请以 root 用户身份输入以下命令：

   # yum install tang

2. 选择一个未被占用的端口，例如 7500/tcp，并允许 tangd 服务绑定到该端口：

   # semanage port -a -t tangd_port_t -p tcp 7500

   请注意，一个端口一次只能由一个服务使用，因此尝试使用已占用的端口会出现 ValueError: Port already defined 错误消息。

3. 在防火墙中打开端口：

   # firewall-cmd --add-port=7500/tcp
   # firewall-cmd --runtime-to-permanent

4. 启用 tangd 服务：

   # systemctl enable tangd.socket

5. 创建覆盖文件：

   # systemctl edit tangd.socket

6. 在以下编辑器屏幕中，其打开了位于 /etc/systemd/system/tangd.socket.d/ 目录中的一个空 override.conf 文件，通过添加以下行将 Tang 服务器的默认端口从 80 改为之前选择的端口号：

   [Socket]
   ListenStream=
   ListenStream=7500

   重要

   在以 # Anything between here和 # Lines below this 开头的行之间插入之前的代码片段，否则系统会丢弃您的更改。

7. 按 Ctrl+O ，并按 Enter 保存更改。按 Ctrl+X 退出编辑器。

8. 重新载入更改的配置：

   # systemctl daemon-reload

9. 检查您的配置是否正常工作：

   # systemctl show tangd.socket -p Listen
   Listen=[::]:7500 (Stream)

10. 启动 tangd 服务：

    # systemctl restart tangd.socket

    由于 tangd 使用了 systemd 套接字激活机制，因此服务器会在第一次连接进来时就立即启动。在第一次启动时会自动生成一组新的加密密钥。要执行手动生成密钥等加密操作，请使用 jose 工具。

流程

1. 重命名 /var/db/tang 密钥数据库目录中的所有密钥，使其前面有一个 .，将它们隐藏起来，以防被看到。请注意，以下示例中的文件名与 Tang 服务器的密钥数据库目录中的独特文件名不同：

   # cd /var/db/tang
   # ls -l
   -rw-r--r--. 1 root root 349 Feb  7 14:55 UV6dqXSwe1bRKG3KbJmdiR020hY.jwk
   -rw-r--r--. 1 root root 354 Feb  7 14:55 y9hxLTQSiSB5jSEGWnjhY8fDTJU.jwk
   # mv UV6dqXSwe1bRKG3KbJmdiR020hY.jwk .UV6dqXSwe1bRKG3KbJmdiR020hY.jwk
   # mv y9hxLTQSiSB5jSEGWnjhY8fDTJU.jwk .y9hxLTQSiSB5jSEGWnjhY8fDTJU.jwk

2. 检查是否重命名了，是否隐藏了 Tang 服务器中的所有密钥：

   # ls -l
   total 0

3. 使用 /usr/libexec/tangd-keygen 命令，在Tang 服务器上的 /var/db/tang 中生成新的密钥：

   # /usr/libexec/tangd-keygen /var/db/tang
   # ls /var/db/tang
   3ZWS6-cDrCG61UPJS2BMmPU4I54.jwk zyLuX6hijUy_PSeUEFDi7hi38.jwk

4. 检查您的 Tang 服务器是否可以显示新密钥对的签名密钥，例如：

   # tang-show-keys 7500
   3ZWS6-cDrCG61UPJS2BMmPU4I54

5. 在 NBDE 客户端上，使用 clevis luks report 命令检查 Tang 服务器显示的密钥是否保持不变。您可以使用 clevis luks list 命令识别带有相关绑定的插槽，例如：

   # clevis luks list -d /dev/sda2
   1: tang '{"url":"http://tang.srv"}'
   # clevis luks report -d /dev/sda2 -s 1
   ...
   Report detected that some keys were rotated.
   Do you want to regenerate luks metadata with "clevis luks regen -d /dev/sda2 -s 1"? [ynYN]

6. 要为新密钥重新生成 LUKS 元数据，在上一个命令提示时按 y，或使用 clevis luks regen 命令：

   # clevis luks regen -d /dev/sda2 -s 1

7. 当您确定所有旧客户端都使用新密钥时，您可以从 Tang 服务器中删除旧密钥，例如：

   # cd /var/db/tang
   # rm .*.jwk

流程

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

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

2. 切换到管理访问权限，提供您的凭据，然后单击 存储。在 Storage 表中，点包含您计划添加的加密卷的磁盘来自动解锁。

3. 在以下带有所选磁盘详情的页面中，点 Keys 部分中的 + 来添加 Tang 密钥：

   

4. 选择 Tang keyserver 作为 Key source，提供 Tang 服务器的地址，以及解锁 LUKS 加密的设备的密码。点击 Add 确认：

   

   以下对话框窗口提供了 命令，可用于验证密钥哈希是否匹配。

5. 在 Tang 服务器上的终端中，使用 tang-show-keys 命令来显示密钥哈希以进行比较。在本例中，Tang 服务器运行在端口 7500 上：

   # tang-show-keys 7500
   x100_1k6GPiDOaMlL3WbpCjHOy9ul1bSfdhI3M08wO0

6. 当 web 控制台中的密钥哈希与之前列出的命令的输出中的密钥哈希相同时，请点击 Trust key：

   
7. 在 RHEL 8.8 及更高版本中，选择加密的根文件系统和 Tang 服务器后，您可以跳过在内核命令行中添加 rd.neednet=1 参数，安装 clevis-dracut 软件包，以及重新生成一个初始 RAM 磁盘(initrd)。对于非 root 文件系统，web 控制台现在启用 remote-cryptsetup.target 和 clevis-luks-akspass.path systemd 单元，安装 clevis-systemd 软件包，并将 _netdev 参数添加到 fstab 和 crypttab 配置文件中。

验证

1. 检查新添加的 Tang 密钥现在是否在 Keys 部分使用 Keyserver 类型列出：

   

2. 验证绑定可用于早期引导，例如：

   # lsinitrd | grep clevis-luks
   lrwxrwxrwx   1 root     root           48 Jan  4 02:56 etc/systemd/system/cryptsetup.target.wants/clevis-luks-askpass.path -> /usr/lib/systemd/system/clevis-luks-askpass.path
   …

流程

1. 要自动解锁现有的 LUKS 加密卷，请安装 clevis-luks 子软件包：

   # yum install clevis-luks

2. 识别 PBD 的 LUKS 加密卷。在以下示例中，块设备是指 /dev/sda2 ：

   # lsblk
   NAME                                          MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINT
   sda                                             8:0    0    12G  0 disk
   ├─sda1                                          8:1    0     1G  0 part  /boot
   └─sda2                                          8:2    0    11G  0 part
     └─luks-40e20552-2ade-4954-9d56-565aa7994fb6 253:0    0    11G  0 crypt
       ├─rhel-root                               253:0    0   9.8G  0 lvm   /
       └─rhel-swap                               253:1    0   1.2G  0 lvm   [SWAP]

3. 使用 clevis luks bind 命令将卷绑定到 Tang 服务器：

   # clevis luks bind -d /dev/sda2 tang '{"url":"http://tang.srv"}'
   The advertisement contains the following signing keys:
   
   _OsIk0T-E2l6qjfdDiwVmidoZjA
   
   Do you wish to trust these keys? [ynYN] y
   You are about to initialize a LUKS device for metadata storage.
   Attempting to initialize it may result in data loss if data was
   already written into the LUKS header gap in a different format.
   A backup is advised before initialization is performed.
   
   Do you wish to initialize /dev/sda2? [yn] y
   Enter existing LUKS password:

   此命令执行四个步骤：

   1. 使用与 LUKS 主密钥相同的无序状态测量法创建新的密钥。
   2. 使用 Clevis 加密新密钥.
   3. 将 Clevis JWE 对象存储在 LUKS2 标头令牌中，或者使用 LUKSMeta（如果使用非默认的 LUKS1 标头）。
   4. 启用与 LUKS 一起使用的新密钥。
   注意

   绑定过程假定至少有一个可用的 LUKS 密码插槽。clevis luks bind 命令占用了其中一个插槽。

   现在可以使用您的现有密码和 Clevis 策略来解锁卷。

4. 要启用早期引导系统来处理磁盘绑定，请在已安装的系统上使用 dracut 工具。在 RHEL 中，Clevis 生成一个没有特定于主机配置选项的通用 initrd（初始 RAM 磁盘），没有向内核命令行自动添加 rd.neednet=1 等参数。如果您的配置依赖于在早期引导期间需要网络的 Tang pin ，请在检测到 Tang 绑定时使用 --hostonly-cmdline 参数和 dracut add rd.neednet=1 ：

   1. 安装 clevis-dracut 软件包：

      # yum install clevis-dracut

   2. 重新生成初始 RAM 磁盘：

      # dracut -fv --regenerate-all --hostonly-cmdline

   3. 或者，在 /etc/dracut.conf.d/ 目录中创建 .conf 文件，并将 hostonly_cmdline=yes 选项添加到该文件中。然后，您可以使用 without -hostonly-cmdline 的 dracut，例如：

      # echo "hostonly_cmdline=yes" > /etc/dracut.conf.d/clevis.conf
      # dracut -fv --regenerate-all

   4. 您还可以通过使用安装了 Clevis 的系统上的 grubby 工具，确保在早期引导时 Tang pin 的网络可用：

      # grubby --update-kernel=ALL --args="rd.neednet=1"

验证

1. 验证 Clevis JWE 对象是否已成功放入 LUKS 标头中，使用 clevis luks list 命令：

   # clevis luks list -d /dev/sda2
   1: tang '{"url":"http://tang.srv:port"}'

2. 检查绑定是否在早期引导时可用，例如：

   # lsinitrd | grep clevis-luks
   lrwxrwxrwx   1 root     root           48 Jan  4 02:56 etc/systemd/system/cryptsetup.target.wants/clevis-luks-askpass.path -> /usr/lib/systemd/system/clevis-luks-askpass.path
   …

流程

1. 您可以在 dracut 命令中提供静态网络配置作为 kernel-cmdline 选项的值，例如：

   # dracut -fv --regenerate-all --kernel-cmdline "ip=192.0.2.10::192.0.2.1:255.255.255.0::ens3:none nameserver=192.0.2.100"

2. 或者，在 /etc/dracut.conf.d/ 目录中创建带有静态网络信息的 .conf 文件，然后重新生成初始 RAM 磁盘镜像：

   # cat /etc/dracut.conf.d/static_ip.conf
   kernel_cmdline="ip=192.0.2.10::192.0.2.1:255.255.255.0::ens3:none nameserver=192.0.2.100"
   # dracut -fv --regenerate-all

流程

1. 要自动解锁现有的 LUKS 加密卷，请安装 clevis-luks 子软件包：

   # yum install clevis-luks

2. 识别 PBD 的 LUKS 加密卷。在以下示例中，块设备是指 /dev/sda2 ：

   # lsblk
   NAME                                          MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINT
   sda                                             8:0    0    12G  0 disk
   ├─sda1                                          8:1    0     1G  0 part  /boot
   └─sda2                                          8:2    0    11G  0 part
     └─luks-40e20552-2ade-4954-9d56-565aa7994fb6 253:0    0    11G  0 crypt
       ├─rhel-root                               253:0    0   9.8G  0 lvm   /
       └─rhel-swap                               253:1    0   1.2G  0 lvm   [SWAP]

3. 使用 clevis luks bind 命令将卷绑定到 TPM 2.0 设备，例如：

   # clevis luks bind -d /dev/sda2 tpm2 '{"hash":"sha256","key":"rsa"}'
   ...
   Do you wish to initialize /dev/sda2? [yn] y
   Enter existing LUKS password:

   此命令执行四个步骤：

   1. 使用与 LUKS 主密钥相同的无序状态测量法创建新的密钥。
   2. 使用 Clevis 加密新密钥.
   3. 将 Clevis JWE 对象存储在 LUKS2 标头令牌中，或者使用 LUKSMeta（如果使用非默认的 LUKS1 标头）。

   4. 启用与 LUKS 一起使用的新密钥。

      注意

      绑定过程假定至少有一个可用的 LUKS 密码插槽。clevis luks bind 命令占用了其中一个插槽。

      或者，如果您要将数据封装为特定的平台配置寄存器(PCR)状态，请在 clevis luks bind 命令中添加 pcr_bank 和 pcr_ids 值，例如：

      # clevis luks bind -d /dev/sda2 tpm2 '{"hash":"sha256","key":"rsa","pcr_bank":"sha256","pcr_ids":"0,1"}'

      重要

      由于只有 PCR 哈希值与密封时使用的策略匹配，并且可以重写哈希时，数据才会被解封，因此添加一个强大的密码短语，以便您可以在 PCR 中的值变化时手动解锁加密的卷。

      如果在升级 shim-x64 软件包后系统无法自动解锁加密的卷，请遵照 重启后，Clevis TPM2 不再解密 LUKS 设备 KCS 文章中的步骤进行操作。

4. 现在可以使用您的现有密码和 Clevis 策略来解锁卷。

5. 要启用早期引导系统来处理磁盘绑定，请在已安装的系统上使用 dracut 工具：

   # yum install clevis-dracut
   # dracut -fv --regenerate-all

验证

1. 要验证 Clevis JWE 对象是否已成功放入 LUKS 标头中，请使用 clevis luks list 命令：

   # clevis luks list -d /dev/sda2
   1: tpm2 '{"hash":"sha256","key":"rsa"}'

流程

1. 检查卷（如 /dev/sda2） 是使用哪个 LUKS 版本加密的，并标识绑定到 Clevis 的插槽和令牌：

   # cryptsetup luksDump /dev/sda2
   LUKS header information
   Version:        2
   ...
   Keyslots:
     0: luks2
   ...
   1: luks2
         Key:        512 bits
         Priority:   normal
         Cipher:     aes-xts-plain64
   ...
         Tokens:
           0: clevis
                 Keyslot:  1
   ...

   在上例中，Clevis 令牌标识为 0 ，关联的密钥插槽是 1。

2. 如果是 LUKS2 加密，请删除令牌：

   # cryptsetup token remove --token-id 0 /dev/sda2

3. 如果您的设备是由 LUKS1 加密的，其在 cryptsetup luksDump 命令的输出中标识为 Version: 1 字符串，请使用 luksmeta wipe 命令执行这个额外步骤：

   # luksmeta wipe -d /dev/sda2 -s 1

4. 擦除包含 Clevis 密码短语的密钥插槽：

   # cryptsetup luksKillSlot /dev/sda2 1

流程

1. 指示 Kickstart 对磁盘进行分区，以便使用临时密码为所有挂载点（除 /boot ）启用了 LUKS 加密。注册过程的这一步中的密码是临时密码。

   part /boot --fstype="xfs" --ondisk=vda --size=256
   part / --fstype="xfs" --ondisk=vda --grow --encrypted --passphrase=temppass

   请注意，兼容 OSPP 的系统需要更复杂的配置，例如：

   part /boot --fstype="xfs" --ondisk=vda --size=256
   part / --fstype="xfs" --ondisk=vda --size=2048 --encrypted --passphrase=temppass
   part /var --fstype="xfs" --ondisk=vda --size=1024 --encrypted --passphrase=temppass
   part /tmp --fstype="xfs" --ondisk=vda --size=1024 --encrypted --passphrase=temppass
   part /home --fstype="xfs" --ondisk=vda --size=2048 --grow --encrypted --passphrase=temppass
   part /var/log --fstype="xfs" --ondisk=vda --size=1024 --encrypted --passphrase=temppass
   part /var/log/audit --fstype="xfs" --ondisk=vda --size=1024 --encrypted --passphrase=temppass

2. 通过在 %packages 部分中列出它们来安装相关的 Clevis 软件包：

   %packages
   clevis-dracut
   clevis-luks
   clevis-systemd
   %end

3. 可选： 要确保您可以根据需要手动解锁加密的卷，请在删除临时密码短语前添加更强大的密码短语。如需更多信息，请参阅 如何给现有 LUKS 设备添加密语、密钥或 keyfile 的文章。

4. 在 %post 部分中调用 clevis luks bind 来执行绑定。之后，删除临时密码：

   %post
   clevis luks bind -y -k - -d /dev/vda2 \
   tang '{"url":"http://tang.srv"}' <<< "temppass"
   cryptsetup luksRemoveKey /dev/vda2 <<< "temppass"
   dracut -fv --regenerate-all
   %end

   如果您的配置依赖于在早期引导过程中需要网络的 Tang pin，或者使用带有静态 IP 配置的 NBDE 客户端，那么您必须修改dracut 命令，如 配置 LUKS 加密卷的手动注册 中所述。

   请注意，RHEL 8.3 提供了 clevis luks bind 命令的 -y 选项。在 RHEL 8.2 及更旧版本中，在 clevis luks bind 命令中将 -y 替换为 -f，并从 Tang 服务器下载公告：

   %post
   curl -sfg http://tang.srv/adv -o adv.jws
   clevis luks bind -f -k - -d /dev/vda2 \
   tang '{"url":"http://tang.srv","adv":"adv.jws"}' <<< "temppass"
   cryptsetup luksRemoveKey /dev/vda2 <<< "temppass"
   dracut -fv --regenerate-all
   %end

   警告

   cryptsetup luksRemoveKey 命令可以防止对应用该命令的 LUKS2 设备进行任何进一步的管理。您只能对 LUKS1 设备使用 dmsetup 命令恢复删除的主密钥。

流程

1. 要自动解锁 LUKS 加密的可移动存储设备，如 USB 驱动器，请安装 clevis-udisks2 软件包：

   # yum install clevis-udisks2

2. 重启系统，然后使用 clevis luks bind 命令执行绑定步骤，如 配置 LUKS 加密卷的手动注册 中所述，例如：

   # clevis luks bind -d /dev/sdb1 tang '{"url":"http://tang.srv"}'

3. 现在，可以在 GNOME 桌面会话中自动解锁 LUKS 加密的可移动设备。绑定到 Clevis 策略的设备也可以通过 clevis luks unlock 命令解锁：

   # clevis luks unlock -d /dev/sdb1

流程

1. 从 registry.redhat.io 注册中心中拉取 tang 容器镜像：

   # podman pull registry.redhat.io/rhel8/tang

2. 运行容器，指定其端口，并指定到 Tang 密钥的路径。前面的示例运行 tang 容器，指定端口 7500，并指示到 /var/db/tang 目录的 Tang 密钥的路径：

   # podman run -d -p 7500:7500 -v tang-keys:/var/db/tang --name tang registry.redhat.io/rhel8/tang

   请注意，Tang 默认使用端口 80，但这可能与其他服务冲突，如 Apache HTTP 服务器。

3. 可选：为了提高安全性，请定期轮转 Tang 密钥。您可以使用 tangd-rotate-keys 脚本，例如：

   # podman run --rm -v tang-keys:/var/db/tang registry.redhat.io/rhel8/tang tangd-rotate-keys -v -d /var/db/tang
   Rotated key 'rZAMKAseaXBe0rcKXL1hCCIq-DY.jwk' -> .'rZAMKAseaXBe0rcKXL1hCCIq-DY.jwk'
   Rotated key 'x1AIpc6WmnCU-CabD8_4q18vDuw.jwk' -> .'x1AIpc6WmnCU-CabD8_4q18vDuw.jwk'
   Created new key GrMMX_WfdqomIU_4RyjpcdlXb0E.jwk
   Created new key _dTTfn17sZZqVAp80u3ygFDHtjk.jwk
   Keys rotated successfully.

文件系统规则示例

1. 要定义一条规则，记录对 /etc/passwd 文件的所有写访问和每个属性的修改：

   # auditctl -w /etc/passwd -p wa -k passwd_changes

2. 要定义一条规则，记录对 /etc/selinux/ 目录中所有文件的写访问和每个属性的修改：

   # auditctl -w /etc/selinux/ -p wa -k selinux_changes

系统调用规则示例

1. 要定义一条规则，当程序每次使用 adjtimex 或 settimeofday 系统调用时就创建一条日志，系统使用 64 位构架：

   # auditctl -a always,exit -F arch=b64 -S adjtimex -S settimeofday -k time_change

2. 定义一条规则，在 ID 为 1000 或以上的系统用户每次删除或重命名文件时创建一条日志：

   # auditctl -a always,exit -S unlink -S unlinkat -S rename -S renameat -F auid>=1000 -F auid!=4294967295 -k delete

   请注意，-F auid!=4294967295 选项用于排除未设置登录 UID 的用户。