步骤

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. 将 SHA1 子策略应用到 DEFAULT 加密策略：

   # update-crypto-policies --set DEFAULT:SHA1
   Setting system policy to DEFAULT:SHA1
   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.

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 文件，如包含以下内容的 ~/crypto-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 ~/crypto-playbook.yml --syntax-check

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

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

   # ansible-playbook ~/crypto-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 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 包装器，并且 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-rhel9-ds.xml

2. 重启您的系统。

验证

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

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

流程

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

   # ansible-playbook -i localhost, -c local /usr/share/scap-security-guide/ansible/rhel9-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-rhel9-ds.xml

步骤

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

   # oscap xccdf eval --profile hipaa --results <hipaa-results.xml> /usr/share/xml/scap/ssg/content/ssg-rhel9-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-rhel9-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/RHEL9/rhel-9.oval.xml.bz2 | bzip2 --decompress > rhel-9.oval.xml

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

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

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

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

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

流程

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

   # podman images
   REPOSITORY                            TAG      IMAGE ID       CREATED       SIZE
   registry.access.redhat.com/ubi9/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-rhel9-ds.xml

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

流程

1. 安装 Keylime 验证器：

   # dnf install keylime-verifier

2. 通过在 /etc/keylime/verifier.conf.d/ 目录中创建一个新的 .conf 文件来定义验证器的 IP 地址和端口，例如：/etc/keylime/verifier.conf.d/00-verifier-ip.conf，其内容如下：

   [verifier]
   ip = <verifier_IP_address>

   • 将 <verifier_IP_address> 替换为验证器的 IP 地址。或者，使用 ip = * 或 ip = 0.0.0.0 将验证器绑定到所有可用 IP 地址。
   • 另外，您还可以使用 port 选项更改验证器的端口默认值 8881 。

3. 可选：为代理列表配置 verifier 的数据库。默认配置使用验证器的 /var/lib/keylime/cv_data.sqlite/ 目录中的 SQLite 数据库。您可以通过在 /etc/keylime/verifier.conf.d/ 目录中创建一个新的 .conf 文件来定义一个不同的数据库，例如：/etc/keylime/verifier.conf.d/00-db-url.conf，其内容如下：

   [verifier]
   database_url = <protocol>://<name>:<password>@<ip_address_or_hostname>/<properties>

   将 <protocol>://<name>:<password>@<ip_address_or_hostname>/<properties> 替换为数据库的 URL，如 postgresql://verifier:UQ?nRNY9g7GZzN7@198.51.100.1/verifierdb。

   确保您使用的凭证为 Keylime 提供了权限，来创建数据库结构。

4. 将证书和密钥添加到验证器（verifier）中。您可以让 Keylime 生成它们，或使用现有的密钥和证书生成它们：

   • 使用默认 tls_dir = generate 选项，Keylime 在 /var/lib/keylime/cv_ca/ 目录中为验证器、注册器和租户生成新证书。

   • 要在配置中加载现有的密钥和证书，请在验证器配置中定义其位置。

     注意

     证书必须可以被运行 Keylime 服务的 keylime 用户访问。

     在 /etc/keylime/verifier.conf.d/ 目录中创建一个新的 .conf 文件，例如： /etc/keylime/verifier.conf.d/00-keys-and-certs.conf，其内容如下：

     [verifier]
     tls_dir = /var/lib/keylime/cv_ca
     server_key = </path/to/server_key>
     server_key_password = <passphrase1>
     server_cert = </path/to/server_cert>
     trusted_client_ca = ['</path/to/ca/cert1>', '</path/to/ca/cert2>']
     client_key = </path/to/client_key>
     client_key_password = <passphrase2>
     client_cert = </path/to/client_cert>
     trusted_server_ca = ['</path/to/ca/cert3>', '</path/to/ca/cert4>']

     注意

     使用绝对路径定义密钥和证书位置。或者，相对路径是从 tls_dir 选项中定义的目录解析的。

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

   # firewall-cmd --add-port 8881/tcp
   # firewall-cmd --runtime-to-permanent

   如果您使用其他端口，请将 8881 替换为 .conf 文件中定义的端口号。

6. 启动验证器（verifier）服务：

   # systemctl enable --now keylime_verifier

   注意

   在默认配置中，在启动 keylime_registrar 服务前启动 keylime_verifier，因为验证器会为其他 Keylime 组件创建 CA 和证书。使用自定义证书时不需要这个顺序。

流程

1. 安装 Keylime 注册器：

   # dnf install keylime-registrar

2. 通过在 /etc/keylime/registrar.conf.d/ 目录中创建一个新的 .conf 文件来定义注册中心的 IP 地址和端口，例如：/etc/keylime/registrar.conf.d/00-registrar-ip.conf，其内容如下：

   [registrar]
   ip = <registrar_IP_address>

   • 将 <registrar_IP_address> 替换为注册中心的 IP 地址。或者，使用 ip = * 或 ip = 0.0.0.0 将注册器绑定到所有可用 IP 地址。
   • 可选，使用 port 选项更改 Keylime 代理连接的端口。默认值为 8890。
   • 可选，使用 tls_port 选项更改 Keylime 验证器和租户连接的 TLS 端口。默认值为 8891。

3. 可选：为代理列表配置注册数据库。默认配置使用 registrar 的 /var/lib/keylime/reg_data.sqlite 目录中的 SQLite 数据库。您可以在 /etc/keylime/registrar.conf.d/ 目录中创建一个新的 .conf 文件，例如： /etc/keylime/registrar.conf.d/00-db-url.conf，其内容如下：

   [registrar]
   database_url = <protocol>://<name>:<password>@<ip_address_or_hostname>/<properties>

   将 <protocol>://<name>:<password>@<ip_address_or_hostname>/<properties> 替换为数据库的 URL，如 postgresql://registrar:EKYX-bqY2?#raXm@198.51.100.1/registrardb。

   确保您使用的凭证对 Keylime 有权限，以创建数据库结构。

4. 在注册器中添加证书和密钥：

   • 您可以使用默认配置，并将密钥和证书加载到 /var/lib/keylime/reg_ca/ 目录中。

   • 或者，您可以在配置中定义密钥和证书的位置。在 /etc/keylime/registrar.conf.d/ 目录中创建一个新的 .conf 文件，例如： /etc/keylime/registrar.conf.d/00-keys-and-certs.conf，其内容如下：

     [registrar]
     tls_dir = /var/lib/keylime/reg_ca
     server_key = </path/to/server_key>
     server_key_password = <passphrase1>
     server_cert = </path/to/server_cert>
     trusted_client_ca = ['</path/to/ca/cert1>', '</path/to/ca/cert2>']

     注意

     使用绝对路径定义密钥和证书位置。或者，您可以在 tls_dir 选项中定义目录，并使用相对于该目录的路径。

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

   # firewall-cmd --add-port 8890/tcp --add-port 8891/tcp
   # firewall-cmd --runtime-to-permanent

   如果您使用其他端口，请将 8890 或 8891 替换为 .conf 文件中定义的端口号。

6. 启动 keylime_registrar 服务：

   # systemctl enable --now keylime_registrar

   注意

   在默认配置中，在启动 keylime_registrar 服务前启动 keylime_verifier，因为验证器会为其他 Keylime 组件创建 CA 和证书。使用自定义证书时不需要这个顺序。

流程

1. 创建定义所需角色的 playbook:

   1. 创建新 YAML 文件，并在文本编辑器中打开，例如：

      # vi keylime-playbook.yml

   2. 插入以下内容：

      ---
      - name: Manage keylime servers
        hosts: all
        vars:
          keylime_server_verifier_ip: "{{ ansible_host }}"
          keylime_server_registrar_ip: "{{ ansible_host }}"
          keylime_server_verifier_tls_dir: <ver_tls_directory>
          keylime_server_verifier_server_cert: <ver_server_certfile>
          keylime_server_verifier_server_key: <ver_server_key>
          keylime_server_verifier_server_key_passphrase: <ver_server_key_passphrase>
          keylime_server_verifier_trusted_client_ca: <ver_trusted_client_ca_list>
          keylime_server_verifier_client_cert: <ver_client_certfile>
          keylime_server_verifier_client_key: <ver_client_key>
          keylime_server_verifier_client_key_passphrase: <ver_client_key_passphrase>
          keylime_server_verifier_trusted_server_ca: <ver_trusted_server_ca_list>
          keylime_server_registrar_tls_dir: <reg_tls_directory>
          keylime_server_registrar_server_cert: <reg_server_certfile>
          keylime_server_registrar_server_key: <reg_server_key>
          keylime_server_registrar_server_key_passphrase: <reg_server_key_passphrase>
          keylime_server_registrar_trusted_client_ca: <reg_trusted_client_ca_list>
        roles:
          - rhel-system-roles.keylime_server

      您可以在 keylime_server RHEL 系统角色的变量 中找到更多变量。

2. 运行 playbook：

   $ ansible-playbook <keylime-playbook.yml>

验证

1. 检查 keylime_verifier 服务是否活跃并在受管主机上运行：

   # systemctl status keylime_verifier
   ● keylime_verifier.service - The Keylime verifier
        Loaded: loaded (/usr/lib/systemd/system/keylime_verifier.service; disabled; vendor preset: disabled)
        Active: active (running) since Wed 2022-11-09 10:10:08 EST; 1min 45s ago

2. 检查 keylime_registrar 服务是否活跃且在运行：

   # systemctl status keylime_registrar
   ● keylime_registrar.service - The Keylime registrar service
        Loaded: loaded (/usr/lib/systemd/system/keylime_registrar.service; disabled; vendor preset: disabled)
        Active: active (running) since Wed 2022-11-09 10:10:17 EST; 1min 42s ago
   ...

流程

1. 安装 Keylime 租户：

   # dnf install keylime-tenant

2. 通过编辑 /etc/keylime/tenant.conf.d/00-verifier-ip.conf 文件将租户的连接定义到 Keylime 验证器的连接：

   [tenant]
   verifier_ip = <verifier_ip>

   • 将 <verifier_ip> 替换为验证器系统的 IP 地址。
   • 如果验证器使用与默认值 8881 不同的端口，请添加 verifier_port = <verifier_port> 设置。

3. 通过编辑 /etc/keylime/tenant.conf.d/00-registrar-ip.conf 文件将租户的连接定义到 Keylime 注册器的连接：

   [tenant]
   registrar_ip = <registrar_ip>
   registrar_port = <registrar_port>

   • 将 <registrar_ip> 替换为注册器系统的 IP 地址。
   • 如果注册器使用与默认值 8891 不同的端口，请添加 registrar_port = <registrar_port> 设置。

4. 在租户中添加证书和密钥：

   1. 您可以使用默认配置，并将密钥和证书加载到 /var/lib/keylime/cv_ca 目录。

   2. 或者，您可以在配置中定义密钥和证书的位置。在 /etc/keylime/tenant.conf.d/ 目录中创建一个新的 .conf 文件，例如：/etc/keylime/tenant.conf.d/00-keys-and-certs.conf，其内容如下：

      [tenant]
      tls_dir = /var/lib/keylime/cv_ca
      client_key = tenant-key.pem
      client_key_password = <passphrase1>
      client_cert = tenant-cert.pem
      trusted_server_ca = ['</path/to/ca/cert>']

      trusted_server_ca 参数接受到验证器和注册器服务器 CA 证书的路径。您可以提供多个以逗号分隔的路径，例如，验证器和注册器使用不同的 CA。

      注意

      使用绝对路径定义密钥和证书位置。或者，您可以在 tls_dir 选项中定义目录，并使用相对于该目录的路径。

5. 可选：如果无法使用 /var/lib/keylime/tpm_cert_store 目录中的证书验证可信平台模块(TPM)签署密钥(EK)，请将证书添加到该目录。这在使用具有模拟 TPM 的虚拟机时会出现这种情况。

验证

1. 检查 verifier 的状态：

   # keylime_tenant -c cvstatus
   Reading configuration from ['/etc/keylime/logging.conf']
   2022-10-14 12:56:08.155 - keylime.tpm - INFO - TPM2-TOOLS Version: 5.2
   Reading configuration from ['/etc/keylime/tenant.conf']
   2022-10-14 12:56:08.157 - keylime.tenant - INFO - Setting up client TLS...
   2022-10-14 12:56:08.158 - keylime.tenant - INFO - Using default client_cert option for tenant
   2022-10-14 12:56:08.158 - keylime.tenant - INFO - Using default client_key option for tenant
   2022-10-14 12:56:08.178 - keylime.tenant - INFO - TLS is enabled.
   2022-10-14 12:56:08.178 - keylime.tenant - WARNING - Using default UUID d432fbb3-d2f1-4a97-9ef7-75bd81c00000
   2022-10-14 12:56:08.221 - keylime.tenant - INFO - Verifier at 127.0.0.1 with Port 8881 does not have agent d432fbb3-d2f1-4a97-9ef7-75bd81c00000.

   如果正确设置了，且没有配置代理，验证器会响应它无法识别的默认代理 UUID。

2. 检查 registrar 的状态：

   # keylime_tenant -c regstatus
   Reading configuration from ['/etc/keylime/logging.conf']
   2022-10-14 12:56:02.114 - keylime.tpm - INFO - TPM2-TOOLS Version: 5.2
   Reading configuration from ['/etc/keylime/tenant.conf']
   2022-10-14 12:56:02.116 - keylime.tenant - INFO - Setting up client TLS...
   2022-10-14 12:56:02.116 - keylime.tenant - INFO - Using default client_cert option for tenant
   2022-10-14 12:56:02.116 - keylime.tenant - INFO - Using default client_key option for tenant
   2022-10-14 12:56:02.137 - keylime.tenant - INFO - TLS is enabled.
   2022-10-14 12:56:02.137 - keylime.tenant - WARNING - Using default UUID d432fbb3-d2f1-4a97-9ef7-75bd81c00000
   2022-10-14 12:56:02.171 - keylime.registrar_client - CRITICAL - Error: could not get agent d432fbb3-d2f1-4a97-9ef7-75bd81c00000 data from Registrar Server: 404
   2022-10-14 12:56:02.172 - keylime.registrar_client - CRITICAL - Response code 404: agent d432fbb3-d2f1-4a97-9ef7-75bd81c00000 not found
   2022-10-14 12:56:02.172 - keylime.tenant - INFO - Agent d432fbb3-d2f1-4a97-9ef7-75bd81c00000 does not exist on the registrar. Please register the agent with the registrar.
   2022-10-14 12:56:02.172 - keylime.tenant - INFO - {"code": 404, "status": "Agent d432fbb3-d2f1-4a97-9ef7-75bd81c00000 does not exist on registrar 127.0.0.1 port 8891.", "results": {}}

   如果正确设置了，且没有配置代理，注册器会响应它无法识别的默认代理 UUID。

流程

1. 安装 Keylime 代理：

   # dnf install keylime-agent

   这个命令会安装 keylime-agent-rust 软件包。

2. 在配置文件中定义代理的 IP 地址和端口。在 /etc/keylime/agent.conf.d/ 目录中创建一个新的 .conf 文件，例如：/etc/keylime/agent.conf.d/00-agent-ip.conf，其内容如下：

   [agent]
   ip = '<agent_ip>'

   注意

   Keylime 代理配置使用 TOML 格式，它与用于其他组件配置的 INI 格式不同。因此，使用有效 TOML 语法输入值，例如，在带单引号的路径以及带方括号的多个路径的数组。

   • 将 <agent_IP_address> 替换为代理的 IP 地址。或者，使用 ip = '*' 或 ip = '0.0.0.0' 将代理绑定到所有可用 IP 地址。
   • 另外，您还可以使用 port = '<agent_port>' 选项更改代理端口的默认值 9002 。

3. 在配置文件中定义注册的 IP 地址和端口。在 /etc/keylime/agent.conf.d/ 目录中创建一个新的 .conf 文件，例如： /etc/keylime/agent.conf.d/00-registrar-ip.conf，其内容如下：

   [agent]
   registrar_ip = '<registrar_IP_address>'

   • 将 <registrar_IP_address> 替换为注册中心的 IP 地址。
   • 另外，您还可以使用 registrar_port = '<registrar_port>' 选项更改注册器端口的默认值 8890。

4. 可选：定义代理的通用唯一标识符(UUID)。如果没有定义，则使用默认 UUID。在 /etc/keylime/agent.conf.d/ 目录中创建一个新的 .conf 文件，例如：/etc/keylime/agent.conf.d/00-agent-uuid.conf，其内容如下：

   [agent]
   uuid = '<agent_UUID>'

   • 将 <agent_UUID> 替换为代理的 UUID，如 d432fbb3-d2f1-4a97-9ef7-abcdef012345。您可以使用 uuidgen 工具生成 UUID。

5. 可选：加载代理的现有密钥和证书。如果代理没有接收 server_key 和 server_cert，它会生成自己的密钥和自签名证书。

   在配置中定义密钥和证书的位置。在 /etc/keylime/agent.conf.d/ 目录中创建一个新的 .conf 文件，例如： /etc/keylime/agent.conf.d/00-keys-and-certs.conf，其内容如下：

   [agent]
   server_key = '</path/to/server_key>'
   server_key_password = '<passphrase1>'
   server_cert = '</path/to/server_cert>'
   trusted_client_ca = '</path/to/ca/cert>'
   trusted_client_ca = '[</path/to/ca/cert3>, </path/to/ca/cert4>]'

   注意

   使用绝对路径定义密钥和证书位置。Keylime 代理不接受相对路径。

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

   # firewall-cmd --add-port 9002/tcp
   # firewall-cmd --runtime-to-permanent

   如果您使用不同的端口，请将 9002 替换为 .conf 文件中定义的端口号。

7. 启用并启动 keylime_agent 服务：

   # systemctl enable --now keylime_agent

8. 可选：在配置了 Keylime 租户的系统中，验证代理是否已正确配置，并可以连接到注册器。

   # keylime_tenant -c regstatus --uuid <agent_uuid>
   Reading configuration from ['/etc/keylime/logging.conf']
   ...
   ==\n-----END CERTIFICATE-----\n", "ip": "127.0.0.1", "port": 9002, "regcount": 1, "operational_state": "Registered"}}}

   • 将 <agent_uuid> 替换为代理的 UUID。

     如果正确配置了注册器和代理，输出会显示代理的 IP 地址和端口，后跟 "operational_state"："Registered"。

9. 通过在 /etc/ima/ima-policy 文件中输入以下内容来创建新的 IMA 策略：

   # PROC_SUPER_MAGIC
   dont_measure fsmagic=0x9fa0
   # SYSFS_MAGIC
   dont_measure fsmagic=0x62656572
   # DEBUGFS_MAGIC
   dont_measure fsmagic=0x64626720
   # TMPFS_MAGIC
   dont_measure fsmagic=0x01021994
   # RAMFS_MAGIC
   dont_measure fsmagic=0x858458f6
   # SECURITYFS_MAGIC
   dont_measure fsmagic=0x73636673
   # SELINUX_MAGIC
   dont_measure fsmagic=0xf97cff8c
   # CGROUP_SUPER_MAGIC
   dont_measure fsmagic=0x27e0eb
   # OVERLAYFS_MAGIC
   dont_measure fsmagic=0x794c7630
   # Do not measure log, audit or tmp files
   dont_measure obj_type=var_log_t
   dont_measure obj_type=auditd_log_t
   dont_measure obj_type=tmp_t
   # MEASUREMENTS
   measure func=BPRM_CHECK
   measure func=FILE_MMAP mask=MAY_EXEC
   measure func=MODULE_CHECK uid=0

10. 重启系统以应用新的 IMA 策略。

验证

1. 验证代理是否正在运行：

   # systemctl status keylime_agent
   ● keylime_agent.service - The Keylime compute agent
        Loaded: loaded (/usr/lib/systemd/system/keylime_agent.service; enabled; preset: disabled)
        Active: active (running) since ...

流程

1. 在配置并运行 Keylime 代理的受监控系统上，从系统的当前状态生成一个 allowlist：

   # /usr/share/keylime/scripts/create_allowlist.sh -o <allowlist.txt> -h sha256sum

   将 <allowlist.txt> 替换为 allowlist 的文件名。

   重要

   使用 SHA-256 哈希功能。SHA-1 不安全，在 RHEL 9 中已弃用。如需更多信息，请参阅 Red Hat Enterprise Linux 9 中的 SHA-1 弃用。

2. 将生成的 allowlist 复制到配置了 keylime_tenant 工具的系统中，例如：

   # scp <allowlist.txt> root@<tenant.ip>:/root/<allowlist.txt>

3. 可选：您可以通过在租户系统上创建一个文件并输入要排除的文件和目录，来定义排除在 Keylime 测量之外的文件或目录列表。excludelist 接受 Python 正则表达式，每行一个正则表达式。有关特殊字符的完整列表，请参阅 docs.python.org 中的正则表达式操作。例如，要从 Keylime 测量中排除 /tmp/ 目录中的所有文件以及 /var/ 目录的一些子目录，请使用以下内容创建一个 /root/<excludelist.txt> 文件：

   /var/cache/.*
   /var/lock/.*
   /var/log/.*
   /var/run/.*
   /var/spool/.*
   /var/tmp/.*
   /tmp/.*

   在租户系统上保存 excludelist。

4. 将 allowlist 和 excludelist 合并到 Keylime 运行时策略中：

   # keylime_create_policy -a <allowlist.txt> -e <excludelist.txt> -o <policy.json>

5. 在配置了 Keylime 租户的系统上，使用 keylime_tenant 工具置备代理：

   # keylime_tenant -c add -t <agent_ip> -u <agent_uuid> --runtime-policy <policy.json> --cert default

   • 将 <agent_ip> 替换为代理的 IP 地址。
   • 将 <agent_uuid> 替换为代理的 UUID。
   • 将 <policy.json> 替换为 Keylime 运行时策略文件的路径。

   • 使用 --cert 选项时，租户通过使用指定目录或默认的 /var/lib/keylime/ca/ 目录中的 CA 证书和密钥为代理生成和签名证书。如果目录不包含 CA 证书和密钥，则租户将根据 /etc/keylime/ca.conf 文件中的配置自动生成它们，并将其保存到指定的目录中。然后，租户将这些密钥和证书发送给代理。

     在生成 CA 证书或签名代理证书时，可能会提示您输入访问 CA 私钥的密码：Please enter the password to decrypt your keystore:

     如果您不想使用证书，请使用 -f 选项，而不向代理发送文件。置备代理需要发送任何文件，即使是空文件。

     注意

     Keylime 对发送到代理的文件进行加密，只有在代理系统符合 TPM 策略和 IMA allowlist 时才解密该文件。默认情况下，Keylime 解压缩 .zip 文件。

   例如，使用以下命令，keylime_tenant 在 127.0.0.1 处添加一个新的 UUID 为 d432fbb3-d2f1-4a97-9ef7-75bd81c00000 的 Keylime 代理，并加载运行时策略 policy.json。它还在默认目录中生成一个证书，并将证书文件发送给代理。只有满足 /etc/keylime/verifier.conf 中的 TPM 策略才对文件进行解密：

   # keylime_tenant -c add -t 127.0.0.1 -u d432fbb3-d2f1-4a97-9ef7-75bd81c00000 --cert default --runtime-policy policy.json

   注意

   您可以使用 # keylime_tenant -c delete -u <agent_uuid> 命令停止 Keylime 监控节点。

   您可以使用 keylime_tenant -c update 命令修改已注册的代理的配置。

验证

1. 可选：在验证前重启被监控的系统，以验证设置是否持久。

2. 验证代理是否成功：

   # keylime_tenant -c cvstatus -u <agent.uuid>
   ...
   {"<agent.uuid>": {"operational_state": "Get Quote"..."attestation_count": 5
   ...

   将 <agent.uuid> 替换为代理的 UUID。

   如果 operational_state 的值为 Get Quote，并且 attestation_count 非零，则此代理的验证成功。

   如果 operational_state 的值为 Invalid Quote 或 Failed，则验证失败，命令会显示类似如下的输出：

   {"<agent.uuid>": {"operational_state": "Invalid Quote", ... "ima.validation.ima-ng.not_in_allowlist", "attestation_count": 5, "last_received_quote": 1684150329, "last_successful_attestation": 1684150327}}

3. 如果验证失败，请在验证器日志中显示更多详细信息：

   # journalctl -u keylime_verifier
   keylime.tpm - INFO - Checking IMA measurement list...
   keylime.ima - WARNING - File not found in allowlist: /root/bad-script.sh
   keylime.ima - ERROR - IMA ERRORS: template-hash 0 fnf 1 hash 0 good 781
   keylime.cloudverifier - WARNING - agent D432FBB3-D2F1-4A97-9EF7-75BD81C00000 failed, stopping polling

流程

1. 在配置并运行 Keylime 代理的监控系统上，安装 python3-keylime 软件包，其包含 create_mb_refstate 脚本：

   # dnf -y install python3-keylime

2. 在被监控的系统上，使用 create_mb_refstate 脚本从系统当前状态的测量引导日志中生成一个策略：

   # /usr/share/keylime/scripts/create_mb_refstate /sys/kernel/security/tpm0/binary_bios_measurements <./measured_boot_reference_state.json>

   将 <./measured_boot_reference_state.json> 替换为保存所生成的策略的路径。

   重要

   使用 create_mb_refstate 脚本生成的策略基于系统的当前状态，非常严格。任何系统修改，包括内核更新和系统更新都会更改引导过程，系统就会失败。

3. 将生成的策略复制到配置了 keylime_tenant 工具的系统上，例如：

   # scp root@<agent_ip>:<./measured_boot_reference_state.json> <./measured_boot_reference_state.json>

4. 在配置了 Keylime 租户的系统上，使用 keylime_tenant 工具置备代理：

   # keylime_tenant -c add -t <agent_ip> -u <agent_uuid> --mb_refstate <./measured_boot_reference_state.json>

   • 将 <agent_ip> 替换为代理的 IP 地址。
   • 将 <agent_uuid> 替换为代理的 UUID。
   • 将 <./measured_boot_reference_state.json> 替换为计算引导策略的路径。

   如果将测量引导与运行时监控结合起来进行配置，请在输入 keylime_tenant -c add 命令时提供这两个用例中的所有选项。

   注意

   您可以使用 # keylime_tenant -c delete -t <agent_ip> -u <agent_uuid> 命令停止 Keylime 监控节点。

   您可以使用 keylime_tenant -c update 命令修改已注册的代理的配置。

验证

1. 重启被监控的系统，并验证代理是否成功：

   # keylime_tenant -c cvstatus -u <agent_uuid>
   ...
   {"<agent.uuid>": {"operational_state": "Get Quote"..."attestation_count": 5
   ...

   将 <agent_uuid> 替换为代理的 UUID。

   如果 operational_state 的值为 Get Quote，并且 attestation_count 非零，则此代理的验证成功。

   如果 operational_state 的值为 Invalid Quote 或 Failed，则验证失败，命令会显示类似如下的输出：

   {"<agent.uuid>": {"operational_state": "Invalid Quote", ... "ima.validation.ima-ng.not_in_allowlist", "attestation_count": 5, "last_received_quote": 1684150329, "last_successful_attestation": 1684150327}}

2. 如果验证失败，请在验证器日志中显示更多详细信息：

   # journalctl -u keylime_verifier
   {"d432fbb3-d2f1-4a97-9ef7-75bd81c00000": {"operational_state": "Tenant Quote Failed", ... "last_event_id": "measured_boot.invalid_pcr_0", "attestation_count": 0, "last_received_quote": 1684487093, "last_successful_attestation": 0}}

流程

1. 安装 aide 软件包：

   # dnf 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 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. 卸载您要加密的设备上的所有文件系统，例如：

   # 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：

   # dnf install clevis

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

   $ clevis decrypt < secret.jwe

步骤

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

   # dnf 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 9.2 及更高版本中，选择了加密的根文件系统和 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
   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 子软件包：

   # dnf 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 工具：

   # dnf 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 子软件包：

   # dnf 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 工具：

   # dnf 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 加密，由 Version 表示：1 string 在 cryptsetup luksDump 命令的输出中，使用 luksmeta flush 命令执行这个额外步骤：

   # 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 软件包：

   # dnf 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/rhel9/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/rhel9/tang

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

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

   # podman run --rm -v tang-keys:/var/db/tang registry.redhat.io/rhel9/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 ，并添加所需的参数。以下 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 角色使用的端口。

3. 验证 playbook 语法：

   # ansible-playbook ~/my-tang-playbook.yml --syntax-check

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

4. 应用完成的 playbook:

   # ansible-playbook ~/my-tang-playbook.yml

步骤

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 ~/my-clevis-playbook.yml --syntax-check

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

5. 应用完成的 playbook:

   # ansible-playbook ~/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