第247集：集群安全管理

教学目标

• 了解集群安全管理的基本概念和重要性

• 掌握集群环境中常见的安全威胁和风险

• 学习集群安全策略的制定和实施方法

• 熟悉集群认证与授权机制的配置和管理

• 掌握集群网络安全、数据安全和安全审计的实践技巧

• 能够根据实际场景设计和实施集群安全解决方案

核心知识点讲解

1. 集群安全管理概述

1.1 集群安全的基本概念

集群安全 是指保护集群系统免受未经授权的访问、使用、披露、修改或破坏的能力，确保集群系统的保密性、完整性和可用性。

1.2 集群安全的重要性

集群安全在以下方面发挥重要作用：

• 保护业务数据：防止敏感数据泄露和篡改

• 确保服务可用性：防止恶意攻击导致服务中断

• 满足合规要求：符合行业安全标准和法规要求

• 保护知识产权：防止核心技术和商业机密被窃取

• 维护企业声誉：避免安全事件对企业形象的损害

• 降低运营成本：减少安全事件的处理成本和损失

1.3 集群安全的挑战

集群环境面临的安全挑战包括：

• 复杂性：集群系统由多个节点和组件组成，安全配置复杂

• 攻击面大：多个节点和网络连接增加了潜在的攻击点

• 动态性：集群节点和服务的状态不断变化，安全管理难度大

• 高可用性要求：安全措施不能影响集群的高可用性

• 性能影响：安全措施可能对集群性能产生影响

• 合规性要求：不同行业和地区有不同的安全合规要求

2. 集群安全威胁

2.1 常见安全威胁

2.1.1 网络攻击

• DDoS攻击：分布式拒绝服务攻击，消耗集群资源，导致服务不可用

• 网络嗅探：捕获网络数据包，窃取敏感信息

• 中间人攻击：拦截和篡改网络通信

• 端口扫描：探测集群开放的端口和服务，寻找攻击漏洞

• ARP欺骗：伪造ARP数据包，重定向网络流量

2.1.2 系统攻击

• 特权提升：获取更高的系统权限

• 恶意代码：病毒、木马、蠕虫等恶意软件

• 漏洞利用：利用系统或应用程序的漏洞进行攻击

• 密码破解：通过暴力破解、字典攻击等方式获取用户密码

• 权限滥用：合法用户滥用其权限

2.1.3 数据攻击

• 数据泄露：敏感数据被未授权访问或披露

• 数据篡改：未经授权修改数据

• 数据销毁：恶意删除或破坏数据

• 数据勒索：加密数据并要求支付赎金

• 数据窃取：通过各种手段窃取数据

2.1.4 集群特定攻击

• 集群节点劫持：控制集群节点，破坏集群完整性

• 集群配置攻击：修改集群配置，导致集群故障

• 集群服务攻击：针对集群服务的特定攻击

• 集群通信攻击：干扰集群节点间的通信

• 共享存储攻击：攻击集群共享存储系统

2.2 安全风险评估

安全风险评估 是识别、分析和评估集群系统安全风险的过程。

2.2.1 风险评估步骤

1. 资产识别：识别集群中的关键资产，包括硬件、软件、数据和服务

2. 威胁识别：识别可能影响资产的安全威胁

3. 漏洞识别：识别系统和应用程序中的安全漏洞

4. 风险分析：分析威胁发生的可能性和影响程度

5. 风险评估：评估风险等级，确定是否需要采取措施

6. 风险处理：制定和实施风险处理计划

7. 风险监控：持续监控风险变化

2.2.2 风险评估工具

• OpenVAS：开源漏洞扫描工具

• Nessus：商业漏洞扫描工具

• Qualys：云端安全评估工具

• Nmap：网络扫描和安全评估工具

• Metasploit：渗透测试框架

• OWASP ZAP：Web应用安全扫描工具

3. 集群安全策略

3.1 安全策略的基本概念

安全策略 是组织为保护其信息资产而制定的规则、标准和指南，定义了安全目标、责任和实施方法。

3.2 安全策略的组成部分

• 安全目标：明确安全保护的目标和范围

• 安全标准：定义安全控制的具体要求

• 安全程序：规定安全操作的流程和方法

• 安全指南：提供安全实施的建议和最佳实践

• 安全责任：明确各角色的安全责任

• 安全度量：评估安全控制有效性的指标

3.3 集群安全策略制定

3.3.1 制定步骤

1. 需求分析：分析业务需求、合规要求和安全风险

2. 策略设计：设计安全策略框架和具体内容

3. 策略评审：组织相关人员评审安全策略

4. 策略批准：获得管理层批准

5. 策略发布：向相关人员发布安全策略

6. 策略培训：对相关人员进行安全策略培训

7. 策略实施：实施安全控制措施

8. 策略监控：监控安全策略的执行情况

9. 策略更新：定期更新安全策略，适应新的威胁和需求

3.3.2 关键安全策略

• 访问控制策略：定义谁可以访问什么资源，以及如何访问

• 密码策略：规定密码的复杂度、长度、过期时间等

• 网络安全策略：定义网络分区、防火墙规则、加密要求等

• 数据安全策略：规定数据分类、保护措施、备份要求等

• 系统安全策略：定义系统配置、补丁管理、漏洞扫描要求等

• 事件响应策略：规定安全事件的检测、报告和处理流程

• 灾难恢复策略：定义安全事件后的恢复流程和要求

4. 认证与授权

4.1 认证机制

认证 是验证用户身份的过程，确保用户是其声称的身份。

4.1.1 传统认证方式

• 用户名/密码：最基本的认证方式

• SSH密钥：使用公钥和私钥进行认证

• 证书认证：使用数字证书进行认证

• 双因素认证：结合两种不同类型的认证因素

4.1.2 现代认证方式

• 生物识别：使用指纹、面部识别等生物特征

• 智能卡：使用存储用户身份信息的智能卡

• 单点登录（SSO）：一次登录，访问多个系统

• 联合认证：使用第三方身份提供商进行认证

• 多因素认证（MFA）：结合多种认证因素

4.1.3 集群认证配置

Pacemaker 集群认证：

# 配置 Pacemaker 集群认证
pcs cluster auth node1 node2 -u hacluster -p password

# 配置 SSH 无密码认证
ssh-keygen -t rsa
ssh-copy-id node1
ssh-copy-id node2

Kubernetes 集群认证：

# 创建 Kubernetes 服务账户
kubectl create serviceaccount admin-user

# 绑定集群管理员角色
kubectl create clusterrolebinding admin-user-binding --clusterrole=cluster-admin --serviceaccount=default:admin-user

# 获取访问令牌
kubectl get secret $(kubectl get serviceaccount admin-user -o jsonpath='{.secrets[0].name}') -o jsonpath='{.data.token}' | base64 --decode

Ceph 集群认证：

# 创建 Ceph 用户
ceph auth get-or-create client.admin mon 'allow *' osd 'allow *' mds 'allow *'

# 查看 Ceph 用户
ceph auth list

# 导出 Ceph 密钥
ceph auth get client.admin -o /etc/ceph/ceph.client.admin.keyring

4.2 授权机制

授权 是决定认证用户可以访问哪些资源以及可以执行哪些操作的过程。

4.2.1 授权模型

• 自主访问控制（DAC）：资源所有者决定谁可以访问资源

• 强制访问控制（MAC）：系统根据安全策略强制控制访问

• 基于角色的访问控制（RBAC）：根据用户角色控制访问

• 基于属性的访问控制（ABAC）：根据用户、资源和环境属性控制访问

• 基于规则的访问控制（RBAC）：根据预定义的规则控制访问

4.2.2 集群授权配置

Pacemaker 集群授权：

# 配置 Pacemaker 访问控制
pcs property set cluster-authorization=true

# 创建 Pacemaker 用户
pcs user create operator password

# 分配权限
pcs acl create operator-role description="Operator role"
pcs acl rule create operator-role read xpath=/cib
pcs acl rule create operator-role write xpath=/cib/resources

Kubernetes 集群授权：

# 创建 Kubernetes 角色
kubectl create role pod-reader --verb=get,list --resource=pods

# 创建角色绑定
kubectl create rolebinding user-pod-reader --role=pod-reader --user=user1

# 创建集群角色
kubectl create clusterrole node-reader --verb=get,list --resource=nodes

# 创建集群角色绑定
kubectl create clusterrolebinding user-node-reader --clusterrole=node-reader --user=user1

Ceph 集群授权：

# 创建 Ceph 只读用户
ceph auth get-or-create client.reader mon 'allow r' osd 'allow r'

# 创建 Ceph 存储用户
ceph auth get-or-create client.volumes mon 'allow r' osd 'allow rwx pool=volumes'

4.3 集中式认证与授权

4.3.1 LDAP/Active Directory

LDAP（轻量级目录访问协议）和 Active Directory 是常用的集中式认证与授权系统。

• 配置示例：

# 安装 LDAP 客户端
yum install -y openldap-clients nss-pam-ldapd

# 配置 LDAP 认证
authconfig --enableldap --enableldapauth --ldapserver=ldap://ldap.example.com --ldapbasedn=dc=example,dc=com --enablemkhomedir --update

# 测试 LDAP 认证
ldapsearch -x -b dc=example,dc=com

4.3.2 Kerberos

Kerberos 是一种网络认证协议，提供强大的认证机制。

• 配置示例：

# 安装 Kerberos 客户端
yum install -y krb5-workstation

# 配置 Kerberos
cat > /etc/krb5.conf << 'EOF'
[libdefaults]
  default_realm = EXAMPLE.COM

[realms]
  EXAMPLE.COM = {
    kdc = kdc.example.com
    admin_server = kdc.example.com
  }

[domain_realm]
  .example.com = EXAMPLE.COM
  example.com = EXAMPLE.COM
EOF

# 测试 Kerberos 认证
kinit user@EXAMPLE.COM
klist

4.3.3 OAuth 2.0/OIDC

OAuth 2.0 和 OpenID Connect (OIDC) 是现代的认证与授权协议，适用于云环境和API访问。

• 配置示例：

# 安装 OAuth 2.0 客户端
yum install -y python3-oauth2client

# 配置 OAuth 2.0 认证
# 1. 注册应用程序到 OAuth 2.0 提供商
# 2. 获取客户端ID和客户端密钥
# 3. 配置应用程序使用 OAuth 2.0 认证

5. 网络安全

5.1 网络分区

网络分区 是将网络划分为不同的安全区域，限制区域间的通信，减少攻击面。

5.1.1 网络分区策略

• DMZ区域：放置面向外部的服务，如Web服务器

• 应用区域：放置应用服务器，只允许来自DMZ的特定流量

• 数据区域：放置数据库和存储系统，只允许来自应用区域的特定流量

• 管理区域：放置管理服务器，只允许来自特定管理终端的流量

• 集群内部网络：集群节点间的通信网络，隔离外部访问

5.1.2 网络分区配置

# 配置网络接口
cat > /etc/sysconfig/network-scripts/ifcfg-eth0 << 'EOF'
DEVICE=eth0
BOOTPROTO=static
IPADDR=192.168.1.10
NETMASK=255.255.255.0
GATEWAY=192.168.1.1
DNS1=8.8.8.8
ONBOOT=yes
EOF

cat > /etc/sysconfig/network-scripts/ifcfg-eth1 << 'EOF'
DEVICE=eth1
BOOTPROTO=static
IPADDR=10.0.0.10
NETMASK=255.255.255.0
ONBOOT=yes
EOF

# 重启网络服务
systemctl restart network

# 配置防火墙
firewall-cmd --permanent --zone=public --add-interface=eth0
firewall-cmd --permanent --zone=internal --add-interface=eth1
firewall-cmd --permanent --zone=public --add-service=http
firewall-cmd --permanent --zone=public --add-service=https
firewall-cmd --permanent --zone=internal --add-source=10.0.0.0/24
firewall-cmd --permanent --zone=internal --add-port=22/tcp
firewall-cmd --reload

5.2 防火墙配置

防火墙 是一种网络安全设备，根据预定义的规则过滤网络流量，允许或拒绝数据包通过。

5.2.1 防火墙类型

• 硬件防火墙：专用的硬件设备

• 软件防火墙：运行在服务器上的软件

• 主机防火墙：保护单个主机的防火墙

• 网络防火墙：保护整个网络的防火墙

• 分布式防火墙：分布在多个节点上的防火墙

5.2.2 防火墙配置

iptables 配置：

# 查看当前规则
iptables -L -n

# 配置默认策略
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT

# 允许本地回环
iptables -A INPUT -i lo -j ACCEPT

# 允许已建立的连接
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# 允许SSH访问
iptables -A INPUT -p tcp --dport 22 -s 192.168.1.0/24 -j ACCEPT

# 允许HTTP/HTTPS访问
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# 保存规则
iptables-save > /etc/sysconfig/iptables

# 重启防火墙
systemctl restart iptables
systemctl enable iptables

firewalld 配置：

# 查看当前区域
firewall-cmd --get-active-zones

# 查看区域规则
firewall-cmd --zone=public --list-all

# 添加服务
firewall-cmd --permanent --zone=public --add-service=http
firewall-cmd --permanent --zone=public --add-service=https

# 添加端口
firewall-cmd --permanent --zone=public --add-port=22/tcp

# 添加富规则
firewall-cmd --permanent --zone=public --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" service name="ssh" accept'

# 重新加载规则
firewall-cmd --reload

5.3 加密通信

加密通信 是使用加密算法对网络通信进行加密，保护数据传输的安全性。

5.3.1 SSL/TLS 配置

配置 HTTPS：

# 安装证书
mkdir -p /etc/ssl/certs
cp server.crt /etc/ssl/certs/
cp server.key /etc/ssl/private/

# 配置 Apache
cat > /etc/httpd/conf.d/ssl.conf << 'EOF'
<VirtualHost *:443>
    ServerName example.com
    SSLEngine on
    SSLCertificateFile /etc/ssl/certs/server.crt
    SSLCertificateKeyFile /etc/ssl/private/server.key
    DocumentRoot /var/www/html
</VirtualHost>
EOF

# 重启 Apache
systemctl restart httpd
systemctl enable httpd

5.3.2 SSH 加密配置

# 配置 SSH
cat > /etc/ssh/sshd_config << 'EOF'
Port 22
Protocol 2
HostKey /etc/ssh/ssh_host_rsa_key
HostKey /etc/ssh/ssh_host_ecdsa_key
HostKey /etc/ssh/ssh_host_ed25519_key
PermitRootLogin no
MaxAuthTries 3
MaxSessions 10
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys
PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM yes
X11Forwarding no
AllowTcpForwarding no
AllowUsers user1 user2
EOF

# 重启 SSH
systemctl restart sshd
systemctl enable sshd

5.3.3 集群内部通信加密

Pacemaker/Corosync 通信加密：

# 配置 Corosync 加密
cat > /etc/corosync/corosync.conf << 'EOF'
totem {
    version: 2
    secauth: on
    threads: 0
    interface {
        ringnumber: 0
        bindnetaddr: 10.0.0.0
        mcastaddr: 226.94.1.1
        mcastport: 5405
        ttl: 1
    }
}

nodelist {
    node {
        ring0_addr: node1
        name: node1
        nodeid: 1
    }
    node {
        ring0_addr: node2
        name: node2
        nodeid: 2
    }
}

quorum {
    provider: corosync_votequorum
    two_node: 1
}

logging {
    to_logfile: yes
    logfile: /var/log/cluster/corosync.log
    to_syslog: yes
    timestamp: on
}
EOF

# 重启 Corosync
systemctl restart corosync
systemctl enable corosync

Kubernetes 通信加密：

# Kubernetes 自动配置 TLS 加密
# 1. 生成证书
# 2. 配置 API Server 使用证书
# 3. 配置 kubelet 使用证书
# 4. 配置 etcd 使用 TLS 加密

6. 数据安全

6.1 数据分类

数据分类 是根据数据的敏感度和重要性将数据划分为不同的类别，应用不同的保护措施。

6.1.1 数据分类标准

• 公开数据：可以公开访问的数据，如公司简介

• 内部数据：仅供内部员工访问的数据，如内部文档

• 机密数据：需要严格保护的数据，如财务报表

• 敏感数据：受法规保护的数据，如个人身份信息

• 核心数据：企业核心竞争力相关的数据，如商业机密

6.1.2 数据分类实施

• 识别数据：识别系统中的数据

• 评估数据：评估数据的敏感度和重要性

• 分类数据：根据分类标准对数据进行分类

• 标记数据：为数据添加分类标记

• 保护数据：根据分类应用相应的保护措施

• 监控数据：监控数据的访问和使用情况

6.2 数据加密

数据加密 是使用加密算法将明文数据转换为密文，防止未授权访问。

6.2.1 加密类型

• 传输加密：加密网络传输中的数据，如SSL/TLS

• 存储加密：加密存储在磁盘上的数据，如LUKS

• 应用加密：应用程序级别的数据加密

• 数据库加密：数据库级别的数据加密

6.2.2 存储加密配置

LUKS 磁盘加密：

# 安装 cryptsetup
yum install -y cryptsetup

# 创建加密卷
cryptsetup luksFormat /dev/sdb

# 打开加密卷
cryptsetup open /dev/sdb cryptdata

# 创建文件系统
mkfs.xfs /dev/mapper/cryptdata

# 挂载加密卷
mkdir -p /mnt/cryptdata
mount /dev/mapper/cryptdata /mnt/cryptdata

# 自动挂载配置
cat >> /etc/fstab << 'EOF'
/dev/mapper/cryptdata /mnt/cryptdata xfs defaults 0 0
EOF

# 配置自动解锁
cat >> /etc/crypttab << 'EOF'
cryptdata /dev/sdb /root/keyfile luks
EOF

# 创建密钥文件
openssl rand -hex 32 > /root/keyfile
chmod 600 /root/keyfile
cryptsetup luksAddKey /dev/sdb /root/keyfile

6.2.3 数据备份加密

# 使用 GPG 加密备份
# 生成 GPG 密钥
gpg --gen-key

# 加密文件
gpg -e -r user@example.com backup.tar.gz

# 解密文件
gpg -d backup.tar.gz.gpg > backup.tar.gz

# 使用 OpenSSL 加密备份
# 加密文件
openssl enc -aes-256-cbc -salt -in backup.tar.gz -out backup.tar.gz.enc -k password

# 解密文件
openssl enc -d -aes-256-cbc -in backup.tar.gz.enc -out backup.tar.gz -k password

6.3 数据备份与恢复

数据备份 是创建数据的副本，以便在数据丢失或损坏时恢复。

6.3.1 备份策略

• 完全备份：备份所有数据

• 增量备份：备份自上次备份以来更改的数据

• 差异备份：备份自上次完全备份以来更改的数据

• 合成备份：将完全备份和增量备份合成为新的完全备份

6.3.2 备份配置

# 使用 rsync 备份
rsync -avz --delete /data/ /backup/data/

# 使用 tar 备份
tar -czf /backup/backup-$(date +%Y%m%d).tar.gz /data/

# 使用 Amanda 备份
# 安装 Amanda
yum install -y amanda-server amanda-client

# 配置 Amanda
# 1. 创建配置文件
# 2. 配置客户端
# 3. 运行备份

# 使用 Bacula 备份
# 安装 Bacula
yum install -y bacula-director bacula-storage bacula-client

# 配置 Bacula
# 1. 创建配置文件
# 2. 配置客户端
# 3. 运行备份

6.3.3 恢复测试

• 定期恢复测试：定期测试备份的可恢复性

• 恢复演练：模拟数据丢失场景，测试恢复流程

• 恢复时间测试：测试恢复操作所需的时间

• 恢复验证：验证恢复的数据的完整性和一致性

7. 系统安全

7.1 系统加固

系统加固 是通过配置和措施增强系统安全性，减少安全漏洞。

7.1.1 系统加固措施

• 最小化安装：只安装必要的软件包

• 禁用不必要的服务：关闭不需要的系统服务

• 配置 SELinux：启用和配置 SELinux

• 配置 AppArmor：启用和配置 AppArmor（适用于 Debian/Ubuntu）

• 限制 su 和 sudo：限制可以使用 su 和 sudo 的用户

• 配置系统日志：确保系统日志的完整性和安全性

• 禁用 IPv6：如果不需要，禁用 IPv6

• 配置 TCP 安全参数：启用 SYN cookies、TCP 保护等

7.1.2 系统加固配置

# 最小化安装
# 在安装系统时选择最小化安装

# 禁用不必要的服务
systemctl stop avahi-daemon cups iscsi iscsid rpcbind
systemctl disable avahi-daemon cups iscsi iscsid rpcbind

# 配置 SELinux
cat > /etc/selinux/config << 'EOF'
SELINUX=enforcing
SELINUXTYPE=targeted
EOF

# 重启系统以应用 SELinux 配置
# reboot

# 配置 TCP 安全参数
cat > /etc/sysctl.d/security.conf << 'EOF'
# 启用 SYN cookies
net.ipv4.tcp_syncookies = 1

# 禁用 IP 转发
net.ipv4.ip_forward = 0

# 禁用 ICMP 重定向
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0

# 启用源地址验证
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1

# 禁用 ICMP 广播响应
net.ipv4.icmp_echo_ignore_broadcasts = 1

# 启用恶意 ICMP 保护
net.ipv4.icmp_ignore_bogus_error_responses = 1
EOF

# 应用 sysctl 配置
sysctl -p /etc/sysctl.d/security.conf

7.2 补丁管理

补丁管理 是及时安装系统和应用程序的安全补丁，修复已知漏洞。

7.2.1 补丁管理流程

• 补丁评估：评估补丁的必要性和风险

• 补丁测试：在测试环境中测试补丁

• 补丁部署：在生产环境中部署补丁

• 补丁验证：验证补丁安装是否成功

• 补丁回滚：当补丁导致问题时，执行回滚操作

7.2.2 补丁管理工具

• YUM/DNF：RHEL/CentOS 系统的包管理工具

• APT：Debian/Ubuntu 系统的包管理工具

• Zypper：SUSE 系统的包管理工具

• WSUS：Windows 系统的补丁管理工具

• Spacewalk：开源的系统管理和补丁管理工具

• Foreman：开源的生命周期管理工具

7.2.3 补丁管理配置

# 使用 YUM 管理补丁
# 检查可用补丁
yum check-update

# 安装安全补丁
yum update --security

# 安装所有补丁
yum update

# 自动更新配置
cat > /etc/yum/yum-cron.conf << 'EOF'
[base]
# 应用更新的类型：none, security, default, all
apply_updates = security

# 检查更新的频率：hourly, daily, weekly
check_interval = daily

# 随机延迟（分钟）
random_sleep = 360
EOF

# 启动 yum-cron
systemctl start yum-cron
systemctl enable yum-cron

# 使用 APT 管理补丁
# 检查可用补丁
apt update

# 安装安全补丁
apt upgrade -s

# 安装所有补丁
apt full-upgrade

# 自动更新配置
# 安装 unattended-upgrades
apt install unattended-upgrades

# 配置自动更新
cat > /etc/apt/apt.conf.d/50unattended-upgrades << 'EOF'
Unattended-Upgrade::Allowed-Origins {
        "${distro_id}:${distro_codename}";
        "${distro_id}:${distro_codename}-security";
};

Unattended-Upgrade::Automatic-Reboot "true";
EOF

# 启用自动更新
cat > /etc/apt/apt.conf.d/20auto-upgrades << 'EOF'
APT::Periodic::Update-Package-Lists "1";
APT::Periodic::Download-Upgradeable-Packages "1";
APT::Periodic::AutocleanInterval "7";
APT::Periodic::Unattended-Upgrade "1";
EOF

7.3 漏洞扫描

漏洞扫描 是使用工具扫描系统和应用程序中的安全漏洞，及时发现和修复安全问题。

7.3.1 漏洞扫描工具

• OpenVAS：开源漏洞扫描工具

• Nessus：商业漏洞扫描工具

• Qualys：云端安全评估工具

• Nmap：网络扫描和安全评估工具

• Nikto：Web服务器漏洞扫描工具

• OpenSCAP：开源安全合规评估工具

7.3.2 漏洞扫描配置

使用 OpenVAS：

# 安装 OpenVAS
yum install -y openvas

# 初始化 OpenVAS
greenbone-nvt-sync
greenbone-scapdata-sync
greenbone-certdata-sync
openvas-setup

# 启动 OpenVAS
systemctl start openvas-scanner openvas-manager openvas-gsa
systemctl enable openvas-scanner openvas-manager openvas-gsa

# 访问 OpenVAS Web 界面
# 浏览器访问: https://server_ip:9392
# 用户名: admin
# 密码: 安装时设置的密码

# 创建扫描任务
# 1. 登录 OpenVAS Web 界面
# 2. 点击"Scans" -> "Tasks" -> "New Task"
# 3. 填写任务信息，点击"Create Task"
# 4. 点击任务旁边的播放按钮开始扫描
# 5. 查看扫描报告

使用 OpenSCAP：

# 安装 OpenSCAP
yum install -y openscap-scanner scap-security-guide

# 扫描系统
oscap xccdf eval --profile xccdf_org.ssgproject.content_profile_rht-ccp --report /tmp/scan-report.html /usr/share/xml/scap/ssg/content/ssg-rhel7-ds.xml

# 查看扫描报告
firefox /tmp/scan-report.html

8. 安全审计

8.1 安全审计的基本概念

安全审计 是收集、分析和评估安全相关事件的过程，确保安全策略的执行和安全控制的有效性。

8.2 安全审计的目标

• 检测安全事件：及时发现安全事件

• 调查安全事件：分析安全事件的原因和影响

• 证明合规性：证明符合安全标准和法规要求

• 评估安全控制：评估安全控制的有效性

• 改进安全措施：根据审计结果改进安全措施

8.3 审计日志管理

8.3.1 审计日志配置

配置 rsyslog：

# 配置 rsyslog
cat > /etc/rsyslog.conf << 'EOF'
# 日志记录格式
$ActionFileDefaultTemplate RSYSLOG_TraditionalFileFormat

# 日志文件权限
$FileOwner root
$FileGroup adm
$FileCreateMode 0640
$DirCreateMode 0755
$Umask 0022

# 日志文件位置
*.info;mail.none;authpriv.none;cron.none                /var/log/messages
authpriv.*                                              /var/log/secure
mail.*                                                  -/var/log/maillog
cron.*                                                  /var/log/cron
*.emerg                                                 :omusrmsg:*
uucp,news.crit                                          /var/log/spooler
local7.*                                                /var/log/boot.log

# 远程日志服务器
*.* @@logserver:514
EOF

# 重启 rsyslog
systemctl restart rsyslog
systemctl enable rsyslog

配置 auditd：

# 安装 auditd
yum install -y audit

# 配置 auditd
cat > /etc/audit/auditd.conf << 'EOF'
local_events = yes
write_logs = yes
log_file = /var/log/audit/audit.log
log_group = root
log_format = RAW
flush = INCREMENTAL
freq = 20
max_log_file = 8
num_logs = 5
priority_boost = 4
action_mail_acct = root
disable_on_error = no
auditctl = /sbin/auditctl
EOF

# 配置审计规则
cat > /etc/audit/rules.d/audit.rules << 'EOF'
# 监控系统调用
-a always,exit -F arch=b64 -S execve -k exec

# 监控文件访问
-w /etc/passwd -p wa -k passwd
-w /etc/shadow -p wa -k shadow
-w /etc/sudoers -p wa -k sudoers

# 监控目录访问
-w /etc/ -p wa -k etc
-w /var/log/ -p wa -k log

# 监控身份验证
-w /var/run/utmp -p wa -k utmp
-w /var/log/wtmp -p wa -k wtmp
-w /var/log/btmp -p wa -k btmp
EOF

# 重启 auditd
systemctl restart auditd
systemctl enable auditd

# 查看审计日志
auditctl -l
audit2allow -a
aureport -a

8.3.2 日志分析工具

• ELK Stack：Elasticsearch, Logstash, Kibana

• Graylog：开源日志管理平台

• Splunk：商业日志管理和分析平台

• LogRhythm：商业安全信息和事件管理（SIEM）平台

• IBM QRadar：商业 SIEM 平台

• ArcSight：商业 SIEM 平台

8.3.3 日志分析配置

配置 ELK Stack：

# 安装 Elasticsearch
rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
echo "[elasticsearch-7.x]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md" > /etc/yum.repos.d/elasticsearch.repo
yum install -y elasticsearch

# 配置 Elasticsearch
cat > /etc/elasticsearch/elasticsearch.yml << 'EOF'
cluster.name: my-cluster
node.name: node-1
path.data: /var/lib/elasticsearch
path.logs: /var/log/elasticsearch
network.host: 0.0.0.0
http.port: 9200
discovery.seed_hosts: ["127.0.0.1"]
cluster.initial_master_nodes: ["node-1"]
EOF

# 启动 Elasticsearch
systemctl start elasticsearch
systemctl enable elasticsearch

# 安装 Logstash
yum install -y logstash

# 配置 Logstash
cat > /etc/logstash/conf.d/audit.conf << 'EOF'
input {
  file {
    path => "/var/log/audit/audit.log"
    start_position => "beginning"
  }
}

filter {
  grok {
    match => { "message" => "type=%{WORD:type} msg=audit\(%{NUMBER:timestamp}\): %{GREEDYDATA:message}" }
  }
}

output {
  elasticsearch {
    hosts => ["localhost:9200"]
    index => "audit-%{+YYYY.MM.dd}"
  }
}
EOF

# 启动 Logstash
systemctl start logstash
systemctl enable logstash

# 安装 Kibana
yum install -y kibana

# 配置 Kibana
cat > /etc/kibana/kibana.yml << 'EOF'
server.port: 5601
server.host: "0.0.0.0"
elasticsearch.hosts: ["http://localhost:9200"]
EOF

# 启动 Kibana
systemctl start kibana
systemctl enable kibana

# 访问 Kibana Web 界面
# 浏览器访问: http://server_ip:5601
# 配置索引模式，查看日志

9. 安全事件响应

9.1 安全事件的基本概念

安全事件 是违反安全策略或可能影响系统安全的事件，如未经授权的访问、数据泄露、系统入侵等。

9.2 安全事件响应流程

1. 准备：制定安全事件响应计划，建立响应团队，准备响应工具和资源

2. 检测：通过监控和告警系统检测安全事件

3. 分析：分析安全事件的原因、影响和范围

4. 控制：采取措施控制安全事件的影响，防止进一步损害

5. 根除：消除安全事件的根源，修复漏洞

6. 恢复：恢复系统和服务的正常运行

7. 总结：总结安全事件的经验教训，改进安全措施

9.3 安全事件响应计划

安全事件响应计划 是指导安全事件响应过程的文档，包括响应流程、角色和责任、工具和资源等。

9.3.1 响应计划内容

• 响应团队：定义响应团队的组成和角色

• 响应流程：详细描述响应的步骤和方法

• 通信计划：定义内部和外部通信的方式和内容

• 升级流程：定义事件升级的条件和流程

• 工具和资源：列出响应所需的工具和资源

• 恢复流程：定义系统和服务的恢复步骤

• 演练计划：定义响应演练的频率和方法

• 事后分析：定义事件后分析的流程和内容

9.3.2 响应计划测试

• 桌面演练：响应团队讨论和模拟响应流程

• 功能演练：测试响应流程的特定功能

• 全面演练：模拟完整的安全事件，测试整个响应流程

• 桌面演练：定期进行桌面演练，保持响应能力

10. 集群安全最佳实践

10.1 设计原则

• 深度防御：实施多层安全控制，即使一层被突破，还有其他层保护

• 最小权限：只授予用户和服务完成任务所需的最小权限

• 默认安全：系统和服务默认配置为安全状态

• 安全开发生命周期：将安全融入整个开发生命周期

• 持续改进：定期评估和改进安全措施

• 安全意识：提高所有人员的安全意识

10.2 实施策略

• 定期安全评估：定期进行安全评估，识别安全风险

• 自动化安全控制：使用自动化工具实施和管理安全控制

• 集中式安全管理：使用集中式工具管理安全配置和策略

• 安全监控：实施全面的安全监控，及时发现安全事件

• 快速响应：建立快速响应机制，及时处理安全事件

• 持续教育：定期对员工进行安全培训和教育

10.3 关键最佳实践

• 使用强密码和多因素认证：防止未授权访问

• 定期备份数据：确保数据可以在安全事件后恢复

• 及时安装安全补丁：修复已知漏洞

• 实施网络分段：减少攻击面

• 加密敏感数据：保护敏感数据的保密性

• 监控系统和网络：及时发现异常行为

• 限制物理访问：防止物理攻击和盗窃

• 制定安全策略：明确安全要求和责任

• 定期进行安全演练：提高安全事件响应能力

• 保持安全更新：了解最新的安全威胁和防御措施

实用案例分析

案例1：Pacemaker 集群安全配置

场景描述

某企业部署了一个 2 节点的 Pacemaker 高可用集群，用于运行关键业务应用。需要配置集群安全，包括认证、授权、网络安全和系统安全。

解决方案

1. 环境准备：

   • 集群节点：node1, node2

   • 操作系统：CentOS 7

   • 集群软件：Pacemaker, Corosync

2. 认证配置：

# 配置 SSH 无密码认证
ssh-keygen -t rsa
ssh-copy-id node1
ssh-copy-id node2

# 配置 Pacemaker 集群认证
pcs cluster auth node1 node2 -u hacluster -p secure_password

3. 授权配置：

# 配置 Pacemaker 访问控制
pcs property set cluster-authorization=true

# 创建 Pacemaker 用户
pcs user create operator secure_password
pcs user create monitor secure_password

# 分配权限
pcs acl create operator-role description="Operator role"
pcs acl rule create operator-role read xpath=/cib
pcs acl rule create operator-role write xpath=/cib/resources

pcs acl create monitor-role description="Monitor role"
pcs acl rule create monitor-role read xpath=/cib

4. 网络安全配置：

# 配置网络接口
# node1
echo "DEVICE=eth0
BOOTPROTO=static
IPADDR=192.168.1.10
NETMASK=255.255.255.0
GATEWAY=192.168.1.1
DNS1=8.8.8.8
ONBOOT=yes" > /etc/sysconfig/network-scripts/ifcfg-eth0

echo "DEVICE=eth1
BOOTPROTO=static
IPADDR=10.0.0.10
NETMASK=255.255.255.0
ONBOOT=yes" > /etc/sysconfig/network-scripts/ifcfg-eth1

# node2
echo "DEVICE=eth0
BOOTPROTO=static
IPADDR=192.168.1.11
NETMASK=255.255.255.0
GATEWAY=192.168.1.1
DNS1=8.8.8.8
ONBOOT=yes" > /etc/sysconfig/network-scripts/ifcfg-eth0

echo "DEVICE=eth1
BOOTPROTO=static
IPADDR=10.0.0.11
NETMASK=255.255.255.0
ONBOOT=yes" > /etc/sysconfig/network-scripts/ifcfg-eth1

# 重启网络服务
systemctl restart network

# 配置防火墙
firewall-cmd --permanent --zone=public --add-service=http
firewall-cmd --permanent --zone=public --add-service=https
firewall-cmd --permanent --zone=public --add-service=ssh
firewall-cmd --permanent --zone=internal --add-source=10.0.0.0/24
firewall-cmd --permanent --zone=internal --add-port=22/tcp
firewall-cmd --permanent --zone=internal --add-port=5405/udp
firewall-cmd --permanent --zone=internal --add-port=2224/tcp
firewall-cmd --reload

# 配置 Corosync 加密
cat > /etc/corosync/corosync.conf << 'EOF'
totem {
    version: 2
    secauth: on
    threads: 0
    interface {
        ringnumber: 0
        bindnetaddr: 10.0.0.0
        mcastaddr: 226.94.1.1
        mcastport: 5405
        ttl: 1
    }
}

nodelist {
    node {
        ring0_addr: node1
        name: node1
        nodeid: 1
    }
    node {
        ring0_addr: node2
        name: node2
        nodeid: 2
    }
}

quorum {
    provider: corosync_votequorum
    two_node: 1
}

logging {
    to_logfile: yes
    logfile: /var/log/cluster/corosync.log
    to_syslog: yes
    timestamp: on
}
EOF

5. 系统安全配置：

# 系统加固
# 最小化安装
# 禁用不必要的服务
systemctl stop avahi-daemon cups iscsi iscsid rpcbind
systemctl disable avahi-daemon cups iscsi iscsid rpcbind

# 配置 SELinux
cat > /etc/selinux/config << 'EOF'
SELINUX=enforcing
SELINUXTYPE=targeted
EOF

# 配置 TCP 安全参数
cat > /etc/sysctl.d/security.conf << 'EOF'
net.ipv4.tcp_syncookies = 1
net.ipv4.ip_forward = 0
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1
net.ipv4.icmp_echo_ignore_broadcasts = 1
net.ipv4.icmp_ignore_bogus_error_responses = 1
EOF

# 应用 sysctl 配置
sysctl -p /etc/sysctl.d/security.conf

# 配置自动更新
cat > /etc/yum/yum-cron.conf << 'EOF'
[base]
apply_updates = security
check_interval = daily
random_sleep = 360
EOF

# 启动 yum-cron
systemctl start yum-cron
systemctl enable yum-cron

6. 安全监控配置：

# 配置 auditd
cat > /etc/audit/rules.d/audit.rules << 'EOF'
-w /etc/passwd -p wa -k passwd
-w /etc/shadow -p wa -k shadow
-w /etc/sudoers -p wa -k sudoers
-w /etc/corosync/ -p wa -k corosync
-w /etc/pacemaker/ -p wa -k pacemaker
-w /var/log/cluster/ -p wa -k cluster-log
EOF

# 重启 auditd
systemctl restart auditd
systemctl enable auditd

# 配置 rsyslog 远程日志
cat >> /etc/rsyslog.conf << 'EOF'
*.* @@logserver:514
EOF

# 重启 rsyslog
systemctl restart rsyslog
systemctl enable rsyslog

7. 安全测试：

   • 执行漏洞扫描，检查系统漏洞

   • 测试认证和授权机制，确保只有授权用户可以访问

   • 测试网络安全，确保网络分区和防火墙规则有效

   • 模拟安全事件，测试响应流程

案例2：Kubernetes 集群安全配置

场景描述

某企业部署了一个 Kubernetes 集群，用于运行容器化应用。需要配置集群安全，包括认证、授权、网络安全、容器安全和系统安全。

解决方案

1. 环境准备：

   • 集群节点：master1, master2, worker1, worker2

   • 操作系统：CentOS 7

   • 集群软件：Kubernetes 1.21

2. 认证配置：

# 配置 Kubernetes 认证
# 1. 生成证书
mkdir -p /etc/kubernetes/pki

# 生成 CA 证书
openssl genrsa -out /etc/kubernetes/pki/ca.key 2048
openssl req -x509 -new -nodes -key /etc/kubernetes/pki/ca.key -subj "/CN=kubernetes" -days 3650 -out /etc/kubernetes/pki/ca.crt

# 生成 API Server 证书
openssl genrsa -out /etc/kubernetes/pki/apiserver.key 2048
openssl req -new -key /etc/kubernetes/pki/apiserver.key -subj "/CN=kubernetes" -out /etc/kubernetes/pki/apiserver.csr
openssl x509 -req -in /etc/kubernetes/pki/apiserver.csr -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -out /etc/kubernetes/pki/apiserver.crt -days 3650

# 生成 kubelet 证书
openssl genrsa -out /etc/kubernetes/pki/kubelet.key 2048
openssl req -new -key /etc/kubernetes/pki/kubelet.key -subj "/CN=system:node:$(hostname)" -out /etc/kubernetes/pki/kubelet.csr
openssl x509 -req -in /etc/kubernetes/pki/kubelet.csr -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -out /etc/kubernetes/pki/kubelet.crt -days 3650

# 2. 配置 kubeconfig
kubectl config set-cluster kubernetes --server=https://master1:6443 --certificate-authority=/etc/kubernetes/pki/ca.crt
kubectl config set-credentials admin --client-certificate=/etc/kubernetes/pki/apiserver.crt --client-key=/etc/kubernetes/pki/apiserver.key
kubectl config set-context kubernetes --cluster=kubernetes --user=admin
kubectl config use-context kubernetes

# 3. 配置 RBAC
kubectl create clusterrolebinding cluster-admin-binding --clusterrole=cluster-admin --user=system:admin

3. 网络安全配置：

# 配置网络策略
kubectl apply -f - << 'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
EOF

# 配置允许特定流量的网络策略
kubectl apply -f - << 'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-web
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Ingress
  ingress:
  - from:
    - ipBlock:
        cidr: 192.168.1.0/24
    ports:
    - protocol: TCP
      port: 80
    - protocol: TCP
      port: 443
EOF

# 配置 Calico 网络插件
# 安装 Calico
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

# 配置 Calico 网络策略
kubectl apply -f - << 'EOF'
apiVersion: projectcalico.org/v3
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: default
spec:
  selector: all()
  types:
  - Ingress
  - Egress
EOF

# 配置 API Server 安全
cat > /etc/kubernetes/manifests/kube-apiserver.yaml << 'EOF'
apiVersion: v1
kind: Pod
metadata:
  annotations:
    scheduler.alpha.kubernetes.io/critical-pod: ""
  creationTimestamp: null
  labels:
    component: kube-apiserver
    tier: control-plane
  name: kube-apiserver
  namespace: kube-system
spec:
  containers:
  - command:
    - kube-apiserver
    - --advertise-address=192.168.1.10
    - --allow-privileged=true
    - --authorization-mode=Node,RBAC
    - --client-ca-file=/etc/kubernetes/pki/ca.crt
    - --enable-admission-plugins=NodeRestriction
    - --enable-bootstrap-token-auth=true
    - --etcd-cafile=/etc/kubernetes/pki/etcd/ca.crt
    - --etcd-certfile=/etc/kubernetes/pki/apiserver-etcd-client.crt
    - --etcd-keyfile=/etc/kubernetes/pki/apiserver-etcd-client.key
    - --etcd-servers=https://127.0.0.1:2379
    - --kubelet-client-certificate=/etc/kubernetes/pki/apiserver-kubelet-client.crt
    - --kubelet-client-key=/etc/kubernetes/pki/apiserver-kubelet-client.key
    - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
    - --proxy-client-cert-file=/etc/kubernetes/pki/front-proxy-client.crt
    - --proxy-client-key-file=/etc/kubernetes/pki/front-proxy-client.key
    - --requestheader-allowed-names=front-proxy-client
    - --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.crt
    - --requestheader-extra-headers-prefix=X-Remote-Extra-
    - --requestheader-group-headers=X-Remote-Group
    - --requestheader-username-headers=X-Remote-User
    - --secure-port=6443
    - --service-account-key-file=/etc/kubernetes/pki/sa.pub
    - --service-cluster-ip-range=10.96.0.0/12
    - --tls-cert-file=/etc/kubernetes/pki/apiserver.crt
    - --tls-private-key-file=/etc/kubernetes/pki/apiserver.key
    image: k8s.gcr.io/kube-apiserver:v1.21.0
    imagePullPolicy: IfNotPresent
    livenessProbe:
      failureThreshold: 8
      httpGet:
        host: 192.168.1.10
        path: /livez
        port: 6443
        scheme: HTTPS
      initialDelaySeconds: 10
      periodSeconds: 10
      timeoutSeconds: 15
    name: kube-apiserver
    readinessProbe:
      failureThreshold: 3
      httpGet:
        host: 192.168.1.10
        path: /readyz
        port: 6443
        scheme: HTTPS
      initialDelaySeconds: 10
      periodSeconds: 10
      timeoutSeconds: 15
    resources:
      requests:
        cpu: 250m
    volumeMounts:
    - mountPath: /etc/ssl/certs
      name: ca-certs
      readOnly: true
    - mountPath: /etc/pki
      name: etc-pki
      readOnly: true
    - mountPath: /etc/kubernetes/pki
      name: k8s-certs
      readOnly: true
  hostNetwork: true
  priorityClassName: system-node-critical
  volumes:
  - hostPath:
      path: /etc/ssl/certs
      type: DirectoryOrCreate
    name: ca-certs
  - hostPath:
      path: /etc/pki
      type: DirectoryOrCreate
    name: etc-pki
  - hostPath:
      path: /etc/kubernetes/pki
      type: DirectoryOrCreate
    name: k8s-certs
status: {}
EOF

3. **容器安全配置**：

```bash
# 配置 Pod 安全策略
kubectl apply -f - << 'EOF'
apiVersion: policy/v1beta1
kind: PodSecurityPolicy
metadata:
  name: restricted
  annotations:
    seccomp.security.alpha.kubernetes.io/allowedProfileNames: 'docker/default'
    apparmor.security.beta.kubernetes.io/allowedProfileNames: 'runtime/default'
    seccomp.security.alpha.kubernetes.io/defaultProfileName:  'docker/default'
    apparmor.security.beta.kubernetes.io/defaultProfileName:  'runtime/default'
spec:
  privileged: false
  allowPrivilegeEscalation: false
  requiredDropCapabilities:
    - ALL
  volumes:
    - 'configMap'
    - 'emptyDir'
    - 'projected'
    - 'secret'
    - 'downwardAPI'
    - 'persistentVolumeClaim'
  hostNetwork: false
  hostPID: false
  hostIPC: false
  runAsUser:
    rule: 'MustRunAsNonRoot'
  seLinux:
    rule: 'RunAsAny'
  supplementalGroups:
    rule: 'MustRunAs'
    ranges:
      - min: 1
        max: 65535
  fsGroup:
    rule: 'MustRunAs'
    ranges:
      - min: 1
        max: 65535
  readOnlyRootFilesystem: false
EOF

# 绑定 Pod 安全策略
kubectl create clusterrole psp:restricted --verb=use --resource=podsecuritypolicies --resource-name=restricted
kubectl create clusterrolebinding psp:restricted --clusterrole=psp:restricted --group=system:authenticated

# 使用安全的容器镜像
# 1. 使用官方镜像
# 2. 定期更新镜像
# 3. 扫描镜像漏洞
# 4. 使用最小化镜像

# 配置镜像扫描
# 安装 Trivy
curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh -s -- -b /usr/local/bin v0.18.3

# 扫描镜像
 trivy image nginx:latest

4. 系统安全配置：

# 系统加固
# 最小化安装
# 禁用不必要的服务
systemctl stop avahi-daemon cups iscsi iscsid rpcbind
systemctl disable avahi-daemon cups iscsi iscsid rpcbind

# 配置 SELinux
cat > /etc/selinux/config << 'EOF'
SELINUX=enforcing
SELINUXTYPE=targeted
EOF

# 配置 TCP 安全参数
cat > /etc/sysctl.d/security.conf << 'EOF'
net.ipv4.tcp_syncookies = 1
net.ipv4.ip_forward = 1
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1
net.ipv4.icmp_echo_ignore_broadcasts = 1
net.ipv4.icmp_ignore_bogus_error_responses = 1
EOF

# 应用 sysctl 配置
sysctl -p /etc/sysctl.d/security.conf

# 配置自动更新
cat > /etc/yum/yum-cron.conf << 'EOF'
[base]
apply_updates = security
check_interval = daily
random_sleep = 360
EOF

# 启动 yum-cron
systemctl start yum-cron
systemctl enable yum-cron

5. 安全监控配置：

# 配置 Prometheus 和 Grafana 监控安全指标
# 安装 Prometheus 和 Grafana
kubectl apply -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/master/bundle.yaml

# 配置安全监控告警
kubectl apply -f - << 'EOF'
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: security-alerts
  namespace: monitoring
spec:
  groups:
  - name: security
    rules:
    - alert: FailedAuthentication
      expr: sum(rate(kubelet_authentication_errors_total[5m])) > 0
      for: 5m
      labels:
        severity: warning
      annotations:
        summary: "Failed authentication detected"
description: "{{ $value }} failed authentication attempts in the last 5 minutes"
    - alert: PrivilegedPod
      expr: sum(kube_pod_container_info{securityContext_privileged=true}) > 0
      for: 5m
      labels:
        severity: critical
      annotations:
        summary: "Privileged pod detected"
description: "Privileged pod running in the cluster"
EOF

6. 安全测试：

   • 执行漏洞扫描，检查系统和容器漏洞
   • 测试认证和授权机制，确保只有授权用户可以访问
   • 测试网络安全，确保网络策略和防火墙规则有效
   • 模拟安全事件，测试响应流程

案例3：Ceph 集群安全配置

场景描述

某企业部署了一个 Ceph 存储集群，用于存储关键业务数据。需要配置集群安全，包括认证、授权、网络安全、数据安全和系统安全。

解决方案

1. 环境准备：

   • 集群节点：mon1, mon2, mon3, osd1, osd2, osd3
   • 操作系统：CentOS 7
   • 集群软件：Ceph 15.2.13

2. 认证配置：

# 配置 Ceph 认证
# 创建 Ceph 集群
ceph-deploy new mon1 mon2 mon3

# 安装 Ceph
ceph-deploy install mon1 mon2 mon3 osd1 osd2 osd3

# 初始化监控节点
ceph-deploy mon create-initial

# 创建 Ceph 用户
ceph auth get-or-create client.admin mon 'allow *' osd 'allow *' mds 'allow *'
ceph auth get-or-create client.volumes mon 'allow r' osd 'allow rwx pool=volumes'
ceph auth get-or-create client.backup mon 'allow r' osd 'allow rwx pool=backup'

# 导出密钥
ceph auth get client.admin -o /etc/ceph/ceph.client.admin.keyring
ceph auth get client.volumes -o /etc/ceph/ceph.client.volumes.keyring
ceph auth get client.backup -o /etc/ceph/ceph.client.backup.keyring

3. 网络安全配置：

# 配置网络接口
# mon1
cat > /etc/sysconfig/network-scripts/ifcfg-eth0 << 'EOF'
DEVICE=eth0
BOOTPROTO=static
IPADDR=192.168.1.10
NETMASK=255.255.255.0
GATEWAY=192.168.1.1
DNS1=8.8.8.8
ONBOOT=yes
EOF

cat > /etc/sysconfig/network-scripts/ifcfg-eth1 << 'EOF'
DEVICE=eth1
BOOTPROTO=static
IPADDR=10.0.0.10
NETMASK=255.255.255.0
ONBOOT=yes
EOF

# 重启网络服务
systemctl restart network

# 配置防火墙
firewall-cmd --permanent --zone=public --add-service=ssh
firewall-cmd --permanent --zone=internal --add-source=10.0.0.0/24
firewall-cmd --permanent --zone=internal --add-port=6789/tcp
firewall-cmd --permanent --zone=internal --add-port=6800-7300/tcp
firewall-cmd --reload

# 配置 Ceph 网络
cat > /etc/ceph/ceph.conf << 'EOF'
[global]
fsid = $(grep fsid /etc/ceph/ceph.conf | awk '{print $3}')
mon_initial_members = mon1, mon2, mon3
mon_host = 10.0.0.10,10.0.0.11,10.0.0.12
auth_cluster_required = cephx
auth_service_required = cephx
auth_client_required = cephx
public_network = 192.168.1.0/24
cluster_network = 10.0.0.0/24
EOF

# 重启 Ceph 服务
systemctl restart ceph.target

4. 数据安全配置：

# 数据加密配置
# 启用 OSD 加密
ceph osd pool create encrypted_pool 128
ceph osd pool application enable encrypted_pool rbd

# 配置 RBD 加密
rbd create --size 1024 encrypted_image --pool encrypted_pool
rbd encryption format encrypted_image --pool encrypted_pool --key-wrap-algorithm aes-256-cbc --key-file /path/to/keyfile
rbd map encrypted_image --pool encrypted_pool --key-file /path/to/keyfile

# 数据备份配置
# 创建备份池
ceph osd pool create backup 128
ceph osd pool application enable backup rbd

# 配置定期备份
cat > /etc/cron.d/ceph-backup << 'EOF'
0 0 * * * root rbd snap create backup/image@$(date +\%Y\%m\%d) && rbd snap protect backup/image@$(date +\%Y\%m\%d)
EOF

# 数据恢复测试
# 测试备份恢复
rbd snap clone backup/image@20230101 backup/recovered_image
rbd map backup/recovered_image

5. 系统安全配置：

# 系统加固
# 最小化安装
# 禁用不必要的服务
systemctl stop avahi-daemon cups iscsi iscsid rpcbind
systemctl disable avahi-daemon cups iscsi iscsid rpcbind

# 配置 SELinux
cat > /etc/selinux/config << 'EOF'
SELINUX=enforcing
SELINUXTYPE=targeted
EOF

# 配置 TCP 安全参数
cat > /etc/sysctl.d/security.conf << 'EOF'
net.ipv4.tcp_syncookies = 1
net.ipv4.ip_forward = 0
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1
net.ipv4.icmp_echo_ignore_broadcasts = 1
net.ipv4.icmp_ignore_bogus_error_responses = 1
EOF

# 应用 sysctl 配置
sysctl -p /etc/sysctl.d/security.conf

# 配置自动更新
cat > /etc/yum/yum-cron.conf << 'EOF'
[base]
apply_updates = security
check_interval = daily
random_sleep = 360
EOF

# 启动 yum-cron
systemctl start yum-cron
systemctl enable yum-cron

6. 安全监控配置：

# 配置 Ceph 监控
# 安装 Prometheus 和 Grafana
yum install -y prometheus grafana

# 配置 Ceph 导出器
yum install -y ceph-exporter

# 配置 Prometheus 监控 Ceph
cat > /etc/prometheus/prometheus.yml << 'EOF'
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'ceph'
    static_configs:
      - targets: ['mon1:9128', 'mon2:9128', 'mon3:9128']
  - job_name: 'node'
    static_configs:
      - targets: ['mon1:9100', 'mon2:9100', 'mon3:9100', 'osd1:9100', 'osd2:9100', 'osd3:9100']
EOF

# 启动服务
systemctl start prometheus grafana
systemctl enable prometheus grafana

# 配置安全告警
# 在 Grafana 中创建告警规则，监控以下指标：
# - Ceph 集群健康状态
# - OSD 状态
# - 认证失败次数
# - 网络流量异常

7. 安全测试：

   • 执行漏洞扫描，检查系统漏洞
   • 测试认证和授权机制，确保只有授权用户可以访问
   • 测试网络安全，确保网络分区和防火墙规则有效
   • 测试数据安全，确保数据加密和备份有效
   • 模拟安全事件，测试响应流程

课后练习

练习1：Pacemaker 集群安全配置

1. 目标：配置一个 2 节点的 Pacemaker 高可用集群的安全设置。

2. 要求：

   • 配置 SSH 无密码认证
   • 配置 Pacemaker 集群认证
   • 配置网络分区和防火墙规则
   • 配置 Corosync 加密通信
   • 配置系统加固和自动更新
   • 配置安全监控和审计

3. 步骤：

   • 准备 2 台 CentOS 7 服务器
   • 安装 Pacemaker 和 Corosync
   • 按照案例1的步骤配置集群安全
   • 测试安全配置的有效性

练习2：Kubernetes 集群安全配置

1. 目标：配置一个 Kubernetes 集群的安全设置。

2. 要求：

   • 配置 Kubernetes 认证和授权
   • 配置网络策略和 Calico 网络插件
   • 配置 Pod 安全策略
   • 配置容器镜像安全扫描
   • 配置系统加固和自动更新
   • 配置安全监控和告警

3. 步骤：

   • 准备 3 台 CentOS 7 服务器（1 个 master，2 个 worker）
   • 安装 Kubernetes 集群
   • 按照案例2的步骤配置集群安全
   • 测试安全配置的有效性

练习3：Ceph 集群安全配置

1. 目标：配置一个 Ceph 存储集群的安全设置。

2. 要求：

   • 配置 Ceph 认证和授权
   • 配置网络分区和防火墙规则
   • 配置数据加密和备份
   • 配置系统加固和自动更新
   • 配置安全监控和告警

3. 步骤：

   • 准备 6 台 CentOS 7 服务器（3 个 monitor，3 个 OSD）
   • 安装 Ceph 集群
   • 按照案例3的步骤配置集群安全
   • 测试安全配置的有效性

练习4：安全事件响应演练

1. 目标：演练安全事件的响应流程。

2. 要求：

   • 制定安全事件响应计划
   • 模拟常见的安全事件（如未授权访问、数据泄露）
   • 按照响应流程处理安全事件
   • 总结经验教训，改进安全措施

3. 步骤：

   • 制定安全事件响应计划
   • 组织响应团队
   • 模拟安全事件
   • 执行响应流程
   • 进行事后分析和总结

练习5：集群安全评估

1. 目标：评估集群系统的安全状况。

2. 要求：

   • 执行漏洞扫描，识别安全漏洞
   • 评估认证和授权机制的有效性
   • 评估网络安全和数据安全措施
   • 评估系统加固和补丁管理状态
   • 生成安全评估报告，提出改进建议

3. 步骤：

   • 选择合适的漏洞扫描工具
   • 对集群系统进行全面扫描
   • 分析扫描结果
   • 评估各项安全措施的有效性
   • 生成安全评估报告
   • 提出改进建议并实施

5. **系统安全配置**：



```bash
# 系统加固
# 最小化安装
# 禁用不必要的服务
systemctl stop avahi-daemon cups iscsi iscsid rpcbind
systemctl disable avahi-daemon cups iscsi iscsid rpcbind

# 配置 SELinux
cat > /etc/selinux/config << 'EOF'
SELINUX=enforcing
SELINUXTYPE=targeted
EOF

# 配置 TCP 安全参数
cat > /etc/sysctl.d/security.conf << 'EOF'
net.ipv4.tcp_syncookies = 1
net.ipv4.ip_forward = 1
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1
net.ipv4.icmp_echo_ignore_broadcasts = 1
net.ipv4.icmp_ignore_bogus_error_responses = 1
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF

# 应用 sysctl 配置
sysctl -p /etc/sysctl.d/security.conf

# 配置自动更新
cat > /etc/yum/yum-cron.conf << 'EOF'
[base]
apply_updates = security
check_interval = daily
random_sleep = 360
EOF

# 启动 yum-cron
systemctl start yum-cron
systemctl enable yum-cron

6. 安全监控配置：

# 部署 Prometheus + Grafana 监控
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/kube-prometheus-stack --namespace monitoring --create-namespace

# 部署 Falco 容器安全监控
helm repo add falcosecurity https://falcosecurity.github.io/charts
helm repo update
helm install falco falcosecurity/falco --namespace falco --create-namespace

# 部署 Auditd
kubectl apply -f - << 'EOF'
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: auditd
  namespace: kube-system
spec:
  selector:
    matchLabels:
      app: auditd
  template:
    metadata:
      labels:
        app: auditd
    spec:
      containers:
      - name: auditd
        image: ubuntu:18.04
        command: ["/bin/bash", "-c"]
        args:
        - apt-get update && apt-get install -y auditd && /usr/sbin/auditd -n
        securityContext:
          privileged: true
        volumeMounts:
        - name: auditd-config
          mountPath: /etc/audit/
        - name: audit-logs
          mountPath: /var/log/audit/
      volumes:
      - name: auditd-config
        configMap:
          name: auditd-config
      - name: audit-logs
        hostPath:
          path: /var/log/audit/
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: auditd-config
  namespace: kube-system
data:
  auditd.conf: |
    local_events = yes
    write_logs = yes
    log_file = /var/log/audit/audit.log
    log_group = root
    log_format = RAW
    flush = INCREMENTAL
    freq = 20
    max_log_file = 8
    num_logs = 5
    priority_boost = 4
    disp_qos = lossy
    dispatcher = /sbin/audispd
    name_format = NONE
    name = mydomain
    max_log_file_action = rotate
    space_left = 75
    space_left_action = syslog
    action_mail_acct = root
    admin_space_left = 50
    admin_space_left_action = suspend
    disk_full_action = suspend
    disk_error_action = suspend
    use_libwrap = yes
    tcp_listen_port = 60
    tcp_listen_queue = 5
    tcp_max_per_addr = 1
    tcp_client_ports = 1024-65535
    tcp_client_max_idle = 0
    enable_krb5 = no
    krb5_principal = auditd
  rules.d/audit.rules: |
    -w /etc/passwd -p wa -k passwd
    -w /etc/shadow -p wa -k shadow
    -w /etc/sudoers -p wa -k sudoers
    -w /etc/kubernetes/ -p wa -k kubernetes
EOF

7. 安全测试：

   • 执行漏洞扫描，检查系统和容器漏洞

   • 测试认证和授权机制，确保只有授权用户可以访问

   • 测试网络安全，确保网络策略有效

   • 测试容器安全，确保容器运行在安全的环境中

   • 模拟安全事件，测试响应流程

案例3：Ceph 存储集群安全配置

场景描述

某企业部署了一个 Ceph 存储集群，用于提供块存储、文件存储和对象存储服务。需要配置集群安全，包括认证、授权、网络安全和数据安全。

解决方案

1. 环境准备：

   • 集群节点：mon1, mon2, mon3, osd1, osd2, osd3

   • 操作系统：CentOS 7

   • 集群软件：Ceph 16.2

2. 认证配置：

# 配置 Ceph 认证
# 创建 Ceph 用户
ceph auth get-or-create client.admin mon 'allow *' osd 'allow *' mds 'allow *'
ceph auth get-or-create client.glance mon 'allow r' osd 'allow class-read object_prefix rbd_children, allow rwx pool=images'
ceph auth get-or-create client.cinder mon 'allow r' osd 'allow class-read object_prefix rbd_children, allow rwx pool=volumes, allow rwx pool=vms, allow rx pool=images'
ceph auth get-or-create client.radosgw mon 'allow rwx' osd 'allow rwx pool=.rgw.root, allow rwx pool=default.rgw.control, allow rwx pool=default.rgw.meta, allow rwx pool=default.rgw.log, allow rwx pool=default.rgw.buckets.index, allow rwx pool=default.rgw.buckets.data'

# 查看 Ceph 用户
ceph auth list

# 导出 Ceph 密钥
ceph auth get client.admin -o /etc/ceph/ceph.client.admin.keyring
ceph auth get client.glance -o /etc/ceph/ceph.client.glance.keyring
ceph auth get client.cinder -o /etc/ceph/ceph.client.cinder.keyring
ceph auth get client.radosgw -o /etc/ceph/ceph.client.radosgw.keyring

# 配置客户端认证
# 1. 复制密钥文件到客户端
# 2. 配置客户端使用密钥文件

3. 网络安全配置：

# 配置网络接口
# 管理网络
cat > /etc/sysconfig/network-scripts/ifcfg-eth0 << 'EOF'
DEVICE=eth0
BOOTPROTO=static
IPADDR=192.168.1.10
NETMASK=255.255.255.0
GATEWAY=192.168.1.1
DNS1=8.8.8.8
ONBOOT=yes
EOF

# 集群网络
cat > /etc/sysconfig/network-scripts/ifcfg-eth1 << 'EOF'
DEVICE=eth1
BOOTPROTO=static
IPADDR=10.0.0.10
NETMASK=255.255.255.0
ONBOOT=yes
EOF

# 存储网络
cat > /etc/sysconfig/network-scripts/ifcfg-eth2 << 'EOF'
DEVICE=eth2
BOOTPROTO=static
IPADDR=192.168.2.10
NETMASK=255.255.255.0
ONBOOT=yes
EOF

# 重启网络服务
systemctl restart network

# 配置防火墙
firewall-cmd --permanent --zone=public --add-service=http
firewall-cmd --permanent --zone=public --add-service=https
firewall-cmd --permanent --zone=public --add-service=ssh
firewall-cmd --permanent --zone=internal --add-source=10.0.0.0/24
firewall-cmd --permanent --zone=internal --add-port=22/tcp
firewall-cmd --permanent --zone=internal --add-port=6789/tcp
firewall-cmd --permanent --zone=storage --add-source=192.168.2.0/24
firewall-cmd --permanent --zone=storage --add-port=6800-7300/tcp
firewall-cmd --reload

# 配置 Ceph 网络
cat > /etc/ceph/ceph.conf << 'EOF'
[global]
    fsid = $(uuidgen)
    mon initial members = mon1, mon2, mon3
    mon host = 192.168.1.10, 192.168.1.11, 192.168.1.12
    auth cluster required = cephx
    auth service required = cephx
    auth client required = cephx
    osd pool default size = 3
    osd pool default min size = 2
    osd pool default pg num = 128
    osd pool default pgp num = 128
    osd crush chooseleaf type = 0

[mon]
    mon cluster log file = /var/log/ceph/mon.$name.log

[osd]
    osd data = /var/lib/ceph/osd/ceph-$id
    osd journal = /var/lib/ceph/osd/ceph-$id/journal
    osd journal size = 1024
    osd cluster public network = 192.168.1.0/24
    osd cluster network = 192.168.2.0/24

[mds]
    mds log file = /var/log/ceph/mds.$name.log
EOF

# 配置 Ceph 加密
# 1. 启用 Cephx 认证
ceph auth get-or-create client.admin mon 'allow *' osd 'allow *' mds 'allow *'

# 2. 配置 TLS 加密
# 生成 TLS 证书
mkdir -p /etc/ceph/tls
cd /etc/ceph/tls

# 生成 CA 证书
openssl genrsa -out ca.key 4096
openssl req -new -x509 -key ca.key -out ca.crt -subj "/CN=ceph-ca"

# 生成 Mon 证书
for mon in mon1 mon2 mon3; do
    openssl genrsa -out ${mon}.key 2048
    openssl req -new -key ${mon}.key -out ${mon}.csr -subj "/CN=${mon}"
    openssl x509 -req -in ${mon}.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out ${mon}.crt -days 3650
done

# 生成 OSD 证书
for osd in osd1 osd2 osd3; do
    openssl genrsa -out ${osd}.key 2048
    openssl req -new -key ${osd}.key -out ${osd}.csr -subj "/CN=${osd}"
    openssl x509 -req -in ${osd}.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out ${osd}.crt -days 3650
done

# 配置 Ceph 使用 TLS
cat >> /etc/ceph/ceph.conf << 'EOF'

[global]
    mon ssl = true
    mon ssl key = /etc/ceph/tls/$name.key
    mon ssl cert = /etc/ceph/tls/$name.crt
    mon ssl ca = /etc/ceph/tls/ca.crt
    osd ssl = true
    osd ssl key = /etc/ceph/tls/$name.key
    osd ssl cert = /etc/ceph/tls/$name.crt
    osd ssl ca = /etc/ceph/tls/ca.crt
    mds ssl = true
    mds ssl key = /etc/ceph/tls/$name.key
    mds ssl cert = /etc/ceph/tls/$name.crt
    mds ssl ca = /etc/ceph/tls/ca.crt
    client ssl = true
    client ssl key = /etc/ceph/tls/client.key
    client ssl cert = /etc/ceph/tls/client.crt
    client ssl ca = /etc/ceph/tls/ca.crt
EOF