流程

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

流程

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

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

流程

1. 登录到 web 控制台。如需更多信息，请参阅 Web 控制台的日志记录。

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

   

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

   

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

流程

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. 签出到 /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.yml 文件：

   ---
   - hosts: all
     tasks:
     - name: Configure crypto policies
       include_role:
         name: rhel-system-roles.crypto_policies
       vars:
         - crypto_policies_policy: FUTURE
         - crypto_policies_reboot_ok: true

   您可以将 FUTURE 值替换为您喜欢的加密策略，例如：DEFAULT、 LEGACY 和 FIPS:OSPP。

   crypto_policies_reboot_ok: true 变量会导致系统在系统角色更改加密策略后重启系统。

   如需了解更多详细信息，请参阅 crypto_policies 系统角色变量和事实。

2. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file playbook.yml

验证

1. 在控制节点上，创建另一个 playbook，例如,名为 verify_playbook.yml:

   - hosts: all
     tasks:
    - name: Verify active crypto policy
      include_role:
        name: rhel-system-roles.crypto_policies
   
    - debug:
        var: crypto_policies_active

   此 playbook 不更改系统上的任何配置，只报告受管节点上的活动策略。

2. 运行同一个清单文件上的 playbook:

   # ansible-playbook -i inventory_file 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
   $ ssh-keygen -D pkcs11:
   ssh-rsa AAAAB3NzaC1yc2E...KKZMzcQZzx pkcs11:id=%02;object=SIGN%20pubkey;token=SSH%20key;manufacturer=piv_II?module-path=/usr/lib64/pkcs11/opensc-pkcs11.so
   ecdsa-sha2-nistp256 AAA...J0hkYnnsM= pkcs11:id=%01;object=PIV%20AUTH%20pubkey;token=SSH%20key;manufacturer=piv_II?module-path=/usr/lib64/pkcs11/opensc-pkcs11.so

2. 要使用远程服务器上的智能卡（example.com）启用验证，将公钥传送到远程服务器。使用带有上一步中创建的 key.pub 的 ssh-copy-id 命令：

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

3. 要使用在第 1 步的 ssh-keygen -D 命令输出中的 ECDSA 密钥连接到 example.com，您只能使用 URI 中的一个子集，它是您的密钥的唯一参考，例如：

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

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

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

   因为 OpenSSH 使用 p11-kit-proxy wrapper 和 OpenSC PKCS #11 模块注册到 PKCS#11 Kit，所以您可以简化前面的命令：

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

流程

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 hipaa --remediate /usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml

2. 重启您的系统。

验证

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

   $ oscap xccdf eval --report hipaa_report.html --profile hipaa /usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml

流程

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

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

2. 重新启动系统。

验证

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

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

流程

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，例如：

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

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

   # oscap-podman 096cae65a207 xccdf eval --report report.html --profile hipaa /usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml

   如果要评估符合 OSPP 或 PCI-DSS 基准的安全合规性，请用您容器镜像的 ID 替换 096cae65a207，用 ospp 或 pci-dss 替换 hipaa 。请注意，oscap-podman 命令需要 root 权限。

流程

1. 安装 aide 软件包：

   # yum install aide

2. 生成初始数据库：

   # aide --init

   注意

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

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

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

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

流程

1. 启动手动检查：

   # aide --check
   Start timestamp: 2018-07-11 12:41:20 +0200 (AIDE 0.16)
   AIDE found differences between database and filesystem!!
   ...
   [trimmed for clarity]

2. 至少，将系统配置为每周运行 AIDE。最好地，每天运行 AIDE。例如，要使用 cron 命令计划在每天早上 04:05 执行 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

3. 另外，还可列出指定用户密钥环中的所有密钥：

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

流程

1. 在 修复 模式下为当前引导条目启用 IMA 和 EVM，并通过添加以下内核命令行参数来允许用户收集和更新 IMA 测量：

   # grubby --update-kernel=/boot/vmlinuz-$(uname -r) --args="ima_policy=appraise_tcb ima_appraise=fix evm=fix"

   该命令在 fix 模式下为当前引导条目启用 IMA 和 EVM，并允许用户收集和更新 IMA 测量。

   ima_policy=appraise_tcb 内核命令行参数确保内核使用默认的可信计算基础(TCB)测量策略和 appraisal 步骤。评估步骤禁止访问之前和当前测量结果不匹配的文件。

2. 重启以使更改生效。

3. 可选：验证参数是否已添加到内核命令行中：

   # cat /proc/cmdline
   BOOT_IMAGE=(hd0,msdos1)/vmlinuz-4.18.0-167.el8.x86_64 root=/dev/mapper/rhel-root ro crashkernel=auto resume=/dev/mapper/rhel-swap rd.lvm.lv=rhel/root rd.lvm.lv=rhel/swap rhgb quiet ima_policy=appraise_tcb ima_appraise=fix evm=fix

4. 创建一个内核主密钥来保护 EVM 密钥：

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

   kmk 完全保留在内核空间内存中。kmk 的 32 字节长值是从 /dev/urandom 文件中的随机字节生成的，并放在用户(@u)密钥环中。密钥序列号位于前面输出的第一行。

5. 根据 kmk 创建加密的 EVM 密钥：

   # keyctl add encrypted evm-key "new user:kmk 64" @u
   641780271

   命令使用 kmk 生成并加密 64 字节长用户密钥（名为 evm-key），并将其放在用户(@u)密钥环中。密钥序列号位于前面输出的第一行。

   重要

   用户密钥必须命名为 evm-key，因为它是 EVM 子系统预期使用的且正在使用的名称。

6. 为导出的密钥创建一个目录。

   # mkdir -p /etc/keys/

7. 搜索 kmk ，并将其未加密的值导出到新目录中。

   # keyctl pipe $(keyctl search @u user kmk) > /etc/keys/kmk

8. 搜索 evm-key ，并将其加密值导出到新目录中。

   # keyctl pipe $(keyctl search @u encrypted evm-key) > /etc/keys/evm-key

   evm-key 已在早期由内核主密钥加密。

9. 可选：查看新创建的密钥。

   # keyctl show
   Session Keyring
   974575405   --alswrv     0        0      keyring: ses 299489774 --alswrv 0 65534 \ keyring: uid.0 748544121 --alswrv 0 0 \ user: kmk
   641780271   --alswrv     0        0           \_ encrypted: evm-key
   
   # ls -l /etc/keys/
   total 8
   -rw-r--r--. 1 root root 246 Jun 24 12:44 evm-key
   -rw-r--r--. 1 root root  32 Jun 24 12:43 kmk

10. 可选：如果密钥已从密钥环中删除，例如在系统重启后，您可以导入已导出的 kmk 和 evm-key，而不是创建新密钥。

    1. 导入 kmk。

       # keyctl add user kmk "$(cat /etc/keys/kmk)" @u
       451342217

    2. 导入 evm-key。

       # keyctl add encrypted evm-key "load $(cat /etc/keys/evm-key)" @u
       924537557

11. 激活 EVM。

    # echo 1 > /sys/kernel/security/evm

12. 重新标记整个系统。

    # find / -fstype xfs -type f -uid 0 -exec head -n 1 '{}' >/dev/null \;

    警告

    在不重新标记系统的情况下启用 IMA 和 EVM 可能会导致系统上的大多数文件无法访问。

流程

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. 使用以下内容创建新 playbook.yml 文件：

   - hosts: all
     vars:
       storage_volumes:
         - name: barefs
           type: disk
           disks:
            - sdb
           fs_type: xfs
           fs_label: label-name
           mount_point: /mnt/data
           encryption: true
           encryption_password: your-password
     roles:
      - rhel-system-roles.storage

   您还可以在 playbook.yml 文件中添加其他加密参数，如encryption_key、encryption_cipher、encryption_key_size 和 encryption_luks 版本。

2. 可选：验证 playbook 语法：

   # ansible-playbook --syntax-check playbook.yml

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

验证

1. 查看加密状态：

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

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

   # cryptsetup luksDump /dev/sdb
   
   Version:       	2
   Epoch:         	6
   Metadata area: 	16384 [bytes]
   Keyslots area: 	33521664 [bytes]
   UUID:          	a4c6be82-7347-4a91-a8ad-9479b72c9426
   Label:         	(no label)
   Subsystem:     	(no subsystem)
   Flags:       	allow-discards
   
   Data segments:
     0: crypt
   	offset: 33554432 [bytes]
   	length: (whole device)
   	cipher: aes-xts-plain64
   	sector: 4096 [bytes]
   [...]

3. 查看 playbook.yml 文件中的 cryptsetup 参数，其被 storage 角色支持：

   # cat ~/playbook.yml
   
       - hosts: all
         vars:
           storage_volumes:
             - name: foo
               type: disk
               disks:
                - nvme0n1
               fs_type: xfs
               fs_label: label-name
               mount_point: /mnt/data
               encryption: true
               #encryption_password: passwdpasswd
               encryption_key: /home/passwd_key
               encryption_cipher: aes-xts-plain64
               encryption_key_size: 512
               encryption_luks_version: luks2
   
         roles:
          - rhel-system-roles.storage

流程

1. 在带有加密卷的系统上安装 Clevis 及其 pins：

   # yum install clevis

2. 要解密数据，请使用 clevis decrypt 命令，并提供 JSON Web 加密(JWE)格式的密码文本，例如：

   $ clevis decrypt < secret.jwe

流程

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. 在 web 浏览器中输入以下地址来打开 RHEL web 控制台：

   https://<localhost>:9090

   连接到远程系统时，将 <localhost> 部分替换为远程服务器的主机名或 IP 地址。

2. 提供您的凭证并点击 Storage。在 Filesystems 部分中，点包含您计划添加的加密的卷的磁盘来自动解锁。
3. 在以下列出了所选磁盘的分区和驱动器详情的窗口中，点加密的文件系统旁的 > 来扩展您要使用 Tang 服务器解锁的加密卷的详情，然后点 Encryption。

4. 点击 Keys 部分中的 + 来添加 Tang 键：

   

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

   

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

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

   # tang-show-keys 7500
   fM-EwYeiTxS66X3s1UAywsGKGnxnpll8ig0KOQmr9CM

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

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

验证

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

   

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

   # lsinitrd | grep clevis
   clevis
   clevis-pin-null
   clevis-pin-sss
   clevis-pin-tang
   clevis-pin-tpm2
   lrwxrwxrwx   1 root     root           48 Feb 14 17:45 etc/systemd/system/cryptsetup.target.wants/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 工具：

   # yum install clevis-dracut

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

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

   或者，在 /etc/dracut.conf.d/ 中创建一个 .conf 文件，并将 hostonly_cmdline=yes 选项添加到该文件中，例如：

   # echo "hostonly_cmdline=yes" > /etc/dracut.conf.d/clevis.conf

   注意

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

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

   然后您可以使用不带 --hostonly-cmdline 的 dracut ：

   # dracut -fv --regenerate-all

验证

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

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

流程

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. 准备包含 Tang 服务器设置的 playbook。您可以从头开始，或使用 /usr/share/ansible/roles/rhel-system-roles.nbde_server/examples/ 目录中的一个 playbook 示例。

   # cp /usr/share/ansible/roles/rhel-system-roles.nbde_server/examples/simple_deploy.yml ./my-tang-playbook.yml

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

   # vi my-tang-playbook.yml

3. 添加所需参数。以下 playbook 示例确保部署 Tang 服务器和密钥轮转：

   ---
   - hosts: all
   
     vars:
       nbde_server_rotate_keys: yes
       nbde_server_manage_firewall: true
       nbde_server_manage_selinux: true
   
     roles:
       - rhel-system-roles.nbde_server

   注意

   因为 nbde_server_manage_firewall 和 nbde_server_manage_selinux 都被设为 true，所以 nbde_server 角色使用 firewall 和 selinux 角色来管理 nbde_server 角色使用的端口。

4. 应用完成的 playbook:

   # ansible-playbook -i inventory-file my-tang-playbook.yml

   其中：* inventory-file 是清单文件。* logging-playbook.yml 是您使用的 playbook。

流程

1. 准备包含 Clevis 客户端设置的 playbook。您可以从头开始，或使用 /usr/share/ansible/roles/rhel-system-roles.nbde_client/examples/ 目录中的一个 playbook 示例。

   # cp /usr/share/ansible/roles/rhel-system-roles.nbde_client/examples/high_availability.yml ./my-clevis-playbook.yml

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

   # vi my-clevis-playbook.yml

3. 添加所需参数。以下 playbook 示例配置 Clevis 客户端，以便在两个 Tang 服务器中至少有一个可用时自动解锁两个 LUKS 加密卷：

   ---
   - hosts: all
   
     vars:
       nbde_client_bindings:
         - device: /dev/rhel/root
           encryption_key_src: /etc/luks/keyfile
           servers:
             - http://server1.example.com
             - http://server2.example.com
         - device: /dev/rhel/swap
           encryption_key_src: /etc/luks/keyfile
           servers:
             - http://server1.example.com
             - http://server2.example.com
   
     roles:
       - rhel-system-roles.nbde_client

4. 应用完成的 playbook:

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

文件系统规则示例

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 的用户。

流程

1. 将 /usr/lib/systemd/system/auditd.service 文件复制到 /etc/systemd/system/ 目录中：

   # cp -f /usr/lib/systemd/system/auditd.service /etc/systemd/system/

2. 在您选择的文本编辑器中编辑 /etc/systemd/system/auditd.service 文件，例如：

   # vi /etc/systemd/system/auditd.service

3. 注释掉包含 augenrules 的行，将包含 auditctl -R 命令的行取消注释：

   #ExecStartPost=-/sbin/augenrules --load
   ExecStartPost=-/sbin/auditctl -R /etc/audit/audit.rules

4. 重新载入 systemd 守护进程以获取 auditd.service 文件中的修改：

   # systemctl daemon-reload

5. 重启 auditd 服务：

   # service auditd restart

流程

1. 在 RHEL 8.6 及更高版本中，将 /usr/share/audit/sample-rules/ 目录中的预配置的规则文件 44-installers.rules 复制到 /etc/audit/rules.d/ 目录中：

   # cp /usr/share/audit/sample-rules/44-installers.rules /etc/audit/rules.d/

   在 RHEL 8.5 及更早版本中，在 /etc/audit/rules.d/ 目录中创建一个名为 44-installers.rules 的新文件，并插入以下规则：

   -a always,exit -F perm=x -F path=/usr/bin/dnf-3 -F key=software-installer
   -a always,exit -F perm=x -F path=/usr/bin/yum -F

   您可以使用相同的语法为安装软件的其他工具，如 pip 和 npm 添加额外的规则。

2. 加载审计规则：

   # augenrules --load

验证